git builtin "push"
This adds a builtin "push" command, which is largely just a C'ification of
the "git-push.sh" script.
Now, the reason I did it as a built-in is partly because it's yet another
step on relying less on shell, but it's actually mostly because I've
wanted to be able to push to _multiple_ repositories, and the most obvious
and simplest interface for that would seem be to just have a "remotes"
file that has multiple URL entries.
(For "pull", having multiple entries should either just select the first
one, or you could fall back on the others on failure - your choice).
And quite frankly, it just became too damn messy to do that in shell.
Besides, we actually have a fair amount of infrastructure in C, so it just
wasn't that hard to do.
Of course, this is almost totally untested. It probably doesn't work for
anything but the one trial I threw at it. "Simple" doesn't necessarily
mean "obviously correct".
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-04-30 06:22:49 +02:00
|
|
|
/*
|
|
|
|
|
* "git push"
|
|
|
|
|
*/
|
|
|
|
|
#include "cache.h"
|
|
|
|
|
#include "refs.h"
|
|
|
|
|
#include "run-command.h"
|
|
|
|
|
#include "builtin.h"
|
2007-05-12 17:45:53 +02:00
|
|
|
#include "remote.h"
|
2007-09-11 05:03:04 +02:00
|
|
|
#include "transport.h"
|
2007-11-05 04:35:37 +01:00
|
|
|
#include "parse-options.h"
|
2011-08-20 00:08:47 +02:00
|
|
|
#include "submodule.h"
|
git builtin "push"
This adds a builtin "push" command, which is largely just a C'ification of
the "git-push.sh" script.
Now, the reason I did it as a built-in is partly because it's yet another
step on relying less on shell, but it's actually mostly because I've
wanted to be able to push to _multiple_ repositories, and the most obvious
and simplest interface for that would seem be to just have a "remotes"
file that has multiple URL entries.
(For "pull", having multiple entries should either just select the first
one, or you could fall back on the others on failure - your choice).
And quite frankly, it just became too damn messy to do that in shell.
Besides, we actually have a fair amount of infrastructure in C, so it just
wasn't that hard to do.
Of course, this is almost totally untested. It probably doesn't work for
anything but the one trial I threw at it. "Simple" doesn't necessarily
mean "obviously correct".
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-04-30 06:22:49 +02:00
|
|
|
|
2007-11-05 04:35:37 +01:00
|
|
|
static const char * const push_usage[] = {
|
2010-04-10 04:50:19 +02:00
|
|
|
"git push [<options>] [<repository> [<refspec>...]]",
|
2007-11-05 04:35:37 +01:00
|
|
|
NULL,
|
|
|
|
|
};
|
git builtin "push"
This adds a builtin "push" command, which is largely just a C'ification of
the "git-push.sh" script.
Now, the reason I did it as a built-in is partly because it's yet another
step on relying less on shell, but it's actually mostly because I've
wanted to be able to push to _multiple_ repositories, and the most obvious
and simplest interface for that would seem be to just have a "remotes"
file that has multiple URL entries.
(For "pull", having multiple entries should either just select the first
one, or you could fall back on the others on failure - your choice).
And quite frankly, it just became too damn messy to do that in shell.
Besides, we actually have a fair amount of infrastructure in C, so it just
wasn't that hard to do.
Of course, this is almost totally untested. It probably doesn't work for
anything but the one trial I threw at it. "Simple" doesn't necessarily
mean "obviously correct".
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-04-30 06:22:49 +02:00
|
|
|
|
2008-07-20 14:02:20 +02:00
|
|
|
static int thin;
|
2009-12-30 20:57:42 +01:00
|
|
|
static int deleterefs;
|
2007-01-19 13:49:27 +01:00
|
|
|
static const char *receivepack;
|
2010-02-24 13:50:24 +01:00
|
|
|
static int verbosity;
|
2012-02-13 21:17:15 +01:00
|
|
|
static int progress = -1;
|
git builtin "push"
This adds a builtin "push" command, which is largely just a C'ification of
the "git-push.sh" script.
Now, the reason I did it as a built-in is partly because it's yet another
step on relying less on shell, but it's actually mostly because I've
wanted to be able to push to _multiple_ repositories, and the most obvious
and simplest interface for that would seem be to just have a "remotes"
file that has multiple URL entries.
(For "pull", having multiple entries should either just select the first
one, or you could fall back on the others on failure - your choice).
And quite frankly, it just became too damn messy to do that in shell.
Besides, we actually have a fair amount of infrastructure in C, so it just
wasn't that hard to do.
Of course, this is almost totally untested. It probably doesn't work for
anything but the one trial I threw at it. "Simple" doesn't necessarily
mean "obviously correct".
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-04-30 06:22:49 +02:00
|
|
|
|
2006-08-15 19:23:48 +02:00
|
|
|
static const char **refspec;
|
|
|
|
|
static int refspec_nr;
|
2010-07-31 14:54:55 +02:00
|
|
|
static int refspec_alloc;
|
git builtin "push"
This adds a builtin "push" command, which is largely just a C'ification of
the "git-push.sh" script.
Now, the reason I did it as a built-in is partly because it's yet another
step on relying less on shell, but it's actually mostly because I've
wanted to be able to push to _multiple_ repositories, and the most obvious
and simplest interface for that would seem be to just have a "remotes"
file that has multiple URL entries.
(For "pull", having multiple entries should either just select the first
one, or you could fall back on the others on failure - your choice).
And quite frankly, it just became too damn messy to do that in shell.
Besides, we actually have a fair amount of infrastructure in C, so it just
wasn't that hard to do.
Of course, this is almost totally untested. It probably doesn't work for
anything but the one trial I threw at it. "Simple" doesn't necessarily
mean "obviously correct".
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-04-30 06:22:49 +02:00
|
|
|
|
|
|
|
|
static void add_refspec(const char *ref)
|
|
|
|
|
{
|
2010-07-31 14:54:55 +02:00
|
|
|
refspec_nr++;
|
|
|
|
|
ALLOC_GROW(refspec, refspec_nr, refspec_alloc);
|
|
|
|
|
refspec[refspec_nr-1] = ref;
|
git builtin "push"
This adds a builtin "push" command, which is largely just a C'ification of
the "git-push.sh" script.
Now, the reason I did it as a built-in is partly because it's yet another
step on relying less on shell, but it's actually mostly because I've
wanted to be able to push to _multiple_ repositories, and the most obvious
and simplest interface for that would seem be to just have a "remotes"
file that has multiple URL entries.
(For "pull", having multiple entries should either just select the first
one, or you could fall back on the others on failure - your choice).
And quite frankly, it just became too damn messy to do that in shell.
Besides, we actually have a fair amount of infrastructure in C, so it just
wasn't that hard to do.
Of course, this is almost totally untested. It probably doesn't work for
anything but the one trial I threw at it. "Simple" doesn't necessarily
mean "obviously correct".
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-04-30 06:22:49 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void set_refspecs(const char **refs, int nr)
|
|
|
|
|
{
|
2007-05-25 07:20:56 +02:00
|
|
|
int i;
|
|
|
|
|
for (i = 0; i < nr; i++) {
|
|
|
|
|
const char *ref = refs[i];
|
|
|
|
|
if (!strcmp("tag", ref)) {
|
|
|
|
|
char *tag;
|
|
|
|
|
int len;
|
|
|
|
|
if (nr <= ++i)
|
2011-02-23 00:42:11 +01:00
|
|
|
die(_("tag shorthand without <tag>"));
|
2007-05-25 07:20:56 +02:00
|
|
|
len = strlen(refs[i]) + 11;
|
2009-12-30 20:57:42 +01:00
|
|
|
if (deleterefs) {
|
|
|
|
|
tag = xmalloc(len+1);
|
|
|
|
|
strcpy(tag, ":refs/tags/");
|
|
|
|
|
} else {
|
|
|
|
|
tag = xmalloc(len);
|
|
|
|
|
strcpy(tag, "refs/tags/");
|
|
|
|
|
}
|
2007-05-25 07:20:56 +02:00
|
|
|
strcat(tag, refs[i]);
|
|
|
|
|
ref = tag;
|
2009-12-30 20:57:42 +01:00
|
|
|
} else if (deleterefs && !strchr(ref, ':')) {
|
|
|
|
|
char *delref;
|
|
|
|
|
int len = strlen(ref)+1;
|
2010-01-29 11:31:30 +01:00
|
|
|
delref = xmalloc(len+1);
|
2009-12-30 20:57:42 +01:00
|
|
|
strcpy(delref, ":");
|
|
|
|
|
strcat(delref, ref);
|
|
|
|
|
ref = delref;
|
|
|
|
|
} else if (deleterefs)
|
2011-02-23 00:42:11 +01:00
|
|
|
die(_("--delete only accepts plain target ref names"));
|
2007-05-25 07:20:56 +02:00
|
|
|
add_refspec(ref);
|
git builtin "push"
This adds a builtin "push" command, which is largely just a C'ification of
the "git-push.sh" script.
Now, the reason I did it as a built-in is partly because it's yet another
step on relying less on shell, but it's actually mostly because I've
wanted to be able to push to _multiple_ repositories, and the most obvious
and simplest interface for that would seem be to just have a "remotes"
file that has multiple URL entries.
(For "pull", having multiple entries should either just select the first
one, or you could fall back on the others on failure - your choice).
And quite frankly, it just became too damn messy to do that in shell.
Besides, we actually have a fair amount of infrastructure in C, so it just
wasn't that hard to do.
Of course, this is almost totally untested. It probably doesn't work for
anything but the one trial I threw at it. "Simple" doesn't necessarily
mean "obviously correct".
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-04-30 06:22:49 +02:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
push: error out when the "upstream" semantics does not make sense
The user can say "git push" without specifying any refspec. When using
the "upstream" semantics via the push.default configuration, the user
wants to update the "upstream" branch of the current branch, which is the
branch at a remote repository the current branch is set to integrate with,
with this command.
However, there are cases that such a "git push" that uses the "upstream"
semantics does not make sense:
- The current branch does not have branch.$name.remote configured. By
definition, "git push" that does not name where to push to will not
know where to push to. The user may explicitly say "git push $there",
but again, by definition, no branch at repository $there is set to
integrate with the current branch in this case and we wouldn't know
which remote branch to update.
- The current branch does have branch.$name.remote configured, but it
does not specify branch.$name.merge that names what branch at the
remote this branch integrates with. "git push" knows where to push in
this case (or the user may explicitly say "git push $remote" to tell us
where to push), but we do not know which remote branch to update.
- The current branch does have its remote and upstream branch configured,
but the user said "git push $there", where $there is not the remote
named by "branch.$name.remote". By definition, no branch at repository
$there is set to integrate with the current branch in this case, and
this push is not meant to update any branch at the remote repository
$there.
The first two cases were already checked correctly, but the third case was
not checked and we ended up updating the branch named branch.$name.merge
at repository $there, which was totally bogus.
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2012-03-31 01:07:12 +02:00
|
|
|
static int push_url_of_remote(struct remote *remote, const char ***url_p)
|
|
|
|
|
{
|
|
|
|
|
if (remote->pushurl_nr) {
|
|
|
|
|
*url_p = remote->pushurl;
|
|
|
|
|
return remote->pushurl_nr;
|
|
|
|
|
}
|
|
|
|
|
*url_p = remote->url;
|
|
|
|
|
return remote->url_nr;
|
|
|
|
|
}
|
|
|
|
|
|
2011-03-02 21:12:10 +01:00
|
|
|
static void setup_push_upstream(struct remote *remote)
|
2009-03-16 16:42:51 +01:00
|
|
|
{
|
|
|
|
|
struct strbuf refspec = STRBUF_INIT;
|
|
|
|
|
struct branch *branch = branch_get(NULL);
|
|
|
|
|
if (!branch)
|
2011-04-02 02:55:55 +02:00
|
|
|
die(_("You are not currently on a branch.\n"
|
2011-03-02 21:12:10 +01:00
|
|
|
"To push the history leading to the current (detached HEAD)\n"
|
|
|
|
|
"state now, use\n"
|
|
|
|
|
"\n"
|
2011-04-02 02:55:55 +02:00
|
|
|
" git push %s HEAD:<name-of-remote-branch>\n"),
|
2011-03-02 21:12:10 +01:00
|
|
|
remote->name);
|
push: error out when the "upstream" semantics does not make sense
The user can say "git push" without specifying any refspec. When using
the "upstream" semantics via the push.default configuration, the user
wants to update the "upstream" branch of the current branch, which is the
branch at a remote repository the current branch is set to integrate with,
with this command.
However, there are cases that such a "git push" that uses the "upstream"
semantics does not make sense:
- The current branch does not have branch.$name.remote configured. By
definition, "git push" that does not name where to push to will not
know where to push to. The user may explicitly say "git push $there",
but again, by definition, no branch at repository $there is set to
integrate with the current branch in this case and we wouldn't know
which remote branch to update.
- The current branch does have branch.$name.remote configured, but it
does not specify branch.$name.merge that names what branch at the
remote this branch integrates with. "git push" knows where to push in
this case (or the user may explicitly say "git push $remote" to tell us
where to push), but we do not know which remote branch to update.
- The current branch does have its remote and upstream branch configured,
but the user said "git push $there", where $there is not the remote
named by "branch.$name.remote". By definition, no branch at repository
$there is set to integrate with the current branch in this case, and
this push is not meant to update any branch at the remote repository
$there.
The first two cases were already checked correctly, but the third case was
not checked and we ended up updating the branch named branch.$name.merge
at repository $there, which was totally bogus.
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2012-03-31 01:07:12 +02:00
|
|
|
if (!branch->merge_nr || !branch->merge || !branch->remote_name)
|
2011-04-02 02:55:55 +02:00
|
|
|
die(_("The current branch %s has no upstream branch.\n"
|
2011-03-02 21:12:10 +01:00
|
|
|
"To push the current branch and set the remote as upstream, use\n"
|
|
|
|
|
"\n"
|
2011-04-02 02:55:55 +02:00
|
|
|
" git push --set-upstream %s %s\n"),
|
2011-03-02 21:12:10 +01:00
|
|
|
branch->name,
|
|
|
|
|
remote->name,
|
2009-03-16 16:42:51 +01:00
|
|
|
branch->name);
|
|
|
|
|
if (branch->merge_nr != 1)
|
2011-04-02 02:55:55 +02:00
|
|
|
die(_("The current branch %s has multiple upstream branches, "
|
2011-02-23 00:42:11 +01:00
|
|
|
"refusing to push."), branch->name);
|
push: error out when the "upstream" semantics does not make sense
The user can say "git push" without specifying any refspec. When using
the "upstream" semantics via the push.default configuration, the user
wants to update the "upstream" branch of the current branch, which is the
branch at a remote repository the current branch is set to integrate with,
with this command.
However, there are cases that such a "git push" that uses the "upstream"
semantics does not make sense:
- The current branch does not have branch.$name.remote configured. By
definition, "git push" that does not name where to push to will not
know where to push to. The user may explicitly say "git push $there",
but again, by definition, no branch at repository $there is set to
integrate with the current branch in this case and we wouldn't know
which remote branch to update.
- The current branch does have branch.$name.remote configured, but it
does not specify branch.$name.merge that names what branch at the
remote this branch integrates with. "git push" knows where to push in
this case (or the user may explicitly say "git push $remote" to tell us
where to push), but we do not know which remote branch to update.
- The current branch does have its remote and upstream branch configured,
but the user said "git push $there", where $there is not the remote
named by "branch.$name.remote". By definition, no branch at repository
$there is set to integrate with the current branch in this case, and
this push is not meant to update any branch at the remote repository
$there.
The first two cases were already checked correctly, but the third case was
not checked and we ended up updating the branch named branch.$name.merge
at repository $there, which was totally bogus.
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2012-03-31 01:07:12 +02:00
|
|
|
if (strcmp(branch->remote_name, remote->name))
|
|
|
|
|
die(_("You are pushing to remote '%s', which is not the upstream of\n"
|
|
|
|
|
"your current branch '%s', without telling me what to push\n"
|
|
|
|
|
"to update which remote branch."),
|
|
|
|
|
remote->name, branch->name);
|
|
|
|
|
|
2009-03-16 16:42:51 +01:00
|
|
|
strbuf_addf(&refspec, "%s:%s", branch->name, branch->merge[0]->src);
|
|
|
|
|
add_refspec(refspec.buf);
|
|
|
|
|
}
|
|
|
|
|
|
2011-03-02 21:12:10 +01:00
|
|
|
static void setup_default_push_refspecs(struct remote *remote)
|
2009-03-16 16:42:51 +01:00
|
|
|
{
|
|
|
|
|
switch (push_default) {
|
2009-07-19 02:19:47 +02:00
|
|
|
default:
|
2009-03-16 16:42:51 +01:00
|
|
|
case PUSH_DEFAULT_MATCHING:
|
|
|
|
|
add_refspec(":");
|
|
|
|
|
break;
|
|
|
|
|
|
2011-02-16 01:54:24 +01:00
|
|
|
case PUSH_DEFAULT_UPSTREAM:
|
2011-03-02 21:12:10 +01:00
|
|
|
setup_push_upstream(remote);
|
2009-03-16 16:42:51 +01:00
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case PUSH_DEFAULT_CURRENT:
|
|
|
|
|
add_refspec("HEAD");
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case PUSH_DEFAULT_NOTHING:
|
2011-02-23 00:42:11 +01:00
|
|
|
die(_("You didn't specify any refspecs to push, and "
|
|
|
|
|
"push.default is \"nothing\"."));
|
2009-03-16 16:42:51 +01:00
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2009-11-18 02:42:22 +01:00
|
|
|
static int push_with_options(struct transport *transport, int flags)
|
|
|
|
|
{
|
|
|
|
|
int err;
|
|
|
|
|
int nonfastforward;
|
2010-02-24 13:50:24 +01:00
|
|
|
|
2010-02-24 13:50:27 +01:00
|
|
|
transport_set_verbosity(transport, verbosity, progress);
|
2010-02-24 13:50:24 +01:00
|
|
|
|
2009-11-18 02:42:22 +01:00
|
|
|
if (receivepack)
|
|
|
|
|
transport_set_option(transport,
|
|
|
|
|
TRANS_OPT_RECEIVEPACK, receivepack);
|
|
|
|
|
if (thin)
|
|
|
|
|
transport_set_option(transport, TRANS_OPT_THIN, "yes");
|
|
|
|
|
|
2010-02-24 13:50:24 +01:00
|
|
|
if (verbosity > 0)
|
2011-02-23 00:42:11 +01:00
|
|
|
fprintf(stderr, _("Pushing to %s\n"), transport->url);
|
2009-11-18 02:42:22 +01:00
|
|
|
err = transport_push(transport, refspec_nr, refspec, flags,
|
|
|
|
|
&nonfastforward);
|
2009-12-04 00:31:44 +01:00
|
|
|
if (err != 0)
|
2011-02-23 00:42:11 +01:00
|
|
|
error(_("failed to push some refs to '%s'"), transport->url);
|
2009-12-04 00:31:44 +01:00
|
|
|
|
2009-11-18 02:42:22 +01:00
|
|
|
err |= transport_disconnect(transport);
|
|
|
|
|
|
|
|
|
|
if (!err)
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
if (nonfastforward && advice_push_nonfastforward) {
|
2011-02-23 00:42:12 +01:00
|
|
|
fprintf(stderr, _("To prevent you from losing history, non-fast-forward updates were rejected\n"
|
2010-08-02 15:42:44 +02:00
|
|
|
"Merge the remote changes (e.g. 'git pull') before pushing again. See the\n"
|
2011-02-23 00:42:12 +01:00
|
|
|
"'Note about fast-forwards' section of 'git push --help' for details.\n"));
|
2009-11-18 02:42:22 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return 1;
|
|
|
|
|
}
|
|
|
|
|
|
2007-09-11 05:03:04 +02:00
|
|
|
static int do_push(const char *repo, int flags)
|
git builtin "push"
This adds a builtin "push" command, which is largely just a C'ification of
the "git-push.sh" script.
Now, the reason I did it as a built-in is partly because it's yet another
step on relying less on shell, but it's actually mostly because I've
wanted to be able to push to _multiple_ repositories, and the most obvious
and simplest interface for that would seem be to just have a "remotes"
file that has multiple URL entries.
(For "pull", having multiple entries should either just select the first
one, or you could fall back on the others on failure - your choice).
And quite frankly, it just became too damn messy to do that in shell.
Besides, we actually have a fair amount of infrastructure in C, so it just
wasn't that hard to do.
Of course, this is almost totally untested. It probably doesn't work for
anything but the one trial I threw at it. "Simple" doesn't necessarily
mean "obviously correct".
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-04-30 06:22:49 +02:00
|
|
|
{
|
2007-05-12 17:45:53 +02:00
|
|
|
int i, errs;
|
|
|
|
|
struct remote *remote = remote_get(repo);
|
2009-06-09 18:01:34 +02:00
|
|
|
const char **url;
|
|
|
|
|
int url_nr;
|
git builtin "push"
This adds a builtin "push" command, which is largely just a C'ification of
the "git-push.sh" script.
Now, the reason I did it as a built-in is partly because it's yet another
step on relying less on shell, but it's actually mostly because I've
wanted to be able to push to _multiple_ repositories, and the most obvious
and simplest interface for that would seem be to just have a "remotes"
file that has multiple URL entries.
(For "pull", having multiple entries should either just select the first
one, or you could fall back on the others on failure - your choice).
And quite frankly, it just became too damn messy to do that in shell.
Besides, we actually have a fair amount of infrastructure in C, so it just
wasn't that hard to do.
Of course, this is almost totally untested. It probably doesn't work for
anything but the one trial I threw at it. "Simple" doesn't necessarily
mean "obviously correct".
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-04-30 06:22:49 +02: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 06:47:20 +01:00
|
|
|
if (!remote) {
|
|
|
|
|
if (repo)
|
2011-02-23 00:42:11 +01:00
|
|
|
die(_("bad repository '%s'"), repo);
|
2011-04-02 02:55:55 +02:00
|
|
|
die(_("No configured push destination.\n"
|
2011-03-02 21:12:11 +01:00
|
|
|
"Either specify the URL from the command-line or configure a remote repository using\n"
|
|
|
|
|
"\n"
|
|
|
|
|
" git remote add <name> <url>\n"
|
|
|
|
|
"\n"
|
|
|
|
|
"and then push using the remote name\n"
|
|
|
|
|
"\n"
|
2011-04-02 02:55:55 +02:00
|
|
|
" git push <name>\n"));
|
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 06:47:20 +01:00
|
|
|
}
|
git builtin "push"
This adds a builtin "push" command, which is largely just a C'ification of
the "git-push.sh" script.
Now, the reason I did it as a built-in is partly because it's yet another
step on relying less on shell, but it's actually mostly because I've
wanted to be able to push to _multiple_ repositories, and the most obvious
and simplest interface for that would seem be to just have a "remotes"
file that has multiple URL entries.
(For "pull", having multiple entries should either just select the first
one, or you could fall back on the others on failure - your choice).
And quite frankly, it just became too damn messy to do that in shell.
Besides, we actually have a fair amount of infrastructure in C, so it just
wasn't that hard to do.
Of course, this is almost totally untested. It probably doesn't work for
anything but the one trial I threw at it. "Simple" doesn't necessarily
mean "obviously correct".
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-04-30 06:22:49 +02:00
|
|
|
|
2008-04-17 13:17:20 +02:00
|
|
|
if (remote->mirror)
|
|
|
|
|
flags |= (TRANSPORT_PUSH_MIRROR|TRANSPORT_PUSH_FORCE);
|
|
|
|
|
|
2008-08-16 19:58:32 +02:00
|
|
|
if ((flags & TRANSPORT_PUSH_ALL) && refspec) {
|
|
|
|
|
if (!strcmp(*refspec, "refs/tags/*"))
|
2011-02-23 00:42:11 +01:00
|
|
|
return error(_("--all and --tags are incompatible"));
|
|
|
|
|
return error(_("--all can't be combined with refspecs"));
|
2008-08-16 19:58:32 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if ((flags & TRANSPORT_PUSH_MIRROR) && refspec) {
|
|
|
|
|
if (!strcmp(*refspec, "refs/tags/*"))
|
2011-02-23 00:42:11 +01:00
|
|
|
return error(_("--mirror and --tags are incompatible"));
|
|
|
|
|
return error(_("--mirror can't be combined with refspecs"));
|
2008-08-16 19:58:32 +02:00
|
|
|
}
|
2008-04-17 13:17:20 +02:00
|
|
|
|
|
|
|
|
if ((flags & (TRANSPORT_PUSH_ALL|TRANSPORT_PUSH_MIRROR)) ==
|
|
|
|
|
(TRANSPORT_PUSH_ALL|TRANSPORT_PUSH_MIRROR)) {
|
2011-02-23 00:42:11 +01:00
|
|
|
return error(_("--all and --mirror are incompatible"));
|
2008-04-17 13:17:20 +02:00
|
|
|
}
|
|
|
|
|
|
2009-03-16 16:42:51 +01:00
|
|
|
if (!refspec && !(flags & TRANSPORT_PUSH_ALL)) {
|
|
|
|
|
if (remote->push_refspec_nr) {
|
|
|
|
|
refspec = remote->push_refspec;
|
|
|
|
|
refspec_nr = remote->push_refspec_nr;
|
|
|
|
|
} else if (!(flags & TRANSPORT_PUSH_MIRROR))
|
2011-03-02 21:12:10 +01:00
|
|
|
setup_default_push_refspecs(remote);
|
2007-05-12 17:45:53 +02:00
|
|
|
}
|
2007-04-07 08:04:53 +02:00
|
|
|
errs = 0;
|
push: error out when the "upstream" semantics does not make sense
The user can say "git push" without specifying any refspec. When using
the "upstream" semantics via the push.default configuration, the user
wants to update the "upstream" branch of the current branch, which is the
branch at a remote repository the current branch is set to integrate with,
with this command.
However, there are cases that such a "git push" that uses the "upstream"
semantics does not make sense:
- The current branch does not have branch.$name.remote configured. By
definition, "git push" that does not name where to push to will not
know where to push to. The user may explicitly say "git push $there",
but again, by definition, no branch at repository $there is set to
integrate with the current branch in this case and we wouldn't know
which remote branch to update.
- The current branch does have branch.$name.remote configured, but it
does not specify branch.$name.merge that names what branch at the
remote this branch integrates with. "git push" knows where to push in
this case (or the user may explicitly say "git push $remote" to tell us
where to push), but we do not know which remote branch to update.
- The current branch does have its remote and upstream branch configured,
but the user said "git push $there", where $there is not the remote
named by "branch.$name.remote". By definition, no branch at repository
$there is set to integrate with the current branch in this case, and
this push is not meant to update any branch at the remote repository
$there.
The first two cases were already checked correctly, but the third case was
not checked and we ended up updating the branch named branch.$name.merge
at repository $there, which was totally bogus.
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2012-03-31 01:07:12 +02:00
|
|
|
url_nr = push_url_of_remote(remote, &url);
|
2009-11-18 02:42:22 +01:00
|
|
|
if (url_nr) {
|
|
|
|
|
for (i = 0; i < url_nr; i++) {
|
|
|
|
|
struct transport *transport =
|
|
|
|
|
transport_get(remote, url[i]);
|
|
|
|
|
if (push_with_options(transport, flags))
|
|
|
|
|
errs++;
|
2009-08-08 09:51:08 +02:00
|
|
|
}
|
2009-11-18 02:42:22 +01:00
|
|
|
} else {
|
|
|
|
|
struct transport *transport =
|
|
|
|
|
transport_get(remote, NULL);
|
|
|
|
|
|
|
|
|
|
if (push_with_options(transport, flags))
|
|
|
|
|
errs++;
|
git builtin "push"
This adds a builtin "push" command, which is largely just a C'ification of
the "git-push.sh" script.
Now, the reason I did it as a built-in is partly because it's yet another
step on relying less on shell, but it's actually mostly because I've
wanted to be able to push to _multiple_ repositories, and the most obvious
and simplest interface for that would seem be to just have a "remotes"
file that has multiple URL entries.
(For "pull", having multiple entries should either just select the first
one, or you could fall back on the others on failure - your choice).
And quite frankly, it just became too damn messy to do that in shell.
Besides, we actually have a fair amount of infrastructure in C, so it just
wasn't that hard to do.
Of course, this is almost totally untested. It probably doesn't work for
anything but the one trial I threw at it. "Simple" doesn't necessarily
mean "obviously correct".
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-04-30 06:22:49 +02:00
|
|
|
}
|
2007-04-07 08:04:53 +02:00
|
|
|
return !!errs;
|
git builtin "push"
This adds a builtin "push" command, which is largely just a C'ification of
the "git-push.sh" script.
Now, the reason I did it as a built-in is partly because it's yet another
step on relying less on shell, but it's actually mostly because I've
wanted to be able to push to _multiple_ repositories, and the most obvious
and simplest interface for that would seem be to just have a "remotes"
file that has multiple URL entries.
(For "pull", having multiple entries should either just select the first
one, or you could fall back on the others on failure - your choice).
And quite frankly, it just became too damn messy to do that in shell.
Besides, we actually have a fair amount of infrastructure in C, so it just
wasn't that hard to do.
Of course, this is almost totally untested. It probably doesn't work for
anything but the one trial I threw at it. "Simple" doesn't necessarily
mean "obviously correct".
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-04-30 06:22:49 +02:00
|
|
|
}
|
|
|
|
|
|
2011-08-20 00:08:47 +02:00
|
|
|
static int option_parse_recurse_submodules(const struct option *opt,
|
|
|
|
|
const char *arg, int unset)
|
|
|
|
|
{
|
|
|
|
|
int *flags = opt->value;
|
|
|
|
|
if (arg) {
|
|
|
|
|
if (!strcmp(arg, "check"))
|
|
|
|
|
*flags |= TRANSPORT_RECURSE_SUBMODULES_CHECK;
|
|
|
|
|
else
|
|
|
|
|
die("bad %s argument: %s", opt->long_name, arg);
|
|
|
|
|
} else
|
|
|
|
|
die("option %s needs an argument (check)", opt->long_name);
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2006-07-29 07:44:25 +02:00
|
|
|
int cmd_push(int argc, const char **argv, const char *prefix)
|
git builtin "push"
This adds a builtin "push" command, which is largely just a C'ification of
the "git-push.sh" script.
Now, the reason I did it as a built-in is partly because it's yet another
step on relying less on shell, but it's actually mostly because I've
wanted to be able to push to _multiple_ repositories, and the most obvious
and simplest interface for that would seem be to just have a "remotes"
file that has multiple URL entries.
(For "pull", having multiple entries should either just select the first
one, or you could fall back on the others on failure - your choice).
And quite frankly, it just became too damn messy to do that in shell.
Besides, we actually have a fair amount of infrastructure in C, so it just
wasn't that hard to do.
Of course, this is almost totally untested. It probably doesn't work for
anything but the one trial I threw at it. "Simple" doesn't necessarily
mean "obviously correct".
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-04-30 06:22:49 +02:00
|
|
|
{
|
2007-09-11 05:03:04 +02:00
|
|
|
int flags = 0;
|
2007-11-05 04:35:37 +01:00
|
|
|
int tags = 0;
|
2008-04-17 13:17:20 +02:00
|
|
|
int rc;
|
2007-05-12 17:45:53 +02:00
|
|
|
const char *repo = NULL; /* default repository */
|
2007-11-05 04:35:37 +01:00
|
|
|
struct option options[] = {
|
2010-02-24 13:50:24 +01:00
|
|
|
OPT__VERBOSITY(&verbosity),
|
2007-11-05 04:35:37 +01:00
|
|
|
OPT_STRING( 0 , "repo", &repo, "repository", "repository"),
|
2008-07-20 14:02:20 +02:00
|
|
|
OPT_BIT( 0 , "all", &flags, "push all refs", TRANSPORT_PUSH_ALL),
|
|
|
|
|
OPT_BIT( 0 , "mirror", &flags, "mirror all refs",
|
|
|
|
|
(TRANSPORT_PUSH_MIRROR|TRANSPORT_PUSH_FORCE)),
|
2009-12-30 20:57:42 +01:00
|
|
|
OPT_BOOLEAN( 0, "delete", &deleterefs, "delete refs"),
|
2009-10-30 16:04:53 +01:00
|
|
|
OPT_BOOLEAN( 0 , "tags", &tags, "push tags (can't be used with --all or --mirror)"),
|
2009-09-13 18:56:45 +02:00
|
|
|
OPT_BIT('n' , "dry-run", &flags, "dry run", TRANSPORT_PUSH_DRY_RUN),
|
2009-06-23 03:10:01 +02:00
|
|
|
OPT_BIT( 0, "porcelain", &flags, "machine-readable output", TRANSPORT_PUSH_PORCELAIN),
|
2008-07-20 14:02:20 +02:00
|
|
|
OPT_BIT('f', "force", &flags, "force updates", TRANSPORT_PUSH_FORCE),
|
2011-08-20 00:08:47 +02:00
|
|
|
{ OPTION_CALLBACK, 0, "recurse-submodules", &flags, "check",
|
|
|
|
|
"controls recursive pushing of submodules",
|
|
|
|
|
PARSE_OPT_OPTARG, option_parse_recurse_submodules },
|
2007-11-05 04:35:37 +01:00
|
|
|
OPT_BOOLEAN( 0 , "thin", &thin, "use thin pack"),
|
|
|
|
|
OPT_STRING( 0 , "receive-pack", &receivepack, "receive-pack", "receive pack program"),
|
|
|
|
|
OPT_STRING( 0 , "exec", &receivepack, "receive-pack", "receive pack program"),
|
2010-01-16 22:45:31 +01:00
|
|
|
OPT_BIT('u', "set-upstream", &flags, "set upstream for git pull/status",
|
|
|
|
|
TRANSPORT_PUSH_SET_UPSTREAM),
|
2012-02-13 21:17:15 +01:00
|
|
|
OPT_BOOL(0, "progress", &progress, "force progress reporting"),
|
2012-02-22 23:43:41 +01:00
|
|
|
OPT_BIT(0, "prune", &flags, "prune locally removed refs",
|
|
|
|
|
TRANSPORT_PUSH_PRUNE),
|
2007-11-05 04:35:37 +01:00
|
|
|
OPT_END()
|
|
|
|
|
};
|
git builtin "push"
This adds a builtin "push" command, which is largely just a C'ification of
the "git-push.sh" script.
Now, the reason I did it as a built-in is partly because it's yet another
step on relying less on shell, but it's actually mostly because I've
wanted to be able to push to _multiple_ repositories, and the most obvious
and simplest interface for that would seem be to just have a "remotes"
file that has multiple URL entries.
(For "pull", having multiple entries should either just select the first
one, or you could fall back on the others on failure - your choice).
And quite frankly, it just became too damn messy to do that in shell.
Besides, we actually have a fair amount of infrastructure in C, so it just
wasn't that hard to do.
Of course, this is almost totally untested. It probably doesn't work for
anything but the one trial I threw at it. "Simple" doesn't necessarily
mean "obviously correct".
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-04-30 06:22:49 +02:00
|
|
|
|
2011-02-24 15:30:19 +01:00
|
|
|
packet_trace_identity("push");
|
2009-10-25 20:15:22 +01:00
|
|
|
git_config(git_default_config, NULL);
|
2009-05-23 20:53:12 +02:00
|
|
|
argc = parse_options(argc, argv, prefix, options, push_usage, 0);
|
2007-11-05 04:35:37 +01:00
|
|
|
|
2009-12-30 20:57:42 +01:00
|
|
|
if (deleterefs && (tags || (flags & (TRANSPORT_PUSH_ALL | TRANSPORT_PUSH_MIRROR))))
|
2011-02-23 00:42:11 +01:00
|
|
|
die(_("--delete is incompatible with --all, --mirror and --tags"));
|
2009-12-30 20:57:42 +01:00
|
|
|
if (deleterefs && argc < 2)
|
2011-02-23 00:42:11 +01:00
|
|
|
die(_("--delete doesn't make sense without any refs"));
|
2009-12-30 20:57:42 +01:00
|
|
|
|
2007-11-05 04:35:37 +01:00
|
|
|
if (tags)
|
|
|
|
|
add_refspec("refs/tags/*");
|
|
|
|
|
|
|
|
|
|
if (argc > 0) {
|
|
|
|
|
repo = argv[0];
|
|
|
|
|
set_refspecs(argv + 1, argc - 1);
|
git builtin "push"
This adds a builtin "push" command, which is largely just a C'ification of
the "git-push.sh" script.
Now, the reason I did it as a built-in is partly because it's yet another
step on relying less on shell, but it's actually mostly because I've
wanted to be able to push to _multiple_ repositories, and the most obvious
and simplest interface for that would seem be to just have a "remotes"
file that has multiple URL entries.
(For "pull", having multiple entries should either just select the first
one, or you could fall back on the others on failure - your choice).
And quite frankly, it just became too damn messy to do that in shell.
Besides, we actually have a fair amount of infrastructure in C, so it just
wasn't that hard to do.
Of course, this is almost totally untested. It probably doesn't work for
anything but the one trial I threw at it. "Simple" doesn't necessarily
mean "obviously correct".
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-04-30 06:22:49 +02:00
|
|
|
}
|
2007-05-25 07:20:56 +02:00
|
|
|
|
2008-04-17 13:17:20 +02:00
|
|
|
rc = do_push(repo, flags);
|
|
|
|
|
if (rc == -1)
|
2007-11-10 00:32:25 +01:00
|
|
|
usage_with_options(push_usage, options);
|
2008-04-17 13:17:20 +02:00
|
|
|
else
|
|
|
|
|
return rc;
|
git builtin "push"
This adds a builtin "push" command, which is largely just a C'ification of
the "git-push.sh" script.
Now, the reason I did it as a built-in is partly because it's yet another
step on relying less on shell, but it's actually mostly because I've
wanted to be able to push to _multiple_ repositories, and the most obvious
and simplest interface for that would seem be to just have a "remotes"
file that has multiple URL entries.
(For "pull", having multiple entries should either just select the first
one, or you could fall back on the others on failure - your choice).
And quite frankly, it just became too damn messy to do that in shell.
Besides, we actually have a fair amount of infrastructure in C, so it just
wasn't that hard to do.
Of course, this is almost totally untested. It probably doesn't work for
anything but the one trial I threw at it. "Simple" doesn't necessarily
mean "obviously correct".
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-04-30 06:22:49 +02:00
|
|
|
}
|