Andrew's git - gitweb.git/blob

   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        "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 const char **refspec;
  25static int refspec_nr;
  26static int refspec_alloc;
  27static int default_matching_used;
  28
  29static 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
  36static 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
  69static 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
  79static 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
 116static void setup_push_upstream(struct remote *remote, int simple)
 117{
 118        struct strbuf refspec = STRBUF_INIT;
 119        struct branch *branch = branch_get(NULL);
 120        if (!branch)
 121                die(_("You are not currently on a branch.\n"
 122                    "To push the history leading to the current (detached HEAD)\n"
 123                    "state now, use\n"
 124                    "\n"
 125                    "    git push %s HEAD:<name-of-remote-branch>\n"),
 126                    remote->name);
 127        if (!branch->merge_nr || !branch->merge || !branch->remote_name)
 128                die(_("The current branch %s has no upstream branch.\n"
 129                    "To push the current branch and set the remote as upstream, use\n"
 130                    "\n"
 131                    "    git push --set-upstream %s %s\n"),
 132                    branch->name,
 133                    remote->name,
 134                    branch->name);
 135        if (branch->merge_nr != 1)
 136                die(_("The current branch %s has multiple upstream branches, "
 137                    "refusing to push."), branch->name);
 138        if (strcmp(branch->remote_name, remote->name))
 139                die(_("You are pushing to remote '%s', which is not the upstream of\n"
 140                      "your current branch '%s', without telling me what to push\n"
 141                      "to update which remote branch."),
 142                    remote->name, branch->name);
 143        if (simple && strcmp(branch->refname, branch->merge[0]->src))
 144                die_push_simple(branch, remote);
 145
 146        strbuf_addf(&refspec, "%s:%s", branch->name, branch->merge[0]->src);
 147        add_refspec(refspec.buf);
 148}
 149
 150static char warn_unspecified_push_default_msg[] =
 151N_("push.default is unset; its implicit value is changing in\n"
 152   "Git 2.0 from 'matching' to 'simple'. To squelch this message\n"
 153   "and maintain the current behavior after the default changes, use:\n"
 154   "\n"
 155   "  git config --global push.default matching\n"
 156   "\n"
 157   "To squelch this message and adopt the new behavior now, use:\n"
 158   "\n"
 159   "  git config --global push.default simple\n"
 160   "\n"
 161   "See 'git help config' and search for 'push.default' for further information.\n"
 162   "(the 'simple' mode was introduced in Git 1.7.11. Use the similar mode\n"
 163   "'current' instead of 'simple' if you sometimes use older versions of Git)");
 164
 165static void warn_unspecified_push_default_configuration(void)
 166{
 167        static int warn_once;
 168
 169        if (warn_once++)
 170                return;
 171        warning("%s\n", _(warn_unspecified_push_default_msg));
 172}
 173
 174static void setup_default_push_refspecs(struct remote *remote)
 175{
 176        switch (push_default) {
 177        default:
 178        case PUSH_DEFAULT_UNSPECIFIED:
 179                default_matching_used = 1;
 180                warn_unspecified_push_default_configuration();
 181                /* fallthru */
 182        case PUSH_DEFAULT_MATCHING:
 183                add_refspec(":");
 184                break;
 185
 186        case PUSH_DEFAULT_SIMPLE:
 187                setup_push_upstream(remote, 1);
 188                break;
 189
 190        case PUSH_DEFAULT_UPSTREAM:
 191                setup_push_upstream(remote, 0);
 192                break;
 193
 194        case PUSH_DEFAULT_CURRENT:
 195                add_refspec("HEAD");
 196                break;
 197
 198        case PUSH_DEFAULT_NOTHING:
 199                die(_("You didn't specify any refspecs to push, and "
 200                    "push.default is \"nothing\"."));
 201                break;
 202        }
 203}
 204
 205static const char message_advice_pull_before_push[] =
 206        N_("Updates were rejected because the tip of your current branch is behind\n"
 207           "its remote counterpart. Merge the remote changes (e.g. 'git pull')\n"
 208           "before pushing again.\n"
 209           "See the 'Note about fast-forwards' in 'git push --help' for details.");
 210
 211static const char message_advice_use_upstream[] =
 212        N_("Updates were rejected because a pushed branch tip is behind its remote\n"
 213           "counterpart. If you did not intend to push that branch, you may want to\n"
 214           "specify branches to push or set the 'push.default' configuration variable\n"
 215           "to 'simple', 'current' or 'upstream' to push only the current branch.");
 216
 217static const char message_advice_checkout_pull_push[] =
 218        N_("Updates were rejected because a pushed branch tip is behind its remote\n"
 219           "counterpart. Check out this branch and merge the remote changes\n"
 220           "(e.g. 'git pull') before pushing again.\n"
 221           "See the 'Note about fast-forwards' in 'git push --help' for details.");
 222
 223static void advise_pull_before_push(void)
 224{
 225        if (!advice_push_non_ff_current || !advice_push_nonfastforward)
 226                return;
 227        advise(_(message_advice_pull_before_push));
 228}
 229
 230static void advise_use_upstream(void)
 231{
 232        if (!advice_push_non_ff_default || !advice_push_nonfastforward)
 233                return;
 234        advise(_(message_advice_use_upstream));
 235}
 236
 237static void advise_checkout_pull_push(void)
 238{
 239        if (!advice_push_non_ff_matching || !advice_push_nonfastforward)
 240                return;
 241        advise(_(message_advice_checkout_pull_push));
 242}
 243
 244static int push_with_options(struct transport *transport, int flags)
 245{
 246        int err;
 247        int nonfastforward;
 248
 249        transport_set_verbosity(transport, verbosity, progress);
 250
 251        if (receivepack)
 252                transport_set_option(transport,
 253                                     TRANS_OPT_RECEIVEPACK, receivepack);
 254        if (thin)
 255                transport_set_option(transport, TRANS_OPT_THIN, "yes");
 256
 257        if (verbosity > 0)
 258                fprintf(stderr, _("Pushing to %s\n"), transport->url);
 259        err = transport_push(transport, refspec_nr, refspec, flags,
 260                             &nonfastforward);
 261        if (err != 0)
 262                error(_("failed to push some refs to '%s'"), transport->url);
 263
 264        err |= transport_disconnect(transport);
 265        if (!err)
 266                return 0;
 267
 268        switch (nonfastforward) {
 269        default:
 270                break;
 271        case NON_FF_HEAD:
 272                advise_pull_before_push();
 273                break;
 274        case NON_FF_OTHER:
 275                if (default_matching_used)
 276                        advise_use_upstream();
 277                else
 278                        advise_checkout_pull_push();
 279                break;
 280        }
 281
 282        return 1;
 283}
 284
 285static int do_push(const char *repo, int flags)
 286{
 287        int i, errs;
 288        struct remote *remote = remote_get(repo);
 289        const char **url;
 290        int url_nr;
 291
 292        if (!remote) {
 293                if (repo)
 294                        die(_("bad repository '%s'"), repo);
 295                die(_("No configured push destination.\n"
 296                    "Either specify the URL from the command-line or configure a remote repository using\n"
 297                    "\n"
 298                    "    git remote add <name> <url>\n"
 299                    "\n"
 300                    "and then push using the remote name\n"
 301                    "\n"
 302                    "    git push <name>\n"));
 303        }
 304
 305        if (remote->mirror)
 306                flags |= (TRANSPORT_PUSH_MIRROR|TRANSPORT_PUSH_FORCE);
 307
 308        if ((flags & TRANSPORT_PUSH_ALL) && refspec) {
 309                if (!strcmp(*refspec, "refs/tags/*"))
 310                        return error(_("--all and --tags are incompatible"));
 311                return error(_("--all can't be combined with refspecs"));
 312        }
 313
 314        if ((flags & TRANSPORT_PUSH_MIRROR) && refspec) {
 315                if (!strcmp(*refspec, "refs/tags/*"))
 316                        return error(_("--mirror and --tags are incompatible"));
 317                return error(_("--mirror can't be combined with refspecs"));
 318        }
 319
 320        if ((flags & (TRANSPORT_PUSH_ALL|TRANSPORT_PUSH_MIRROR)) ==
 321                                (TRANSPORT_PUSH_ALL|TRANSPORT_PUSH_MIRROR)) {
 322                return error(_("--all and --mirror are incompatible"));
 323        }
 324
 325        if (!refspec && !(flags & TRANSPORT_PUSH_ALL)) {
 326                if (remote->push_refspec_nr) {
 327                        refspec = remote->push_refspec;
 328                        refspec_nr = remote->push_refspec_nr;
 329                } else if (!(flags & TRANSPORT_PUSH_MIRROR))
 330                        setup_default_push_refspecs(remote);
 331        }
 332        errs = 0;
 333        url_nr = push_url_of_remote(remote, &url);
 334        if (url_nr) {
 335                for (i = 0; i < url_nr; i++) {
 336                        struct transport *transport =
 337                                transport_get(remote, url[i]);
 338                        if (push_with_options(transport, flags))
 339                                errs++;
 340                }
 341        } else {
 342                struct transport *transport =
 343                        transport_get(remote, NULL);
 344
 345                if (push_with_options(transport, flags))
 346                        errs++;
 347        }
 348        return !!errs;
 349}
 350
 351static int option_parse_recurse_submodules(const struct option *opt,
 352                                   const char *arg, int unset)
 353{
 354        int *flags = opt->value;
 355
 356        if (*flags & (TRANSPORT_RECURSE_SUBMODULES_CHECK |
 357                      TRANSPORT_RECURSE_SUBMODULES_ON_DEMAND))
 358                die("%s can only be used once.", opt->long_name);
 359
 360        if (arg) {
 361                if (!strcmp(arg, "check"))
 362                        *flags |= TRANSPORT_RECURSE_SUBMODULES_CHECK;
 363                else if (!strcmp(arg, "on-demand"))
 364                        *flags |= TRANSPORT_RECURSE_SUBMODULES_ON_DEMAND;
 365                else
 366                        die("bad %s argument: %s", opt->long_name, arg);
 367        } else
 368                die("option %s needs an argument (check|on-demand)",
 369                                opt->long_name);
 370
 371        return 0;
 372}
 373
 374int cmd_push(int argc, const char **argv, const char *prefix)
 375{
 376        int flags = 0;
 377        int tags = 0;
 378        int rc;
 379        const char *repo = NULL;        /* default repository */
 380        struct option options[] = {
 381                OPT__VERBOSITY(&verbosity),
 382                OPT_STRING( 0 , "repo", &repo, "repository", "repository"),
 383                OPT_BIT( 0 , "all", &flags, "push all refs", TRANSPORT_PUSH_ALL),
 384                OPT_BIT( 0 , "mirror", &flags, "mirror all refs",
 385                            (TRANSPORT_PUSH_MIRROR|TRANSPORT_PUSH_FORCE)),
 386                OPT_BOOLEAN( 0, "delete", &deleterefs, "delete refs"),
 387                OPT_BOOLEAN( 0 , "tags", &tags, "push tags (can't be used with --all or --mirror)"),
 388                OPT_BIT('n' , "dry-run", &flags, "dry run", TRANSPORT_PUSH_DRY_RUN),
 389                OPT_BIT( 0,  "porcelain", &flags, "machine-readable output", TRANSPORT_PUSH_PORCELAIN),
 390                OPT_BIT('f', "force", &flags, "force updates", TRANSPORT_PUSH_FORCE),
 391                { OPTION_CALLBACK, 0, "recurse-submodules", &flags, "check",
 392                        "controls recursive pushing of submodules",
 393                        PARSE_OPT_OPTARG, option_parse_recurse_submodules },
 394                OPT_BOOLEAN( 0 , "thin", &thin, "use thin pack"),
 395                OPT_STRING( 0 , "receive-pack", &receivepack, "receive-pack", "receive pack program"),
 396                OPT_STRING( 0 , "exec", &receivepack, "receive-pack", "receive pack program"),
 397                OPT_BIT('u', "set-upstream", &flags, "set upstream for git pull/status",
 398                        TRANSPORT_PUSH_SET_UPSTREAM),
 399                OPT_BOOL(0, "progress", &progress, "force progress reporting"),
 400                OPT_BIT(0, "prune", &flags, "prune locally removed refs",
 401                        TRANSPORT_PUSH_PRUNE),
 402                OPT_END()
 403        };
 404
 405        packet_trace_identity("push");
 406        git_config(git_default_config, NULL);
 407        argc = parse_options(argc, argv, prefix, options, push_usage, 0);
 408
 409        if (deleterefs && (tags || (flags & (TRANSPORT_PUSH_ALL | TRANSPORT_PUSH_MIRROR))))
 410                die(_("--delete is incompatible with --all, --mirror and --tags"));
 411        if (deleterefs && argc < 2)
 412                die(_("--delete doesn't make sense without any refs"));
 413
 414        if (tags)
 415                add_refspec("refs/tags/*");
 416
 417        if (argc > 0) {
 418                repo = argv[0];
 419                set_refspecs(argv + 1, argc - 1);
 420        }
 421
 422        rc = do_push(repo, flags);
 423        if (rc == -1)
 424                usage_with_options(push_usage, options);
 425        else
 426                return rc;
 427}