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
  30 static void add_refspec(const char *ref)
  31 {
  32         refspec_nr++;
  33         ALLOC_GROW(refspec, refspec_nr, refspec_alloc);
  34         refspec[refspec_nr-1] = ref;
  35 }
  36
  37 static void set_refspecs(const char **refs, int nr)
  38 {
  39         int i;
  40         for (i = 0; i < nr; i++) {
  41                 const char *ref = refs[i];
  42                 if (!strcmp("tag", ref)) {
  43                         char *tag;
  44                         int len;
  45                         if (nr <= ++i)
  46                                 die(_("tag shorthand without <tag>"));
  47                         len = strlen(refs[i]) + 11;
  48                         if (deleterefs) {
  49                                 tag = xmalloc(len+1);
  50                                 strcpy(tag, ":refs/tags/");
  51                         } else {
  52                                 tag = xmalloc(len);
  53                                 strcpy(tag, "refs/tags/");
  54                         }
  55                         strcat(tag, refs[i]);
  56                         ref = tag;
  57                 } else if (deleterefs && !strchr(ref, ':')) {
  58                         char *delref;
  59                         int len = strlen(ref)+1;
  60                         delref = xmalloc(len+1);
  61                         strcpy(delref, ":");
  62                         strcat(delref, ref);
  63                         ref = delref;
  64                 } else if (deleterefs)
  65                         die(_("--delete only accepts plain target ref names"));
  66                 add_refspec(ref);
  67         }
  68 }
  69
  70 static int push_url_of_remote(struct remote *remote, const char ***url_p)
  71 {
  72         if (remote->pushurl_nr) {
  73                 *url_p = remote->pushurl;
  74                 return remote->pushurl_nr;
  75         }
  76         *url_p = remote->url;
  77         return remote->url_nr;
  78 }
  79
  80 static NORETURN int die_push_simple(struct branch *branch, struct remote *remote) {
  81         /*
  82          * There's no point in using shorten_unambiguous_ref here,
  83          * as the ambiguity would be on the remote side, not what
  84          * we have locally. Plus, this is supposed to be the simple
  85          * mode. If the user is doing something crazy like setting
  86          * upstream to a non-branch, we should probably be showing
  87          * them the big ugly fully qualified ref.
  88          */
  89         const char *advice_maybe = "";
  90         const char *short_upstream =
  91                 skip_prefix(branch->merge[0]->src, "refs/heads/");
  92
  93         if (!short_upstream)
  94                 short_upstream = branch->merge[0]->src;
  95         /*
  96          * Don't show advice for people who explicitly set
  97          * push.default.
  98          */
  99         if (push_default == PUSH_DEFAULT_UNSPECIFIED)
 100                 advice_maybe = _("\n"
 101                                  "To choose either option permanently, "
 102                                  "see push.default in 'git help config'.");
 103         die(_("The upstream branch of your current branch does not match\n"
 104               "the name of your current branch.  To push to the upstream branch\n"
 105               "on the remote, use\n"
 106               "\n"
 107               "    git push %s HEAD:%s\n"
 108               "\n"
 109               "To push to the branch of the same name on the remote, use\n"
 110               "\n"
 111               "    git push %s %s\n"
 112               "%s"),
 113             remote->name, short_upstream,
 114             remote->name, branch->name, advice_maybe);
 115 }
 116
 117 static const char message_detached_head_die[] =
 118         N_("You are not currently on a branch.\n"
 119            "To push the history leading to the current (detached HEAD)\n"
 120            "state now, use\n"
 121            "\n"
 122            "    git push %s HEAD:<name-of-remote-branch>\n");
 123
 124 static void setup_push_upstream(struct remote *remote, struct branch *branch,
 125                                 int triangular)
 126 {
 127         struct strbuf refspec = STRBUF_INIT;
 128
 129         if (!branch)
 130                 die(_(message_detached_head_die), remote->name);
 131         if (!branch->merge_nr || !branch->merge || !branch->remote_name)
 132                 die(_("The current branch %s has no upstream branch.\n"
 133                     "To push the current branch and set the remote as upstream, use\n"
 134                     "\n"
 135                     "    git push --set-upstream %s %s\n"),
 136                     branch->name,
 137                     remote->name,
 138                     branch->name);
 139         if (branch->merge_nr != 1)
 140                 die(_("The current branch %s has multiple upstream branches, "
 141                     "refusing to push."), branch->name);
 142         if (triangular)
 143                 die(_("You are pushing to remote '%s', which is not the upstream of\n"
 144                       "your current branch '%s', without telling me what to push\n"
 145                       "to update which remote branch."),
 146                     remote->name, branch->name);
 147
 148         if (push_default == PUSH_DEFAULT_SIMPLE) {
 149                 /* Additional safety */
 150                 if (strcmp(branch->refname, branch->merge[0]->src))
 151                         die_push_simple(branch, remote);
 152         }
 153
 154         strbuf_addf(&refspec, "%s:%s", branch->name, branch->merge[0]->src);
 155         add_refspec(refspec.buf);
 156 }
 157
 158 static void setup_push_current(struct remote *remote, struct branch *branch)
 159 {
 160         if (!branch)
 161                 die(_(message_detached_head_die), remote->name);
 162         add_refspec(branch->name);
 163 }
 164
 165 static char warn_unspecified_push_default_msg[] =
 166 N_("push.default is unset; its implicit value has changed in\n"
 167    "Git 2.0 from 'matching' to 'simple'. To squelch this message\n"
 168    "and maintain the traditional behavior, use:\n"
 169    "\n"
 170    "  git config --global push.default matching\n"
 171    "\n"
 172    "To squelch this message and adopt the new behavior now, use:\n"
 173    "\n"
 174    "  git config --global push.default simple\n"
 175    "\n"
 176    "When push.default is set to 'matching', git will push local branches\n"
 177    "to the remote branches that already exist with the same name.\n"
 178    "\n"
 179    "Since Git 2.0, Git defaults to the more conservative 'simple'\n"
 180    "behavior, which only pushes the current branch to the corresponding\n"
 181    "remote branch that 'git pull' uses to update the current branch.\n"
 182    "\n"
 183    "See 'git help config' and search for 'push.default' for further information.\n"
 184    "(the 'simple' mode was introduced in Git 1.7.11. Use the similar mode\n"
 185    "'current' instead of 'simple' if you sometimes use older versions of Git)");
 186
 187 static void warn_unspecified_push_default_configuration(void)
 188 {
 189         static int warn_once;
 190
 191         if (warn_once++)
 192                 return;
 193         warning("%s\n", _(warn_unspecified_push_default_msg));
 194 }
 195
 196 static int is_workflow_triangular(struct remote *remote)
 197 {
 198         struct remote *fetch_remote = remote_get(NULL);
 199         return (fetch_remote && fetch_remote != remote);
 200 }
 201
 202 static void setup_default_push_refspecs(struct remote *remote)
 203 {
 204         struct branch *branch = branch_get(NULL);
 205         int triangular = is_workflow_triangular(remote);
 206
 207         switch (push_default) {
 208         default:
 209         case PUSH_DEFAULT_MATCHING:
 210                 add_refspec(":");
 211                 break;
 212
 213         case PUSH_DEFAULT_UNSPECIFIED:
 214                 warn_unspecified_push_default_configuration();
 215                 /* fallthru */
 216
 217         case PUSH_DEFAULT_SIMPLE:
 218                 if (triangular)
 219                         setup_push_current(remote, branch);
 220                 else
 221                         setup_push_upstream(remote, branch, triangular);
 222                 break;
 223
 224         case PUSH_DEFAULT_UPSTREAM:
 225                 setup_push_upstream(remote, branch, triangular);
 226                 break;
 227
 228         case PUSH_DEFAULT_CURRENT:
 229                 setup_push_current(remote, branch);
 230                 break;
 231
 232         case PUSH_DEFAULT_NOTHING:
 233                 die(_("You didn't specify any refspecs to push, and "
 234                     "push.default is \"nothing\"."));
 235                 break;
 236         }
 237 }
 238
 239 static const char message_advice_pull_before_push[] =
 240         N_("Updates were rejected because the tip of your current branch is behind\n"
 241            "its remote counterpart. Integrate the remote changes (e.g.\n"
 242            "'git pull ...') before pushing again.\n"
 243            "See the 'Note about fast-forwards' in 'git push --help' for details.");
 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_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                 advise_checkout_pull_push();
 335         } else if (reject_reasons & REJECT_ALREADY_EXISTS) {
 336                 advise_ref_already_exists();
 337         } else if (reject_reasons & REJECT_FETCH_FIRST) {
 338                 advise_ref_fetch_first();
 339         } else if (reject_reasons & REJECT_NEEDS_FORCE) {
 340                 advise_ref_needs_force();
 341         }
 342
 343         return 1;
 344 }
 345
 346 static int do_push(const char *repo, int flags)
 347 {
 348         int i, errs;
 349         struct remote *remote = pushremote_get(repo);
 350         const char **url;
 351         int url_nr;
 352
 353         if (!remote) {
 354                 if (repo)
 355                         die(_("bad repository '%s'"), repo);
 356                 die(_("No configured push destination.\n"
 357                     "Either specify the URL from the command-line or configure a remote repository using\n"
 358                     "\n"
 359                     "    git remote add <name> <url>\n"
 360                     "\n"
 361                     "and then push using the remote name\n"
 362                     "\n"
 363                     "    git push <name>\n"));
 364         }
 365
 366         if (remote->mirror)
 367                 flags |= (TRANSPORT_PUSH_MIRROR|TRANSPORT_PUSH_FORCE);
 368
 369         if ((flags & TRANSPORT_PUSH_ALL) && refspec) {
 370                 if (!strcmp(*refspec, "refs/tags/*"))
 371                         return error(_("--all and --tags are incompatible"));
 372                 return error(_("--all can't be combined with refspecs"));
 373         }
 374
 375         if ((flags & TRANSPORT_PUSH_MIRROR) && refspec) {
 376                 if (!strcmp(*refspec, "refs/tags/*"))
 377                         return error(_("--mirror and --tags are incompatible"));
 378                 return error(_("--mirror can't be combined with refspecs"));
 379         }
 380
 381         if ((flags & (TRANSPORT_PUSH_ALL|TRANSPORT_PUSH_MIRROR)) ==
 382                                 (TRANSPORT_PUSH_ALL|TRANSPORT_PUSH_MIRROR)) {
 383                 return error(_("--all and --mirror are incompatible"));
 384         }
 385
 386         if (!refspec && !(flags & TRANSPORT_PUSH_ALL)) {
 387                 if (remote->push_refspec_nr) {
 388                         refspec = remote->push_refspec;
 389                         refspec_nr = remote->push_refspec_nr;
 390                 } else if (!(flags & TRANSPORT_PUSH_MIRROR))
 391                         setup_default_push_refspecs(remote);
 392         }
 393         errs = 0;
 394         url_nr = push_url_of_remote(remote, &url);
 395         if (url_nr) {
 396                 for (i = 0; i < url_nr; i++) {
 397                         struct transport *transport =
 398                                 transport_get(remote, url[i]);
 399                         if (push_with_options(transport, flags))
 400                                 errs++;
 401                 }
 402         } else {
 403                 struct transport *transport =
 404                         transport_get(remote, NULL);
 405
 406                 if (push_with_options(transport, flags))
 407                         errs++;
 408         }
 409         return !!errs;
 410 }
 411
 412 static int option_parse_recurse_submodules(const struct option *opt,
 413                                    const char *arg, int unset)
 414 {
 415         int *flags = opt->value;
 416
 417         if (*flags & (TRANSPORT_RECURSE_SUBMODULES_CHECK |
 418                       TRANSPORT_RECURSE_SUBMODULES_ON_DEMAND))
 419                 die("%s can only be used once.", opt->long_name);
 420
 421         if (arg) {
 422                 if (!strcmp(arg, "check"))
 423                         *flags |= TRANSPORT_RECURSE_SUBMODULES_CHECK;
 424                 else if (!strcmp(arg, "on-demand"))
 425                         *flags |= TRANSPORT_RECURSE_SUBMODULES_ON_DEMAND;
 426                 else
 427                         die("bad %s argument: %s", opt->long_name, arg);
 428         } else
 429                 die("option %s needs an argument (check|on-demand)",
 430                                 opt->long_name);
 431
 432         return 0;
 433 }
 434
 435 int cmd_push(int argc, const char **argv, const char *prefix)
 436 {
 437         int flags = 0;
 438         int tags = 0;
 439         int rc;
 440         const char *repo = NULL;        /* default repository */
 441         struct option options[] = {
 442                 OPT__VERBOSITY(&verbosity),
 443                 OPT_STRING( 0 , "repo", &repo, N_("repository"), N_("repository")),
 444                 OPT_BIT( 0 , "all", &flags, N_("push all refs"), TRANSPORT_PUSH_ALL),
 445                 OPT_BIT( 0 , "mirror", &flags, N_("mirror all refs"),
 446                             (TRANSPORT_PUSH_MIRROR|TRANSPORT_PUSH_FORCE)),
 447                 OPT_BOOL( 0, "delete", &deleterefs, N_("delete refs")),
 448                 OPT_BOOL( 0 , "tags", &tags, N_("push tags (can't be used with --all or --mirror)")),
 449                 OPT_BIT('n' , "dry-run", &flags, N_("dry run"), TRANSPORT_PUSH_DRY_RUN),
 450                 OPT_BIT( 0,  "porcelain", &flags, N_("machine-readable output"), TRANSPORT_PUSH_PORCELAIN),
 451                 OPT_BIT('f', "force", &flags, N_("force updates"), TRANSPORT_PUSH_FORCE),
 452                 { OPTION_CALLBACK,
 453                   0, CAS_OPT_NAME, &cas, N_("refname>:<expect"),
 454                   N_("require old value of ref to be at this value"),
 455                   PARSE_OPT_OPTARG, parseopt_push_cas_option },
 456                 { OPTION_CALLBACK, 0, "recurse-submodules", &flags, N_("check"),
 457                         N_("control recursive pushing of submodules"),
 458                         PARSE_OPT_OPTARG, option_parse_recurse_submodules },
 459                 OPT_BOOL( 0 , "thin", &thin, N_("use thin pack")),
 460                 OPT_STRING( 0 , "receive-pack", &receivepack, "receive-pack", N_("receive pack program")),
 461                 OPT_STRING( 0 , "exec", &receivepack, "receive-pack", N_("receive pack program")),
 462                 OPT_BIT('u', "set-upstream", &flags, N_("set upstream for git pull/status"),
 463                         TRANSPORT_PUSH_SET_UPSTREAM),
 464                 OPT_BOOL(0, "progress", &progress, N_("force progress reporting")),
 465                 OPT_BIT(0, "prune", &flags, N_("prune locally removed refs"),
 466                         TRANSPORT_PUSH_PRUNE),
 467                 OPT_BIT(0, "no-verify", &flags, N_("bypass pre-push hook"), TRANSPORT_PUSH_NO_HOOK),
 468                 OPT_BIT(0, "follow-tags", &flags, N_("push missing but relevant tags"),
 469                         TRANSPORT_PUSH_FOLLOW_TAGS),
 470                 OPT_END()
 471         };
 472
 473         packet_trace_identity("push");
 474         git_config(git_default_config, NULL);
 475         argc = parse_options(argc, argv, prefix, options, push_usage, 0);
 476
 477         if (deleterefs && (tags || (flags & (TRANSPORT_PUSH_ALL | TRANSPORT_PUSH_MIRROR))))
 478                 die(_("--delete is incompatible with --all, --mirror and --tags"));
 479         if (deleterefs && argc < 2)
 480                 die(_("--delete doesn't make sense without any refs"));
 481
 482         if (tags)
 483                 add_refspec("refs/tags/*");
 484
 485         if (argc > 0) {
 486                 repo = argv[0];
 487                 set_refspecs(argv + 1, argc - 1);
 488         }
 489
 490         rc = do_push(repo, flags);
 491         if (rc == -1)
 492                 usage_with_options(push_usage, options);
 493         else
 494                 return rc;
 495 }