kernel
/
git
mirror of https://git.kernel.org/pub/scm/git/git.git
1
0
Fork 0
Code Releases Activity

Merge branch 'js/early-config' 

The start-up sequence of "git" needs to figure out some configured
settings before it finds and set itself up in the location of the
repository and was quite messy due to its "chicken-and-egg" nature.
The code has been restructured.

* js/early-config:
  setup.c: mention unresolved problems
  t1309: document cases where we would want early config not to die()
  setup_git_directory_gently_1(): avoid die()ing
  t1309: test read_early_config()
  read_early_config(): really discover .git/
  read_early_config(): avoid .git/config hack when unneeded
  setup: make read_early_config() reusable
  setup: introduce the discover_git_directory() function
  setup_git_directory_1(): avoid changing global state
  setup: prepare setup_discovered_git_dir() for the root directory
  setup_git_directory(): use is_dir_sep() helper
  t7006: replace dubious test
maint
Junio C Hamano 2017-03-17 13:50:28 -07:00
parent 81944e9b54 5c4003ca3f
commit a0393a298f
7 changed files with 333 additions and 131 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
cache.h
View File

@ -518,6 +518,13 @@ extern void set_git_work_tree(const char *tree);
#define ALTERNATE_DB_ENVIRONMENT "GIT_ALTERNATE_OBJECT_DIRECTORIES"

extern void setup_work_tree(void);
/*
* Find GIT_DIR of the repository that contains the current working directory,
* without changing the working directory or other global state. The result is
* appended to gitdir. The return value is either NULL if no repository was
* found, or pointing to the path inside gitdir's buffer.
*/
extern const char *discover_git_directory(struct strbuf *gitdir);
extern const char *setup_git_directory_gently(int *);
extern const char *setup_git_directory(void);
extern char *prefix_path(const char *prefix, int len, const char *path);
@ -1842,6 +1849,7 @@ extern int git_config_from_blob_sha1(config_fn_t fn, const char *name,
const unsigned char *sha1, void *data);
extern void git_config_push_parameter(const char *text);
extern int git_config_from_parameters(config_fn_t fn, void *data);
extern void read_early_config(config_fn_t cb, void *data);
extern void git_config(config_fn_t fn, void *);
extern int git_config_with_options(config_fn_t fn, void *,
struct git_config_source *config_source,

25
config.c
View File

@ -1503,6 +1503,31 @@ static void configset_iter(struct config_set *cs, config_fn_t fn, void *data)
}
}

void read_early_config(config_fn_t cb, void *data)
{
struct strbuf buf = STRBUF_INIT;

git_config_with_options(cb, data, NULL, 1);

/*
* When setup_git_directory() was not yet asked to discover the
* GIT_DIR, we ask discover_git_directory() to figure out whether there
* is any repository config we should use (but unlike
* setup_git_directory_gently(), no global state is changed, most
* notably, the current working directory is still the same after the
* call).
*/
if (!have_git_dir() && discover_git_directory(&buf)) {
struct git_config_source repo_config;

memset(&repo_config, 0, sizeof(repo_config));
strbuf_addstr(&buf, "/config");
repo_config.file = buf.buf;
git_config_with_options(cb, data, &repo_config, 1);
}
strbuf_release(&buf);
}

static void git_config_check_init(void);

void git_config(config_fn_t fn, void *data)

31
pager.c
View File

@ -43,37 +43,6 @@ static int core_pager_config(const char *var, const char *value, void *data)
return 0;
}

static void read_early_config(config_fn_t cb, void *data)
{
git_config_with_options(cb, data, NULL, 1);

/*
* Note that this is a really dirty hack that does the wrong thing in
* many cases. The crux of the problem is that we cannot run
* setup_git_directory() early on in git's setup, so we have no idea if
* we are in a repository or not, and therefore are not sure whether
* and how to read repository-local config.
*
* So if we _aren't_ in a repository (or we are but we would reject its
* core.repositoryformatversion), we'll read whatever is in .git/config
* blindly. Similarly, if we _are_ in a repository, but not at the
* root, we'll fail to find .git/config (because it's really
* ../.git/config, etc). See t7006 for a complete set of failures.
*
* However, we have historically provided this hack because it does
* work some of the time (namely when you are at the top-level of a
* valid repository), and would rarely make things worse (i.e., you do
* not generally have a .git/config file sitting around).
*/
if (!startup_info->have_repository) {
struct git_config_source repo_config;

memset(&repo_config, 0, sizeof(repo_config));
repo_config.file = ".git/config";
git_config_with_options(cb, data, &repo_config, 1);
}
}

const char *git_pager(int stdout_is_tty)
{
const char *pager;

293
setup.c
View File

@ -531,6 +531,7 @@ const char *read_gitfile_gently(const char *path, int *return_error_code)
ssize_t len;

if (stat(path, &st)) {
/* NEEDSWORK: discern between ENOENT vs other errors */
error_code = READ_GITFILE_ERR_STAT_FAILED;
goto cleanup_return;
}
@ -721,8 +722,10 @@ static const char *setup_discovered_git_dir(const char *gitdir,
if (offset == cwd->len)
return NULL;

/* Make "offset" point to past the '/', and add a '/' at the end */
offset++;
/* Make "offset" point past the '/' (already the case for root dirs) */
if (offset != offset_1st_component(cwd->buf))
offset++;
/* Add a '/' at the end */
strbuf_addch(cwd, '/');
return cwd->buf + offset;
}
@ -816,21 +819,171 @@ static int canonicalize_ceiling_entry(struct string_list_item *item,
}
}

enum discovery_result {
GIT_DIR_NONE = 0,
GIT_DIR_EXPLICIT,
GIT_DIR_DISCOVERED,
GIT_DIR_BARE,
/* these are errors */
GIT_DIR_HIT_CEILING = -1,
GIT_DIR_HIT_MOUNT_POINT = -2,
GIT_DIR_INVALID_GITFILE = -3
};

/*
* We cannot decide in this function whether we are in the work tree or
* not, since the config can only be read _after_ this function was called.
*
* Also, we avoid changing any global state (such as the current working
* directory) to allow early callers.
*
* The directory where the search should start needs to be passed in via the
* `dir` parameter; upon return, the `dir` buffer will contain the path of
* the directory where the search ended, and `gitdir` will contain the path of
* the discovered .git/ directory, if any. If `gitdir` is not absolute, it
* is relative to `dir` (i.e. *not* necessarily the cwd).
*/
static const char *setup_git_directory_gently_1(int *nongit_ok)
static enum discovery_result setup_git_directory_gently_1(struct strbuf *dir,
struct strbuf *gitdir,
int die_on_error)
{
const char *env_ceiling_dirs = getenv(CEILING_DIRECTORIES_ENVIRONMENT);
struct string_list ceiling_dirs = STRING_LIST_INIT_DUP;
static struct strbuf cwd = STRBUF_INIT;
const char *gitdirenv, *ret;
char *gitfile;
int offset, offset_parent, ceil_offset = -1;
const char *gitdirenv;
int ceil_offset = -1, min_offset = has_dos_drive_prefix(dir->buf) ? 3 : 1;
dev_t current_device = 0;
int one_filesystem = 1;

/*
* If GIT_DIR is set explicitly, we're not going
* to do any discovery, but we still do repository
* validation.
*/
gitdirenv = getenv(GIT_DIR_ENVIRONMENT);
if (gitdirenv) {
strbuf_addstr(gitdir, gitdirenv);
return GIT_DIR_EXPLICIT;
}

if (env_ceiling_dirs) {
int empty_entry_found = 0;

string_list_split(&ceiling_dirs, env_ceiling_dirs, PATH_SEP, -1);
filter_string_list(&ceiling_dirs, 0,
canonicalize_ceiling_entry, &empty_entry_found);
ceil_offset = longest_ancestor_length(dir->buf, &ceiling_dirs);
string_list_clear(&ceiling_dirs, 0);
}

if (ceil_offset < 0)
ceil_offset = min_offset - 2;

/*
* Test in the following order (relative to the dir):
* - .git (file containing "gitdir: <path>")
* - .git/
* - ./ (bare)
* - ../.git
* - ../.git/
* - ../ (bare)
* - ../../.git/
* etc.
*/
one_filesystem = !git_env_bool("GIT_DISCOVERY_ACROSS_FILESYSTEM", 0);
if (one_filesystem)
current_device = get_device_or_die(dir->buf, NULL, 0);
for (;;) {
int offset = dir->len, error_code = 0;

if (offset > min_offset)
strbuf_addch(dir, '/');
strbuf_addstr(dir, DEFAULT_GIT_DIR_ENVIRONMENT);
gitdirenv = read_gitfile_gently(dir->buf, die_on_error ?
NULL : &error_code);
if (!gitdirenv) {
if (die_on_error ||
error_code == READ_GITFILE_ERR_NOT_A_FILE) {
/* NEEDSWORK: fail if .git is not file nor dir */
if (is_git_directory(dir->buf))
gitdirenv = DEFAULT_GIT_DIR_ENVIRONMENT;
} else if (error_code != READ_GITFILE_ERR_STAT_FAILED)
return GIT_DIR_INVALID_GITFILE;
}
strbuf_setlen(dir, offset);
if (gitdirenv) {
strbuf_addstr(gitdir, gitdirenv);
return GIT_DIR_DISCOVERED;
}

if (is_git_directory(dir->buf)) {
strbuf_addstr(gitdir, ".");
return GIT_DIR_BARE;
}

if (offset <= min_offset)
return GIT_DIR_HIT_CEILING;

while (--offset > ceil_offset && !is_dir_sep(dir->buf[offset]))
; /* continue */
if (offset <= ceil_offset)
return GIT_DIR_HIT_CEILING;

strbuf_setlen(dir, offset > min_offset ? offset : min_offset);
if (one_filesystem &&
current_device != get_device_or_die(dir->buf, NULL, offset))
return GIT_DIR_HIT_MOUNT_POINT;
}
}

const char *discover_git_directory(struct strbuf *gitdir)
{
struct strbuf dir = STRBUF_INIT, err = STRBUF_INIT;
size_t gitdir_offset = gitdir->len, cwd_len;
struct repository_format candidate;

if (strbuf_getcwd(&dir))
return NULL;

cwd_len = dir.len;
if (setup_git_directory_gently_1(&dir, gitdir, 0) <= 0) {
strbuf_release(&dir);
return NULL;
}

/*
* The returned gitdir is relative to dir, and if dir does not reflect
* the current working directory, we simply make the gitdir absolute.
*/
if (dir.len < cwd_len && !is_absolute_path(gitdir->buf + gitdir_offset)) {
/* Avoid a trailing "/." */
if (!strcmp(".", gitdir->buf + gitdir_offset))
strbuf_setlen(gitdir, gitdir_offset);
else
strbuf_addch(&dir, '/');
strbuf_insert(gitdir, gitdir_offset, dir.buf, dir.len);
}

strbuf_reset(&dir);
strbuf_addf(&dir, "%s/config", gitdir->buf + gitdir_offset);
read_repository_format(&candidate, dir.buf);
strbuf_release(&dir);

if (verify_repository_format(&candidate, &err) < 0) {
warning("ignoring git dir '%s': %s",
gitdir->buf + gitdir_offset, err.buf);
strbuf_release(&err);
return NULL;
}

return gitdir->buf + gitdir_offset;
}

const char *setup_git_directory_gently(int *nongit_ok)
{
static struct strbuf cwd = STRBUF_INIT;
struct strbuf dir = STRBUF_INIT, gitdir = STRBUF_INIT;
const char *prefix;

/*
* We may have read an incomplete configuration before
* setting-up the git directory. If so, clear the cache so
@ -850,98 +1003,43 @@ static const char *setup_git_directory_gently_1(int *nongit_ok)

if (strbuf_getcwd(&cwd))
die_errno(_("Unable to read current working directory"));
offset = cwd.len;
strbuf_addbuf(&dir, &cwd);

/*
* If GIT_DIR is set explicitly, we're not going
* to do any discovery, but we still do repository
* validation.
*/
gitdirenv = getenv(GIT_DIR_ENVIRONMENT);
if (gitdirenv)
return setup_explicit_git_dir(gitdirenv, &cwd, nongit_ok);

if (env_ceiling_dirs) {
int empty_entry_found = 0;

string_list_split(&ceiling_dirs, env_ceiling_dirs, PATH_SEP, -1);
filter_string_list(&ceiling_dirs, 0,
canonicalize_ceiling_entry, &empty_entry_found);
ceil_offset = longest_ancestor_length(cwd.buf, &ceiling_dirs);
string_list_clear(&ceiling_dirs, 0);
switch (setup_git_directory_gently_1(&dir, &gitdir, 1)) {
case GIT_DIR_NONE:
prefix = NULL;
break;
case GIT_DIR_EXPLICIT:
prefix = setup_explicit_git_dir(gitdir.buf, &cwd, nongit_ok);
break;
case GIT_DIR_DISCOVERED:
if (dir.len < cwd.len && chdir(dir.buf))
die(_("Cannot change to '%s'"), dir.buf);
prefix = setup_discovered_git_dir(gitdir.buf, &cwd, dir.len,
nongit_ok);
break;
case GIT_DIR_BARE:
if (dir.len < cwd.len && chdir(dir.buf))
die(_("Cannot change to '%s'"), dir.buf);
prefix = setup_bare_git_dir(&cwd, dir.len, nongit_ok);
break;
case GIT_DIR_HIT_CEILING:
prefix = setup_nongit(cwd.buf, nongit_ok);
break;
case GIT_DIR_HIT_MOUNT_POINT:
if (nongit_ok) {
*nongit_ok = 1;
strbuf_release(&cwd);
strbuf_release(&dir);
return NULL;
}
die(_("Not a git repository (or any parent up to mount point %s)\n"
"Stopping at filesystem boundary (GIT_DISCOVERY_ACROSS_FILESYSTEM not set)."),
dir.buf);
default:
die("BUG: unhandled setup_git_directory_1() result");
}

if (ceil_offset < 0 && has_dos_drive_prefix(cwd.buf))
ceil_offset = 1;

/*
* Test in the following order (relative to the cwd):
* - .git (file containing "gitdir: <path>")
* - .git/
* - ./ (bare)
* - ../.git
* - ../.git/
* - ../ (bare)
* - ../../.git/
* etc.
*/
one_filesystem = !git_env_bool("GIT_DISCOVERY_ACROSS_FILESYSTEM", 0);
if (one_filesystem)
current_device = get_device_or_die(".", NULL, 0);
for (;;) {
gitfile = (char*)read_gitfile(DEFAULT_GIT_DIR_ENVIRONMENT);
if (gitfile)
gitdirenv = gitfile = xstrdup(gitfile);
else {
if (is_git_directory(DEFAULT_GIT_DIR_ENVIRONMENT))
gitdirenv = DEFAULT_GIT_DIR_ENVIRONMENT;
}

if (gitdirenv) {
ret = setup_discovered_git_dir(gitdirenv,
&cwd, offset,
nongit_ok);
free(gitfile);
return ret;
}
free(gitfile);

if (is_git_directory("."))
return setup_bare_git_dir(&cwd, offset, nongit_ok);

offset_parent = offset;
while (--offset_parent > ceil_offset && cwd.buf[offset_parent] != '/');
if (offset_parent <= ceil_offset)
return setup_nongit(cwd.buf, nongit_ok);
if (one_filesystem) {
dev_t parent_device = get_device_or_die("..", cwd.buf,
offset);
if (parent_device != current_device) {
if (nongit_ok) {
if (chdir(cwd.buf))
die_errno(_("Cannot come back to cwd"));
*nongit_ok = 1;
return NULL;
}
strbuf_setlen(&cwd, offset);
die(_("Not a git repository (or any parent up to mount point %s)\n"
"Stopping at filesystem boundary (GIT_DISCOVERY_ACROSS_FILESYSTEM not set)."),
cwd.buf);
}
}
if (chdir("..")) {
strbuf_setlen(&cwd, offset);
die_errno(_("Cannot change to '%s/..'"), cwd.buf);
}
offset = offset_parent;
}
}

const char *setup_git_directory_gently(int *nongit_ok)
{
const char *prefix;

prefix = setup_git_directory_gently_1(nongit_ok);
if (prefix)
setenv(GIT_PREFIX_ENVIRONMENT, prefix, 1);
else
@ -950,6 +1048,9 @@ const char *setup_git_directory_gently(int *nongit_ok)
startup_info->have_repository = !nongit_ok || !*nongit_ok;
startup_info->prefix = prefix;

strbuf_release(&dir);
strbuf_release(&gitdir);

return prefix;
}


15
t/helper/test-config.c
View File

@ -66,6 +66,16 @@ static int iterate_cb(const char *var, const char *value, void *data)
return 0;
}

static int early_config_cb(const char *var, const char *value, void *vdata)
{
const char *key = vdata;

if (!strcmp(key, var))
printf("%s\n", value);

return 0;
}

int cmd_main(int argc, const char **argv)
{
int i, val;
@ -73,6 +83,11 @@ int cmd_main(int argc, const char **argv)
const struct string_list *strptr;
struct config_set cs;

if (argc == 3 && !strcmp(argv[1], "read_early_config")) {
read_early_config(early_config_cb, (void *)argv[2]);
return 0;
}

setup_git_directory();

git_configset_init(&cs);

74
t/t1309-early-config.sh Executable file
View File

@ -0,0 +1,74 @@
#!/bin/sh

test_description='Test read_early_config()'

. ./test-lib.sh

test_expect_success 'read early config' '
test_config early.config correct &&
test-config read_early_config early.config >output &&
test correct = "$(cat output)"
'

test_expect_success 'in a sub-directory' '
test_config early.config sub &&
mkdir -p sub &&
(
cd sub &&
test-config read_early_config early.config
) >output &&
test sub = "$(cat output)"
'

test_expect_success 'ceiling' '
test_config early.config ceiling &&
mkdir -p sub &&
(
GIT_CEILING_DIRECTORIES="$PWD" &&
export GIT_CEILING_DIRECTORIES &&
cd sub &&
test-config read_early_config early.config
) >output &&
test -z "$(cat output)"
'

test_expect_success 'ceiling #2' '
mkdir -p xdg/git &&
git config -f xdg/git/config early.config xdg &&
test_config early.config ceiling &&
mkdir -p sub &&
(
XDG_CONFIG_HOME="$PWD"/xdg &&
GIT_CEILING_DIRECTORIES="$PWD" &&
export GIT_CEILING_DIRECTORIES XDG_CONFIG_HOME &&
cd sub &&
test-config read_early_config early.config
) >output &&
test xdg = "$(cat output)"
'

test_with_config () {
rm -rf throwaway &&
git init throwaway &&
(
cd throwaway &&
echo "$*" >.git/config &&
test-config read_early_config early.config
)
}

test_expect_success 'ignore .git/ with incompatible repository version' '
test_with_config "[core]repositoryformatversion = 999999" 2>err &&
grep "warning:.* Expected git repo version <= [1-9]" err
'

test_expect_failure 'ignore .git/ with invalid repository version' '
test_with_config "[core]repositoryformatversion = invalid"
'


test_expect_failure 'ignore .git/ with invalid config' '
test_with_config "["
'

test_done

18
t/t7006-pager.sh
View File

@ -360,27 +360,37 @@ test_pager_choices 'git aliasedlog'
test_default_pager expect_success 'git -p aliasedlog'
test_PAGER_overrides expect_success 'git -p aliasedlog'
test_core_pager_overrides expect_success 'git -p aliasedlog'
test_core_pager_subdir expect_failure 'git -p aliasedlog'
test_core_pager_subdir expect_success 'git -p aliasedlog'
test_GIT_PAGER_overrides expect_success 'git -p aliasedlog'

test_default_pager expect_success 'git -p true'
test_PAGER_overrides expect_success 'git -p true'
test_core_pager_overrides expect_success 'git -p true'
test_core_pager_subdir expect_failure 'git -p true'
test_core_pager_subdir expect_success 'git -p true'
test_GIT_PAGER_overrides expect_success 'git -p true'

test_default_pager expect_success test_must_fail 'git -p request-pull'
test_PAGER_overrides expect_success test_must_fail 'git -p request-pull'
test_core_pager_overrides expect_success test_must_fail 'git -p request-pull'
test_core_pager_subdir expect_failure test_must_fail 'git -p request-pull'
test_core_pager_subdir expect_success test_must_fail 'git -p request-pull'
test_GIT_PAGER_overrides expect_success test_must_fail 'git -p request-pull'

test_default_pager expect_success test_must_fail 'git -p'
test_PAGER_overrides expect_success test_must_fail 'git -p'
test_local_config_ignored expect_failure test_must_fail 'git -p'
test_no_local_config_subdir expect_success test_must_fail 'git -p'
test_GIT_PAGER_overrides expect_success test_must_fail 'git -p'

test_expect_success TTY 'core.pager in repo config works and retains cwd' '
sane_unset GIT_PAGER &&
test_config core.pager "cat >cwd-retained" &&
(
cd sub &&
rm -f cwd-retained &&
test_terminal git -p rev-parse HEAD &&
test_path_is_file cwd-retained
)
'

test_doesnt_paginate expect_failure test_must_fail 'git -p nonsense'

test_pager_choices 'git shortlog'