Merge branch 'vd/scalar-to-main'
Hoist the remainder of "scalar" out of contrib/ to the main part of the codebase. * vd/scalar-to-main: Documentation/technical: include Scalar technical doc t/perf: add 'GIT_PERF_USE_SCALAR' run option t/perf: add Scalar performance tests scalar-clone: add test coverage scalar: add to 'git help -a' command list scalar: implement the `help` subcommand git help: special-case `scalar` scalar: include in standard Git build & installation scalar: fix command documentation section header
This commit is contained in:
Junio C Hamano
@ -610,7 +610,7 @@ unset(CMAKE_REQUIRED_INCLUDES)
|
||||
#programs
|
||||
set(PROGRAMS_BUILT
|
||||
git git-daemon git-http-backend git-sh-i18n--envsubst
|
||||
git-shell)
|
||||
git-shell scalar)
|
||||
|
||||
if(NOT CURL_FOUND)
|
||||
list(APPEND excluded_progs git-http-fetch git-http-push)
|
||||
@ -757,6 +757,9 @@ target_link_libraries(git-sh-i18n--envsubst common-main)
|
||||
add_executable(git-shell ${CMAKE_SOURCE_DIR}/shell.c)
|
||||
target_link_libraries(git-shell common-main)
|
||||
|
||||
add_executable(scalar ${CMAKE_SOURCE_DIR}/scalar.c)
|
||||
target_link_libraries(scalar common-main)
|
||||
|
||||
if(CURL_FOUND)
|
||||
add_library(http_obj OBJECT ${CMAKE_SOURCE_DIR}/http.c)
|
||||
|
||||
@ -903,7 +906,7 @@ list(TRANSFORM git_perl_scripts PREPEND "${CMAKE_BINARY_DIR}/")
|
||||
|
||||
#install
|
||||
foreach(program ${PROGRAMS_BUILT})
|
||||
if(program STREQUAL "git" OR program STREQUAL "git-shell")
|
||||
if(program MATCHES "^(git|git-shell|scalar)$")
|
||||
install(TARGETS ${program}
|
||||
RUNTIME DESTINATION bin)
|
||||
else()
|
||||
@ -977,7 +980,7 @@ endif()
|
||||
|
||||
#wrapper scripts
|
||||
set(wrapper_scripts
|
||||
git git-upload-pack git-receive-pack git-upload-archive git-shell git-remote-ext)
|
||||
git git-upload-pack git-receive-pack git-upload-archive git-shell git-remote-ext scalar)
|
||||
|
||||
set(wrapper_test_scripts
|
||||
test-fake-ssh test-tool)
|
||||
|
||||
2
contrib/scalar/.gitignore
vendored
2
contrib/scalar/.gitignore
vendored
@ -1,2 +0,0 @@
|
||||
/*.exe
|
||||
/scalar
|
||||
@ -1,35 +0,0 @@
|
||||
# The default target of this Makefile is...
|
||||
all::
|
||||
|
||||
# Import tree-wide shared Makefile behavior and libraries
|
||||
include ../../shared.mak
|
||||
|
||||
include ../../config.mak.uname
|
||||
-include ../../config.mak.autogen
|
||||
-include ../../config.mak
|
||||
|
||||
TARGETS = scalar$(X) scalar.o
|
||||
GITLIBS = ../../common-main.o ../../libgit.a ../../xdiff/lib.a
|
||||
|
||||
all:: scalar$(X) ../../bin-wrappers/scalar
|
||||
|
||||
$(GITLIBS):
|
||||
$(QUIET_SUBDIR0)../.. $(QUIET_SUBDIR1) $(subst ../../,,$@)
|
||||
|
||||
$(TARGETS): $(GITLIBS) scalar.c
|
||||
$(QUIET_SUBDIR0)../.. $(QUIET_SUBDIR1) $(patsubst %,contrib/scalar/%,$@)
|
||||
|
||||
clean:
|
||||
$(RM) $(TARGETS) ../../bin-wrappers/scalar
|
||||
|
||||
../../bin-wrappers/scalar: ../../wrap-for-bin.sh Makefile
|
||||
@mkdir -p ../../bin-wrappers
|
||||
$(QUIET_GEN)sed -e '1s|#!.*/sh|#!$(SHELL_PATH_SQ)|' \
|
||||
-e 's|@@BUILD_DIR@@|$(shell cd ../.. && pwd)|' \
|
||||
-e 's|@@PROG@@|contrib/scalar/scalar$(X)|' < $< > $@ && \
|
||||
chmod +x $@
|
||||
|
||||
test: all
|
||||
$(MAKE) -C t
|
||||
|
||||
.PHONY: $(GITLIBS) all clean test FORCE
|
||||
@ -1,906 +0,0 @@
|
||||
/*
|
||||
* The Scalar command-line interface.
|
||||
*/
|
||||
|
||||
#include "cache.h"
|
||||
#include "gettext.h"
|
||||
#include "parse-options.h"
|
||||
#include "config.h"
|
||||
#include "run-command.h"
|
||||
#include "simple-ipc.h"
|
||||
#include "fsmonitor-ipc.h"
|
||||
#include "fsmonitor-settings.h"
|
||||
#include "refs.h"
|
||||
#include "dir.h"
|
||||
#include "packfile.h"
|
||||
#include "help.h"
|
||||
|
||||
static void setup_enlistment_directory(int argc, const char **argv,
|
||||
const char * const *usagestr,
|
||||
const struct option *options,
|
||||
struct strbuf *enlistment_root)
|
||||
{
|
||||
struct strbuf path = STRBUF_INIT;
|
||||
int enlistment_is_repo_parent = 0;
|
||||
size_t len;
|
||||
|
||||
if (startup_info->have_repository)
|
||||
BUG("gitdir already set up?!?");
|
||||
|
||||
if (argc > 1)
|
||||
usage_with_options(usagestr, options);
|
||||
|
||||
/* find the worktree, determine its corresponding root */
|
||||
if (argc == 1) {
|
||||
strbuf_add_absolute_path(&path, argv[0]);
|
||||
if (!is_directory(path.buf))
|
||||
die(_("'%s' does not exist"), path.buf);
|
||||
if (chdir(path.buf) < 0)
|
||||
die_errno(_("could not switch to '%s'"), path.buf);
|
||||
} else if (strbuf_getcwd(&path) < 0)
|
||||
die(_("need a working directory"));
|
||||
|
||||
strbuf_trim_trailing_dir_sep(&path);
|
||||
|
||||
/* check if currently in enlistment root with src/ workdir */
|
||||
len = path.len;
|
||||
strbuf_addstr(&path, "/src");
|
||||
if (is_nonbare_repository_dir(&path)) {
|
||||
enlistment_is_repo_parent = 1;
|
||||
if (chdir(path.buf) < 0)
|
||||
die_errno(_("could not switch to '%s'"), path.buf);
|
||||
}
|
||||
strbuf_setlen(&path, len);
|
||||
|
||||
setup_git_directory();
|
||||
|
||||
if (!the_repository->worktree)
|
||||
die(_("Scalar enlistments require a worktree"));
|
||||
|
||||
if (enlistment_root) {
|
||||
if (enlistment_is_repo_parent)
|
||||
strbuf_addbuf(enlistment_root, &path);
|
||||
else
|
||||
strbuf_addstr(enlistment_root, the_repository->worktree);
|
||||
}
|
||||
|
||||
strbuf_release(&path);
|
||||
}
|
||||
|
||||
static int run_git(const char *arg, ...)
|
||||
{
|
||||
struct strvec argv = STRVEC_INIT;
|
||||
va_list args;
|
||||
const char *p;
|
||||
int res;
|
||||
|
||||
va_start(args, arg);
|
||||
strvec_push(&argv, arg);
|
||||
while ((p = va_arg(args, const char *)))
|
||||
strvec_push(&argv, p);
|
||||
va_end(args);
|
||||
|
||||
res = run_command_v_opt(argv.v, RUN_GIT_CMD);
|
||||
|
||||
strvec_clear(&argv);
|
||||
return res;
|
||||
}
|
||||
|
||||
struct scalar_config {
|
||||
const char *key;
|
||||
const char *value;
|
||||
int overwrite_on_reconfigure;
|
||||
};
|
||||
|
||||
static int set_scalar_config(const struct scalar_config *config, int reconfigure)
|
||||
{
|
||||
char *value = NULL;
|
||||
int res;
|
||||
|
||||
if ((reconfigure && config->overwrite_on_reconfigure) ||
|
||||
git_config_get_string(config->key, &value)) {
|
||||
trace2_data_string("scalar", the_repository, config->key, "created");
|
||||
res = git_config_set_gently(config->key, config->value);
|
||||
} else {
|
||||
trace2_data_string("scalar", the_repository, config->key, "exists");
|
||||
res = 0;
|
||||
}
|
||||
|
||||
free(value);
|
||||
return res;
|
||||
}
|
||||
|
||||
static int have_fsmonitor_support(void)
|
||||
{
|
||||
return fsmonitor_ipc__is_supported() &&
|
||||
fsm_settings__get_reason(the_repository) == FSMONITOR_REASON_OK;
|
||||
}
|
||||
|
||||
static int set_recommended_config(int reconfigure)
|
||||
{
|
||||
struct scalar_config config[] = {
|
||||
/* Required */
|
||||
{ "am.keepCR", "true", 1 },
|
||||
{ "core.FSCache", "true", 1 },
|
||||
{ "core.multiPackIndex", "true", 1 },
|
||||
{ "core.preloadIndex", "true", 1 },
|
||||
#ifndef WIN32
|
||||
{ "core.untrackedCache", "true", 1 },
|
||||
#else
|
||||
/*
|
||||
* Unfortunately, Scalar's Functional Tests demonstrated
|
||||
* that the untracked cache feature is unreliable on Windows
|
||||
* (which is a bummer because that platform would benefit the
|
||||
* most from it). For some reason, freshly created files seem
|
||||
* not to update the directory's `lastModified` time
|
||||
* immediately, but the untracked cache would need to rely on
|
||||
* that.
|
||||
*
|
||||
* Therefore, with a sad heart, we disable this very useful
|
||||
* feature on Windows.
|
||||
*/
|
||||
{ "core.untrackedCache", "false", 1 },
|
||||
#endif
|
||||
{ "core.logAllRefUpdates", "true", 1 },
|
||||
{ "credential.https://dev.azure.com.useHttpPath", "true", 1 },
|
||||
{ "credential.validate", "false", 1 }, /* GCM4W-only */
|
||||
{ "gc.auto", "0", 1 },
|
||||
{ "gui.GCWarning", "false", 1 },
|
||||
{ "index.threads", "true", 1 },
|
||||
{ "index.version", "4", 1 },
|
||||
{ "merge.stat", "false", 1 },
|
||||
{ "merge.renames", "true", 1 },
|
||||
{ "pack.useBitmaps", "false", 1 },
|
||||
{ "pack.useSparse", "true", 1 },
|
||||
{ "receive.autoGC", "false", 1 },
|
||||
{ "feature.manyFiles", "false", 1 },
|
||||
{ "feature.experimental", "false", 1 },
|
||||
{ "fetch.unpackLimit", "1", 1 },
|
||||
{ "fetch.writeCommitGraph", "false", 1 },
|
||||
#ifdef WIN32
|
||||
{ "http.sslBackend", "schannel", 1 },
|
||||
#endif
|
||||
/* Optional */
|
||||
{ "status.aheadBehind", "false" },
|
||||
{ "commitGraph.generationVersion", "1" },
|
||||
{ "core.autoCRLF", "false" },
|
||||
{ "core.safeCRLF", "false" },
|
||||
{ "fetch.showForcedUpdates", "false" },
|
||||
{ NULL, NULL },
|
||||
};
|
||||
int i;
|
||||
char *value;
|
||||
|
||||
for (i = 0; config[i].key; i++) {
|
||||
if (set_scalar_config(config + i, reconfigure))
|
||||
return error(_("could not configure %s=%s"),
|
||||
config[i].key, config[i].value);
|
||||
}
|
||||
|
||||
if (have_fsmonitor_support()) {
|
||||
struct scalar_config fsmonitor = { "core.fsmonitor", "true" };
|
||||
if (set_scalar_config(&fsmonitor, reconfigure))
|
||||
return error(_("could not configure %s=%s"),
|
||||
fsmonitor.key, fsmonitor.value);
|
||||
}
|
||||
|
||||
/*
|
||||
* The `log.excludeDecoration` setting is special because it allows
|
||||
* for multiple values.
|
||||
*/
|
||||
if (git_config_get_string("log.excludeDecoration", &value)) {
|
||||
trace2_data_string("scalar", the_repository,
|
||||
"log.excludeDecoration", "created");
|
||||
if (git_config_set_multivar_gently("log.excludeDecoration",
|
||||
"refs/prefetch/*",
|
||||
CONFIG_REGEX_NONE, 0))
|
||||
return error(_("could not configure "
|
||||
"log.excludeDecoration"));
|
||||
} else {
|
||||
trace2_data_string("scalar", the_repository,
|
||||
"log.excludeDecoration", "exists");
|
||||
free(value);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int toggle_maintenance(int enable)
|
||||
{
|
||||
return run_git("maintenance", enable ? "start" : "unregister", NULL);
|
||||
}
|
||||
|
||||
static int add_or_remove_enlistment(int add)
|
||||
{
|
||||
int res;
|
||||
|
||||
if (!the_repository->worktree)
|
||||
die(_("Scalar enlistments require a worktree"));
|
||||
|
||||
res = run_git("config", "--global", "--get", "--fixed-value",
|
||||
"scalar.repo", the_repository->worktree, NULL);
|
||||
|
||||
/*
|
||||
* If we want to add and the setting is already there, then do nothing.
|
||||
* If we want to remove and the setting is not there, then do nothing.
|
||||
*/
|
||||
if ((add && !res) || (!add && res))
|
||||
return 0;
|
||||
|
||||
return run_git("config", "--global", add ? "--add" : "--unset",
|
||||
add ? "--no-fixed-value" : "--fixed-value",
|
||||
"scalar.repo", the_repository->worktree, NULL);
|
||||
}
|
||||
|
||||
static int start_fsmonitor_daemon(void)
|
||||
{
|
||||
assert(have_fsmonitor_support());
|
||||
|
||||
if (fsmonitor_ipc__get_state() != IPC_STATE__LISTENING)
|
||||
return run_git("fsmonitor--daemon", "start", NULL);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int stop_fsmonitor_daemon(void)
|
||||
{
|
||||
assert(have_fsmonitor_support());
|
||||
|
||||
if (fsmonitor_ipc__get_state() == IPC_STATE__LISTENING)
|
||||
return run_git("fsmonitor--daemon", "stop", NULL);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int register_dir(void)
|
||||
{
|
||||
if (add_or_remove_enlistment(1))
|
||||
return error(_("could not add enlistment"));
|
||||
|
||||
if (set_recommended_config(0))
|
||||
return error(_("could not set recommended config"));
|
||||
|
||||
if (toggle_maintenance(1))
|
||||
return error(_("could not turn on maintenance"));
|
||||
|
||||
if (have_fsmonitor_support() && start_fsmonitor_daemon()) {
|
||||
return error(_("could not start the FSMonitor daemon"));
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int unregister_dir(void)
|
||||
{
|
||||
int res = 0;
|
||||
|
||||
if (toggle_maintenance(0))
|
||||
res = error(_("could not turn off maintenance"));
|
||||
|
||||
if (add_or_remove_enlistment(0))
|
||||
res = error(_("could not remove enlistment"));
|
||||
|
||||
return res;
|
||||
}
|
||||
|
||||
/* printf-style interface, expects `<key>=<value>` argument */
|
||||
static int set_config(const char *fmt, ...)
|
||||
{
|
||||
struct strbuf buf = STRBUF_INIT;
|
||||
char *value;
|
||||
int res;
|
||||
va_list args;
|
||||
|
||||
va_start(args, fmt);
|
||||
strbuf_vaddf(&buf, fmt, args);
|
||||
va_end(args);
|
||||
|
||||
value = strchr(buf.buf, '=');
|
||||
if (value)
|
||||
*(value++) = '\0';
|
||||
res = git_config_set_gently(buf.buf, value);
|
||||
strbuf_release(&buf);
|
||||
|
||||
return res;
|
||||
}
|
||||
|
||||
static char *remote_default_branch(const char *url)
|
||||
{
|
||||
struct child_process cp = CHILD_PROCESS_INIT;
|
||||
struct strbuf out = STRBUF_INIT;
|
||||
|
||||
cp.git_cmd = 1;
|
||||
strvec_pushl(&cp.args, "ls-remote", "--symref", url, "HEAD", NULL);
|
||||
if (!pipe_command(&cp, NULL, 0, &out, 0, NULL, 0)) {
|
||||
const char *line = out.buf;
|
||||
|
||||
while (*line) {
|
||||
const char *eol = strchrnul(line, '\n'), *p;
|
||||
size_t len = eol - line;
|
||||
char *branch;
|
||||
|
||||
if (!skip_prefix(line, "ref: ", &p) ||
|
||||
!strip_suffix_mem(line, &len, "\tHEAD")) {
|
||||
line = eol + (*eol == '\n');
|
||||
continue;
|
||||
}
|
||||
|
||||
eol = line + len;
|
||||
if (skip_prefix(p, "refs/heads/", &p)) {
|
||||
branch = xstrndup(p, eol - p);
|
||||
strbuf_release(&out);
|
||||
return branch;
|
||||
}
|
||||
|
||||
error(_("remote HEAD is not a branch: '%.*s'"),
|
||||
(int)(eol - p), p);
|
||||
strbuf_release(&out);
|
||||
return NULL;
|
||||
}
|
||||
}
|
||||
warning(_("failed to get default branch name from remote; "
|
||||
"using local default"));
|
||||
strbuf_reset(&out);
|
||||
|
||||
child_process_init(&cp);
|
||||
cp.git_cmd = 1;
|
||||
strvec_pushl(&cp.args, "symbolic-ref", "--short", "HEAD", NULL);
|
||||
if (!pipe_command(&cp, NULL, 0, &out, 0, NULL, 0)) {
|
||||
strbuf_trim(&out);
|
||||
return strbuf_detach(&out, NULL);
|
||||
}
|
||||
|
||||
strbuf_release(&out);
|
||||
error(_("failed to get default branch name"));
|
||||
return NULL;
|
||||
}
|
||||
|
||||
static int delete_enlistment(struct strbuf *enlistment)
|
||||
{
|
||||
#ifdef WIN32
|
||||
struct strbuf parent = STRBUF_INIT;
|
||||
size_t offset;
|
||||
char *path_sep;
|
||||
#endif
|
||||
|
||||
if (unregister_dir())
|
||||
return error(_("failed to unregister repository"));
|
||||
|
||||
#ifdef WIN32
|
||||
/*
|
||||
* Change the current directory to one outside of the enlistment so
|
||||
* that we may delete everything underneath it.
|
||||
*/
|
||||
offset = offset_1st_component(enlistment->buf);
|
||||
path_sep = find_last_dir_sep(enlistment->buf + offset);
|
||||
strbuf_add(&parent, enlistment->buf,
|
||||
path_sep ? path_sep - enlistment->buf : offset);
|
||||
if (chdir(parent.buf) < 0) {
|
||||
int res = error_errno(_("could not switch to '%s'"), parent.buf);
|
||||
strbuf_release(&parent);
|
||||
return res;
|
||||
}
|
||||
strbuf_release(&parent);
|
||||
#endif
|
||||
|
||||
if (have_fsmonitor_support() && stop_fsmonitor_daemon())
|
||||
return error(_("failed to stop the FSMonitor daemon"));
|
||||
|
||||
if (remove_dir_recursively(enlistment, 0))
|
||||
return error(_("failed to delete enlistment directory"));
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*
|
||||
* Dummy implementation; Using `get_version_info()` would cause a link error
|
||||
* without this.
|
||||
*/
|
||||
void load_builtin_commands(const char *prefix, struct cmdnames *cmds)
|
||||
{
|
||||
die("not implemented");
|
||||
}
|
||||
|
||||
static int cmd_clone(int argc, const char **argv)
|
||||
{
|
||||
const char *branch = NULL;
|
||||
int full_clone = 0, single_branch = 0;
|
||||
struct option clone_options[] = {
|
||||
OPT_STRING('b', "branch", &branch, N_("<branch>"),
|
||||
N_("branch to checkout after clone")),
|
||||
OPT_BOOL(0, "full-clone", &full_clone,
|
||||
N_("when cloning, create full working directory")),
|
||||
OPT_BOOL(0, "single-branch", &single_branch,
|
||||
N_("only download metadata for the branch that will "
|
||||
"be checked out")),
|
||||
OPT_END(),
|
||||
};
|
||||
const char * const clone_usage[] = {
|
||||
N_("scalar clone [<options>] [--] <repo> [<dir>]"),
|
||||
NULL
|
||||
};
|
||||
const char *url;
|
||||
char *enlistment = NULL, *dir = NULL;
|
||||
struct strbuf buf = STRBUF_INIT;
|
||||
int res;
|
||||
|
||||
argc = parse_options(argc, argv, NULL, clone_options, clone_usage, 0);
|
||||
|
||||
if (argc == 2) {
|
||||
url = argv[0];
|
||||
enlistment = xstrdup(argv[1]);
|
||||
} else if (argc == 1) {
|
||||
url = argv[0];
|
||||
|
||||
strbuf_addstr(&buf, url);
|
||||
/* Strip trailing slashes, if any */
|
||||
while (buf.len > 0 && is_dir_sep(buf.buf[buf.len - 1]))
|
||||
strbuf_setlen(&buf, buf.len - 1);
|
||||
/* Strip suffix `.git`, if any */
|
||||
strbuf_strip_suffix(&buf, ".git");
|
||||
|
||||
enlistment = find_last_dir_sep(buf.buf);
|
||||
if (!enlistment) {
|
||||
die(_("cannot deduce worktree name from '%s'"), url);
|
||||
}
|
||||
enlistment = xstrdup(enlistment + 1);
|
||||
} else {
|
||||
usage_msg_opt(_("You must specify a repository to clone."),
|
||||
clone_usage, clone_options);
|
||||
}
|
||||
|
||||
if (is_directory(enlistment))
|
||||
die(_("directory '%s' exists already"), enlistment);
|
||||
|
||||
dir = xstrfmt("%s/src", enlistment);
|
||||
|
||||
strbuf_reset(&buf);
|
||||
if (branch)
|
||||
strbuf_addf(&buf, "init.defaultBranch=%s", branch);
|
||||
else {
|
||||
char *b = repo_default_branch_name(the_repository, 1);
|
||||
strbuf_addf(&buf, "init.defaultBranch=%s", b);
|
||||
free(b);
|
||||
}
|
||||
|
||||
if ((res = run_git("-c", buf.buf, "init", "--", dir, NULL)))
|
||||
goto cleanup;
|
||||
|
||||
if (chdir(dir) < 0) {
|
||||
res = error_errno(_("could not switch to '%s'"), dir);
|
||||
goto cleanup;
|
||||
}
|
||||
|
||||
setup_git_directory();
|
||||
|
||||
/* common-main already logs `argv` */
|
||||
trace2_def_repo(the_repository);
|
||||
|
||||
if (!branch && !(branch = remote_default_branch(url))) {
|
||||
res = error(_("failed to get default branch for '%s'"), url);
|
||||
goto cleanup;
|
||||
}
|
||||
|
||||
if (set_config("remote.origin.url=%s", url) ||
|
||||
set_config("remote.origin.fetch="
|
||||
"+refs/heads/%s:refs/remotes/origin/%s",
|
||||
single_branch ? branch : "*",
|
||||
single_branch ? branch : "*") ||
|
||||
set_config("remote.origin.promisor=true") ||
|
||||
set_config("remote.origin.partialCloneFilter=blob:none")) {
|
||||
res = error(_("could not configure remote in '%s'"), dir);
|
||||
goto cleanup;
|
||||
}
|
||||
|
||||
if (!full_clone &&
|
||||
(res = run_git("sparse-checkout", "init", "--cone", NULL)))
|
||||
goto cleanup;
|
||||
|
||||
if (set_recommended_config(0))
|
||||
return error(_("could not configure '%s'"), dir);
|
||||
|
||||
if ((res = run_git("fetch", "--quiet", "origin", NULL))) {
|
||||
warning(_("partial clone failed; attempting full clone"));
|
||||
|
||||
if (set_config("remote.origin.promisor") ||
|
||||
set_config("remote.origin.partialCloneFilter")) {
|
||||
res = error(_("could not configure for full clone"));
|
||||
goto cleanup;
|
||||
}
|
||||
|
||||
if ((res = run_git("fetch", "--quiet", "origin", NULL)))
|
||||
goto cleanup;
|
||||
}
|
||||
|
||||
if ((res = set_config("branch.%s.remote=origin", branch)))
|
||||
goto cleanup;
|
||||
if ((res = set_config("branch.%s.merge=refs/heads/%s",
|
||||
branch, branch)))
|
||||
goto cleanup;
|
||||
|
||||
strbuf_reset(&buf);
|
||||
strbuf_addf(&buf, "origin/%s", branch);
|
||||
res = run_git("checkout", "-f", "-t", buf.buf, NULL);
|
||||
if (res)
|
||||
goto cleanup;
|
||||
|
||||
res = register_dir();
|
||||
|
||||
cleanup:
|
||||
free(enlistment);
|
||||
free(dir);
|
||||
strbuf_release(&buf);
|
||||
return res;
|
||||
}
|
||||
|
||||
static int cmd_diagnose(int argc, const char **argv)
|
||||
{
|
||||
struct option options[] = {
|
||||
OPT_END(),
|
||||
};
|
||||
const char * const usage[] = {
|
||||
N_("scalar diagnose [<enlistment>]"),
|
||||
NULL
|
||||
};
|
||||
struct strbuf diagnostics_root = STRBUF_INIT;
|
||||
int res = 0;
|
||||
|
||||
argc = parse_options(argc, argv, NULL, options,
|
||||
usage, 0);
|
||||
|
||||
setup_enlistment_directory(argc, argv, usage, options, &diagnostics_root);
|
||||
strbuf_addstr(&diagnostics_root, "/.scalarDiagnostics");
|
||||
|
||||
res = run_git("diagnose", "--mode=all", "-s", "%Y%m%d_%H%M%S",
|
||||
"-o", diagnostics_root.buf, NULL);
|
||||
|
||||
strbuf_release(&diagnostics_root);
|
||||
return res;
|
||||
}
|
||||
|
||||
static int cmd_list(int argc, const char **argv)
|
||||
{
|
||||
if (argc != 1)
|
||||
die(_("`scalar list` does not take arguments"));
|
||||
|
||||
if (run_git("config", "--global", "--get-all", "scalar.repo", NULL) < 0)
|
||||
return -1;
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int cmd_register(int argc, const char **argv)
|
||||
{
|
||||
struct option options[] = {
|
||||
OPT_END(),
|
||||
};
|
||||
const char * const usage[] = {
|
||||
N_("scalar register [<enlistment>]"),
|
||||
NULL
|
||||
};
|
||||
|
||||
argc = parse_options(argc, argv, NULL, options,
|
||||
usage, 0);
|
||||
|
||||
setup_enlistment_directory(argc, argv, usage, options, NULL);
|
||||
|
||||
return register_dir();
|
||||
}
|
||||
|
||||
static int get_scalar_repos(const char *key, const char *value, void *data)
|
||||
{
|
||||
struct string_list *list = data;
|
||||
|
||||
if (!strcmp(key, "scalar.repo"))
|
||||
string_list_append(list, value);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int cmd_reconfigure(int argc, const char **argv)
|
||||
{
|
||||
int all = 0;
|
||||
struct option options[] = {
|
||||
OPT_BOOL('a', "all", &all,
|
||||
N_("reconfigure all registered enlistments")),
|
||||
OPT_END(),
|
||||
};
|
||||
const char * const usage[] = {
|
||||
N_("scalar reconfigure [--all | <enlistment>]"),
|
||||
NULL
|
||||
};
|
||||
struct string_list scalar_repos = STRING_LIST_INIT_DUP;
|
||||
int i, res = 0;
|
||||
struct repository r = { NULL };
|
||||
struct strbuf commondir = STRBUF_INIT, gitdir = STRBUF_INIT;
|
||||
|
||||
argc = parse_options(argc, argv, NULL, options,
|
||||
usage, 0);
|
||||
|
||||
if (!all) {
|
||||
setup_enlistment_directory(argc, argv, usage, options, NULL);
|
||||
|
||||
return set_recommended_config(1);
|
||||
}
|
||||
|
||||
if (argc > 0)
|
||||
usage_msg_opt(_("--all or <enlistment>, but not both"),
|
||||
usage, options);
|
||||
|
||||
git_config(get_scalar_repos, &scalar_repos);
|
||||
|
||||
for (i = 0; i < scalar_repos.nr; i++) {
|
||||
const char *dir = scalar_repos.items[i].string;
|
||||
|
||||
strbuf_reset(&commondir);
|
||||
strbuf_reset(&gitdir);
|
||||
|
||||
if (chdir(dir) < 0) {
|
||||
warning_errno(_("could not switch to '%s'"), dir);
|
||||
res = -1;
|
||||
} else if (discover_git_directory(&commondir, &gitdir) < 0) {
|
||||
warning_errno(_("git repository gone in '%s'"), dir);
|
||||
res = -1;
|
||||
} else {
|
||||
git_config_clear();
|
||||
|
||||
the_repository = &r;
|
||||
r.commondir = commondir.buf;
|
||||
r.gitdir = gitdir.buf;
|
||||
|
||||
if (set_recommended_config(1) < 0)
|
||||
res = -1;
|
||||
}
|
||||
}
|
||||
|
||||
string_list_clear(&scalar_repos, 1);
|
||||
strbuf_release(&commondir);
|
||||
strbuf_release(&gitdir);
|
||||
|
||||
return res;
|
||||
}
|
||||
|
||||
static int cmd_run(int argc, const char **argv)
|
||||
{
|
||||
struct option options[] = {
|
||||
OPT_END(),
|
||||
};
|
||||
struct {
|
||||
const char *arg, *task;
|
||||
} tasks[] = {
|
||||
{ "config", NULL },
|
||||
{ "commit-graph", "commit-graph" },
|
||||
{ "fetch", "prefetch" },
|
||||
{ "loose-objects", "loose-objects" },
|
||||
{ "pack-files", "incremental-repack" },
|
||||
{ NULL, NULL }
|
||||
};
|
||||
struct strbuf buf = STRBUF_INIT;
|
||||
const char *usagestr[] = { NULL, NULL };
|
||||
int i;
|
||||
|
||||
strbuf_addstr(&buf, N_("scalar run <task> [<enlistment>]\nTasks:\n"));
|
||||
for (i = 0; tasks[i].arg; i++)
|
||||
strbuf_addf(&buf, "\t%s\n", tasks[i].arg);
|
||||
usagestr[0] = buf.buf;
|
||||
|
||||
argc = parse_options(argc, argv, NULL, options,
|
||||
usagestr, 0);
|
||||
|
||||
if (!argc)
|
||||
usage_with_options(usagestr, options);
|
||||
|
||||
if (!strcmp("all", argv[0])) {
|
||||
i = -1;
|
||||
} else {
|
||||
for (i = 0; tasks[i].arg && strcmp(tasks[i].arg, argv[0]); i++)
|
||||
; /* keep looking for the task */
|
||||
|
||||
if (i > 0 && !tasks[i].arg) {
|
||||
error(_("no such task: '%s'"), argv[0]);
|
||||
usage_with_options(usagestr, options);
|
||||
}
|
||||
}
|
||||
|
||||
argc--;
|
||||
argv++;
|
||||
setup_enlistment_directory(argc, argv, usagestr, options, NULL);
|
||||
strbuf_release(&buf);
|
||||
|
||||
if (i == 0)
|
||||
return register_dir();
|
||||
|
||||
if (i > 0)
|
||||
return run_git("maintenance", "run",
|
||||
"--task", tasks[i].task, NULL);
|
||||
|
||||
if (register_dir())
|
||||
return -1;
|
||||
for (i = 1; tasks[i].arg; i++)
|
||||
if (run_git("maintenance", "run",
|
||||
"--task", tasks[i].task, NULL))
|
||||
return -1;
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int remove_deleted_enlistment(struct strbuf *path)
|
||||
{
|
||||
int res = 0;
|
||||
strbuf_realpath_forgiving(path, path->buf, 1);
|
||||
|
||||
if (run_git("config", "--global",
|
||||
"--unset", "--fixed-value",
|
||||
"scalar.repo", path->buf, NULL) < 0)
|
||||
res = -1;
|
||||
|
||||
if (run_git("config", "--global",
|
||||
"--unset", "--fixed-value",
|
||||
"maintenance.repo", path->buf, NULL) < 0)
|
||||
res = -1;
|
||||
|
||||
return res;
|
||||
}
|
||||
|
||||
static int cmd_unregister(int argc, const char **argv)
|
||||
{
|
||||
struct option options[] = {
|
||||
OPT_END(),
|
||||
};
|
||||
const char * const usage[] = {
|
||||
N_("scalar unregister [<enlistment>]"),
|
||||
NULL
|
||||
};
|
||||
|
||||
argc = parse_options(argc, argv, NULL, options,
|
||||
usage, 0);
|
||||
|
||||
/*
|
||||
* Be forgiving when the enlistment or worktree does not even exist any
|
||||
* longer; This can be the case if a user deleted the worktree by
|
||||
* mistake and _still_ wants to unregister the thing.
|
||||
*/
|
||||
if (argc == 1) {
|
||||
struct strbuf src_path = STRBUF_INIT, workdir_path = STRBUF_INIT;
|
||||
|
||||
strbuf_addf(&src_path, "%s/src/.git", argv[0]);
|
||||
strbuf_addf(&workdir_path, "%s/.git", argv[0]);
|
||||
if (!is_directory(src_path.buf) && !is_directory(workdir_path.buf)) {
|
||||
/* remove possible matching registrations */
|
||||
int res = -1;
|
||||
|
||||
strbuf_strip_suffix(&src_path, "/.git");
|
||||
res = remove_deleted_enlistment(&src_path) && res;
|
||||
|
||||
strbuf_strip_suffix(&workdir_path, "/.git");
|
||||
res = remove_deleted_enlistment(&workdir_path) && res;
|
||||
|
||||
strbuf_release(&src_path);
|
||||
strbuf_release(&workdir_path);
|
||||
return res;
|
||||
}
|
||||
strbuf_release(&src_path);
|
||||
strbuf_release(&workdir_path);
|
||||
}
|
||||
|
||||
setup_enlistment_directory(argc, argv, usage, options, NULL);
|
||||
|
||||
return unregister_dir();
|
||||
}
|
||||
|
||||
static int cmd_delete(int argc, const char **argv)
|
||||
{
|
||||
char *cwd = xgetcwd();
|
||||
struct option options[] = {
|
||||
OPT_END(),
|
||||
};
|
||||
const char * const usage[] = {
|
||||
N_("scalar delete <enlistment>"),
|
||||
NULL
|
||||
};
|
||||
struct strbuf enlistment = STRBUF_INIT;
|
||||
int res = 0;
|
||||
|
||||
argc = parse_options(argc, argv, NULL, options,
|
||||
usage, 0);
|
||||
|
||||
if (argc != 1)
|
||||
usage_with_options(usage, options);
|
||||
|
||||
setup_enlistment_directory(argc, argv, usage, options, &enlistment);
|
||||
|
||||
if (dir_inside_of(cwd, enlistment.buf) >= 0)
|
||||
res = error(_("refusing to delete current working directory"));
|
||||
else {
|
||||
close_object_store(the_repository->objects);
|
||||
res = delete_enlistment(&enlistment);
|
||||
}
|
||||
strbuf_release(&enlistment);
|
||||
free(cwd);
|
||||
|
||||
return res;
|
||||
}
|
||||
|
||||
static int cmd_version(int argc, const char **argv)
|
||||
{
|
||||
int verbose = 0, build_options = 0;
|
||||
struct option options[] = {
|
||||
OPT__VERBOSE(&verbose, N_("include Git version")),
|
||||
OPT_BOOL(0, "build-options", &build_options,
|
||||
N_("include Git's build options")),
|
||||
OPT_END(),
|
||||
};
|
||||
const char * const usage[] = {
|
||||
N_("scalar verbose [-v | --verbose] [--build-options]"),
|
||||
NULL
|
||||
};
|
||||
struct strbuf buf = STRBUF_INIT;
|
||||
|
||||
argc = parse_options(argc, argv, NULL, options,
|
||||
usage, 0);
|
||||
|
||||
if (argc != 0)
|
||||
usage_with_options(usage, options);
|
||||
|
||||
get_version_info(&buf, build_options);
|
||||
fprintf(stderr, "%s\n", buf.buf);
|
||||
strbuf_release(&buf);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static struct {
|
||||
const char *name;
|
||||
int (*fn)(int, const char **);
|
||||
} builtins[] = {
|
||||
{ "clone", cmd_clone },
|
||||
{ "list", cmd_list },
|
||||
{ "register", cmd_register },
|
||||
{ "unregister", cmd_unregister },
|
||||
{ "run", cmd_run },
|
||||
{ "reconfigure", cmd_reconfigure },
|
||||
{ "delete", cmd_delete },
|
||||
{ "version", cmd_version },
|
||||
{ "diagnose", cmd_diagnose },
|
||||
{ NULL, NULL},
|
||||
};
|
||||
|
||||
int cmd_main(int argc, const char **argv)
|
||||
{
|
||||
struct strbuf scalar_usage = STRBUF_INIT;
|
||||
int i;
|
||||
|
||||
while (argc > 1 && *argv[1] == '-') {
|
||||
if (!strcmp(argv[1], "-C")) {
|
||||
if (argc < 3)
|
||||
die(_("-C requires a <directory>"));
|
||||
if (chdir(argv[2]) < 0)
|
||||
die_errno(_("could not change to '%s'"),
|
||||
argv[2]);
|
||||
argc -= 2;
|
||||
argv += 2;
|
||||
} else if (!strcmp(argv[1], "-c")) {
|
||||
if (argc < 3)
|
||||
die(_("-c requires a <key>=<value> argument"));
|
||||
git_config_push_parameter(argv[2]);
|
||||
argc -= 2;
|
||||
argv += 2;
|
||||
} else
|
||||
break;
|
||||
}
|
||||
|
||||
if (argc > 1) {
|
||||
argv++;
|
||||
argc--;
|
||||
|
||||
for (i = 0; builtins[i].name; i++)
|
||||
if (!strcmp(builtins[i].name, argv[0]))
|
||||
return !!builtins[i].fn(argc, argv);
|
||||
}
|
||||
|
||||
strbuf_addstr(&scalar_usage,
|
||||
N_("scalar [-C <directory>] [-c <key>=<value>] "
|
||||
"<command> [<options>]\n\nCommands:\n"));
|
||||
for (i = 0; builtins[i].name; i++)
|
||||
strbuf_addf(&scalar_usage, "\t%s\n", builtins[i].name);
|
||||
|
||||
usage(scalar_usage.buf);
|
||||
}
|
||||
@ -1,166 +0,0 @@
|
||||
scalar(1)
|
||||
=========
|
||||
|
||||
NAME
|
||||
----
|
||||
scalar - A tool for managing large Git repositories
|
||||
|
||||
SYNOPSIS
|
||||
--------
|
||||
[verse]
|
||||
scalar clone [--single-branch] [--branch <main-branch>] [--full-clone] <url> [<enlistment>]
|
||||
scalar list
|
||||
scalar register [<enlistment>]
|
||||
scalar unregister [<enlistment>]
|
||||
scalar run ( all | config | commit-graph | fetch | loose-objects | pack-files ) [<enlistment>]
|
||||
scalar reconfigure [ --all | <enlistment> ]
|
||||
scalar diagnose [<enlistment>]
|
||||
scalar delete <enlistment>
|
||||
|
||||
DESCRIPTION
|
||||
-----------
|
||||
|
||||
Scalar is a repository management tool that optimizes Git for use in large
|
||||
repositories. Scalar improves performance by configuring advanced Git settings,
|
||||
maintaining repositories in the background, and helping to reduce data sent
|
||||
across the network.
|
||||
|
||||
An important Scalar concept is the enlistment: this is the top-level directory
|
||||
of the project. It usually contains the subdirectory `src/` which is a Git
|
||||
worktree. This encourages the separation between tracked files (inside `src/`)
|
||||
and untracked files, such as build artifacts (outside `src/`). When registering
|
||||
an existing Git worktree with Scalar whose name is not `src`, the enlistment
|
||||
will be identical to the worktree.
|
||||
|
||||
The `scalar` command implements various subcommands, and different options
|
||||
depending on the subcommand. With the exception of `clone`, `list` and
|
||||
`reconfigure --all`, all subcommands expect to be run in an enlistment.
|
||||
|
||||
The following options can be specified _before_ the subcommand:
|
||||
|
||||
-C <directory>::
|
||||
Before running the subcommand, change the working directory. This
|
||||
option imitates the same option of linkgit:git[1].
|
||||
|
||||
-c <key>=<value>::
|
||||
For the duration of running the specified subcommand, configure this
|
||||
setting. This option imitates the same option of linkgit:git[1].
|
||||
|
||||
COMMANDS
|
||||
--------
|
||||
|
||||
Clone
|
||||
~~~~~
|
||||
|
||||
clone [<options>] <url> [<enlistment>]::
|
||||
Clones the specified repository, similar to linkgit:git-clone[1]. By
|
||||
default, only commit and tree objects are cloned. Once finished, the
|
||||
worktree is located at `<enlistment>/src`.
|
||||
+
|
||||
The sparse-checkout feature is enabled (except when run with `--full-clone`)
|
||||
and the only files present are those in the top-level directory. Use
|
||||
`git sparse-checkout set` to expand the set of directories you want to see,
|
||||
or `git sparse-checkout disable` to expand to all files (see
|
||||
linkgit:git-sparse-checkout[1] for more details). You can explore the
|
||||
subdirectories outside your sparse-checkout by using `git ls-tree
|
||||
HEAD[:<directory>]`.
|
||||
|
||||
-b <name>::
|
||||
--branch <name>::
|
||||
Instead of checking out the branch pointed to by the cloned
|
||||
repository's HEAD, check out the `<name>` branch instead.
|
||||
|
||||
--[no-]single-branch::
|
||||
Clone only the history leading to the tip of a single branch, either
|
||||
specified by the `--branch` option or the primary branch remote's
|
||||
`HEAD` points at.
|
||||
+
|
||||
Further fetches into the resulting repository will only update the
|
||||
remote-tracking branch for the branch this option was used for the initial
|
||||
cloning. If the HEAD at the remote did not point at any branch when
|
||||
`--single-branch` clone was made, no remote-tracking branch is created.
|
||||
|
||||
--[no-]full-clone::
|
||||
A sparse-checkout is initialized by default. This behavior can be
|
||||
turned off via `--full-clone`.
|
||||
|
||||
List
|
||||
~~~~
|
||||
|
||||
list::
|
||||
List enlistments that are currently registered by Scalar. This
|
||||
subcommand does not need to be run inside an enlistment.
|
||||
|
||||
Register
|
||||
~~~~~~~~
|
||||
|
||||
register [<enlistment>]::
|
||||
Adds the enlistment's repository to the list of registered repositories
|
||||
and starts background maintenance. If `<enlistment>` is not provided,
|
||||
then the enlistment associated with the current working directory is
|
||||
registered.
|
||||
+
|
||||
Note: when this subcommand is called in a worktree that is called `src/`, its
|
||||
parent directory is considered to be the Scalar enlistment. If the worktree is
|
||||
_not_ called `src/`, it itself will be considered to be the Scalar enlistment.
|
||||
|
||||
Unregister
|
||||
~~~~~~~~~~
|
||||
|
||||
unregister [<enlistment>]::
|
||||
Remove the specified repository from the list of repositories
|
||||
registered with Scalar and stop the scheduled background maintenance.
|
||||
|
||||
Run
|
||||
~~~
|
||||
|
||||
scalar run ( all | config | commit-graph | fetch | loose-objects | pack-files ) [<enlistment>]::
|
||||
Run the given maintenance task (or all tasks, if `all` was specified).
|
||||
Except for `all` and `config`, this subcommand simply hands off to
|
||||
linkgit:git-maintenance[1] (mapping `fetch` to `prefetch` and
|
||||
`pack-files` to `incremental-repack`).
|
||||
+
|
||||
These tasks are run automatically as part of the scheduled maintenance,
|
||||
as soon as the repository is registered with Scalar. It should therefore
|
||||
not be necessary to run this subcommand manually.
|
||||
+
|
||||
The `config` task is specific to Scalar and configures all those
|
||||
opinionated default settings that make Git work more efficiently with
|
||||
large repositories. As this task is run as part of `scalar clone`
|
||||
automatically, explicit invocations of this task are rarely needed.
|
||||
|
||||
Reconfigure
|
||||
~~~~~~~~~~~
|
||||
|
||||
After a Scalar upgrade, or when the configuration of a Scalar enlistment
|
||||
was somehow corrupted or changed by mistake, this subcommand allows to
|
||||
reconfigure the enlistment.
|
||||
|
||||
With the `--all` option, all enlistments currently registered with Scalar
|
||||
will be reconfigured. Use this option after each Scalar upgrade.
|
||||
|
||||
Diagnose
|
||||
~~~~~~~~
|
||||
|
||||
diagnose [<enlistment>]::
|
||||
When reporting issues with Scalar, it is often helpful to provide the
|
||||
information gathered by this command, including logs and certain
|
||||
statistics describing the data shape of the current enlistment.
|
||||
+
|
||||
The output of this command is a `.zip` file that is written into
|
||||
a directory adjacent to the worktree in the `src` directory.
|
||||
|
||||
Delete
|
||||
~~~~~~
|
||||
|
||||
delete <enlistment>::
|
||||
This subcommand lets you delete an existing Scalar enlistment from your
|
||||
local file system, unregistering the repository.
|
||||
|
||||
SEE ALSO
|
||||
--------
|
||||
linkgit:git-clone[1], linkgit:git-maintenance[1].
|
||||
|
||||
Scalar
|
||||
---
|
||||
Associated with the linkgit:git[1] suite
|
||||
@ -1,81 +0,0 @@
|
||||
# Import tree-wide shared Makefile behavior and libraries
|
||||
include ../../../shared.mak
|
||||
|
||||
# Run scalar tests
|
||||
#
|
||||
# Copyright (c) 2005,2021 Junio C Hamano, Johannes Schindelin
|
||||
#
|
||||
|
||||
-include ../../../config.mak.autogen
|
||||
-include ../../../config.mak
|
||||
|
||||
SHELL_PATH ?= $(SHELL)
|
||||
PERL_PATH ?= /usr/bin/perl
|
||||
RM ?= rm -f
|
||||
PROVE ?= prove
|
||||
DEFAULT_TEST_TARGET ?= test
|
||||
TEST_LINT ?= test-lint
|
||||
|
||||
ifdef TEST_OUTPUT_DIRECTORY
|
||||
TEST_RESULTS_DIRECTORY = $(TEST_OUTPUT_DIRECTORY)/test-results
|
||||
else
|
||||
TEST_RESULTS_DIRECTORY = ../../../t/test-results
|
||||
endif
|
||||
|
||||
# Shell quote;
|
||||
SHELL_PATH_SQ = $(subst ','\'',$(SHELL_PATH))
|
||||
PERL_PATH_SQ = $(subst ','\'',$(PERL_PATH))
|
||||
TEST_RESULTS_DIRECTORY_SQ = $(subst ','\'',$(TEST_RESULTS_DIRECTORY))
|
||||
|
||||
T = $(sort $(wildcard t[0-9][0-9][0-9][0-9]-*.sh))
|
||||
|
||||
all: $(DEFAULT_TEST_TARGET)
|
||||
|
||||
test: $(TEST_LINT)
|
||||
$(MAKE) aggregate-results-and-cleanup
|
||||
|
||||
prove: $(TEST_LINT)
|
||||
@echo "*** prove ***"; GIT_CONFIG=.git/config $(PROVE) --exec '$(SHELL_PATH_SQ)' $(GIT_PROVE_OPTS) $(T) :: $(GIT_TEST_OPTS)
|
||||
$(MAKE) clean-except-prove-cache
|
||||
|
||||
$(T):
|
||||
@echo "*** $@ ***"; GIT_CONFIG=.git/config '$(SHELL_PATH_SQ)' $@ $(GIT_TEST_OPTS)
|
||||
|
||||
clean-except-prove-cache:
|
||||
$(RM) -r 'trash directory'.*
|
||||
$(RM) -r valgrind/bin
|
||||
|
||||
clean: clean-except-prove-cache
|
||||
$(RM) .prove
|
||||
|
||||
test-lint: test-lint-duplicates test-lint-executable test-lint-shell-syntax
|
||||
|
||||
test-lint-duplicates:
|
||||
@dups=`echo $(T) | tr ' ' '\n' | sed 's/-.*//' | sort | uniq -d` && \
|
||||
test -z "$$dups" || { \
|
||||
echo >&2 "duplicate test numbers:" $$dups; exit 1; }
|
||||
|
||||
test-lint-executable:
|
||||
@bad=`for i in $(T); do test -x "$$i" || echo $$i; done` && \
|
||||
test -z "$$bad" || { \
|
||||
echo >&2 "non-executable tests:" $$bad; exit 1; }
|
||||
|
||||
test-lint-shell-syntax:
|
||||
@'$(PERL_PATH_SQ)' ../../../t/check-non-portable-shell.pl $(T)
|
||||
|
||||
aggregate-results-and-cleanup: $(T)
|
||||
$(MAKE) aggregate-results
|
||||
$(MAKE) clean
|
||||
|
||||
aggregate-results:
|
||||
for f in '$(TEST_RESULTS_DIRECTORY_SQ)'/t*-*.counts; do \
|
||||
echo "$$f"; \
|
||||
done | '$(SHELL_PATH_SQ)' ../../../t/aggregate-results.sh
|
||||
|
||||
valgrind:
|
||||
$(MAKE) GIT_TEST_OPTS="$(GIT_TEST_OPTS) --valgrind"
|
||||
|
||||
test-results:
|
||||
mkdir -p test-results
|
||||
|
||||
.PHONY: $(T) aggregate-results clean valgrind
|
||||
@ -1,216 +0,0 @@
|
||||
#!/bin/sh
|
||||
|
||||
test_description='test the `scalar` command'
|
||||
|
||||
TEST_DIRECTORY=$PWD/../../../t
|
||||
export TEST_DIRECTORY
|
||||
|
||||
# Make it work with --no-bin-wrappers
|
||||
PATH=$PWD/..:$PATH
|
||||
|
||||
. ../../../t/test-lib.sh
|
||||
|
||||
GIT_TEST_MAINT_SCHEDULER="crontab:test-tool crontab ../cron.txt,launchctl:true,schtasks:true"
|
||||
export GIT_TEST_MAINT_SCHEDULER
|
||||
|
||||
test_expect_success 'scalar shows a usage' '
|
||||
test_expect_code 129 scalar -h
|
||||
'
|
||||
|
||||
test_expect_success 'scalar invoked on enlistment root' '
|
||||
test_when_finished rm -rf test src deeper &&
|
||||
|
||||
for enlistment_root in test src deeper/test
|
||||
do
|
||||
git init ${enlistment_root}/src &&
|
||||
|
||||
# Register
|
||||
scalar register ${enlistment_root} &&
|
||||
scalar list >out &&
|
||||
grep "$(pwd)/${enlistment_root}/src\$" out &&
|
||||
|
||||
# Delete (including enlistment root)
|
||||
scalar delete $enlistment_root &&
|
||||
test_path_is_missing $enlistment_root &&
|
||||
scalar list >out &&
|
||||
! grep "^$(pwd)/${enlistment_root}/src\$" out || return 1
|
||||
done
|
||||
'
|
||||
|
||||
test_expect_success 'scalar invoked on enlistment src repo' '
|
||||
test_when_finished rm -rf test src deeper &&
|
||||
|
||||
for enlistment_root in test src deeper/test
|
||||
do
|
||||
git init ${enlistment_root}/src &&
|
||||
|
||||
# Register
|
||||
scalar register ${enlistment_root}/src &&
|
||||
scalar list >out &&
|
||||
grep "$(pwd)/${enlistment_root}/src\$" out &&
|
||||
|
||||
# Delete (will not include enlistment root)
|
||||
scalar delete ${enlistment_root}/src &&
|
||||
test_path_is_dir $enlistment_root &&
|
||||
scalar list >out &&
|
||||
! grep "^$(pwd)/${enlistment_root}/src\$" out || return 1
|
||||
done
|
||||
'
|
||||
|
||||
test_expect_success 'scalar invoked when enlistment root and repo are the same' '
|
||||
test_when_finished rm -rf test src deeper &&
|
||||
|
||||
for enlistment_root in test src deeper/test
|
||||
do
|
||||
git init ${enlistment_root} &&
|
||||
|
||||
# Register
|
||||
scalar register ${enlistment_root} &&
|
||||
scalar list >out &&
|
||||
grep "$(pwd)/${enlistment_root}\$" out &&
|
||||
|
||||
# Delete (will not include enlistment root)
|
||||
scalar delete ${enlistment_root} &&
|
||||
test_path_is_missing $enlistment_root &&
|
||||
scalar list >out &&
|
||||
! grep "^$(pwd)/${enlistment_root}\$" out &&
|
||||
|
||||
# Make sure we did not accidentally delete the trash dir
|
||||
test_path_is_dir "$TRASH_DIRECTORY" || return 1
|
||||
done
|
||||
'
|
||||
|
||||
test_expect_success 'scalar repo search respects GIT_CEILING_DIRECTORIES' '
|
||||
test_when_finished rm -rf test &&
|
||||
|
||||
git init test/src &&
|
||||
mkdir -p test/src/deep &&
|
||||
GIT_CEILING_DIRECTORIES="$(pwd)/test/src" &&
|
||||
! scalar register test/src/deep 2>err &&
|
||||
grep "not a git repository" err
|
||||
'
|
||||
|
||||
test_expect_success 'scalar enlistments need a worktree' '
|
||||
test_when_finished rm -rf bare test &&
|
||||
|
||||
git init --bare bare/src &&
|
||||
! scalar register bare/src 2>err &&
|
||||
grep "Scalar enlistments require a worktree" err &&
|
||||
|
||||
git init test/src &&
|
||||
! scalar register test/src/.git 2>err &&
|
||||
grep "Scalar enlistments require a worktree" err
|
||||
'
|
||||
|
||||
test_expect_success FSMONITOR_DAEMON 'scalar register starts fsmon daemon' '
|
||||
git init test/src &&
|
||||
test_must_fail git -C test/src fsmonitor--daemon status &&
|
||||
scalar register test/src &&
|
||||
git -C test/src fsmonitor--daemon status &&
|
||||
test_cmp_config -C test/src true core.fsmonitor
|
||||
'
|
||||
|
||||
test_expect_success 'scalar unregister' '
|
||||
git init vanish/src &&
|
||||
scalar register vanish/src &&
|
||||
git config --get --global --fixed-value \
|
||||
maintenance.repo "$(pwd)/vanish/src" &&
|
||||
scalar list >scalar.repos &&
|
||||
grep -F "$(pwd)/vanish/src" scalar.repos &&
|
||||
rm -rf vanish/src/.git &&
|
||||
scalar unregister vanish &&
|
||||
test_must_fail git config --get --global --fixed-value \
|
||||
maintenance.repo "$(pwd)/vanish/src" &&
|
||||
scalar list >scalar.repos &&
|
||||
! grep -F "$(pwd)/vanish/src" scalar.repos
|
||||
'
|
||||
|
||||
test_expect_success 'set up repository to clone' '
|
||||
test_commit first &&
|
||||
test_commit second &&
|
||||
test_commit third &&
|
||||
git switch -c parallel first &&
|
||||
mkdir -p 1/2 &&
|
||||
test_commit 1/2/3 &&
|
||||
git config uploadPack.allowFilter true &&
|
||||
git config uploadPack.allowAnySHA1InWant true
|
||||
'
|
||||
|
||||
test_expect_success 'scalar clone' '
|
||||
second=$(git rev-parse --verify second:second.t) &&
|
||||
scalar clone "file://$(pwd)" cloned --single-branch &&
|
||||
(
|
||||
cd cloned/src &&
|
||||
|
||||
git config --get --global --fixed-value maintenance.repo \
|
||||
"$(pwd)" &&
|
||||
|
||||
git for-each-ref --format="%(refname)" refs/remotes/origin/ >actual &&
|
||||
echo "refs/remotes/origin/parallel" >expect &&
|
||||
test_cmp expect actual &&
|
||||
|
||||
test_path_is_missing 1/2 &&
|
||||
test_must_fail git rev-list --missing=print $second &&
|
||||
git rev-list $second &&
|
||||
git cat-file blob $second >actual &&
|
||||
echo "second" >expect &&
|
||||
test_cmp expect actual
|
||||
)
|
||||
'
|
||||
|
||||
test_expect_success 'scalar reconfigure' '
|
||||
git init one/src &&
|
||||
scalar register one &&
|
||||
git -C one/src config core.preloadIndex false &&
|
||||
scalar reconfigure one &&
|
||||
test true = "$(git -C one/src config core.preloadIndex)" &&
|
||||
git -C one/src config core.preloadIndex false &&
|
||||
scalar reconfigure -a &&
|
||||
test true = "$(git -C one/src config core.preloadIndex)"
|
||||
'
|
||||
|
||||
test_expect_success 'scalar delete without enlistment shows a usage' '
|
||||
test_expect_code 129 scalar delete
|
||||
'
|
||||
|
||||
test_expect_success 'scalar delete with enlistment' '
|
||||
scalar delete cloned &&
|
||||
test_path_is_missing cloned
|
||||
'
|
||||
|
||||
test_expect_success 'scalar supports -c/-C' '
|
||||
test_when_finished "scalar delete sub" &&
|
||||
git init sub &&
|
||||
scalar -C sub -c status.aheadBehind=bogus register &&
|
||||
test -z "$(git -C sub config --local status.aheadBehind)" &&
|
||||
test true = "$(git -C sub config core.preloadIndex)"
|
||||
'
|
||||
|
||||
test_expect_success '`scalar [...] <dir>` errors out when dir is missing' '
|
||||
! scalar run config cloned 2>err &&
|
||||
grep "cloned. does not exist" err
|
||||
'
|
||||
|
||||
SQ="'"
|
||||
test_expect_success UNZIP 'scalar diagnose' '
|
||||
scalar clone "file://$(pwd)" cloned --single-branch &&
|
||||
git repack &&
|
||||
echo "$(pwd)/.git/objects/" >>cloned/src/.git/objects/info/alternates &&
|
||||
test_commit -C cloned/src loose &&
|
||||
scalar diagnose cloned >out 2>err &&
|
||||
grep "Available space" out &&
|
||||
sed -n "s/.*$SQ\\(.*\\.zip\\)$SQ.*/\\1/p" <err >zip_path &&
|
||||
zip_path=$(cat zip_path) &&
|
||||
test -n "$zip_path" &&
|
||||
"$GIT_UNZIP" -v "$zip_path" &&
|
||||
folder=${zip_path%.zip} &&
|
||||
test_path_is_missing "$folder" &&
|
||||
"$GIT_UNZIP" -p "$zip_path" diagnostics.log >out &&
|
||||
test_file_not_empty out &&
|
||||
"$GIT_UNZIP" -p "$zip_path" packs-local.txt >out &&
|
||||
grep "$(pwd)/.git/objects" out &&
|
||||
"$GIT_UNZIP" -p "$zip_path" objects-local.txt >out &&
|
||||
grep "^Total: [1-9]" out
|
||||
'
|
||||
|
||||
test_done
|
||||
Reference in New Issue
Block a user