Andrew's git - gitweb.git/blob

   1/*
   2 * not really _using_ the compat macros, just make sure the_index
   3 * declaration matches the definition in this file.
   4 */
   5#define USE_THE_INDEX_COMPATIBILITY_MACROS
   6#include "cache.h"
   7#include "repository.h"
   8#include "object-store.h"
   9#include "config.h"
  10#include "object.h"
  11#include "lockfile.h"
  12#include "submodule-config.h"
  13
  14/* The main repository */
  15static struct repository the_repo;
  16struct repository *the_repository;
  17struct index_state the_index;
  18
  19void initialize_the_repository(void)
  20{
  21        the_repository = &the_repo;
  22
  23        the_repo.index = &the_index;
  24        the_repo.objects = raw_object_store_new();
  25        the_repo.parsed_objects = parsed_object_pool_new();
  26
  27        repo_set_hash_algo(&the_repo, GIT_HASH_SHA1);
  28}
  29
  30static void expand_base_dir(char **out, const char *in,
  31                            const char *base_dir, const char *def_in)
  32{
  33        free(*out);
  34        if (in)
  35                *out = xstrdup(in);
  36        else
  37                *out = xstrfmt("%s/%s", base_dir, def_in);
  38}
  39
  40static void repo_set_commondir(struct repository *repo,
  41                               const char *commondir)
  42{
  43        struct strbuf sb = STRBUF_INIT;
  44
  45        free(repo->commondir);
  46
  47        if (commondir) {
  48                repo->different_commondir = 1;
  49                repo->commondir = xstrdup(commondir);
  50                return;
  51        }
  52
  53        repo->different_commondir = get_common_dir_noenv(&sb, repo->gitdir);
  54        repo->commondir = strbuf_detach(&sb, NULL);
  55}
  56
  57void repo_set_gitdir(struct repository *repo,
  58                     const char *root,
  59                     const struct set_gitdir_args *o)
  60{
  61        const char *gitfile = read_gitfile(root);
  62        /*
  63         * repo->gitdir is saved because the caller could pass "root"
  64         * that also points to repo->gitdir. We want to keep it alive
  65         * until after xstrdup(root). Then we can free it.
  66         */
  67        char *old_gitdir = repo->gitdir;
  68
  69        repo->gitdir = xstrdup(gitfile ? gitfile : root);
  70        free(old_gitdir);
  71
  72        repo_set_commondir(repo, o->commondir);
  73
  74        if (!repo->objects->odb) {
  75                repo->objects->odb = xcalloc(1, sizeof(*repo->objects->odb));
  76                repo->objects->odb_tail = &repo->objects->odb->next;
  77        }
  78        expand_base_dir(&repo->objects->odb->path, o->object_dir,
  79                        repo->commondir, "objects");
  80
  81        free(repo->objects->alternate_db);
  82        repo->objects->alternate_db = xstrdup_or_null(o->alternate_db);
  83        expand_base_dir(&repo->graft_file, o->graft_file,
  84                        repo->commondir, "info/grafts");
  85        expand_base_dir(&repo->index_file, o->index_file,
  86                        repo->gitdir, "index");
  87}
  88
  89void repo_set_hash_algo(struct repository *repo, int hash_algo)
  90{
  91        repo->hash_algo = &hash_algos[hash_algo];
  92}
  93
  94/*
  95 * Attempt to resolve and set the provided 'gitdir' for repository 'repo'.
  96 * Return 0 upon success and a non-zero value upon failure.
  97 */
  98static int repo_init_gitdir(struct repository *repo, const char *gitdir)
  99{
 100        int ret = 0;
 101        int error = 0;
 102        char *abspath = NULL;
 103        const char *resolved_gitdir;
 104        struct set_gitdir_args args = { NULL };
 105
 106        abspath = real_pathdup(gitdir, 0);
 107        if (!abspath) {
 108                ret = -1;
 109                goto out;
 110        }
 111
 112        /* 'gitdir' must reference the gitdir directly */
 113        resolved_gitdir = resolve_gitdir_gently(abspath, &error);
 114        if (!resolved_gitdir) {
 115                ret = -1;
 116                goto out;
 117        }
 118
 119        repo_set_gitdir(repo, resolved_gitdir, &args);
 120
 121out:
 122        free(abspath);
 123        return ret;
 124}
 125
 126void repo_set_worktree(struct repository *repo, const char *path)
 127{
 128        repo->worktree = real_pathdup(path, 1);
 129
 130        trace2_def_repo(repo);
 131}
 132
 133static int read_and_verify_repository_format(struct repository_format *format,
 134                                             const char *commondir)
 135{
 136        int ret = 0;
 137        struct strbuf sb = STRBUF_INIT;
 138
 139        strbuf_addf(&sb, "%s/config", commondir);
 140        read_repository_format(format, sb.buf);
 141        strbuf_reset(&sb);
 142
 143        if (verify_repository_format(format, &sb) < 0) {
 144                warning("%s", sb.buf);
 145                ret = -1;
 146        }
 147
 148        strbuf_release(&sb);
 149        return ret;
 150}
 151
 152/*
 153 * Initialize 'repo' based on the provided 'gitdir'.
 154 * Return 0 upon success and a non-zero value upon failure.
 155 */
 156int repo_init(struct repository *repo,
 157              const char *gitdir,
 158              const char *worktree)
 159{
 160        struct repository_format format = REPOSITORY_FORMAT_INIT;
 161        memset(repo, 0, sizeof(*repo));
 162
 163        repo->objects = raw_object_store_new();
 164        repo->parsed_objects = parsed_object_pool_new();
 165
 166        if (repo_init_gitdir(repo, gitdir))
 167                goto error;
 168
 169        if (read_and_verify_repository_format(&format, repo->commondir))
 170                goto error;
 171
 172        repo_set_hash_algo(repo, format.hash_algo);
 173
 174        if (worktree)
 175                repo_set_worktree(repo, worktree);
 176
 177        clear_repository_format(&format);
 178        return 0;
 179
 180error:
 181        repo_clear(repo);
 182        return -1;
 183}
 184
 185int repo_submodule_init(struct repository *subrepo,
 186                        struct repository *superproject,
 187                        const struct submodule *sub)
 188{
 189        struct strbuf gitdir = STRBUF_INIT;
 190        struct strbuf worktree = STRBUF_INIT;
 191        int ret = 0;
 192
 193        if (!sub) {
 194                ret = -1;
 195                goto out;
 196        }
 197
 198        strbuf_repo_worktree_path(&gitdir, superproject, "%s/.git", sub->path);
 199        strbuf_repo_worktree_path(&worktree, superproject, "%s", sub->path);
 200
 201        if (repo_init(subrepo, gitdir.buf, worktree.buf)) {
 202                /*
 203                 * If initilization fails then it may be due to the submodule
 204                 * not being populated in the superproject's worktree.  Instead
 205                 * we can try to initilize the submodule by finding it's gitdir
 206                 * in the superproject's 'modules' directory.  In this case the
 207                 * submodule would not have a worktree.
 208                 */
 209                strbuf_reset(&gitdir);
 210                strbuf_repo_git_path(&gitdir, superproject,
 211                                     "modules/%s", sub->name);
 212
 213                if (repo_init(subrepo, gitdir.buf, NULL)) {
 214                        ret = -1;
 215                        goto out;
 216                }
 217        }
 218
 219        subrepo->submodule_prefix = xstrfmt("%s%s/",
 220                                            superproject->submodule_prefix ?
 221                                            superproject->submodule_prefix :
 222                                            "", sub->path);
 223
 224out:
 225        strbuf_release(&gitdir);
 226        strbuf_release(&worktree);
 227        return ret;
 228}
 229
 230void repo_clear(struct repository *repo)
 231{
 232        FREE_AND_NULL(repo->gitdir);
 233        FREE_AND_NULL(repo->commondir);
 234        FREE_AND_NULL(repo->graft_file);
 235        FREE_AND_NULL(repo->index_file);
 236        FREE_AND_NULL(repo->worktree);
 237        FREE_AND_NULL(repo->submodule_prefix);
 238
 239        raw_object_store_clear(repo->objects);
 240        FREE_AND_NULL(repo->objects);
 241
 242        parsed_object_pool_clear(repo->parsed_objects);
 243        FREE_AND_NULL(repo->parsed_objects);
 244
 245        if (repo->config) {
 246                git_configset_clear(repo->config);
 247                FREE_AND_NULL(repo->config);
 248        }
 249
 250        if (repo->submodule_cache) {
 251                submodule_cache_free(repo->submodule_cache);
 252                repo->submodule_cache = NULL;
 253        }
 254
 255        if (repo->index) {
 256                discard_index(repo->index);
 257                if (repo->index != &the_index)
 258                        FREE_AND_NULL(repo->index);
 259        }
 260}
 261
 262int repo_read_index(struct repository *repo)
 263{
 264        if (!repo->index)
 265                repo->index = xcalloc(1, sizeof(*repo->index));
 266
 267        return read_index_from(repo->index, repo->index_file, repo->gitdir);
 268}
 269
 270int repo_hold_locked_index(struct repository *repo,
 271                           struct lock_file *lf,
 272                           int flags)
 273{
 274        if (!repo->index_file)
 275                BUG("the repo hasn't been setup");
 276        return hold_lock_file_for_update(lf, repo->index_file, flags);
 277}