scalar.c

   1 /*
   2  * The Scalar command-line interface.
   3  */
   4
   5 #define USE_THE_REPOSITORY_VARIABLE
   6
   7 #include "git-compat-util.h"
   8 #include "abspath.h"
   9 #include "gettext.h"
  10 #include "parse-options.h"
  11 #include "config.h"
  12 #include "run-command.h"
  13 #include "simple-ipc.h"
  14 #include "fsmonitor-ipc.h"
  15 #include "fsmonitor-settings.h"
  16 #include "refs.h"
  17 #include "dir.h"
  18 #include "packfile.h"
  19 #include "help.h"
  20 #include "setup.h"
  21 #include "trace2.h"
  22
  23 static void setup_enlistment_directory(int argc, const char **argv,
  24                                        const char * const *usagestr,
  25                                        const struct option *options,
  26                                        struct strbuf *enlistment_root)
  27 {
  28         struct strbuf path = STRBUF_INIT;
  29         int enlistment_is_repo_parent = 0;
  30         size_t len;
  31
  32         if (startup_info->have_repository)
  33                 BUG("gitdir already set up?!?");
  34
  35         if (argc > 1)
  36                 usage_with_options(usagestr, options);
  37
  38         /* find the worktree, determine its corresponding root */
  39         if (argc == 1) {
  40                 strbuf_add_absolute_path(&path, argv[0]);
  41                 if (!is_directory(path.buf))
  42                         die(_("'%s' does not exist"), path.buf);
  43                 if (chdir(path.buf) < 0)
  44                         die_errno(_("could not switch to '%s'"), path.buf);
  45         } else if (strbuf_getcwd(&path) < 0)
  46                 die(_("need a working directory"));
  47
  48         strbuf_trim_trailing_dir_sep(&path);
  49
  50         /* check if currently in enlistment root with src/ workdir */
  51         len = path.len;
  52         strbuf_addstr(&path, "/src");
  53         if (is_nonbare_repository_dir(&path)) {
  54                 enlistment_is_repo_parent = 1;
  55                 if (chdir(path.buf) < 0)
  56                         die_errno(_("could not switch to '%s'"), path.buf);
  57         }
  58         strbuf_setlen(&path, len);
  59
  60         setup_git_directory();
  61
  62         if (!the_repository->worktree)
  63                 die(_("Scalar enlistments require a worktree"));
  64
  65         if (enlistment_root) {
  66                 if (enlistment_is_repo_parent)
  67                         strbuf_addbuf(enlistment_root, &path);
  68                 else
  69                         strbuf_addstr(enlistment_root, the_repository->worktree);
  70         }
  71
  72         strbuf_release(&path);
  73 }
  74
  75 LAST_ARG_MUST_BE_NULL
  76 static int run_git(const char *arg, ...)
  77 {
  78         struct child_process cmd = CHILD_PROCESS_INIT;
  79         va_list args;
  80         const char *p;
  81
  82         va_start(args, arg);
  83         strvec_push(&cmd.args, arg);
  84         while ((p = va_arg(args, const char *)))
  85                 strvec_push(&cmd.args, p);
  86         va_end(args);
  87
  88         cmd.git_cmd = 1;
  89         return run_command(&cmd);
  90 }
  91
  92 struct scalar_config {
  93         const char *key;
  94         const char *value;
  95         int overwrite_on_reconfigure;
  96 };
  97
  98 static int set_scalar_config(const struct scalar_config *config, int reconfigure)
  99 {
 100         char *value = NULL;
 101         int res;
 102
 103         if ((reconfigure && config->overwrite_on_reconfigure) ||
 104             git_config_get_string(config->key, &value)) {
 105                 trace2_data_string("scalar", the_repository, config->key, "created");
 106                 res = git_config_set_gently(config->key, config->value);
 107         } else {
 108                 trace2_data_string("scalar", the_repository, config->key, "exists");
 109                 res = 0;
 110         }
 111
 112         free(value);
 113         return res;
 114 }
 115
 116 static int have_fsmonitor_support(void)
 117 {
 118         return fsmonitor_ipc__is_supported() &&
 119                fsm_settings__get_reason(the_repository) == FSMONITOR_REASON_OK;
 120 }
 121
 122 static int set_recommended_config(int reconfigure)
 123 {
 124         struct scalar_config config[] = {
 125                 /* Required */
 126                 { "am.keepCR", "true", 1 },
 127                 { "core.FSCache", "true", 1 },
 128                 { "core.multiPackIndex", "true", 1 },
 129                 { "core.preloadIndex", "true", 1 },
 130 #ifndef WIN32
 131                 { "core.untrackedCache", "true", 1 },
 132 #else
 133                 /*
 134                  * Unfortunately, Scalar's Functional Tests demonstrated
 135                  * that the untracked cache feature is unreliable on Windows
 136                  * (which is a bummer because that platform would benefit the
 137                  * most from it). For some reason, freshly created files seem
 138                  * not to update the directory's `lastModified` time
 139                  * immediately, but the untracked cache would need to rely on
 140                  * that.
 141                  *
 142                  * Therefore, with a sad heart, we disable this very useful
 143                  * feature on Windows.
 144                  */
 145                 { "core.untrackedCache", "false", 1 },
 146 #endif
 147                 { "core.logAllRefUpdates", "true", 1 },
 148                 { "credential.https://dev.azure.com.useHttpPath", "true", 1 },
 149                 { "credential.validate", "false", 1 }, /* GCM4W-only */
 150                 { "gc.auto", "0", 1 },
 151                 { "gui.GCWarning", "false", 1 },
 152                 { "index.skipHash", "false", 1 },
 153                 { "index.threads", "true", 1 },
 154                 { "index.version", "4", 1 },
 155                 { "merge.stat", "false", 1 },
 156                 { "merge.renames", "true", 1 },
 157                 { "pack.useBitmaps", "false", 1 },
 158                 { "pack.useSparse", "true", 1 },
 159                 { "receive.autoGC", "false", 1 },
 160                 { "feature.manyFiles", "false", 1 },
 161                 { "feature.experimental", "false", 1 },
 162                 { "fetch.unpackLimit", "1", 1 },
 163                 { "fetch.writeCommitGraph", "false", 1 },
 164 #ifdef WIN32
 165                 { "http.sslBackend", "schannel", 1 },
 166 #endif
 167                 /* Optional */
 168                 { "status.aheadBehind", "false" },
 169                 { "commitGraph.generationVersion", "1" },
 170                 { "core.autoCRLF", "false" },
 171                 { "core.safeCRLF", "false" },
 172                 { "fetch.showForcedUpdates", "false" },
 173                 { NULL, NULL },
 174         };
 175         int i;
 176         char *value;
 177
 178         for (i = 0; config[i].key; i++) {
 179                 if (set_scalar_config(config + i, reconfigure))
 180                         return error(_("could not configure %s=%s"),
 181                                      config[i].key, config[i].value);
 182         }
 183
 184         if (have_fsmonitor_support()) {
 185                 struct scalar_config fsmonitor = { "core.fsmonitor", "true" };
 186                 if (set_scalar_config(&fsmonitor, reconfigure))
 187                         return error(_("could not configure %s=%s"),
 188                                      fsmonitor.key, fsmonitor.value);
 189         }
 190
 191         /*
 192          * The `log.excludeDecoration` setting is special because it allows
 193          * for multiple values.
 194          */
 195         if (git_config_get_string("log.excludeDecoration", &value)) {
 196                 trace2_data_string("scalar", the_repository,
 197                                    "log.excludeDecoration", "created");
 198                 if (git_config_set_multivar_gently("log.excludeDecoration",
 199                                                    "refs/prefetch/*",
 200                                                    CONFIG_REGEX_NONE, 0))
 201                         return error(_("could not configure "
 202                                        "log.excludeDecoration"));
 203         } else {
 204                 trace2_data_string("scalar", the_repository,
 205                                    "log.excludeDecoration", "exists");
 206                 free(value);
 207         }
 208
 209         return 0;
 210 }
 211
 212 static int toggle_maintenance(int enable)
 213 {
 214         return run_git("maintenance",
 215                        enable ? "start" : "unregister",
 216                        enable ? NULL : "--force",
 217                        NULL);
 218 }
 219
 220 static int add_or_remove_enlistment(int add)
 221 {
 222         int res;
 223
 224         if (!the_repository->worktree)
 225                 die(_("Scalar enlistments require a worktree"));
 226
 227         res = run_git("config", "--global", "--get", "--fixed-value",
 228                       "scalar.repo", the_repository->worktree, NULL);
 229
 230         /*
 231          * If we want to add and the setting is already there, then do nothing.
 232          * If we want to remove and the setting is not there, then do nothing.
 233          */
 234         if ((add && !res) || (!add && res))
 235                 return 0;
 236
 237         return run_git("config", "--global", add ? "--add" : "--unset",
 238                        add ? "--no-fixed-value" : "--fixed-value",
 239                        "scalar.repo", the_repository->worktree, NULL);
 240 }
 241
 242 static int start_fsmonitor_daemon(void)
 243 {
 244         assert(have_fsmonitor_support());
 245
 246         if (fsmonitor_ipc__get_state() != IPC_STATE__LISTENING)
 247                 return run_git("fsmonitor--daemon", "start", NULL);
 248
 249         return 0;
 250 }
 251
 252 static int stop_fsmonitor_daemon(void)
 253 {
 254         assert(have_fsmonitor_support());
 255
 256         if (fsmonitor_ipc__get_state() == IPC_STATE__LISTENING)
 257                 return run_git("fsmonitor--daemon", "stop", NULL);
 258
 259         return 0;
 260 }
 261
 262 static int register_dir(void)
 263 {
 264         if (add_or_remove_enlistment(1))
 265                 return error(_("could not add enlistment"));
 266
 267         if (set_recommended_config(0))
 268                 return error(_("could not set recommended config"));
 269
 270         if (toggle_maintenance(1))
 271                 warning(_("could not turn on maintenance"));
 272
 273         if (have_fsmonitor_support() && start_fsmonitor_daemon()) {
 274                 return error(_("could not start the FSMonitor daemon"));
 275         }
 276
 277         return 0;
 278 }
 279
 280 static int unregister_dir(void)
 281 {
 282         int res = 0;
 283
 284         if (toggle_maintenance(0))
 285                 res = error(_("could not turn off maintenance"));
 286
 287         if (add_or_remove_enlistment(0))
 288                 res = error(_("could not remove enlistment"));
 289
 290         return res;
 291 }
 292
 293 /* printf-style interface, expects `<key>=<value>` argument */
 294 __attribute__((format (printf, 1, 2)))
 295 static int set_config(const char *fmt, ...)
 296 {
 297         struct strbuf buf = STRBUF_INIT;
 298         char *value;
 299         int res;
 300         va_list args;
 301
 302         va_start(args, fmt);
 303         strbuf_vaddf(&buf, fmt, args);
 304         va_end(args);
 305
 306         value = strchr(buf.buf, '=');
 307         if (value)
 308                 *(value++) = '\0';
 309         res = git_config_set_gently(buf.buf, value);
 310         strbuf_release(&buf);
 311
 312         return res;
 313 }
 314
 315 static char *remote_default_branch(const char *url)
 316 {
 317         struct child_process cp = CHILD_PROCESS_INIT;
 318         struct strbuf out = STRBUF_INIT;
 319
 320         cp.git_cmd = 1;
 321         strvec_pushl(&cp.args, "ls-remote", "--symref", url, "HEAD", NULL);
 322         if (!pipe_command(&cp, NULL, 0, &out, 0, NULL, 0)) {
 323                 const char *line = out.buf;
 324
 325                 while (*line) {
 326                         const char *eol = strchrnul(line, '\n'), *p;
 327                         size_t len = eol - line;
 328                         char *branch;
 329
 330                         if (!skip_prefix(line, "ref: ", &p) ||
 331                             !strip_suffix_mem(line, &len, "\tHEAD")) {
 332                                 line = eol + (*eol == '\n');
 333                                 continue;
 334                         }
 335
 336                         eol = line + len;
 337                         if (skip_prefix(p, "refs/heads/", &p)) {
 338                                 branch = xstrndup(p, eol - p);
 339                                 strbuf_release(&out);
 340                                 return branch;
 341                         }
 342
 343                         error(_("remote HEAD is not a branch: '%.*s'"),
 344                               (int)(eol - p), p);
 345                         strbuf_release(&out);
 346                         return NULL;
 347                 }
 348         }
 349         warning(_("failed to get default branch name from remote; "
 350                   "using local default"));
 351         strbuf_reset(&out);
 352
 353         child_process_init(&cp);
 354         cp.git_cmd = 1;
 355         strvec_pushl(&cp.args, "symbolic-ref", "--short", "HEAD", NULL);
 356         if (!pipe_command(&cp, NULL, 0, &out, 0, NULL, 0)) {
 357                 strbuf_trim(&out);
 358                 return strbuf_detach(&out, NULL);
 359         }
 360
 361         strbuf_release(&out);
 362         error(_("failed to get default branch name"));
 363         return NULL;
 364 }
 365
 366 static int delete_enlistment(struct strbuf *enlistment)
 367 {
 368         struct strbuf parent = STRBUF_INIT;
 369         size_t offset;
 370         char *path_sep;
 371
 372         if (unregister_dir())
 373                 return error(_("failed to unregister repository"));
 374
 375         /*
 376          * Change the current directory to one outside of the enlistment so
 377          * that we may delete everything underneath it.
 378          */
 379         offset = offset_1st_component(enlistment->buf);
 380         path_sep = find_last_dir_sep(enlistment->buf + offset);
 381         strbuf_add(&parent, enlistment->buf,
 382                    path_sep ? path_sep - enlistment->buf : offset);
 383         if (chdir(parent.buf) < 0) {
 384                 int res = error_errno(_("could not switch to '%s'"), parent.buf);
 385                 strbuf_release(&parent);
 386                 return res;
 387         }
 388         strbuf_release(&parent);
 389
 390         if (have_fsmonitor_support() && stop_fsmonitor_daemon())
 391                 return error(_("failed to stop the FSMonitor daemon"));
 392
 393         if (remove_dir_recursively(enlistment, 0))
 394                 return error(_("failed to delete enlistment directory"));
 395
 396         return 0;
 397 }
 398
 399 /*
 400  * Dummy implementation; Using `get_version_info()` would cause a link error
 401  * without this.
 402  */
 403 void load_builtin_commands(const char *prefix UNUSED,
 404                            struct cmdnames *cmds UNUSED)
 405 {
 406         die("not implemented");
 407 }
 408
 409 static int cmd_clone(int argc, const char **argv)
 410 {
 411         const char *branch = NULL;
 412         int full_clone = 0, single_branch = 0, show_progress = isatty(2);
 413         int src = 1, tags = 1;
 414         struct option clone_options[] = {
 415                 OPT_STRING('b', "branch", &branch, N_("<branch>"),
 416                            N_("branch to checkout after clone")),
 417                 OPT_BOOL(0, "full-clone", &full_clone,
 418                          N_("when cloning, create full working directory")),
 419                 OPT_BOOL(0, "single-branch", &single_branch,
 420                          N_("only download metadata for the branch that will "
 421                             "be checked out")),
 422                 OPT_BOOL(0, "src", &src,
 423                          N_("create repository within 'src' directory")),
 424                 OPT_BOOL(0, "tags", &tags,
 425                          N_("specify if tags should be fetched during clone")),
 426                 OPT_END(),
 427         };
 428         const char * const clone_usage[] = {
 429                 N_("scalar clone [--single-branch] [--branch <main-branch>] [--full-clone]\n"
 430                    "\t[--[no-]src] [--[no-]tags] <url> [<enlistment>]"),
 431                 NULL
 432         };
 433         const char *url;
 434         char *enlistment = NULL, *dir = NULL;
 435         struct strbuf buf = STRBUF_INIT;
 436         int res;
 437
 438         argc = parse_options(argc, argv, NULL, clone_options, clone_usage, 0);
 439
 440         if (argc == 2) {
 441                 url = argv[0];
 442                 enlistment = xstrdup(argv[1]);
 443         } else if (argc == 1) {
 444                 url = argv[0];
 445
 446                 strbuf_addstr(&buf, url);
 447                 /* Strip trailing slashes, if any */
 448                 while (buf.len > 0 && is_dir_sep(buf.buf[buf.len - 1]))
 449                         strbuf_setlen(&buf, buf.len - 1);
 450                 /* Strip suffix `.git`, if any */
 451                 strbuf_strip_suffix(&buf, ".git");
 452
 453                 enlistment = find_last_dir_sep(buf.buf);
 454                 if (!enlistment) {
 455                         die(_("cannot deduce worktree name from '%s'"), url);
 456                 }
 457                 enlistment = xstrdup(enlistment + 1);
 458         } else {
 459                 usage_msg_opt(_("You must specify a repository to clone."),
 460                               clone_usage, clone_options);
 461         }
 462
 463         if (is_directory(enlistment))
 464                 die(_("directory '%s' exists already"), enlistment);
 465
 466         if (src)
 467                 dir = xstrfmt("%s/src", enlistment);
 468         else
 469                 dir = xstrdup(enlistment);
 470
 471         strbuf_reset(&buf);
 472         if (branch)
 473                 strbuf_addf(&buf, "init.defaultBranch=%s", branch);
 474         else {
 475                 char *b = repo_default_branch_name(the_repository, 1);
 476                 strbuf_addf(&buf, "init.defaultBranch=%s", b);
 477                 free(b);
 478         }
 479
 480         if ((res = run_git("-c", buf.buf, "init", "--", dir, NULL)))
 481                 goto cleanup;
 482
 483         if (chdir(dir) < 0) {
 484                 res = error_errno(_("could not switch to '%s'"), dir);
 485                 goto cleanup;
 486         }
 487
 488         setup_git_directory();
 489
 490         /* common-main already logs `argv` */
 491         trace2_def_repo(the_repository);
 492
 493         if (!branch && !(branch = remote_default_branch(url))) {
 494                 res = error(_("failed to get default branch for '%s'"), url);
 495                 goto cleanup;
 496         }
 497
 498         if (set_config("remote.origin.url=%s", url) ||
 499             set_config("remote.origin.fetch="
 500                        "+refs/heads/%s:refs/remotes/origin/%s",
 501                        single_branch ? branch : "*",
 502                        single_branch ? branch : "*") ||
 503             set_config("remote.origin.promisor=true") ||
 504             set_config("remote.origin.partialCloneFilter=blob:none")) {
 505                 res = error(_("could not configure remote in '%s'"), dir);
 506                 goto cleanup;
 507         }
 508
 509         if (!tags && set_config("remote.origin.tagOpt=--no-tags")) {
 510                 res = error(_("could not disable tags in '%s'"), dir);
 511                 goto cleanup;
 512         }
 513
 514         if (!full_clone &&
 515             (res = run_git("sparse-checkout", "init", "--cone", NULL)))
 516                 goto cleanup;
 517
 518         if (set_recommended_config(0))
 519                 return error(_("could not configure '%s'"), dir);
 520
 521         if ((res = run_git("fetch", "--quiet",
 522                                 show_progress ? "--progress" : "--no-progress",
 523                                 "origin",
 524                                 (tags ? NULL : "--no-tags"),
 525                                 NULL))) {
 526                 warning(_("partial clone failed; attempting full clone"));
 527
 528                 if (set_config("remote.origin.promisor") ||
 529                     set_config("remote.origin.partialCloneFilter")) {
 530                         res = error(_("could not configure for full clone"));
 531                         goto cleanup;
 532                 }
 533
 534                 if ((res = run_git("fetch", "--quiet",
 535                                         show_progress ? "--progress" : "--no-progress",
 536                                         "origin", NULL)))
 537                         goto cleanup;
 538         }
 539
 540         if ((res = set_config("branch.%s.remote=origin", branch)))
 541                 goto cleanup;
 542         if ((res = set_config("branch.%s.merge=refs/heads/%s",
 543                               branch, branch)))
 544                 goto cleanup;
 545
 546         strbuf_reset(&buf);
 547         strbuf_addf(&buf, "origin/%s", branch);
 548         res = run_git("checkout", "-f", "-t", buf.buf, NULL);
 549         if (res)
 550                 goto cleanup;
 551
 552         res = register_dir();
 553
 554 cleanup:
 555         free(enlistment);
 556         free(dir);
 557         strbuf_release(&buf);
 558         return res;
 559 }
 560
 561 static int cmd_diagnose(int argc, const char **argv)
 562 {
 563         struct option options[] = {
 564                 OPT_END(),
 565         };
 566         const char * const usage[] = {
 567                 N_("scalar diagnose [<enlistment>]"),
 568                 NULL
 569         };
 570         struct strbuf diagnostics_root = STRBUF_INIT;
 571         int res = 0;
 572
 573         argc = parse_options(argc, argv, NULL, options,
 574                              usage, 0);
 575
 576         setup_enlistment_directory(argc, argv, usage, options, &diagnostics_root);
 577         strbuf_addstr(&diagnostics_root, "/.scalarDiagnostics");
 578
 579         res = run_git("diagnose", "--mode=all", "-s", "%Y%m%d_%H%M%S",
 580                       "-o", diagnostics_root.buf, NULL);
 581
 582         strbuf_release(&diagnostics_root);
 583         return res;
 584 }
 585
 586 static int cmd_list(int argc, const char **argv UNUSED)
 587 {
 588         if (argc != 1)
 589                 die(_("`scalar list` does not take arguments"));
 590
 591         if (run_git("config", "--global", "--get-all", "scalar.repo", NULL) < 0)
 592                 return -1;
 593         return 0;
 594 }
 595
 596 static int cmd_register(int argc, const char **argv)
 597 {
 598         struct option options[] = {
 599                 OPT_END(),
 600         };
 601         const char * const usage[] = {
 602                 N_("scalar register [<enlistment>]"),
 603                 NULL
 604         };
 605
 606         argc = parse_options(argc, argv, NULL, options,
 607                              usage, 0);
 608
 609         setup_enlistment_directory(argc, argv, usage, options, NULL);
 610
 611         return register_dir();
 612 }
 613
 614 static int get_scalar_repos(const char *key, const char *value,
 615                             const struct config_context *ctx UNUSED,
 616                             void *data)
 617 {
 618         struct string_list *list = data;
 619
 620         if (!strcmp(key, "scalar.repo"))
 621                 string_list_append(list, value);
 622
 623         return 0;
 624 }
 625
 626 static int remove_deleted_enlistment(struct strbuf *path)
 627 {
 628         int res = 0;
 629         strbuf_realpath_forgiving(path, path->buf, 1);
 630
 631         if (run_git("config", "--global",
 632                     "--unset", "--fixed-value",
 633                     "scalar.repo", path->buf, NULL) < 0)
 634                 res = -1;
 635
 636         if (run_git("config", "--global",
 637                     "--unset", "--fixed-value",
 638                     "maintenance.repo", path->buf, NULL) < 0)
 639                 res = -1;
 640
 641         return res;
 642 }
 643
 644 static int cmd_reconfigure(int argc, const char **argv)
 645 {
 646         int all = 0;
 647         struct option options[] = {
 648                 OPT_BOOL('a', "all", &all,
 649                          N_("reconfigure all registered enlistments")),
 650                 OPT_END(),
 651         };
 652         const char * const usage[] = {
 653                 N_("scalar reconfigure [--all | <enlistment>]"),
 654                 NULL
 655         };
 656         struct string_list scalar_repos = STRING_LIST_INIT_DUP;
 657         int i, res = 0;
 658         struct strbuf commondir = STRBUF_INIT, gitdir = STRBUF_INIT;
 659
 660         argc = parse_options(argc, argv, NULL, options,
 661                              usage, 0);
 662
 663         if (!all) {
 664                 setup_enlistment_directory(argc, argv, usage, options, NULL);
 665
 666                 return set_recommended_config(1);
 667         }
 668
 669         if (argc > 0)
 670                 usage_msg_opt(_("--all or <enlistment>, but not both"),
 671                               usage, options);
 672
 673         git_config(get_scalar_repos, &scalar_repos);
 674
 675         for (i = 0; i < scalar_repos.nr; i++) {
 676                 int succeeded = 0;
 677                 struct repository *old_repo, r = { NULL };
 678                 const char *dir = scalar_repos.items[i].string;
 679
 680                 strbuf_reset(&commondir);
 681                 strbuf_reset(&gitdir);
 682
 683                 if (chdir(dir) < 0) {
 684                         struct strbuf buf = STRBUF_INIT;
 685
 686                         if (errno != ENOENT) {
 687                                 warning_errno(_("could not switch to '%s'"), dir);
 688                                 goto loop_end;
 689                         }
 690
 691                         strbuf_addstr(&buf, dir);
 692                         if (remove_deleted_enlistment(&buf))
 693                                 error(_("could not remove stale "
 694                                         "scalar.repo '%s'"), dir);
 695                         else {
 696                                 warning(_("removed stale scalar.repo '%s'"),
 697                                         dir);
 698                                 succeeded = 1;
 699                         }
 700                         strbuf_release(&buf);
 701                         goto loop_end;
 702                 }
 703
 704                 switch (discover_git_directory_reason(&commondir, &gitdir)) {
 705                 case GIT_DIR_INVALID_OWNERSHIP:
 706                         warning(_("repository at '%s' has different owner"), dir);
 707                         goto loop_end;
 708
 709                 case GIT_DIR_INVALID_GITFILE:
 710                 case GIT_DIR_INVALID_FORMAT:
 711                         warning(_("repository at '%s' has a format issue"), dir);
 712                         goto loop_end;
 713
 714                 case GIT_DIR_DISCOVERED:
 715                         succeeded = 1;
 716                         break;
 717
 718                 default:
 719                         warning(_("repository not found in '%s'"), dir);
 720                         break;
 721                 }
 722
 723                 git_config_clear();
 724
 725                 if (repo_init(&r, gitdir.buf, commondir.buf))
 726                         goto loop_end;
 727
 728                 old_repo = the_repository;
 729                 the_repository = &r;
 730
 731                 if (set_recommended_config(1) >= 0)
 732                         succeeded = 1;
 733
 734                 the_repository = old_repo;
 735                 repo_clear(&r);
 736
 737                 if (toggle_maintenance(1) >= 0)
 738                         succeeded = 1;
 739
 740 loop_end:
 741                 if (!succeeded) {
 742                         res = -1;
 743                         warning(_("to unregister this repository from Scalar, run\n"
 744                                   "\tgit config --global --unset --fixed-value scalar.repo \"%s\""),
 745                                 dir);
 746                 }
 747         }
 748
 749         string_list_clear(&scalar_repos, 1);
 750         strbuf_release(&commondir);
 751         strbuf_release(&gitdir);
 752
 753         return res;
 754 }
 755
 756 static int cmd_run(int argc, const char **argv)
 757 {
 758         struct option options[] = {
 759                 OPT_END(),
 760         };
 761         struct {
 762                 const char *arg, *task;
 763         } tasks[] = {
 764                 { "config", NULL },
 765                 { "commit-graph", "commit-graph" },
 766                 { "fetch", "prefetch" },
 767                 { "loose-objects", "loose-objects" },
 768                 { "pack-files", "incremental-repack" },
 769                 { NULL, NULL }
 770         };
 771         struct strbuf buf = STRBUF_INIT;
 772         const char *usagestr[] = { NULL, NULL };
 773         int i;
 774
 775         strbuf_addstr(&buf, N_("scalar run <task> [<enlistment>]\nTasks:\n"));
 776         for (i = 0; tasks[i].arg; i++)
 777                 strbuf_addf(&buf, "\t%s\n", tasks[i].arg);
 778         usagestr[0] = buf.buf;
 779
 780         argc = parse_options(argc, argv, NULL, options,
 781                              usagestr, 0);
 782
 783         if (!argc)
 784                 usage_with_options(usagestr, options);
 785
 786         if (!strcmp("all", argv[0])) {
 787                 i = -1;
 788         } else {
 789                 for (i = 0; tasks[i].arg && strcmp(tasks[i].arg, argv[0]); i++)
 790                         ; /* keep looking for the task */
 791
 792                 if (i > 0 && !tasks[i].arg) {
 793                         error(_("no such task: '%s'"), argv[0]);
 794                         usage_with_options(usagestr, options);
 795                 }
 796         }
 797
 798         argc--;
 799         argv++;
 800         setup_enlistment_directory(argc, argv, usagestr, options, NULL);
 801         strbuf_release(&buf);
 802
 803         if (i == 0)
 804                 return register_dir();
 805
 806         if (i > 0)
 807                 return run_git("maintenance", "run",
 808                                "--task", tasks[i].task, NULL);
 809
 810         if (register_dir())
 811                 return -1;
 812         for (i = 1; tasks[i].arg; i++)
 813                 if (run_git("maintenance", "run",
 814                             "--task", tasks[i].task, NULL))
 815                         return -1;
 816         return 0;
 817 }
 818
 819 static int cmd_unregister(int argc, const char **argv)
 820 {
 821         struct option options[] = {
 822                 OPT_END(),
 823         };
 824         const char * const usage[] = {
 825                 N_("scalar unregister [<enlistment>]"),
 826                 NULL
 827         };
 828
 829         argc = parse_options(argc, argv, NULL, options,
 830                              usage, 0);
 831
 832         /*
 833          * Be forgiving when the enlistment or worktree does not even exist any
 834          * longer; This can be the case if a user deleted the worktree by
 835          * mistake and _still_ wants to unregister the thing.
 836          */
 837         if (argc == 1) {
 838                 struct strbuf src_path = STRBUF_INIT, workdir_path = STRBUF_INIT;
 839
 840                 strbuf_addf(&src_path, "%s/src/.git", argv[0]);
 841                 strbuf_addf(&workdir_path, "%s/.git", argv[0]);
 842                 if (!is_directory(src_path.buf) && !is_directory(workdir_path.buf)) {
 843                         /* remove possible matching registrations */
 844                         int res = -1;
 845
 846                         strbuf_strip_suffix(&src_path, "/.git");
 847                         res = remove_deleted_enlistment(&src_path) && res;
 848
 849                         strbuf_strip_suffix(&workdir_path, "/.git");
 850                         res = remove_deleted_enlistment(&workdir_path) && res;
 851
 852                         strbuf_release(&src_path);
 853                         strbuf_release(&workdir_path);
 854                         return res;
 855                 }
 856                 strbuf_release(&src_path);
 857                 strbuf_release(&workdir_path);
 858         }
 859
 860         setup_enlistment_directory(argc, argv, usage, options, NULL);
 861
 862         return unregister_dir();
 863 }
 864
 865 static int cmd_delete(int argc, const char **argv)
 866 {
 867         char *cwd = xgetcwd();
 868         struct option options[] = {
 869                 OPT_END(),
 870         };
 871         const char * const usage[] = {
 872                 N_("scalar delete <enlistment>"),
 873                 NULL
 874         };
 875         struct strbuf enlistment = STRBUF_INIT;
 876         int res = 0;
 877
 878         argc = parse_options(argc, argv, NULL, options,
 879                              usage, 0);
 880
 881         if (argc != 1)
 882                 usage_with_options(usage, options);
 883
 884         setup_enlistment_directory(argc, argv, usage, options, &enlistment);
 885
 886         if (dir_inside_of(cwd, enlistment.buf) >= 0)
 887                 res = error(_("refusing to delete current working directory"));
 888         else {
 889                 close_object_store(the_repository->objects);
 890                 res = delete_enlistment(&enlistment);
 891         }
 892         strbuf_release(&enlistment);
 893         free(cwd);
 894
 895         return res;
 896 }
 897
 898 static int cmd_help(int argc, const char **argv)
 899 {
 900         struct option options[] = {
 901                 OPT_END(),
 902         };
 903         const char * const usage[] = {
 904                 "scalar help",
 905                 NULL
 906         };
 907
 908         argc = parse_options(argc, argv, NULL, options,
 909                              usage, 0);
 910
 911         if (argc != 0)
 912                 usage_with_options(usage, options);
 913
 914         return run_git("help", "scalar", NULL);
 915 }
 916
 917 static int cmd_version(int argc, const char **argv)
 918 {
 919         int verbose = 0, build_options = 0;
 920         struct option options[] = {
 921                 OPT__VERBOSE(&verbose, N_("include Git version")),
 922                 OPT_BOOL(0, "build-options", &build_options,
 923                          N_("include Git's build options")),
 924                 OPT_END(),
 925         };
 926         const char * const usage[] = {
 927                 N_("scalar verbose [-v | --verbose] [--build-options]"),
 928                 NULL
 929         };
 930         struct strbuf buf = STRBUF_INIT;
 931
 932         argc = parse_options(argc, argv, NULL, options,
 933                              usage, 0);
 934
 935         if (argc != 0)
 936                 usage_with_options(usage, options);
 937
 938         get_version_info(&buf, build_options);
 939         fprintf(stderr, "%s\n", buf.buf);
 940         strbuf_release(&buf);
 941
 942         return 0;
 943 }
 944
 945 static struct {
 946         const char *name;
 947         int (*fn)(int, const char **);
 948 } builtins[] = {
 949         { "clone", cmd_clone },
 950         { "list", cmd_list },
 951         { "register", cmd_register },
 952         { "unregister", cmd_unregister },
 953         { "run", cmd_run },
 954         { "reconfigure", cmd_reconfigure },
 955         { "delete", cmd_delete },
 956         { "help", cmd_help },
 957         { "version", cmd_version },
 958         { "diagnose", cmd_diagnose },
 959         { NULL, NULL},
 960 };
 961
 962 int cmd_main(int argc, const char **argv)
 963 {
 964         struct strbuf scalar_usage = STRBUF_INIT;
 965         int i;
 966
 967         while (argc > 1 && *argv[1] == '-') {
 968                 if (!strcmp(argv[1], "-C")) {
 969                         if (argc < 3)
 970                                 die(_("-C requires a <directory>"));
 971                         if (chdir(argv[2]) < 0)
 972                                 die_errno(_("could not change to '%s'"),
 973                                           argv[2]);
 974                         argc -= 2;
 975                         argv += 2;
 976                 } else if (!strcmp(argv[1], "-c")) {
 977                         if (argc < 3)
 978                                 die(_("-c requires a <key>=<value> argument"));
 979                         git_config_push_parameter(argv[2]);
 980                         argc -= 2;
 981                         argv += 2;
 982                 } else
 983                         break;
 984         }
 985
 986         if (argc > 1) {
 987                 argv++;
 988                 argc--;
 989
 990                 for (i = 0; builtins[i].name; i++)
 991                         if (!strcmp(builtins[i].name, argv[0]))
 992                                 return !!builtins[i].fn(argc, argv);
 993         }
 994
 995         strbuf_addstr(&scalar_usage,
 996                       N_("scalar [-C <directory>] [-c <key>=<value>] "
 997                          "<command> [<options>]\n\nCommands:\n"));
 998         for (i = 0; builtins[i].name; i++)
 999                 strbuf_addf(&scalar_usage, "\t%s\n", builtins[i].name);
1000
1001         usage(scalar_usage.buf);
1002 }