builtin/init-db.c - git - Git at Google

 /*
  * GIT - The information manager from hell
  *
  * Copyright (C) Linus Torvalds, 2005
  */
 #include "builtin.h"
 #include "abspath.h"
 #include "environment.h"
 #include "gettext.h"
 #include "object-file.h"
 #include "parse-options.h"
 #include "path.h"
 #include "refs.h"
 #include "repository.h"
 #include "setup.h"
 #include "strbuf.h"

 static int guess_repository_type(const char *git_dir)
 {
 	const char *slash;
 	char *cwd;
 	int cwd_is_git_dir;

 	/*
 	 * "GIT_DIR=. git init" is always bare.
 	 * "GIT_DIR=`pwd` git init" too.
 	 */
 	if (!strcmp(".", git_dir))
 		return 1;
 	cwd = xgetcwd();
 	cwd_is_git_dir = !strcmp(git_dir, cwd);
 	free(cwd);
 	if (cwd_is_git_dir)
 		return 1;
 	/*
 	 * "GIT_DIR=.git or GIT_DIR=something/.git is usually not.
 	 */
 	if (!strcmp(git_dir, ".git"))
 		return 0;
 	slash = strrchr(git_dir, '/');
 	if (slash && !strcmp(slash, "/.git"))
 		return 0;

 	/*
 	 * Otherwise it is often bare.  At this point
 	 * we are just guessing.
 	 */
 	return 1;
 }

 static int shared_callback(const struct option *opt, const char *arg, int unset)
 {
 	BUG_ON_OPT_NEG(unset);
 	*((int *) opt->value) = (arg) ? git_config_perm("arg", arg) : PERM_GROUP;
 	return 0;
 }

 static const char *const init_db_usage[] = {
 	N_("git init [-q | --quiet] [--bare] [--template=<template-directory>]\n"
 	   "         [--separate-git-dir <git-dir>] [--object-format=<format>]\n"
 	   "         [--ref-format=<format>]\n"
 	   "         [-b <branch-name> | --initial-branch=<branch-name>]\n"
 	   "         [--shared[=<permissions>]] [<directory>]"),
 	NULL
 };

 /*
  * If you want to, you can share the DB area with any number of branches.
  * That has advantages: you can save space by sharing all the SHA1 objects.
  * On the other hand, it might just make lookup slower and messier. You
  * be the judge.  The default case is to have one DB per managed directory.
  */
 int cmd_init_db(int argc, const char **argv, const char *prefix)
 {
 	const char *git_dir;
 	const char *real_git_dir = NULL;
 	const char *work_tree;
 	const char *template_dir = NULL;
 	unsigned int flags = 0;
 	const char *object_format = NULL;
 	const char *ref_format = NULL;
 	const char *initial_branch = NULL;
 	int hash_algo = GIT_HASH_UNKNOWN;
 	unsigned int ref_storage_format = REF_STORAGE_FORMAT_UNKNOWN;
 	int init_shared_repository = -1;
 	const struct option init_db_options[] = {
 		OPT_STRING(0, "template", &template_dir, N_("template-directory"),
 				N_("directory from which templates will be used")),
 		OPT_SET_INT(0, "bare", &is_bare_repository_cfg,
 				N_("create a bare repository"), 1),
 		{ OPTION_CALLBACK, 0, "shared", &init_shared_repository,
 			N_("permissions"),
 			N_("specify that the git repository is to be shared amongst several users"),
 			PARSE_OPT_OPTARG | PARSE_OPT_NONEG, shared_callback, 0},
 		OPT_BIT('q', "quiet", &flags, N_("be quiet"), INIT_DB_QUIET),
 		OPT_STRING(0, "separate-git-dir", &real_git_dir, N_("gitdir"),
 			   N_("separate git dir from working tree")),
 		OPT_STRING('b', "initial-branch", &initial_branch, N_("name"),
 			   N_("override the name of the initial branch")),
 		OPT_STRING(0, "object-format", &object_format, N_("hash"),
 			   N_("specify the hash algorithm to use")),
 		OPT_STRING(0, "ref-format", &ref_format, N_("format"),
 			   N_("specify the reference format to use")),
 		OPT_END()
 	};

 	argc = parse_options(argc, argv, prefix, init_db_options, init_db_usage, 0);

 	if (real_git_dir && is_bare_repository_cfg == 1)
 		die(_("options '%s' and '%s' cannot be used together"), "--separate-git-dir", "--bare");

 	if (real_git_dir && !is_absolute_path(real_git_dir))
 		real_git_dir = real_pathdup(real_git_dir, 1);

 	if (template_dir && *template_dir && !is_absolute_path(template_dir)) {
 		template_dir = absolute_pathdup(template_dir);
 		UNLEAK(template_dir);
 	}

 	if (argc == 1) {
 		int mkdir_tried = 0;
 	retry:
 		if (chdir(argv[0]) < 0) {
 			if (!mkdir_tried) {
 				int saved;
 				/*
 				 * At this point we haven't read any configuration,
 				 * and we know shared_repository should always be 0;
 				 * but just in case we play safe.
 				 */
 				saved = get_shared_repository();
 				set_shared_repository(0);
 				switch (safe_create_leading_directories_const(argv[0])) {
 				case SCLD_OK:
 				case SCLD_PERMS:
 					break;
 				case SCLD_EXISTS:
 					errno = EEXIST;
 					/* fallthru */
 				default:
 					die_errno(_("cannot mkdir %s"), argv[0]);
 					break;
 				}
 				set_shared_repository(saved);
 				if (mkdir(argv[0], 0777) < 0)
 					die_errno(_("cannot mkdir %s"), argv[0]);
 				mkdir_tried = 1;
 				goto retry;
 			}
 			die_errno(_("cannot chdir to %s"), argv[0]);
 		}
 	} else if (0 < argc) {
 		usage(init_db_usage[0]);
 	}
 	if (is_bare_repository_cfg == 1) {
 		char *cwd = xgetcwd();
 		setenv(GIT_DIR_ENVIRONMENT, cwd, argc > 0);
 		free(cwd);
 	}

 	if (object_format) {
 		hash_algo = hash_algo_by_name(object_format);
 		if (hash_algo == GIT_HASH_UNKNOWN)
 			die(_("unknown hash algorithm '%s'"), object_format);
 	}

 	if (ref_format) {
 		ref_storage_format = ref_storage_format_by_name(ref_format);
 		if (ref_storage_format == REF_STORAGE_FORMAT_UNKNOWN)
 			die(_("unknown ref storage format '%s'"), ref_format);
 	}

 	if (init_shared_repository != -1)
 		set_shared_repository(init_shared_repository);

 	/*
 	 * GIT_WORK_TREE makes sense only in conjunction with GIT_DIR
 	 * without --bare.  Catch the error early.
 	 */
 	git_dir = xstrdup_or_null(getenv(GIT_DIR_ENVIRONMENT));
 	work_tree = xstrdup_or_null(getenv(GIT_WORK_TREE_ENVIRONMENT));
 	if ((!git_dir || is_bare_repository_cfg == 1) && work_tree)
 		die(_("%s (or --work-tree=<directory>) not allowed without "
 			  "specifying %s (or --git-dir=<directory>)"),
 		    GIT_WORK_TREE_ENVIRONMENT,
 		    GIT_DIR_ENVIRONMENT);

 	/*
 	 * Set up the default .git directory contents
 	 */
 	if (!git_dir)
 		git_dir = DEFAULT_GIT_DIR_ENVIRONMENT;

 	/*
 	 * When --separate-git-dir is used inside a linked worktree, take
 	 * care to ensure that the common .git/ directory is relocated, not
 	 * the worktree-specific .git/worktrees/<id>/ directory.
 	 */
 	if (real_git_dir) {
 		int err;
 		const char *p;
 		struct strbuf sb = STRBUF_INIT;

 		p = read_gitfile_gently(git_dir, &err);
 		if (p && get_common_dir(&sb, p)) {
 			struct strbuf mainwt = STRBUF_INIT;

 			strbuf_addbuf(&mainwt, &sb);
 			strbuf_strip_suffix(&mainwt, "/.git");
 			if (chdir(mainwt.buf) < 0)
 				die_errno(_("cannot chdir to %s"), mainwt.buf);
 			strbuf_release(&mainwt);
 			git_dir = strbuf_detach(&sb, NULL);
 		}
 		strbuf_release(&sb);
 	}

 	if (is_bare_repository_cfg < 0)
 		is_bare_repository_cfg = guess_repository_type(git_dir);

 	if (!is_bare_repository_cfg) {
 		const char *git_dir_parent = strrchr(git_dir, '/');
 		if (git_dir_parent) {
 			char *rel = xstrndup(git_dir, git_dir_parent - git_dir);
 			git_work_tree_cfg = real_pathdup(rel, 1);
 			free(rel);
 		}
 		if (!git_work_tree_cfg)
 			git_work_tree_cfg = xgetcwd();
 		if (work_tree)
 			set_git_work_tree(work_tree);
 		else
 			set_git_work_tree(git_work_tree_cfg);
 		if (access(get_git_work_tree(), X_OK))
 			die_errno (_("Cannot access work tree '%s'"),
 				   get_git_work_tree());
 	}
 	else {
 		if (real_git_dir)
 			die(_("--separate-git-dir incompatible with bare repository"));
 		if (work_tree)
 			set_git_work_tree(work_tree);
 	}

 	UNLEAK(real_git_dir);
 	UNLEAK(git_dir);
 	UNLEAK(work_tree);

 	flags |= INIT_DB_EXIST_OK;
 	return init_db(git_dir, real_git_dir, template_dir, hash_algo,
 		       ref_storage_format, initial_branch,
 		       init_shared_repository, flags);
 }
	/*
	* GIT - The information manager from hell
	*
	* Copyright (C) Linus Torvalds, 2005
	*/
	#include "builtin.h"
	#include "abspath.h"
	#include "environment.h"
	#include "gettext.h"
	#include "object-file.h"
	#include "parse-options.h"
	#include "path.h"
	#include "refs.h"
	#include "repository.h"
	#include "setup.h"
	#include "strbuf.h"

	static int guess_repository_type(const char *git_dir)
	{
	const char *slash;
	char *cwd;
	int cwd_is_git_dir;

	/*
	* "GIT_DIR=. git init" is always bare.
	* "GIT_DIR=`pwd` git init" too.
	*/
	if (!strcmp(".", git_dir))
	return 1;
	cwd = xgetcwd();
	cwd_is_git_dir = !strcmp(git_dir, cwd);
	free(cwd);
	if (cwd_is_git_dir)
	return 1;
	/*
	* "GIT_DIR=.git or GIT_DIR=something/.git is usually not.
	*/
	if (!strcmp(git_dir, ".git"))
	return 0;
	slash = strrchr(git_dir, '/');
	if (slash && !strcmp(slash, "/.git"))
	return 0;

	/*
	* Otherwise it is often bare. At this point
	* we are just guessing.
	*/
	return 1;
	}

	static int shared_callback(const struct option opt, const char arg, int unset)
	{
	BUG_ON_OPT_NEG(unset);
	((int ) opt->value) = (arg) ? git_config_perm("arg", arg) : PERM_GROUP;
	return 0;
	}

	static const char *const init_db_usage[] = {
	N_("git init [-q \| --quiet] [--bare] [--template=<template-directory>]\n"
	" [--separate-git-dir <git-dir>] [--object-format=<format>]\n"
	" [--ref-format=<format>]\n"
	" [-b <branch-name> \| --initial-branch=<branch-name>]\n"
	" [--shared[=<permissions>]] [<directory>]"),
	NULL
	};

	/*
	* If you want to, you can share the DB area with any number of branches.
	* That has advantages: you can save space by sharing all the SHA1 objects.
	* On the other hand, it might just make lookup slower and messier. You
	* be the judge. The default case is to have one DB per managed directory.
	*/
	int cmd_init_db(int argc, const char *argv, const char prefix)
	{
	const char *git_dir;
	const char *real_git_dir = NULL;
	const char *work_tree;
	const char *template_dir = NULL;
	unsigned int flags = 0;
	const char *object_format = NULL;
	const char *ref_format = NULL;
	const char *initial_branch = NULL;
	int hash_algo = GIT_HASH_UNKNOWN;
	unsigned int ref_storage_format = REF_STORAGE_FORMAT_UNKNOWN;
	int init_shared_repository = -1;
	const struct option init_db_options[] = {
	OPT_STRING(0, "template", &template_dir, N_("template-directory"),
	N_("directory from which templates will be used")),
	OPT_SET_INT(0, "bare", &is_bare_repository_cfg,
	N_("create a bare repository"), 1),
	{ OPTION_CALLBACK, 0, "shared", &init_shared_repository,
	N_("permissions"),
	N_("specify that the git repository is to be shared amongst several users"),
	PARSE_OPT_OPTARG \| PARSE_OPT_NONEG, shared_callback, 0},
	OPT_BIT('q', "quiet", &flags, N_("be quiet"), INIT_DB_QUIET),
	OPT_STRING(0, "separate-git-dir", &real_git_dir, N_("gitdir"),
	N_("separate git dir from working tree")),
	OPT_STRING('b', "initial-branch", &initial_branch, N_("name"),
	N_("override the name of the initial branch")),
	OPT_STRING(0, "object-format", &object_format, N_("hash"),
	N_("specify the hash algorithm to use")),
	OPT_STRING(0, "ref-format", &ref_format, N_("format"),
	N_("specify the reference format to use")),
	OPT_END()
	};

	argc = parse_options(argc, argv, prefix, init_db_options, init_db_usage, 0);

	if (real_git_dir && is_bare_repository_cfg == 1)
	die(_("options '%s' and '%s' cannot be used together"), "--separate-git-dir", "--bare");

	if (real_git_dir && !is_absolute_path(real_git_dir))
	real_git_dir = real_pathdup(real_git_dir, 1);

	if (template_dir && *template_dir && !is_absolute_path(template_dir)) {
	template_dir = absolute_pathdup(template_dir);
	UNLEAK(template_dir);
	}

	if (argc == 1) {
	int mkdir_tried = 0;
	retry:
	if (chdir(argv[0]) < 0) {
	if (!mkdir_tried) {
	int saved;
	/*
	* At this point we haven't read any configuration,
	* and we know shared_repository should always be 0;
	* but just in case we play safe.
	*/
	saved = get_shared_repository();
	set_shared_repository(0);
	switch (safe_create_leading_directories_const(argv[0])) {
	case SCLD_OK:
	case SCLD_PERMS:
	break;
	case SCLD_EXISTS:
	errno = EEXIST;
	/* fallthru */
	default:
	die_errno(_("cannot mkdir %s"), argv[0]);
	break;
	}
	set_shared_repository(saved);
	if (mkdir(argv[0], 0777) < 0)
	die_errno(_("cannot mkdir %s"), argv[0]);
	mkdir_tried = 1;
	goto retry;
	}
	die_errno(_("cannot chdir to %s"), argv[0]);
	}
	} else if (0 < argc) {
	usage(init_db_usage[0]);
	}
	if (is_bare_repository_cfg == 1) {
	char *cwd = xgetcwd();
	setenv(GIT_DIR_ENVIRONMENT, cwd, argc > 0);
	free(cwd);
	}

	if (object_format) {
	hash_algo = hash_algo_by_name(object_format);
	if (hash_algo == GIT_HASH_UNKNOWN)
	die(_("unknown hash algorithm '%s'"), object_format);
	}

	if (ref_format) {
	ref_storage_format = ref_storage_format_by_name(ref_format);
	if (ref_storage_format == REF_STORAGE_FORMAT_UNKNOWN)
	die(_("unknown ref storage format '%s'"), ref_format);
	}

	if (init_shared_repository != -1)
	set_shared_repository(init_shared_repository);

	/*
	* GIT_WORK_TREE makes sense only in conjunction with GIT_DIR
	* without --bare. Catch the error early.
	*/
	git_dir = xstrdup_or_null(getenv(GIT_DIR_ENVIRONMENT));
	work_tree = xstrdup_or_null(getenv(GIT_WORK_TREE_ENVIRONMENT));
	if ((!git_dir \|\| is_bare_repository_cfg == 1) && work_tree)
	die(_("%s (or --work-tree=<directory>) not allowed without "
	"specifying %s (or --git-dir=<directory>)"),
	GIT_WORK_TREE_ENVIRONMENT,
	GIT_DIR_ENVIRONMENT);

	/*
	* Set up the default .git directory contents
	*/
	if (!git_dir)
	git_dir = DEFAULT_GIT_DIR_ENVIRONMENT;

	/*
	* When --separate-git-dir is used inside a linked worktree, take
	* care to ensure that the common .git/ directory is relocated, not
	* the worktree-specific .git/worktrees/<id>/ directory.
	*/
	if (real_git_dir) {
	int err;
	const char *p;
	struct strbuf sb = STRBUF_INIT;

	p = read_gitfile_gently(git_dir, &err);
	if (p && get_common_dir(&sb, p)) {
	struct strbuf mainwt = STRBUF_INIT;

	strbuf_addbuf(&mainwt, &sb);
	strbuf_strip_suffix(&mainwt, "/.git");
	if (chdir(mainwt.buf) < 0)
	die_errno(_("cannot chdir to %s"), mainwt.buf);
	strbuf_release(&mainwt);
	git_dir = strbuf_detach(&sb, NULL);
	}
	strbuf_release(&sb);
	}

	if (is_bare_repository_cfg < 0)
	is_bare_repository_cfg = guess_repository_type(git_dir);

	if (!is_bare_repository_cfg) {
	const char *git_dir_parent = strrchr(git_dir, '/');
	if (git_dir_parent) {
	char *rel = xstrndup(git_dir, git_dir_parent - git_dir);
	git_work_tree_cfg = real_pathdup(rel, 1);
	free(rel);
	}
	if (!git_work_tree_cfg)
	git_work_tree_cfg = xgetcwd();
	if (work_tree)
	set_git_work_tree(work_tree);
	else
	set_git_work_tree(git_work_tree_cfg);
	if (access(get_git_work_tree(), X_OK))
	die_errno (_("Cannot access work tree '%s'"),
	get_git_work_tree());
	}
	else {
	if (real_git_dir)
	die(_("--separate-git-dir incompatible with bare repository"));
	if (work_tree)
	set_git_work_tree(work_tree);
	}

	UNLEAK(real_git_dir);
	UNLEAK(git_dir);
	UNLEAK(work_tree);

	flags \|= INIT_DB_EXIST_OK;
	return init_db(git_dir, real_git_dir, template_dir, hash_algo,
	ref_storage_format, initial_branch,
	init_shared_repository, flags);
	}