Andrew's git / gitweb.git / builtin/push.c
?
builtin / push.con commit Merge branch 'jc/push-cas' (2233ad4)
   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;
  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        if (thin)
 319                transport_set_option(transport, TRANS_OPT_THIN, "yes");
 320
 321        if (!is_empty_cas(&cas)) {
 322                if (!transport->smart_options)
 323                        die("underlying transport does not support --%s option",
 324                            CAS_OPT_NAME);
 325                transport->smart_options->cas = &cas;
 326        }
 327
 328        if (verbosity > 0)
 329                fprintf(stderr, _("Pushing to %s\n"), transport->url);
 330        err = transport_push(transport, refspec_nr, refspec, flags,
 331                             &reject_reasons);
 332        if (err != 0)
 333                error(_("failed to push some refs to '%s'"), transport->url);
 334
 335        err |= transport_disconnect(transport);
 336        if (!err)
 337                return 0;
 338
 339        if (reject_reasons & REJECT_NON_FF_HEAD) {
 340                advise_pull_before_push();
 341        } else if (reject_reasons & REJECT_NON_FF_OTHER) {
 342                if (default_matching_used)
 343                        advise_use_upstream();
 344                else
 345                        advise_checkout_pull_push();
 346        } else if (reject_reasons & REJECT_ALREADY_EXISTS) {
 347                advise_ref_already_exists();
 348        } else if (reject_reasons & REJECT_FETCH_FIRST) {
 349                advise_ref_fetch_first();
 350        } else if (reject_reasons & REJECT_NEEDS_FORCE) {
 351                advise_ref_needs_force();
 352        }
 353
 354        return 1;
 355}
 356
 357static int do_push(const char *repo, int flags)
 358{
 359        int i, errs;
 360        struct remote *remote = pushremote_get(repo);
 361        const char **url;
 362        int url_nr;
 363
 364        if (!remote) {
 365                if (repo)
 366                        die(_("bad repository '%s'"), repo);
 367                die(_("No configured push destination.\n"
 368                    "Either specify the URL from the command-line or configure a remote repository using\n"
 369                    "\n"
 370                    "    git remote add <name> <url>\n"
 371                    "\n"
 372                    "and then push using the remote name\n"
 373                    "\n"
 374                    "    git push <name>\n"));
 375        }
 376
 377        if (remote->mirror)
 378                flags |= (TRANSPORT_PUSH_MIRROR|TRANSPORT_PUSH_FORCE);
 379
 380        if ((flags & TRANSPORT_PUSH_ALL) && refspec) {
 381                if (!strcmp(*refspec, "refs/tags/*"))
 382                        return error(_("--all and --tags are incompatible"));
 383                return error(_("--all can't be combined with refspecs"));
 384        }
 385
 386        if ((flags & TRANSPORT_PUSH_MIRROR) && refspec) {
 387                if (!strcmp(*refspec, "refs/tags/*"))
 388                        return error(_("--mirror and --tags are incompatible"));
 389                return error(_("--mirror can't be combined with refspecs"));
 390        }
 391
 392        if ((flags & (TRANSPORT_PUSH_ALL|TRANSPORT_PUSH_MIRROR)) ==
 393                                (TRANSPORT_PUSH_ALL|TRANSPORT_PUSH_MIRROR)) {
 394                return error(_("--all and --mirror are incompatible"));
 395        }
 396
 397        if (!refspec && !(flags & TRANSPORT_PUSH_ALL)) {
 398                if (remote->push_refspec_nr) {
 399                        refspec = remote->push_refspec;
 400                        refspec_nr = remote->push_refspec_nr;
 401                } else if (!(flags & TRANSPORT_PUSH_MIRROR))
 402                        setup_default_push_refspecs(remote);
 403        }
 404        errs = 0;
 405        url_nr = push_url_of_remote(remote, &url);
 406        if (url_nr) {
 407                for (i = 0; i < url_nr; i++) {
 408                        struct transport *transport =
 409                                transport_get(remote, url[i]);
 410                        if (push_with_options(transport, flags))
 411                                errs++;
 412                }
 413        } else {
 414                struct transport *transport =
 415                        transport_get(remote, NULL);
 416
 417                if (push_with_options(transport, flags))
 418                        errs++;
 419        }
 420        return !!errs;
 421}
 422
 423static int option_parse_recurse_submodules(const struct option *opt,
 424                                   const char *arg, int unset)
 425{
 426        int *flags = opt->value;
 427
 428        if (*flags & (TRANSPORT_RECURSE_SUBMODULES_CHECK |
 429                      TRANSPORT_RECURSE_SUBMODULES_ON_DEMAND))
 430                die("%s can only be used once.", opt->long_name);
 431
 432        if (arg) {
 433                if (!strcmp(arg, "check"))
 434                        *flags |= TRANSPORT_RECURSE_SUBMODULES_CHECK;
 435                else if (!strcmp(arg, "on-demand"))
 436                        *flags |= TRANSPORT_RECURSE_SUBMODULES_ON_DEMAND;
 437                else
 438                        die("bad %s argument: %s", opt->long_name, arg);
 439        } else
 440                die("option %s needs an argument (check|on-demand)",
 441                                opt->long_name);
 442
 443        return 0;
 444}
 445
 446int cmd_push(int argc, const char **argv, const char *prefix)
 447{
 448        int flags = 0;
 449        int tags = 0;
 450        int rc;
 451        const char *repo = NULL;        /* default repository */
 452        struct option options[] = {
 453                OPT__VERBOSITY(&verbosity),
 454                OPT_STRING( 0 , "repo", &repo, N_("repository"), N_("repository")),
 455                OPT_BIT( 0 , "all", &flags, N_("push all refs"), TRANSPORT_PUSH_ALL),
 456                OPT_BIT( 0 , "mirror", &flags, N_("mirror all refs"),
 457                            (TRANSPORT_PUSH_MIRROR|TRANSPORT_PUSH_FORCE)),
 458                OPT_BOOL( 0, "delete", &deleterefs, N_("delete refs")),
 459                OPT_BOOL( 0 , "tags", &tags, N_("push tags (can't be used with --all or --mirror)")),
 460                OPT_BIT('n' , "dry-run", &flags, N_("dry run"), TRANSPORT_PUSH_DRY_RUN),
 461                OPT_BIT( 0,  "porcelain", &flags, N_("machine-readable output"), TRANSPORT_PUSH_PORCELAIN),
 462                OPT_BIT('f', "force", &flags, N_("force updates"), TRANSPORT_PUSH_FORCE),
 463                { OPTION_CALLBACK,
 464                  0, CAS_OPT_NAME, &cas, N_("refname>:<expect"),
 465                  N_("require old value of ref to be at this value"),
 466                  PARSE_OPT_OPTARG, parseopt_push_cas_option },
 467                { OPTION_CALLBACK, 0, "recurse-submodules", &flags, N_("check"),
 468                        N_("control recursive pushing of submodules"),
 469                        PARSE_OPT_OPTARG, option_parse_recurse_submodules },
 470                OPT_BOOL( 0 , "thin", &thin, N_("use thin pack")),
 471                OPT_STRING( 0 , "receive-pack", &receivepack, "receive-pack", N_("receive pack program")),
 472                OPT_STRING( 0 , "exec", &receivepack, "receive-pack", N_("receive pack program")),
 473                OPT_BIT('u', "set-upstream", &flags, N_("set upstream for git pull/status"),
 474                        TRANSPORT_PUSH_SET_UPSTREAM),
 475                OPT_BOOL(0, "progress", &progress, N_("force progress reporting")),
 476                OPT_BIT(0, "prune", &flags, N_("prune locally removed refs"),
 477                        TRANSPORT_PUSH_PRUNE),
 478                OPT_BIT(0, "no-verify", &flags, N_("bypass pre-push hook"), TRANSPORT_PUSH_NO_HOOK),
 479                OPT_BIT(0, "follow-tags", &flags, N_("push missing but relevant tags"),
 480                        TRANSPORT_PUSH_FOLLOW_TAGS),
 481                OPT_END()
 482        };
 483
 484        packet_trace_identity("push");
 485        git_config(git_default_config, NULL);
 486        argc = parse_options(argc, argv, prefix, options, push_usage, 0);
 487
 488        if (deleterefs && (tags || (flags & (TRANSPORT_PUSH_ALL | TRANSPORT_PUSH_MIRROR))))
 489                die(_("--delete is incompatible with --all, --mirror and --tags"));
 490        if (deleterefs && argc < 2)
 491                die(_("--delete doesn't make sense without any refs"));
 492
 493        if (tags)
 494                add_refspec("refs/tags/*");
 495
 496        if (argc > 0) {
 497                repo = argv[0];
 498                set_refspecs(argv + 1, argc - 1);
 499        }
 500
 501        rc = do_push(repo, flags);
 502        if (rc == -1)
 503                usage_with_options(push_usage, options);
 504        else
 505                return rc;
 506}