Andrew's git / gitweb.git / builtin/push.c
?
builtin / push.con commit rev-list: disable object/refname ambiguity check with --stdin (4c30d50)
   1/*
   2 * "git push"
   3 */
   4#include "cache.h"
   5#include "refs.h"
   6#include "run-command.h"
   7#include "builtin.h"
   8#include "remote.h"
   9#include "transport.h"
  10#include "parse-options.h"
  11#include "submodule.h"
  12
  13static const char * const push_usage[] = {
  14        N_("git push [<options>] [<repository> [<refspec>...]]"),
  15        NULL,
  16};
  17
  18static int thin = 1;
  19static int deleterefs;
  20static const char *receivepack;
  21static int verbosity;
  22static int progress = -1;
  23
  24static struct push_cas_option cas;
  25
  26static const char **refspec;
  27static int refspec_nr;
  28static int refspec_alloc;
  29static int default_matching_used;
  30
  31static void add_refspec(const char *ref)
  32{
  33        refspec_nr++;
  34        ALLOC_GROW(refspec, refspec_nr, refspec_alloc);
  35        refspec[refspec_nr-1] = ref;
  36}
  37
  38static void set_refspecs(const char **refs, int nr)
  39{
  40        int i;
  41        for (i = 0; i < nr; i++) {
  42                const char *ref = refs[i];
  43                if (!strcmp("tag", ref)) {
  44                        char *tag;
  45                        int len;
  46                        if (nr <= ++i)
  47                                die(_("tag shorthand without <tag>"));
  48                        len = strlen(refs[i]) + 11;
  49                        if (deleterefs) {
  50                                tag = xmalloc(len+1);
  51                                strcpy(tag, ":refs/tags/");
  52                        } else {
  53                                tag = xmalloc(len);
  54                                strcpy(tag, "refs/tags/");
  55                        }
  56                        strcat(tag, refs[i]);
  57                        ref = tag;
  58                } else if (deleterefs && !strchr(ref, ':')) {
  59                        char *delref;
  60                        int len = strlen(ref)+1;
  61                        delref = xmalloc(len+1);
  62                        strcpy(delref, ":");
  63                        strcat(delref, ref);
  64                        ref = delref;
  65                } else if (deleterefs)
  66                        die(_("--delete only accepts plain target ref names"));
  67                add_refspec(ref);
  68        }
  69}
  70
  71static int push_url_of_remote(struct remote *remote, const char ***url_p)
  72{
  73        if (remote->pushurl_nr) {
  74                *url_p = remote->pushurl;
  75                return remote->pushurl_nr;
  76        }
  77        *url_p = remote->url;
  78        return remote->url_nr;
  79}
  80
  81static NORETURN int die_push_simple(struct branch *branch, struct remote *remote) {
  82        /*
  83         * There's no point in using shorten_unambiguous_ref here,
  84         * as the ambiguity would be on the remote side, not what
  85         * we have locally. Plus, this is supposed to be the simple
  86         * mode. If the user is doing something crazy like setting
  87         * upstream to a non-branch, we should probably be showing
  88         * them the big ugly fully qualified ref.
  89         */
  90        const char *advice_maybe = "";
  91        const char *short_upstream =
  92                skip_prefix(branch->merge[0]->src, "refs/heads/");
  93
  94        if (!short_upstream)
  95                short_upstream = branch->merge[0]->src;
  96        /*
  97         * Don't show advice for people who explicitly set
  98         * push.default.
  99         */
 100        if (push_default == PUSH_DEFAULT_UNSPECIFIED)
 101                advice_maybe = _("\n"
 102                                 "To choose either option permanently, "
 103                                 "see push.default in 'git help config'.");
 104        die(_("The upstream branch of your current branch does not match\n"
 105              "the name of your current branch.  To push to the upstream branch\n"
 106              "on the remote, use\n"
 107              "\n"
 108              "    git push %s HEAD:%s\n"
 109              "\n"
 110              "To push to the branch of the same name on the remote, use\n"
 111              "\n"
 112              "    git push %s %s\n"
 113              "%s"),
 114            remote->name, short_upstream,
 115            remote->name, branch->name, advice_maybe);
 116}
 117
 118static const char message_detached_head_die[] =
 119        N_("You are not currently on a branch.\n"
 120           "To push the history leading to the current (detached HEAD)\n"
 121           "state now, use\n"
 122           "\n"
 123           "    git push %s HEAD:<name-of-remote-branch>\n");
 124
 125static void setup_push_upstream(struct remote *remote, struct branch *branch,
 126                                int triangular)
 127{
 128        struct strbuf refspec = STRBUF_INIT;
 129
 130        if (!branch)
 131                die(_(message_detached_head_die), remote->name);
 132        if (!branch->merge_nr || !branch->merge || !branch->remote_name)
 133                die(_("The current branch %s has no upstream branch.\n"
 134                    "To push the current branch and set the remote as upstream, use\n"
 135                    "\n"
 136                    "    git push --set-upstream %s %s\n"),
 137                    branch->name,
 138                    remote->name,
 139                    branch->name);
 140        if (branch->merge_nr != 1)
 141                die(_("The current branch %s has multiple upstream branches, "
 142                    "refusing to push."), branch->name);
 143        if (triangular)
 144                die(_("You are pushing to remote '%s', which is not the upstream of\n"
 145                      "your current branch '%s', without telling me what to push\n"
 146                      "to update which remote branch."),
 147                    remote->name, branch->name);
 148
 149        if (push_default == PUSH_DEFAULT_SIMPLE) {
 150                /* Additional safety */
 151                if (strcmp(branch->refname, branch->merge[0]->src))
 152                        die_push_simple(branch, remote);
 153        }
 154
 155        strbuf_addf(&refspec, "%s:%s", branch->name, branch->merge[0]->src);
 156        add_refspec(refspec.buf);
 157}
 158
 159static void setup_push_current(struct remote *remote, struct branch *branch)
 160{
 161        if (!branch)
 162                die(_(message_detached_head_die), remote->name);
 163        add_refspec(branch->name);
 164}
 165
 166static char warn_unspecified_push_default_msg[] =
 167N_("push.default is unset; its implicit value is changing in\n"
 168   "Git 2.0 from 'matching' to 'simple'. To squelch this message\n"
 169   "and maintain the current behavior after the default changes, use:\n"
 170   "\n"
 171   "  git config --global push.default matching\n"
 172   "\n"
 173   "To squelch this message and adopt the new behavior now, use:\n"
 174   "\n"
 175   "  git config --global push.default simple\n"
 176   "\n"
 177   "See 'git help config' and search for 'push.default' for further information.\n"
 178   "(the 'simple' mode was introduced in Git 1.7.11. Use the similar mode\n"
 179   "'current' instead of 'simple' if you sometimes use older versions of Git)");
 180
 181static void warn_unspecified_push_default_configuration(void)
 182{
 183        static int warn_once;
 184
 185        if (warn_once++)
 186                return;
 187        warning("%s\n", _(warn_unspecified_push_default_msg));
 188}
 189
 190static int is_workflow_triangular(struct remote *remote)
 191{
 192        struct remote *fetch_remote = remote_get(NULL);
 193        return (fetch_remote && fetch_remote != remote);
 194}
 195
 196static void setup_default_push_refspecs(struct remote *remote)
 197{
 198        struct branch *branch = branch_get(NULL);
 199        int triangular = is_workflow_triangular(remote);
 200
 201        switch (push_default) {
 202        default:
 203        case PUSH_DEFAULT_UNSPECIFIED:
 204                default_matching_used = 1;
 205                warn_unspecified_push_default_configuration();
 206                /* fallthru */
 207        case PUSH_DEFAULT_MATCHING:
 208                add_refspec(":");
 209                break;
 210
 211        case PUSH_DEFAULT_SIMPLE:
 212                if (triangular)
 213                        setup_push_current(remote, branch);
 214                else
 215                        setup_push_upstream(remote, branch, triangular);
 216                break;
 217
 218        case PUSH_DEFAULT_UPSTREAM:
 219                setup_push_upstream(remote, branch, triangular);
 220                break;
 221
 222        case PUSH_DEFAULT_CURRENT:
 223                setup_push_current(remote, branch);
 224                break;
 225
 226        case PUSH_DEFAULT_NOTHING:
 227                die(_("You didn't specify any refspecs to push, and "
 228                    "push.default is \"nothing\"."));
 229                break;
 230        }
 231}
 232
 233static const char message_advice_pull_before_push[] =
 234        N_("Updates were rejected because the tip of your current branch is behind\n"
 235           "its remote counterpart. Integrate the remote changes (e.g.\n"
 236           "'git pull ...') before pushing again.\n"
 237           "See the 'Note about fast-forwards' in 'git push --help' for details.");
 238
 239static const char message_advice_use_upstream[] =
 240        N_("Updates were rejected because a pushed branch tip is behind its remote\n"
 241           "counterpart. If you did not intend to push that branch, you may want to\n"
 242           "specify branches to push or set the 'push.default' configuration variable\n"
 243           "to 'simple', 'current' or 'upstream' to push only the current branch.");
 244
 245static const char message_advice_checkout_pull_push[] =
 246        N_("Updates were rejected because a pushed branch tip is behind its remote\n"
 247           "counterpart. Check out this branch and integrate the remote changes\n"
 248           "(e.g. 'git pull ...') before pushing again.\n"
 249           "See the 'Note about fast-forwards' in 'git push --help' for details.");
 250
 251static const char message_advice_ref_fetch_first[] =
 252        N_("Updates were rejected because the remote contains work that you do\n"
 253           "not have locally. This is usually caused by another repository pushing\n"
 254           "to the same ref. You may want to first integrate the remote changes\n"
 255           "(e.g., 'git pull ...') before pushing again.\n"
 256           "See the 'Note about fast-forwards' in 'git push --help' for details.");
 257
 258static const char message_advice_ref_already_exists[] =
 259        N_("Updates were rejected because the tag already exists in the remote.");
 260
 261static const char message_advice_ref_needs_force[] =
 262        N_("You cannot update a remote ref that points at a non-commit object,\n"
 263           "or update a remote ref to make it point at a non-commit object,\n"
 264           "without using the '--force' option.\n");
 265
 266static void advise_pull_before_push(void)
 267{
 268        if (!advice_push_non_ff_current || !advice_push_update_rejected)
 269                return;
 270        advise(_(message_advice_pull_before_push));
 271}
 272
 273static void advise_use_upstream(void)
 274{
 275        if (!advice_push_non_ff_default || !advice_push_update_rejected)
 276                return;
 277        advise(_(message_advice_use_upstream));
 278}
 279
 280static void advise_checkout_pull_push(void)
 281{
 282        if (!advice_push_non_ff_matching || !advice_push_update_rejected)
 283                return;
 284        advise(_(message_advice_checkout_pull_push));
 285}
 286
 287static void advise_ref_already_exists(void)
 288{
 289        if (!advice_push_already_exists || !advice_push_update_rejected)
 290                return;
 291        advise(_(message_advice_ref_already_exists));
 292}
 293
 294static void advise_ref_fetch_first(void)
 295{
 296        if (!advice_push_fetch_first || !advice_push_update_rejected)
 297                return;
 298        advise(_(message_advice_ref_fetch_first));
 299}
 300
 301static void advise_ref_needs_force(void)
 302{
 303        if (!advice_push_needs_force || !advice_push_update_rejected)
 304                return;
 305        advise(_(message_advice_ref_needs_force));
 306}
 307
 308static int push_with_options(struct transport *transport, int flags)
 309{
 310        int err;
 311        unsigned int reject_reasons;
 312
 313        transport_set_verbosity(transport, verbosity, progress);
 314
 315        if (receivepack)
 316                transport_set_option(transport,
 317                                     TRANS_OPT_RECEIVEPACK, receivepack);
 318        transport_set_option(transport, TRANS_OPT_THIN, thin ? "yes" : NULL);
 319
 320        if (!is_empty_cas(&cas)) {
 321                if (!transport->smart_options)
 322                        die("underlying transport does not support --%s option",
 323                            CAS_OPT_NAME);
 324                transport->smart_options->cas = &cas;
 325        }
 326
 327        if (verbosity > 0)
 328                fprintf(stderr, _("Pushing to %s\n"), transport->url);
 329        err = transport_push(transport, refspec_nr, refspec, flags,
 330                             &reject_reasons);
 331        if (err != 0)
 332                error(_("failed to push some refs to '%s'"), transport->url);
 333
 334        err |= transport_disconnect(transport);
 335        if (!err)
 336                return 0;
 337
 338        if (reject_reasons & REJECT_NON_FF_HEAD) {
 339                advise_pull_before_push();
 340        } else if (reject_reasons & REJECT_NON_FF_OTHER) {
 341                if (default_matching_used)
 342                        advise_use_upstream();
 343                else
 344                        advise_checkout_pull_push();
 345        } else if (reject_reasons & REJECT_ALREADY_EXISTS) {
 346                advise_ref_already_exists();
 347        } else if (reject_reasons & REJECT_FETCH_FIRST) {
 348                advise_ref_fetch_first();
 349        } else if (reject_reasons & REJECT_NEEDS_FORCE) {
 350                advise_ref_needs_force();
 351        }
 352
 353        return 1;
 354}
 355
 356static int do_push(const char *repo, int flags)
 357{
 358        int i, errs;
 359        struct remote *remote = pushremote_get(repo);
 360        const char **url;
 361        int url_nr;
 362
 363        if (!remote) {
 364                if (repo)
 365                        die(_("bad repository '%s'"), repo);
 366                die(_("No configured push destination.\n"
 367                    "Either specify the URL from the command-line or configure a remote repository using\n"
 368                    "\n"
 369                    "    git remote add <name> <url>\n"
 370                    "\n"
 371                    "and then push using the remote name\n"
 372                    "\n"
 373                    "    git push <name>\n"));
 374        }
 375
 376        if (remote->mirror)
 377                flags |= (TRANSPORT_PUSH_MIRROR|TRANSPORT_PUSH_FORCE);
 378
 379        if ((flags & TRANSPORT_PUSH_ALL) && refspec) {
 380                if (!strcmp(*refspec, "refs/tags/*"))
 381                        return error(_("--all and --tags are incompatible"));
 382                return error(_("--all can't be combined with refspecs"));
 383        }
 384
 385        if ((flags & TRANSPORT_PUSH_MIRROR) && refspec) {
 386                if (!strcmp(*refspec, "refs/tags/*"))
 387                        return error(_("--mirror and --tags are incompatible"));
 388                return error(_("--mirror can't be combined with refspecs"));
 389        }
 390
 391        if ((flags & (TRANSPORT_PUSH_ALL|TRANSPORT_PUSH_MIRROR)) ==
 392                                (TRANSPORT_PUSH_ALL|TRANSPORT_PUSH_MIRROR)) {
 393                return error(_("--all and --mirror are incompatible"));
 394        }
 395
 396        if (!refspec && !(flags & TRANSPORT_PUSH_ALL)) {
 397                if (remote->push_refspec_nr) {
 398                        refspec = remote->push_refspec;
 399                        refspec_nr = remote->push_refspec_nr;
 400                } else if (!(flags & TRANSPORT_PUSH_MIRROR))
 401                        setup_default_push_refspecs(remote);
 402        }
 403        errs = 0;
 404        url_nr = push_url_of_remote(remote, &url);
 405        if (url_nr) {
 406                for (i = 0; i < url_nr; i++) {
 407                        struct transport *transport =
 408                                transport_get(remote, url[i]);
 409                        if (push_with_options(transport, flags))
 410                                errs++;
 411                }
 412        } else {
 413                struct transport *transport =
 414                        transport_get(remote, NULL);
 415
 416                if (push_with_options(transport, flags))
 417                        errs++;
 418        }
 419        return !!errs;
 420}
 421
 422static int option_parse_recurse_submodules(const struct option *opt,
 423                                   const char *arg, int unset)
 424{
 425        int *flags = opt->value;
 426
 427        if (*flags & (TRANSPORT_RECURSE_SUBMODULES_CHECK |
 428                      TRANSPORT_RECURSE_SUBMODULES_ON_DEMAND))
 429                die("%s can only be used once.", opt->long_name);
 430
 431        if (arg) {
 432                if (!strcmp(arg, "check"))
 433                        *flags |= TRANSPORT_RECURSE_SUBMODULES_CHECK;
 434                else if (!strcmp(arg, "on-demand"))
 435                        *flags |= TRANSPORT_RECURSE_SUBMODULES_ON_DEMAND;
 436                else
 437                        die("bad %s argument: %s", opt->long_name, arg);
 438        } else
 439                die("option %s needs an argument (check|on-demand)",
 440                                opt->long_name);
 441
 442        return 0;
 443}
 444
 445int cmd_push(int argc, const char **argv, const char *prefix)
 446{
 447        int flags = 0;
 448        int tags = 0;
 449        int rc;
 450        const char *repo = NULL;        /* default repository */
 451        struct option options[] = {
 452                OPT__VERBOSITY(&verbosity),
 453                OPT_STRING( 0 , "repo", &repo, N_("repository"), N_("repository")),
 454                OPT_BIT( 0 , "all", &flags, N_("push all refs"), TRANSPORT_PUSH_ALL),
 455                OPT_BIT( 0 , "mirror", &flags, N_("mirror all refs"),
 456                            (TRANSPORT_PUSH_MIRROR|TRANSPORT_PUSH_FORCE)),
 457                OPT_BOOL( 0, "delete", &deleterefs, N_("delete refs")),
 458                OPT_BOOL( 0 , "tags", &tags, N_("push tags (can't be used with --all or --mirror)")),
 459                OPT_BIT('n' , "dry-run", &flags, N_("dry run"), TRANSPORT_PUSH_DRY_RUN),
 460                OPT_BIT( 0,  "porcelain", &flags, N_("machine-readable output"), TRANSPORT_PUSH_PORCELAIN),
 461                OPT_BIT('f', "force", &flags, N_("force updates"), TRANSPORT_PUSH_FORCE),
 462                { OPTION_CALLBACK,
 463                  0, CAS_OPT_NAME, &cas, N_("refname>:<expect"),
 464                  N_("require old value of ref to be at this value"),
 465                  PARSE_OPT_OPTARG, parseopt_push_cas_option },
 466                { OPTION_CALLBACK, 0, "recurse-submodules", &flags, N_("check"),
 467                        N_("control recursive pushing of submodules"),
 468                        PARSE_OPT_OPTARG, option_parse_recurse_submodules },
 469                OPT_BOOL( 0 , "thin", &thin, N_("use thin pack")),
 470                OPT_STRING( 0 , "receive-pack", &receivepack, "receive-pack", N_("receive pack program")),
 471                OPT_STRING( 0 , "exec", &receivepack, "receive-pack", N_("receive pack program")),
 472                OPT_BIT('u', "set-upstream", &flags, N_("set upstream for git pull/status"),
 473                        TRANSPORT_PUSH_SET_UPSTREAM),
 474                OPT_BOOL(0, "progress", &progress, N_("force progress reporting")),
 475                OPT_BIT(0, "prune", &flags, N_("prune locally removed refs"),
 476                        TRANSPORT_PUSH_PRUNE),
 477                OPT_BIT(0, "no-verify", &flags, N_("bypass pre-push hook"), TRANSPORT_PUSH_NO_HOOK),
 478                OPT_BIT(0, "follow-tags", &flags, N_("push missing but relevant tags"),
 479                        TRANSPORT_PUSH_FOLLOW_TAGS),
 480                OPT_END()
 481        };
 482
 483        packet_trace_identity("push");
 484        git_config(git_default_config, NULL);
 485        argc = parse_options(argc, argv, prefix, options, push_usage, 0);
 486
 487        if (deleterefs && (tags || (flags & (TRANSPORT_PUSH_ALL | TRANSPORT_PUSH_MIRROR))))
 488                die(_("--delete is incompatible with --all, --mirror and --tags"));
 489        if (deleterefs && argc < 2)
 490                die(_("--delete doesn't make sense without any refs"));
 491
 492        if (tags)
 493                add_refspec("refs/tags/*");
 494
 495        if (argc > 0) {
 496                repo = argv[0];
 497                set_refspecs(argv + 1, argc - 1);
 498        }
 499
 500        rc = do_push(repo, flags);
 501        if (rc == -1)
 502                usage_with_options(push_usage, options);
 503        else
 504                return rc;
 505}