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