Merge branch 'nd/files-backend-git-dir'
The "submodule" specific field in the ref_store structure is replaced with a more generic "gitdir" that can later be used also when dealing with ref_store that represents the set of refs visible from the other worktrees. * nd/files-backend-git-dir: (28 commits) refs.h: add a note about sorting order of for_each_ref_* t1406: new tests for submodule ref store t1405: some basic tests on main ref store t/helper: add test-ref-store to test ref-store functions refs: delete pack_refs() in favor of refs_pack_refs() files-backend: avoid ref api targeting main ref store refs: new transaction related ref-store api refs: add new ref-store api refs: rename get_ref_store() to get_submodule_ref_store() and make it public files-backend: replace submodule_allowed check in files_downcast() refs: move submodule code out of files-backend.c path.c: move some code out of strbuf_git_path_submodule() refs.c: make get_main_ref_store() public and use it refs.c: kill register_ref_store(), add register_submodule_ref_store() refs.c: flatten get_ref_store() a bit refs: rename lookup_ref_store() to lookup_submodule_ref_store() refs.c: introduce get_main_ref_store() files-backend: remove the use of git_path() files-backend: add and use files_ref_path() files-backend: add and use files_reflog_path() ...
This commit is contained in:
Junio C Hamano
427
refs.c
427
refs.c
@ -9,6 +9,7 @@
|
||||
#include "refs/refs-internal.h"
|
||||
#include "object.h"
|
||||
#include "tag.h"
|
||||
#include "submodule.h"
|
||||
|
||||
/*
|
||||
* List of all available backends
|
||||
@ -170,11 +171,23 @@ int refname_is_safe(const char *refname)
|
||||
return 1;
|
||||
}
|
||||
|
||||
char *refs_resolve_refdup(struct ref_store *refs,
|
||||
const char *refname, int resolve_flags,
|
||||
unsigned char *sha1, int *flags)
|
||||
{
|
||||
const char *result;
|
||||
|
||||
result = refs_resolve_ref_unsafe(refs, refname, resolve_flags,
|
||||
sha1, flags);
|
||||
return xstrdup_or_null(result);
|
||||
}
|
||||
|
||||
char *resolve_refdup(const char *refname, int resolve_flags,
|
||||
unsigned char *sha1, int *flags)
|
||||
{
|
||||
return xstrdup_or_null(resolve_ref_unsafe(refname, resolve_flags,
|
||||
sha1, flags));
|
||||
return refs_resolve_refdup(get_main_ref_store(),
|
||||
refname, resolve_flags,
|
||||
sha1, flags);
|
||||
}
|
||||
|
||||
/* The argument to filter_refs */
|
||||
@ -184,13 +197,20 @@ struct ref_filter {
|
||||
void *cb_data;
|
||||
};
|
||||
|
||||
int read_ref_full(const char *refname, int resolve_flags, unsigned char *sha1, int *flags)
|
||||
int refs_read_ref_full(struct ref_store *refs, const char *refname,
|
||||
int resolve_flags, unsigned char *sha1, int *flags)
|
||||
{
|
||||
if (resolve_ref_unsafe(refname, resolve_flags, sha1, flags))
|
||||
if (refs_resolve_ref_unsafe(refs, refname, resolve_flags, sha1, flags))
|
||||
return 0;
|
||||
return -1;
|
||||
}
|
||||
|
||||
int read_ref_full(const char *refname, int resolve_flags, unsigned char *sha1, int *flags)
|
||||
{
|
||||
return refs_read_ref_full(get_main_ref_store(), refname,
|
||||
resolve_flags, sha1, flags);
|
||||
}
|
||||
|
||||
int read_ref(const char *refname, unsigned char *sha1)
|
||||
{
|
||||
return read_ref_full(refname, RESOLVE_REF_READING, sha1, NULL);
|
||||
@ -285,34 +305,52 @@ void warn_dangling_symrefs(FILE *fp, const char *msg_fmt, const struct string_li
|
||||
for_each_rawref(warn_if_dangling_symref, &data);
|
||||
}
|
||||
|
||||
int refs_for_each_tag_ref(struct ref_store *refs, each_ref_fn fn, void *cb_data)
|
||||
{
|
||||
return refs_for_each_ref_in(refs, "refs/tags/", fn, cb_data);
|
||||
}
|
||||
|
||||
int for_each_tag_ref(each_ref_fn fn, void *cb_data)
|
||||
{
|
||||
return for_each_ref_in("refs/tags/", fn, cb_data);
|
||||
return refs_for_each_tag_ref(get_main_ref_store(), fn, cb_data);
|
||||
}
|
||||
|
||||
int for_each_tag_ref_submodule(const char *submodule, each_ref_fn fn, void *cb_data)
|
||||
{
|
||||
return for_each_ref_in_submodule(submodule, "refs/tags/", fn, cb_data);
|
||||
return refs_for_each_tag_ref(get_submodule_ref_store(submodule),
|
||||
fn, cb_data);
|
||||
}
|
||||
|
||||
int refs_for_each_branch_ref(struct ref_store *refs, each_ref_fn fn, void *cb_data)
|
||||
{
|
||||
return refs_for_each_ref_in(refs, "refs/heads/", fn, cb_data);
|
||||
}
|
||||
|
||||
int for_each_branch_ref(each_ref_fn fn, void *cb_data)
|
||||
{
|
||||
return for_each_ref_in("refs/heads/", fn, cb_data);
|
||||
return refs_for_each_branch_ref(get_main_ref_store(), fn, cb_data);
|
||||
}
|
||||
|
||||
int for_each_branch_ref_submodule(const char *submodule, each_ref_fn fn, void *cb_data)
|
||||
{
|
||||
return for_each_ref_in_submodule(submodule, "refs/heads/", fn, cb_data);
|
||||
return refs_for_each_branch_ref(get_submodule_ref_store(submodule),
|
||||
fn, cb_data);
|
||||
}
|
||||
|
||||
int refs_for_each_remote_ref(struct ref_store *refs, each_ref_fn fn, void *cb_data)
|
||||
{
|
||||
return refs_for_each_ref_in(refs, "refs/remotes/", fn, cb_data);
|
||||
}
|
||||
|
||||
int for_each_remote_ref(each_ref_fn fn, void *cb_data)
|
||||
{
|
||||
return for_each_ref_in("refs/remotes/", fn, cb_data);
|
||||
return refs_for_each_remote_ref(get_main_ref_store(), fn, cb_data);
|
||||
}
|
||||
|
||||
int for_each_remote_ref_submodule(const char *submodule, each_ref_fn fn, void *cb_data)
|
||||
{
|
||||
return for_each_ref_in_submodule(submodule, "refs/remotes/", fn, cb_data);
|
||||
return refs_for_each_remote_ref(get_submodule_ref_store(submodule),
|
||||
fn, cb_data);
|
||||
}
|
||||
|
||||
int head_ref_namespaced(each_ref_fn fn, void *cb_data)
|
||||
@ -596,16 +634,20 @@ static int delete_pseudoref(const char *pseudoref, const unsigned char *old_sha1
|
||||
return 0;
|
||||
}
|
||||
|
||||
int delete_ref(const char *msg, const char *refname,
|
||||
const unsigned char *old_sha1, unsigned int flags)
|
||||
int refs_delete_ref(struct ref_store *refs, const char *msg,
|
||||
const char *refname,
|
||||
const unsigned char *old_sha1,
|
||||
unsigned int flags)
|
||||
{
|
||||
struct ref_transaction *transaction;
|
||||
struct strbuf err = STRBUF_INIT;
|
||||
|
||||
if (ref_type(refname) == REF_TYPE_PSEUDOREF)
|
||||
if (ref_type(refname) == REF_TYPE_PSEUDOREF) {
|
||||
assert(refs == get_main_ref_store());
|
||||
return delete_pseudoref(refname, old_sha1);
|
||||
}
|
||||
|
||||
transaction = ref_transaction_begin(&err);
|
||||
transaction = ref_store_transaction_begin(refs, &err);
|
||||
if (!transaction ||
|
||||
ref_transaction_delete(transaction, refname, old_sha1,
|
||||
flags, msg, &err) ||
|
||||
@ -620,6 +662,13 @@ int delete_ref(const char *msg, const char *refname,
|
||||
return 0;
|
||||
}
|
||||
|
||||
int delete_ref(const char *msg, const char *refname,
|
||||
const unsigned char *old_sha1, unsigned int flags)
|
||||
{
|
||||
return refs_delete_ref(get_main_ref_store(), msg, refname,
|
||||
old_sha1, flags);
|
||||
}
|
||||
|
||||
int copy_reflog_msg(char *buf, const char *msg)
|
||||
{
|
||||
char *cp = buf;
|
||||
@ -779,11 +828,20 @@ int read_ref_at(const char *refname, unsigned int flags, unsigned long at_time,
|
||||
return 1;
|
||||
}
|
||||
|
||||
struct ref_transaction *ref_transaction_begin(struct strbuf *err)
|
||||
struct ref_transaction *ref_store_transaction_begin(struct ref_store *refs,
|
||||
struct strbuf *err)
|
||||
{
|
||||
struct ref_transaction *tr;
|
||||
assert(err);
|
||||
|
||||
return xcalloc(1, sizeof(struct ref_transaction));
|
||||
tr = xcalloc(1, sizeof(struct ref_transaction));
|
||||
tr->ref_store = refs;
|
||||
return tr;
|
||||
}
|
||||
|
||||
struct ref_transaction *ref_transaction_begin(struct strbuf *err)
|
||||
{
|
||||
return ref_store_transaction_begin(get_main_ref_store(), err);
|
||||
}
|
||||
|
||||
void ref_transaction_free(struct ref_transaction *transaction)
|
||||
@ -900,18 +958,20 @@ int update_ref_oid(const char *msg, const char *refname,
|
||||
old_oid ? old_oid->hash : NULL, flags, onerr);
|
||||
}
|
||||
|
||||
int update_ref(const char *msg, const char *refname,
|
||||
const unsigned char *new_sha1, const unsigned char *old_sha1,
|
||||
unsigned int flags, enum action_on_err onerr)
|
||||
int refs_update_ref(struct ref_store *refs, const char *msg,
|
||||
const char *refname, const unsigned char *new_sha1,
|
||||
const unsigned char *old_sha1, unsigned int flags,
|
||||
enum action_on_err onerr)
|
||||
{
|
||||
struct ref_transaction *t = NULL;
|
||||
struct strbuf err = STRBUF_INIT;
|
||||
int ret = 0;
|
||||
|
||||
if (ref_type(refname) == REF_TYPE_PSEUDOREF) {
|
||||
assert(refs == get_main_ref_store());
|
||||
ret = write_pseudoref(refname, new_sha1, old_sha1, &err);
|
||||
} else {
|
||||
t = ref_transaction_begin(&err);
|
||||
t = ref_store_transaction_begin(refs, &err);
|
||||
if (!t ||
|
||||
ref_transaction_update(t, refname, new_sha1, old_sha1,
|
||||
flags, msg, &err) ||
|
||||
@ -942,6 +1002,15 @@ int update_ref(const char *msg, const char *refname,
|
||||
return 0;
|
||||
}
|
||||
|
||||
int update_ref(const char *msg, const char *refname,
|
||||
const unsigned char *new_sha1,
|
||||
const unsigned char *old_sha1,
|
||||
unsigned int flags, enum action_on_err onerr)
|
||||
{
|
||||
return refs_update_ref(get_main_ref_store(), msg, refname, new_sha1,
|
||||
old_sha1, flags, onerr);
|
||||
}
|
||||
|
||||
char *shorten_unambiguous_ref(const char *refname, int strict)
|
||||
{
|
||||
int i;
|
||||
@ -1127,14 +1196,17 @@ const char *find_descendant_ref(const char *dirname,
|
||||
return NULL;
|
||||
}
|
||||
|
||||
int rename_ref_available(const char *old_refname, const char *new_refname)
|
||||
int refs_rename_ref_available(struct ref_store *refs,
|
||||
const char *old_refname,
|
||||
const char *new_refname)
|
||||
{
|
||||
struct string_list skip = STRING_LIST_INIT_NODUP;
|
||||
struct strbuf err = STRBUF_INIT;
|
||||
int ok;
|
||||
|
||||
string_list_insert(&skip, old_refname);
|
||||
ok = !verify_refname_available(new_refname, NULL, &skip, &err);
|
||||
ok = !refs_verify_refname_available(refs, new_refname,
|
||||
NULL, &skip, &err);
|
||||
if (!ok)
|
||||
error("%s", err.buf);
|
||||
|
||||
@ -1175,10 +1247,9 @@ int head_ref(each_ref_fn fn, void *cb_data)
|
||||
* non-zero value, stop the iteration and return that value;
|
||||
* otherwise, return 0.
|
||||
*/
|
||||
static int do_for_each_ref(const char *submodule, const char *prefix,
|
||||
static int do_for_each_ref(struct ref_store *refs, const char *prefix,
|
||||
each_ref_fn fn, int trim, int flags, void *cb_data)
|
||||
{
|
||||
struct ref_store *refs = get_ref_store(submodule);
|
||||
struct ref_iterator *iter;
|
||||
|
||||
if (!refs)
|
||||
@ -1190,19 +1261,30 @@ static int do_for_each_ref(const char *submodule, const char *prefix,
|
||||
return do_for_each_ref_iterator(iter, fn, cb_data);
|
||||
}
|
||||
|
||||
int refs_for_each_ref(struct ref_store *refs, each_ref_fn fn, void *cb_data)
|
||||
{
|
||||
return do_for_each_ref(refs, "", fn, 0, 0, cb_data);
|
||||
}
|
||||
|
||||
int for_each_ref(each_ref_fn fn, void *cb_data)
|
||||
{
|
||||
return do_for_each_ref(NULL, "", fn, 0, 0, cb_data);
|
||||
return refs_for_each_ref(get_main_ref_store(), fn, cb_data);
|
||||
}
|
||||
|
||||
int for_each_ref_submodule(const char *submodule, each_ref_fn fn, void *cb_data)
|
||||
{
|
||||
return do_for_each_ref(submodule, "", fn, 0, 0, cb_data);
|
||||
return refs_for_each_ref(get_submodule_ref_store(submodule), fn, cb_data);
|
||||
}
|
||||
|
||||
int refs_for_each_ref_in(struct ref_store *refs, const char *prefix,
|
||||
each_ref_fn fn, void *cb_data)
|
||||
{
|
||||
return do_for_each_ref(refs, prefix, fn, strlen(prefix), 0, cb_data);
|
||||
}
|
||||
|
||||
int for_each_ref_in(const char *prefix, each_ref_fn fn, void *cb_data)
|
||||
{
|
||||
return do_for_each_ref(NULL, prefix, fn, strlen(prefix), 0, cb_data);
|
||||
return refs_for_each_ref_in(get_main_ref_store(), prefix, fn, cb_data);
|
||||
}
|
||||
|
||||
int for_each_fullref_in(const char *prefix, each_ref_fn fn, void *cb_data, unsigned int broken)
|
||||
@ -1211,19 +1293,23 @@ int for_each_fullref_in(const char *prefix, each_ref_fn fn, void *cb_data, unsig
|
||||
|
||||
if (broken)
|
||||
flag = DO_FOR_EACH_INCLUDE_BROKEN;
|
||||
return do_for_each_ref(NULL, prefix, fn, 0, flag, cb_data);
|
||||
return do_for_each_ref(get_main_ref_store(),
|
||||
prefix, fn, 0, flag, cb_data);
|
||||
}
|
||||
|
||||
int for_each_ref_in_submodule(const char *submodule, const char *prefix,
|
||||
each_ref_fn fn, void *cb_data)
|
||||
each_ref_fn fn, void *cb_data)
|
||||
{
|
||||
return do_for_each_ref(submodule, prefix, fn, strlen(prefix), 0, cb_data);
|
||||
return refs_for_each_ref_in(get_submodule_ref_store(submodule),
|
||||
prefix, fn, cb_data);
|
||||
}
|
||||
|
||||
int for_each_replace_ref(each_ref_fn fn, void *cb_data)
|
||||
{
|
||||
return do_for_each_ref(NULL, git_replace_ref_base, fn,
|
||||
strlen(git_replace_ref_base), 0, cb_data);
|
||||
return do_for_each_ref(get_main_ref_store(),
|
||||
git_replace_ref_base, fn,
|
||||
strlen(git_replace_ref_base),
|
||||
0, cb_data);
|
||||
}
|
||||
|
||||
int for_each_namespaced_ref(each_ref_fn fn, void *cb_data)
|
||||
@ -1231,19 +1317,25 @@ int for_each_namespaced_ref(each_ref_fn fn, void *cb_data)
|
||||
struct strbuf buf = STRBUF_INIT;
|
||||
int ret;
|
||||
strbuf_addf(&buf, "%srefs/", get_git_namespace());
|
||||
ret = do_for_each_ref(NULL, buf.buf, fn, 0, 0, cb_data);
|
||||
ret = do_for_each_ref(get_main_ref_store(),
|
||||
buf.buf, fn, 0, 0, cb_data);
|
||||
strbuf_release(&buf);
|
||||
return ret;
|
||||
}
|
||||
|
||||
int for_each_rawref(each_ref_fn fn, void *cb_data)
|
||||
int refs_for_each_rawref(struct ref_store *refs, each_ref_fn fn, void *cb_data)
|
||||
{
|
||||
return do_for_each_ref(NULL, "", fn, 0,
|
||||
return do_for_each_ref(refs, "", fn, 0,
|
||||
DO_FOR_EACH_INCLUDE_BROKEN, cb_data);
|
||||
}
|
||||
|
||||
int for_each_rawref(each_ref_fn fn, void *cb_data)
|
||||
{
|
||||
return refs_for_each_rawref(get_main_ref_store(), fn, cb_data);
|
||||
}
|
||||
|
||||
/* This function needs to return a meaningful errno on failure */
|
||||
const char *resolve_ref_recursively(struct ref_store *refs,
|
||||
const char *refs_resolve_ref_unsafe(struct ref_store *refs,
|
||||
const char *refname,
|
||||
int resolve_flags,
|
||||
unsigned char *sha1, int *flags)
|
||||
@ -1322,7 +1414,7 @@ const char *resolve_ref_recursively(struct ref_store *refs,
|
||||
/* backend functions */
|
||||
int refs_init_db(struct strbuf *err)
|
||||
{
|
||||
struct ref_store *refs = get_ref_store(NULL);
|
||||
struct ref_store *refs = get_main_ref_store();
|
||||
|
||||
return refs->be->init_db(refs, err);
|
||||
}
|
||||
@ -1330,7 +1422,7 @@ int refs_init_db(struct strbuf *err)
|
||||
const char *resolve_ref_unsafe(const char *refname, int resolve_flags,
|
||||
unsigned char *sha1, int *flags)
|
||||
{
|
||||
return resolve_ref_recursively(get_ref_store(NULL), refname,
|
||||
return refs_resolve_ref_unsafe(get_main_ref_store(), refname,
|
||||
resolve_flags, sha1, flags);
|
||||
}
|
||||
|
||||
@ -1351,16 +1443,16 @@ int resolve_gitlink_ref(const char *submodule, const char *refname,
|
||||
/* We need to strip off one or more trailing slashes */
|
||||
char *stripped = xmemdupz(submodule, len);
|
||||
|
||||
refs = get_ref_store(stripped);
|
||||
refs = get_submodule_ref_store(stripped);
|
||||
free(stripped);
|
||||
} else {
|
||||
refs = get_ref_store(submodule);
|
||||
refs = get_submodule_ref_store(submodule);
|
||||
}
|
||||
|
||||
if (!refs)
|
||||
return -1;
|
||||
|
||||
if (!resolve_ref_recursively(refs, refname, 0, sha1, &flags) ||
|
||||
if (!refs_resolve_ref_unsafe(refs, refname, 0, sha1, &flags) ||
|
||||
is_null_sha1(sha1))
|
||||
return -1;
|
||||
return 0;
|
||||
@ -1403,17 +1495,13 @@ static struct ref_store *main_ref_store;
|
||||
static struct hashmap submodule_ref_stores;
|
||||
|
||||
/*
|
||||
* Return the ref_store instance for the specified submodule (or the
|
||||
* main repository if submodule is NULL). If that ref_store hasn't
|
||||
* been initialized yet, return NULL.
|
||||
* Return the ref_store instance for the specified submodule. If that
|
||||
* ref_store hasn't been initialized yet, return NULL.
|
||||
*/
|
||||
static struct ref_store *lookup_ref_store(const char *submodule)
|
||||
static struct ref_store *lookup_submodule_ref_store(const char *submodule)
|
||||
{
|
||||
struct submodule_hash_entry *entry;
|
||||
|
||||
if (!submodule)
|
||||
return main_ref_store;
|
||||
|
||||
if (!submodule_ref_stores.tablesize)
|
||||
/* It's initialized on demand in register_ref_store(). */
|
||||
return NULL;
|
||||
@ -1423,34 +1511,12 @@ static struct ref_store *lookup_ref_store(const char *submodule)
|
||||
return entry ? entry->refs : NULL;
|
||||
}
|
||||
|
||||
/*
|
||||
* Register the specified ref_store to be the one that should be used
|
||||
* for submodule (or the main repository if submodule is NULL). It is
|
||||
* a fatal error to call this function twice for the same submodule.
|
||||
*/
|
||||
static void register_ref_store(struct ref_store *refs, const char *submodule)
|
||||
{
|
||||
if (!submodule) {
|
||||
if (main_ref_store)
|
||||
die("BUG: main_ref_store initialized twice");
|
||||
|
||||
main_ref_store = refs;
|
||||
} else {
|
||||
if (!submodule_ref_stores.tablesize)
|
||||
hashmap_init(&submodule_ref_stores, submodule_hash_cmp, 0);
|
||||
|
||||
if (hashmap_put(&submodule_ref_stores,
|
||||
alloc_submodule_hash_entry(submodule, refs)))
|
||||
die("BUG: ref_store for submodule '%s' initialized twice",
|
||||
submodule);
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* Create, record, and return a ref_store instance for the specified
|
||||
* submodule (or the main repository if submodule is NULL).
|
||||
* gitdir.
|
||||
*/
|
||||
static struct ref_store *ref_store_init(const char *submodule)
|
||||
static struct ref_store *ref_store_init(const char *gitdir,
|
||||
unsigned int flags)
|
||||
{
|
||||
const char *be_name = "files";
|
||||
struct ref_storage_be *be = find_ref_storage_backend(be_name);
|
||||
@ -1459,33 +1525,76 @@ static struct ref_store *ref_store_init(const char *submodule)
|
||||
if (!be)
|
||||
die("BUG: reference backend %s is unknown", be_name);
|
||||
|
||||
refs = be->init(submodule);
|
||||
register_ref_store(refs, submodule);
|
||||
refs = be->init(gitdir, flags);
|
||||
return refs;
|
||||
}
|
||||
|
||||
struct ref_store *get_ref_store(const char *submodule)
|
||||
struct ref_store *get_main_ref_store(void)
|
||||
{
|
||||
if (main_ref_store)
|
||||
return main_ref_store;
|
||||
|
||||
main_ref_store = ref_store_init(get_git_dir(),
|
||||
(REF_STORE_READ |
|
||||
REF_STORE_WRITE |
|
||||
REF_STORE_ODB |
|
||||
REF_STORE_MAIN));
|
||||
return main_ref_store;
|
||||
}
|
||||
|
||||
/*
|
||||
* Register the specified ref_store to be the one that should be used
|
||||
* for submodule. It is a fatal error to call this function twice for
|
||||
* the same submodule.
|
||||
*/
|
||||
static void register_submodule_ref_store(struct ref_store *refs,
|
||||
const char *submodule)
|
||||
{
|
||||
if (!submodule_ref_stores.tablesize)
|
||||
hashmap_init(&submodule_ref_stores, submodule_hash_cmp, 0);
|
||||
|
||||
if (hashmap_put(&submodule_ref_stores,
|
||||
alloc_submodule_hash_entry(submodule, refs)))
|
||||
die("BUG: ref_store for submodule '%s' initialized twice",
|
||||
submodule);
|
||||
}
|
||||
|
||||
struct ref_store *get_submodule_ref_store(const char *submodule)
|
||||
{
|
||||
struct strbuf submodule_sb = STRBUF_INIT;
|
||||
struct ref_store *refs;
|
||||
int ret;
|
||||
|
||||
if (!submodule || !*submodule) {
|
||||
refs = lookup_ref_store(NULL);
|
||||
|
||||
if (!refs)
|
||||
refs = ref_store_init(NULL);
|
||||
} else {
|
||||
refs = lookup_ref_store(submodule);
|
||||
|
||||
if (!refs) {
|
||||
struct strbuf submodule_sb = STRBUF_INIT;
|
||||
|
||||
strbuf_addstr(&submodule_sb, submodule);
|
||||
if (is_nonbare_repository_dir(&submodule_sb))
|
||||
refs = ref_store_init(submodule);
|
||||
strbuf_release(&submodule_sb);
|
||||
}
|
||||
/*
|
||||
* FIXME: This case is ideally not allowed. But that
|
||||
* can't happen until we clean up all the callers.
|
||||
*/
|
||||
return get_main_ref_store();
|
||||
}
|
||||
|
||||
refs = lookup_submodule_ref_store(submodule);
|
||||
if (refs)
|
||||
return refs;
|
||||
|
||||
strbuf_addstr(&submodule_sb, submodule);
|
||||
ret = is_nonbare_repository_dir(&submodule_sb);
|
||||
strbuf_release(&submodule_sb);
|
||||
if (!ret)
|
||||
return NULL;
|
||||
|
||||
ret = submodule_to_gitdir(&submodule_sb, submodule);
|
||||
if (ret) {
|
||||
strbuf_release(&submodule_sb);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/* assume that add_submodule_odb() has been called */
|
||||
refs = ref_store_init(submodule_sb.buf,
|
||||
REF_STORE_READ | REF_STORE_ODB);
|
||||
register_submodule_ref_store(refs, submodule);
|
||||
|
||||
strbuf_release(&submodule_sb);
|
||||
return refs;
|
||||
}
|
||||
|
||||
@ -1496,50 +1605,58 @@ void base_ref_store_init(struct ref_store *refs,
|
||||
}
|
||||
|
||||
/* backend functions */
|
||||
int pack_refs(unsigned int flags)
|
||||
int refs_pack_refs(struct ref_store *refs, unsigned int flags)
|
||||
{
|
||||
struct ref_store *refs = get_ref_store(NULL);
|
||||
|
||||
return refs->be->pack_refs(refs, flags);
|
||||
}
|
||||
|
||||
int refs_peel_ref(struct ref_store *refs, const char *refname,
|
||||
unsigned char *sha1)
|
||||
{
|
||||
return refs->be->peel_ref(refs, refname, sha1);
|
||||
}
|
||||
|
||||
int peel_ref(const char *refname, unsigned char *sha1)
|
||||
{
|
||||
struct ref_store *refs = get_ref_store(NULL);
|
||||
return refs_peel_ref(get_main_ref_store(), refname, sha1);
|
||||
}
|
||||
|
||||
return refs->be->peel_ref(refs, refname, sha1);
|
||||
int refs_create_symref(struct ref_store *refs,
|
||||
const char *ref_target,
|
||||
const char *refs_heads_master,
|
||||
const char *logmsg)
|
||||
{
|
||||
return refs->be->create_symref(refs, ref_target,
|
||||
refs_heads_master,
|
||||
logmsg);
|
||||
}
|
||||
|
||||
int create_symref(const char *ref_target, const char *refs_heads_master,
|
||||
const char *logmsg)
|
||||
{
|
||||
struct ref_store *refs = get_ref_store(NULL);
|
||||
|
||||
return refs->be->create_symref(refs, ref_target, refs_heads_master,
|
||||
logmsg);
|
||||
return refs_create_symref(get_main_ref_store(), ref_target,
|
||||
refs_heads_master, logmsg);
|
||||
}
|
||||
|
||||
int ref_transaction_commit(struct ref_transaction *transaction,
|
||||
struct strbuf *err)
|
||||
{
|
||||
struct ref_store *refs = get_ref_store(NULL);
|
||||
struct ref_store *refs = transaction->ref_store;
|
||||
|
||||
return refs->be->transaction_commit(refs, transaction, err);
|
||||
}
|
||||
|
||||
int verify_refname_available(const char *refname,
|
||||
const struct string_list *extra,
|
||||
const struct string_list *skip,
|
||||
struct strbuf *err)
|
||||
int refs_verify_refname_available(struct ref_store *refs,
|
||||
const char *refname,
|
||||
const struct string_list *extra,
|
||||
const struct string_list *skip,
|
||||
struct strbuf *err)
|
||||
{
|
||||
struct ref_store *refs = get_ref_store(NULL);
|
||||
|
||||
return refs->be->verify_refname_available(refs, refname, extra, skip, err);
|
||||
}
|
||||
|
||||
int for_each_reflog(each_ref_fn fn, void *cb_data)
|
||||
int refs_for_each_reflog(struct ref_store *refs, each_ref_fn fn, void *cb_data)
|
||||
{
|
||||
struct ref_store *refs = get_ref_store(NULL);
|
||||
struct ref_iterator *iter;
|
||||
|
||||
iter = refs->be->reflog_iterator_begin(refs);
|
||||
@ -1547,43 +1664,84 @@ int for_each_reflog(each_ref_fn fn, void *cb_data)
|
||||
return do_for_each_ref_iterator(iter, fn, cb_data);
|
||||
}
|
||||
|
||||
int for_each_reflog(each_ref_fn fn, void *cb_data)
|
||||
{
|
||||
return refs_for_each_reflog(get_main_ref_store(), fn, cb_data);
|
||||
}
|
||||
|
||||
int refs_for_each_reflog_ent_reverse(struct ref_store *refs,
|
||||
const char *refname,
|
||||
each_reflog_ent_fn fn,
|
||||
void *cb_data)
|
||||
{
|
||||
return refs->be->for_each_reflog_ent_reverse(refs, refname,
|
||||
fn, cb_data);
|
||||
}
|
||||
|
||||
int for_each_reflog_ent_reverse(const char *refname, each_reflog_ent_fn fn,
|
||||
void *cb_data)
|
||||
{
|
||||
struct ref_store *refs = get_ref_store(NULL);
|
||||
return refs_for_each_reflog_ent_reverse(get_main_ref_store(),
|
||||
refname, fn, cb_data);
|
||||
}
|
||||
|
||||
return refs->be->for_each_reflog_ent_reverse(refs, refname,
|
||||
fn, cb_data);
|
||||
int refs_for_each_reflog_ent(struct ref_store *refs, const char *refname,
|
||||
each_reflog_ent_fn fn, void *cb_data)
|
||||
{
|
||||
return refs->be->for_each_reflog_ent(refs, refname, fn, cb_data);
|
||||
}
|
||||
|
||||
int for_each_reflog_ent(const char *refname, each_reflog_ent_fn fn,
|
||||
void *cb_data)
|
||||
{
|
||||
struct ref_store *refs = get_ref_store(NULL);
|
||||
return refs_for_each_reflog_ent(get_main_ref_store(), refname,
|
||||
fn, cb_data);
|
||||
}
|
||||
|
||||
return refs->be->for_each_reflog_ent(refs, refname, fn, cb_data);
|
||||
int refs_reflog_exists(struct ref_store *refs, const char *refname)
|
||||
{
|
||||
return refs->be->reflog_exists(refs, refname);
|
||||
}
|
||||
|
||||
int reflog_exists(const char *refname)
|
||||
{
|
||||
struct ref_store *refs = get_ref_store(NULL);
|
||||
return refs_reflog_exists(get_main_ref_store(), refname);
|
||||
}
|
||||
|
||||
return refs->be->reflog_exists(refs, refname);
|
||||
int refs_create_reflog(struct ref_store *refs, const char *refname,
|
||||
int force_create, struct strbuf *err)
|
||||
{
|
||||
return refs->be->create_reflog(refs, refname, force_create, err);
|
||||
}
|
||||
|
||||
int safe_create_reflog(const char *refname, int force_create,
|
||||
struct strbuf *err)
|
||||
{
|
||||
struct ref_store *refs = get_ref_store(NULL);
|
||||
return refs_create_reflog(get_main_ref_store(), refname,
|
||||
force_create, err);
|
||||
}
|
||||
|
||||
return refs->be->create_reflog(refs, refname, force_create, err);
|
||||
int refs_delete_reflog(struct ref_store *refs, const char *refname)
|
||||
{
|
||||
return refs->be->delete_reflog(refs, refname);
|
||||
}
|
||||
|
||||
int delete_reflog(const char *refname)
|
||||
{
|
||||
struct ref_store *refs = get_ref_store(NULL);
|
||||
return refs_delete_reflog(get_main_ref_store(), refname);
|
||||
}
|
||||
|
||||
return refs->be->delete_reflog(refs, refname);
|
||||
int refs_reflog_expire(struct ref_store *refs,
|
||||
const char *refname, const unsigned char *sha1,
|
||||
unsigned int flags,
|
||||
reflog_expiry_prepare_fn prepare_fn,
|
||||
reflog_expiry_should_prune_fn should_prune_fn,
|
||||
reflog_expiry_cleanup_fn cleanup_fn,
|
||||
void *policy_cb_data)
|
||||
{
|
||||
return refs->be->reflog_expire(refs, refname, sha1, flags,
|
||||
prepare_fn, should_prune_fn,
|
||||
cleanup_fn, policy_cb_data);
|
||||
}
|
||||
|
||||
int reflog_expire(const char *refname, const unsigned char *sha1,
|
||||
@ -1593,31 +1751,38 @@ int reflog_expire(const char *refname, const unsigned char *sha1,
|
||||
reflog_expiry_cleanup_fn cleanup_fn,
|
||||
void *policy_cb_data)
|
||||
{
|
||||
struct ref_store *refs = get_ref_store(NULL);
|
||||
|
||||
return refs->be->reflog_expire(refs, refname, sha1, flags,
|
||||
prepare_fn, should_prune_fn,
|
||||
cleanup_fn, policy_cb_data);
|
||||
return refs_reflog_expire(get_main_ref_store(),
|
||||
refname, sha1, flags,
|
||||
prepare_fn, should_prune_fn,
|
||||
cleanup_fn, policy_cb_data);
|
||||
}
|
||||
|
||||
int initial_ref_transaction_commit(struct ref_transaction *transaction,
|
||||
struct strbuf *err)
|
||||
{
|
||||
struct ref_store *refs = get_ref_store(NULL);
|
||||
struct ref_store *refs = transaction->ref_store;
|
||||
|
||||
return refs->be->initial_transaction_commit(refs, transaction, err);
|
||||
}
|
||||
|
||||
int refs_delete_refs(struct ref_store *refs, struct string_list *refnames,
|
||||
unsigned int flags)
|
||||
{
|
||||
return refs->be->delete_refs(refs, refnames, flags);
|
||||
}
|
||||
|
||||
int delete_refs(struct string_list *refnames, unsigned int flags)
|
||||
{
|
||||
struct ref_store *refs = get_ref_store(NULL);
|
||||
return refs_delete_refs(get_main_ref_store(), refnames, flags);
|
||||
}
|
||||
|
||||
return refs->be->delete_refs(refs, refnames, flags);
|
||||
int refs_rename_ref(struct ref_store *refs, const char *oldref,
|
||||
const char *newref, const char *logmsg)
|
||||
{
|
||||
return refs->be->rename_ref(refs, oldref, newref, logmsg);
|
||||
}
|
||||
|
||||
int rename_ref(const char *oldref, const char *newref, const char *logmsg)
|
||||
{
|
||||
struct ref_store *refs = get_ref_store(NULL);
|
||||
|
||||
return refs->be->rename_ref(refs, oldref, newref, logmsg);
|
||||
return refs_rename_ref(get_main_ref_store(), oldref, newref, logmsg);
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user