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                         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
  71 static 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
  81 static 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
 118 static 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
 125 static 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
 159 static 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
 166 static char warn_unspecified_push_default_msg[] =
 167 N_("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
 181 static 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
 190 static 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
 196 static 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
 233 static 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
 239 static 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
 245 static 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
 251 static 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
 258 static const char message_advice_ref_already_exists[] =
 259         N_("Updates were rejected because the tag already exists in the remote.");
 260
 261 static 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
 266 static 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
 273 static 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
 280 static 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
 287 static 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
 294 static 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
 301 static 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
 308 static 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
 356 static 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
 422 static 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
 445 int 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 }