builtin/push.c

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