Andrew's git / gitweb.git / builtin/push.c
?
builtin / push.con commit interpret-trailers: add --parse convenience option (99e09da)
   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#include "submodule-config.h"
  13#include "send-pack.h"
  14
  15static const char * const push_usage[] = {
  16        N_("git push [<options>] [<repository> [<refspec>...]]"),
  17        NULL,
  18};
  19
  20static int thin = 1;
  21static int deleterefs;
  22static const char *receivepack;
  23static int verbosity;
  24static int progress = -1;
  25static int recurse_submodules = RECURSE_SUBMODULES_DEFAULT;
  26static enum transport_family family;
  27
  28static struct push_cas_option cas;
  29
  30static const char **refspec;
  31static int refspec_nr;
  32static int refspec_alloc;
  33
  34static void add_refspec(const char *ref)
  35{
  36        refspec_nr++;
  37        ALLOC_GROW(refspec, refspec_nr, refspec_alloc);
  38        refspec[refspec_nr-1] = ref;
  39}
  40
  41static const char *map_refspec(const char *ref,
  42                               struct remote *remote, struct ref *local_refs)
  43{
  44        struct ref *matched = NULL;
  45
  46        /* Does "ref" uniquely name our ref? */
  47        if (count_refspec_match(ref, local_refs, &matched) != 1)
  48                return ref;
  49
  50        if (remote->push) {
  51                struct refspec query;
  52                memset(&query, 0, sizeof(struct refspec));
  53                query.src = matched->name;
  54                if (!query_refspecs(remote->push, remote->push_refspec_nr, &query) &&
  55                    query.dst) {
  56                        struct strbuf buf = STRBUF_INIT;
  57                        strbuf_addf(&buf, "%s%s:%s",
  58                                    query.force ? "+" : "",
  59                                    query.src, query.dst);
  60                        return strbuf_detach(&buf, NULL);
  61                }
  62        }
  63
  64        if (push_default == PUSH_DEFAULT_UPSTREAM &&
  65            starts_with(matched->name, "refs/heads/")) {
  66                struct branch *branch = branch_get(matched->name + 11);
  67                if (branch->merge_nr == 1 && branch->merge[0]->src) {
  68                        struct strbuf buf = STRBUF_INIT;
  69                        strbuf_addf(&buf, "%s:%s",
  70                                    ref, branch->merge[0]->src);
  71                        return strbuf_detach(&buf, NULL);
  72                }
  73        }
  74
  75        return ref;
  76}
  77
  78static void set_refspecs(const char **refs, int nr, const char *repo)
  79{
  80        struct remote *remote = NULL;
  81        struct ref *local_refs = NULL;
  82        int i;
  83
  84        for (i = 0; i < nr; i++) {
  85                const char *ref = refs[i];
  86                if (!strcmp("tag", ref)) {
  87                        struct strbuf tagref = STRBUF_INIT;
  88                        if (nr <= ++i)
  89                                die(_("tag shorthand without <tag>"));
  90                        ref = refs[i];
  91                        if (deleterefs)
  92                                strbuf_addf(&tagref, ":refs/tags/%s", ref);
  93                        else
  94                                strbuf_addf(&tagref, "refs/tags/%s", ref);
  95                        ref = strbuf_detach(&tagref, NULL);
  96                } else if (deleterefs) {
  97                        struct strbuf delref = STRBUF_INIT;
  98                        if (strchr(ref, ':'))
  99                                die(_("--delete only accepts plain target ref names"));
 100                        strbuf_addf(&delref, ":%s", ref);
 101                        ref = strbuf_detach(&delref, NULL);
 102                } else if (!strchr(ref, ':')) {
 103                        if (!remote) {
 104                                /* lazily grab remote and local_refs */
 105                                remote = remote_get(repo);
 106                                local_refs = get_local_heads();
 107                        }
 108                        ref = map_refspec(ref, remote, local_refs);
 109                }
 110                add_refspec(ref);
 111        }
 112}
 113
 114static int push_url_of_remote(struct remote *remote, const char ***url_p)
 115{
 116        if (remote->pushurl_nr) {
 117                *url_p = remote->pushurl;
 118                return remote->pushurl_nr;
 119        }
 120        *url_p = remote->url;
 121        return remote->url_nr;
 122}
 123
 124static NORETURN int die_push_simple(struct branch *branch, struct remote *remote) {
 125        /*
 126         * There's no point in using shorten_unambiguous_ref here,
 127         * as the ambiguity would be on the remote side, not what
 128         * we have locally. Plus, this is supposed to be the simple
 129         * mode. If the user is doing something crazy like setting
 130         * upstream to a non-branch, we should probably be showing
 131         * them the big ugly fully qualified ref.
 132         */
 133        const char *advice_maybe = "";
 134        const char *short_upstream = branch->merge[0]->src;
 135
 136        skip_prefix(short_upstream, "refs/heads/", &short_upstream);
 137
 138        /*
 139         * Don't show advice for people who explicitly set
 140         * push.default.
 141         */
 142        if (push_default == PUSH_DEFAULT_UNSPECIFIED)
 143                advice_maybe = _("\n"
 144                                 "To choose either option permanently, "
 145                                 "see push.default in 'git help config'.");
 146        die(_("The upstream branch of your current branch does not match\n"
 147              "the name of your current branch.  To push to the upstream branch\n"
 148              "on the remote, use\n"
 149              "\n"
 150              "    git push %s HEAD:%s\n"
 151              "\n"
 152              "To push to the branch of the same name on the remote, use\n"
 153              "\n"
 154              "    git push %s %s\n"
 155              "%s"),
 156            remote->name, short_upstream,
 157            remote->name, branch->name, advice_maybe);
 158}
 159
 160static const char message_detached_head_die[] =
 161        N_("You are not currently on a branch.\n"
 162           "To push the history leading to the current (detached HEAD)\n"
 163           "state now, use\n"
 164           "\n"
 165           "    git push %s HEAD:<name-of-remote-branch>\n");
 166
 167static void setup_push_upstream(struct remote *remote, struct branch *branch,
 168                                int triangular, int simple)
 169{
 170        struct strbuf refspec = STRBUF_INIT;
 171
 172        if (!branch)
 173                die(_(message_detached_head_die), remote->name);
 174        if (!branch->merge_nr || !branch->merge || !branch->remote_name)
 175                die(_("The current branch %s has no upstream branch.\n"
 176                    "To push the current branch and set the remote as upstream, use\n"
 177                    "\n"
 178                    "    git push --set-upstream %s %s\n"),
 179                    branch->name,
 180                    remote->name,
 181                    branch->name);
 182        if (branch->merge_nr != 1)
 183                die(_("The current branch %s has multiple upstream branches, "
 184                    "refusing to push."), branch->name);
 185        if (triangular)
 186                die(_("You are pushing to remote '%s', which is not the upstream of\n"
 187                      "your current branch '%s', without telling me what to push\n"
 188                      "to update which remote branch."),
 189                    remote->name, branch->name);
 190
 191        if (simple) {
 192                /* Additional safety */
 193                if (strcmp(branch->refname, branch->merge[0]->src))
 194                        die_push_simple(branch, remote);
 195        }
 196
 197        strbuf_addf(&refspec, "%s:%s", branch->refname, branch->merge[0]->src);
 198        add_refspec(refspec.buf);
 199}
 200
 201static void setup_push_current(struct remote *remote, struct branch *branch)
 202{
 203        struct strbuf refspec = STRBUF_INIT;
 204
 205        if (!branch)
 206                die(_(message_detached_head_die), remote->name);
 207        strbuf_addf(&refspec, "%s:%s", branch->refname, branch->refname);
 208        add_refspec(refspec.buf);
 209}
 210
 211static int is_workflow_triangular(struct remote *remote)
 212{
 213        struct remote *fetch_remote = remote_get(NULL);
 214        return (fetch_remote && fetch_remote != remote);
 215}
 216
 217static void setup_default_push_refspecs(struct remote *remote)
 218{
 219        struct branch *branch = branch_get(NULL);
 220        int triangular = is_workflow_triangular(remote);
 221
 222        switch (push_default) {
 223        default:
 224        case PUSH_DEFAULT_MATCHING:
 225                add_refspec(":");
 226                break;
 227
 228        case PUSH_DEFAULT_UNSPECIFIED:
 229        case PUSH_DEFAULT_SIMPLE:
 230                if (triangular)
 231                        setup_push_current(remote, branch);
 232                else
 233                        setup_push_upstream(remote, branch, triangular, 1);
 234                break;
 235
 236        case PUSH_DEFAULT_UPSTREAM:
 237                setup_push_upstream(remote, branch, triangular, 0);
 238                break;
 239
 240        case PUSH_DEFAULT_CURRENT:
 241                setup_push_current(remote, branch);
 242                break;
 243
 244        case PUSH_DEFAULT_NOTHING:
 245                die(_("You didn't specify any refspecs to push, and "
 246                    "push.default is \"nothing\"."));
 247                break;
 248        }
 249}
 250
 251static const char message_advice_pull_before_push[] =
 252        N_("Updates were rejected because the tip of your current branch is behind\n"
 253           "its remote counterpart. Integrate the remote changes (e.g.\n"
 254           "'git pull ...') before pushing again.\n"
 255           "See the 'Note about fast-forwards' in 'git push --help' for details.");
 256
 257static const char message_advice_checkout_pull_push[] =
 258        N_("Updates were rejected because a pushed branch tip is behind its remote\n"
 259           "counterpart. Check out this branch and integrate the remote changes\n"
 260           "(e.g. 'git pull ...') before pushing again.\n"
 261           "See the 'Note about fast-forwards' in 'git push --help' for details.");
 262
 263static const char message_advice_ref_fetch_first[] =
 264        N_("Updates were rejected because the remote contains work that you do\n"
 265           "not have locally. This is usually caused by another repository pushing\n"
 266           "to the same ref. You may want to first integrate the remote changes\n"
 267           "(e.g., 'git pull ...') before pushing again.\n"
 268           "See the 'Note about fast-forwards' in 'git push --help' for details.");
 269
 270static const char message_advice_ref_already_exists[] =
 271        N_("Updates were rejected because the tag already exists in the remote.");
 272
 273static const char message_advice_ref_needs_force[] =
 274        N_("You cannot update a remote ref that points at a non-commit object,\n"
 275           "or update a remote ref to make it point at a non-commit object,\n"
 276           "without using the '--force' option.\n");
 277
 278static void advise_pull_before_push(void)
 279{
 280        if (!advice_push_non_ff_current || !advice_push_update_rejected)
 281                return;
 282        advise(_(message_advice_pull_before_push));
 283}
 284
 285static void advise_checkout_pull_push(void)
 286{
 287        if (!advice_push_non_ff_matching || !advice_push_update_rejected)
 288                return;
 289        advise(_(message_advice_checkout_pull_push));
 290}
 291
 292static void advise_ref_already_exists(void)
 293{
 294        if (!advice_push_already_exists || !advice_push_update_rejected)
 295                return;
 296        advise(_(message_advice_ref_already_exists));
 297}
 298
 299static void advise_ref_fetch_first(void)
 300{
 301        if (!advice_push_fetch_first || !advice_push_update_rejected)
 302                return;
 303        advise(_(message_advice_ref_fetch_first));
 304}
 305
 306static void advise_ref_needs_force(void)
 307{
 308        if (!advice_push_needs_force || !advice_push_update_rejected)
 309                return;
 310        advise(_(message_advice_ref_needs_force));
 311}
 312
 313static int push_with_options(struct transport *transport, int flags)
 314{
 315        int err;
 316        unsigned int reject_reasons;
 317
 318        transport_set_verbosity(transport, verbosity, progress);
 319        transport->family = family;
 320
 321        if (receivepack)
 322                transport_set_option(transport,
 323                                     TRANS_OPT_RECEIVEPACK, receivepack);
 324        transport_set_option(transport, TRANS_OPT_THIN, thin ? "yes" : NULL);
 325
 326        if (!is_empty_cas(&cas)) {
 327                if (!transport->smart_options)
 328                        die("underlying transport does not support --%s option",
 329                            CAS_OPT_NAME);
 330                transport->smart_options->cas = &cas;
 331        }
 332
 333        if (verbosity > 0)
 334                fprintf(stderr, _("Pushing to %s\n"), transport->url);
 335        err = transport_push(transport, refspec_nr, refspec, flags,
 336                             &reject_reasons);
 337        if (err != 0)
 338                error(_("failed to push some refs to '%s'"), transport->url);
 339
 340        err |= transport_disconnect(transport);
 341        if (!err)
 342                return 0;
 343
 344        if (reject_reasons & REJECT_NON_FF_HEAD) {
 345                advise_pull_before_push();
 346        } else if (reject_reasons & REJECT_NON_FF_OTHER) {
 347                advise_checkout_pull_push();
 348        } else if (reject_reasons & REJECT_ALREADY_EXISTS) {
 349                advise_ref_already_exists();
 350        } else if (reject_reasons & REJECT_FETCH_FIRST) {
 351                advise_ref_fetch_first();
 352        } else if (reject_reasons & REJECT_NEEDS_FORCE) {
 353                advise_ref_needs_force();
 354        }
 355
 356        return 1;
 357}
 358
 359static int do_push(const char *repo, int flags,
 360                   const struct string_list *push_options)
 361{
 362        int i, errs;
 363        struct remote *remote = pushremote_get(repo);
 364        const char **url;
 365        int url_nr;
 366
 367        if (!remote) {
 368                if (repo)
 369                        die(_("bad repository '%s'"), repo);
 370                die(_("No configured push destination.\n"
 371                    "Either specify the URL from the command-line or configure a remote repository using\n"
 372                    "\n"
 373                    "    git remote add <name> <url>\n"
 374                    "\n"
 375                    "and then push using the remote name\n"
 376                    "\n"
 377                    "    git push <name>\n"));
 378        }
 379
 380        if (remote->mirror)
 381                flags |= (TRANSPORT_PUSH_MIRROR|TRANSPORT_PUSH_FORCE);
 382
 383        if (push_options->nr)
 384                flags |= TRANSPORT_PUSH_OPTIONS;
 385
 386        if ((flags & TRANSPORT_PUSH_ALL) && refspec) {
 387                if (!strcmp(*refspec, "refs/tags/*"))
 388                        return error(_("--all and --tags are incompatible"));
 389                return error(_("--all can't be combined with refspecs"));
 390        }
 391
 392        if ((flags & TRANSPORT_PUSH_MIRROR) && refspec) {
 393                if (!strcmp(*refspec, "refs/tags/*"))
 394                        return error(_("--mirror and --tags are incompatible"));
 395                return error(_("--mirror can't be combined with refspecs"));
 396        }
 397
 398        if ((flags & (TRANSPORT_PUSH_ALL|TRANSPORT_PUSH_MIRROR)) ==
 399                                (TRANSPORT_PUSH_ALL|TRANSPORT_PUSH_MIRROR)) {
 400                return error(_("--all and --mirror are incompatible"));
 401        }
 402
 403        if (!refspec && !(flags & TRANSPORT_PUSH_ALL)) {
 404                if (remote->push_refspec_nr) {
 405                        refspec = remote->push_refspec;
 406                        refspec_nr = remote->push_refspec_nr;
 407                } else if (!(flags & TRANSPORT_PUSH_MIRROR))
 408                        setup_default_push_refspecs(remote);
 409        }
 410        errs = 0;
 411        url_nr = push_url_of_remote(remote, &url);
 412        if (url_nr) {
 413                for (i = 0; i < url_nr; i++) {
 414                        struct transport *transport =
 415                                transport_get(remote, url[i]);
 416                        if (flags & TRANSPORT_PUSH_OPTIONS)
 417                                transport->push_options = push_options;
 418                        if (push_with_options(transport, flags))
 419                                errs++;
 420                }
 421        } else {
 422                struct transport *transport =
 423                        transport_get(remote, NULL);
 424                if (flags & TRANSPORT_PUSH_OPTIONS)
 425                        transport->push_options = push_options;
 426                if (push_with_options(transport, flags))
 427                        errs++;
 428        }
 429        return !!errs;
 430}
 431
 432static int option_parse_recurse_submodules(const struct option *opt,
 433                                   const char *arg, int unset)
 434{
 435        int *recurse_submodules = opt->value;
 436
 437        if (unset)
 438                *recurse_submodules = RECURSE_SUBMODULES_OFF;
 439        else if (arg)
 440                *recurse_submodules = parse_push_recurse_submodules_arg(opt->long_name, arg);
 441        else
 442                die("%s missing parameter", opt->long_name);
 443
 444        return 0;
 445}
 446
 447static void set_push_cert_flags(int *flags, int v)
 448{
 449        switch (v) {
 450        case SEND_PACK_PUSH_CERT_NEVER:
 451                *flags &= ~(TRANSPORT_PUSH_CERT_ALWAYS | TRANSPORT_PUSH_CERT_IF_ASKED);
 452                break;
 453        case SEND_PACK_PUSH_CERT_ALWAYS:
 454                *flags |= TRANSPORT_PUSH_CERT_ALWAYS;
 455                *flags &= ~TRANSPORT_PUSH_CERT_IF_ASKED;
 456                break;
 457        case SEND_PACK_PUSH_CERT_IF_ASKED:
 458                *flags |= TRANSPORT_PUSH_CERT_IF_ASKED;
 459                *flags &= ~TRANSPORT_PUSH_CERT_ALWAYS;
 460                break;
 461        }
 462}
 463
 464
 465static int git_push_config(const char *k, const char *v, void *cb)
 466{
 467        int *flags = cb;
 468        int status;
 469
 470        status = git_gpg_config(k, v, NULL);
 471        if (status)
 472                return status;
 473
 474        if (!strcmp(k, "push.followtags")) {
 475                if (git_config_bool(k, v))
 476                        *flags |= TRANSPORT_PUSH_FOLLOW_TAGS;
 477                else
 478                        *flags &= ~TRANSPORT_PUSH_FOLLOW_TAGS;
 479                return 0;
 480        } else if (!strcmp(k, "push.gpgsign")) {
 481                const char *value;
 482                if (!git_config_get_value("push.gpgsign", &value)) {
 483                        switch (git_config_maybe_bool("push.gpgsign", value)) {
 484                        case 0:
 485                                set_push_cert_flags(flags, SEND_PACK_PUSH_CERT_NEVER);
 486                                break;
 487                        case 1:
 488                                set_push_cert_flags(flags, SEND_PACK_PUSH_CERT_ALWAYS);
 489                                break;
 490                        default:
 491                                if (value && !strcasecmp(value, "if-asked"))
 492                                        set_push_cert_flags(flags, SEND_PACK_PUSH_CERT_IF_ASKED);
 493                                else
 494                                        return error("Invalid value for '%s'", k);
 495                        }
 496                }
 497        } else if (!strcmp(k, "push.recursesubmodules")) {
 498                const char *value;
 499                if (!git_config_get_value("push.recursesubmodules", &value))
 500                        recurse_submodules = parse_push_recurse_submodules_arg(k, value);
 501        }
 502
 503        return git_default_config(k, v, NULL);
 504}
 505
 506int cmd_push(int argc, const char **argv, const char *prefix)
 507{
 508        int flags = 0;
 509        int tags = 0;
 510        int push_cert = -1;
 511        int rc;
 512        const char *repo = NULL;        /* default repository */
 513        struct string_list push_options = STRING_LIST_INIT_DUP;
 514        const struct string_list_item *item;
 515
 516        struct option options[] = {
 517                OPT__VERBOSITY(&verbosity),
 518                OPT_STRING( 0 , "repo", &repo, N_("repository"), N_("repository")),
 519                OPT_BIT( 0 , "all", &flags, N_("push all refs"), TRANSPORT_PUSH_ALL),
 520                OPT_BIT( 0 , "mirror", &flags, N_("mirror all refs"),
 521                            (TRANSPORT_PUSH_MIRROR|TRANSPORT_PUSH_FORCE)),
 522                OPT_BOOL('d', "delete", &deleterefs, N_("delete refs")),
 523                OPT_BOOL( 0 , "tags", &tags, N_("push tags (can't be used with --all or --mirror)")),
 524                OPT_BIT('n' , "dry-run", &flags, N_("dry run"), TRANSPORT_PUSH_DRY_RUN),
 525                OPT_BIT( 0,  "porcelain", &flags, N_("machine-readable output"), TRANSPORT_PUSH_PORCELAIN),
 526                OPT_BIT('f', "force", &flags, N_("force updates"), TRANSPORT_PUSH_FORCE),
 527                { OPTION_CALLBACK,
 528                  0, CAS_OPT_NAME, &cas, N_("refname>:<expect"),
 529                  N_("require old value of ref to be at this value"),
 530                  PARSE_OPT_OPTARG, parseopt_push_cas_option },
 531                { OPTION_CALLBACK, 0, "recurse-submodules", &recurse_submodules, "check|on-demand|no",
 532                        N_("control recursive pushing of submodules"),
 533                        PARSE_OPT_OPTARG, option_parse_recurse_submodules },
 534                OPT_BOOL( 0 , "thin", &thin, N_("use thin pack")),
 535                OPT_STRING( 0 , "receive-pack", &receivepack, "receive-pack", N_("receive pack program")),
 536                OPT_STRING( 0 , "exec", &receivepack, "receive-pack", N_("receive pack program")),
 537                OPT_BIT('u', "set-upstream", &flags, N_("set upstream for git pull/status"),
 538                        TRANSPORT_PUSH_SET_UPSTREAM),
 539                OPT_BOOL(0, "progress", &progress, N_("force progress reporting")),
 540                OPT_BIT(0, "prune", &flags, N_("prune locally removed refs"),
 541                        TRANSPORT_PUSH_PRUNE),
 542                OPT_BIT(0, "no-verify", &flags, N_("bypass pre-push hook"), TRANSPORT_PUSH_NO_HOOK),
 543                OPT_BIT(0, "follow-tags", &flags, N_("push missing but relevant tags"),
 544                        TRANSPORT_PUSH_FOLLOW_TAGS),
 545                { OPTION_CALLBACK,
 546                  0, "signed", &push_cert, "yes|no|if-asked", N_("GPG sign the push"),
 547                  PARSE_OPT_OPTARG, option_parse_push_signed },
 548                OPT_BIT(0, "atomic", &flags, N_("request atomic transaction on remote side"), TRANSPORT_PUSH_ATOMIC),
 549                OPT_STRING_LIST('o', "push-option", &push_options, N_("server-specific"), N_("option to transmit")),
 550                OPT_SET_INT('4', "ipv4", &family, N_("use IPv4 addresses only"),
 551                                TRANSPORT_FAMILY_IPV4),
 552                OPT_SET_INT('6', "ipv6", &family, N_("use IPv6 addresses only"),
 553                                TRANSPORT_FAMILY_IPV6),
 554                OPT_END()
 555        };
 556
 557        packet_trace_identity("push");
 558        git_config(git_push_config, &flags);
 559        argc = parse_options(argc, argv, prefix, options, push_usage, 0);
 560        set_push_cert_flags(&flags, push_cert);
 561
 562        if (deleterefs && (tags || (flags & (TRANSPORT_PUSH_ALL | TRANSPORT_PUSH_MIRROR))))
 563                die(_("--delete is incompatible with --all, --mirror and --tags"));
 564        if (deleterefs && argc < 2)
 565                die(_("--delete doesn't make sense without any refs"));
 566
 567        if (recurse_submodules == RECURSE_SUBMODULES_CHECK)
 568                flags |= TRANSPORT_RECURSE_SUBMODULES_CHECK;
 569        else if (recurse_submodules == RECURSE_SUBMODULES_ON_DEMAND)
 570                flags |= TRANSPORT_RECURSE_SUBMODULES_ON_DEMAND;
 571        else if (recurse_submodules == RECURSE_SUBMODULES_ONLY)
 572                flags |= TRANSPORT_RECURSE_SUBMODULES_ONLY;
 573
 574        if (tags)
 575                add_refspec("refs/tags/*");
 576
 577        if (argc > 0) {
 578                repo = argv[0];
 579                set_refspecs(argv + 1, argc - 1, repo);
 580        }
 581
 582        for_each_string_list_item(item, &push_options)
 583                if (strchr(item->string, '\n'))
 584                        die(_("push options must not have new line characters"));
 585
 586        rc = do_push(repo, flags, &push_options);
 587        string_list_clear(&push_options, 0);
 588        if (rc == -1)
 589                usage_with_options(push_usage, options);
 590        else
 591                return rc;
 592}