From ff3a299c457cb159a83df8382ed76731e03db530 Mon Sep 17 00:00:00 2001 From: David Turner Date: Sun, 4 Sep 2016 18:08:08 +0200 Subject: rename_ref_available(): add docstring And improve the internal variable names. Signed-off-by: David Turner Signed-off-by: Junio C Hamano Signed-off-by: Michael Haggerty Signed-off-by: Junio C Hamano --- refs.c | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) (limited to 'refs.c') diff --git a/refs.c b/refs.c index 814cad3163..256fef5da0 100644 --- a/refs.c +++ b/refs.c @@ -1081,20 +1081,20 @@ const char *find_descendant_ref(const char *dirname, return NULL; } -int rename_ref_available(const char *oldname, const char *newname) +int rename_ref_available(const char *old_refname, const char *new_refname) { struct string_list skip = STRING_LIST_INIT_NODUP; struct strbuf err = STRBUF_INIT; - int ret; + int ok; - string_list_insert(&skip, oldname); - ret = !verify_refname_available(newname, NULL, &skip, &err); - if (!ret) + string_list_insert(&skip, old_refname); + ok = !verify_refname_available(new_refname, NULL, &skip, &err); + if (!ok) error("%s", err.buf); string_list_clear(&skip, 0); strbuf_release(&err); - return ret; + return ok; } int head_ref_submodule(const char *submodule, each_ref_fn fn, void *cb_data) -- cgit v1.2.1 From 3dce444f178503bf3da13ade6f79c80d6964d175 Mon Sep 17 00:00:00 2001 From: Ronnie Sahlberg Date: Sun, 4 Sep 2016 18:08:10 +0200 Subject: refs: add a backend method structure Add a `struct ref_storage_be` to represent types of reference stores. In OO notation, this is the class, and will soon hold some class methods (e.g., a factory to create new ref_store instances) and will also serve as the vtable for ref_store instances of that type. As yet, the backends cannot do anything. Signed-off-by: Ronnie Sahlberg Signed-off-by: David Turner Signed-off-by: Junio C Hamano Signed-off-by: Jeff King Signed-off-by: Michael Haggerty Signed-off-by: Junio C Hamano --- refs.c | 19 +++++++++++++++++++ 1 file changed, 19 insertions(+) (limited to 'refs.c') diff --git a/refs.c b/refs.c index 256fef5da0..bee9a4571e 100644 --- a/refs.c +++ b/refs.c @@ -9,6 +9,25 @@ #include "object.h" #include "tag.h" +/* + * List of all available backends + */ +static struct ref_storage_be *refs_backends = &refs_be_files; + +static struct ref_storage_be *find_ref_storage_backend(const char *name) +{ + struct ref_storage_be *be; + for (be = refs_backends; be; be = be->next) + if (!strcmp(be->name, name)) + return be; + return NULL; +} + +int ref_storage_backend_exists(const char *name) +{ + return find_ref_storage_backend(name) != NULL; +} + /* * How to handle various characters in refnames: * 0: An acceptable character for refs -- cgit v1.2.1 From 00eebe351c4b4626a7b8e0b2dc4b7a172f3fd8d9 Mon Sep 17 00:00:00 2001 From: Michael Haggerty Date: Sun, 4 Sep 2016 18:08:11 +0200 Subject: refs: create a base class "ref_store" for files_ref_store We want ref_stores to be polymorphic, so invent a base class of which files_ref_store is a derived class. For now there is exactly one ref_store for the main repository and one for any submodules whose references have been accessed. Signed-off-by: Michael Haggerty Signed-off-by: Junio C Hamano --- refs.c | 93 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 93 insertions(+) (limited to 'refs.c') diff --git a/refs.c b/refs.c index bee9a4571e..ca57a6e1e5 100644 --- a/refs.c +++ b/refs.c @@ -1151,8 +1151,12 @@ int head_ref(each_ref_fn fn, void *cb_data) static int do_for_each_ref(const char *submodule, 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) + return 0; + iter = files_ref_iterator_begin(submodule, prefix, flags); iter = prefix_ref_iterator_begin(iter, prefix, trim); @@ -1284,3 +1288,92 @@ const char *resolve_ref_unsafe(const char *refname, int resolve_flags, errno = ELOOP; return NULL; } + +/* A pointer to the ref_store for the main repository: */ +static struct ref_store *main_ref_store; + +/* A linked list of ref_stores for submodules: */ +static struct ref_store *submodule_ref_stores; + +void base_ref_store_init(struct ref_store *refs, + const struct ref_storage_be *be, + const char *submodule) +{ + refs->be = be; + if (!submodule) { + if (main_ref_store) + die("BUG: main_ref_store initialized twice"); + + refs->submodule = ""; + refs->next = NULL; + main_ref_store = refs; + } else { + if (lookup_ref_store(submodule)) + die("BUG: ref_store for submodule '%s' initialized twice", + submodule); + + refs->submodule = xstrdup(submodule); + refs->next = submodule_ref_stores; + submodule_ref_stores = refs; + } +} + +struct ref_store *ref_store_init(const char *submodule) +{ + const char *be_name = "files"; + struct ref_storage_be *be = find_ref_storage_backend(be_name); + + if (!be) + die("BUG: reference backend %s is unknown", be_name); + + if (!submodule || !*submodule) + return be->init(NULL); + else + return be->init(submodule); +} + +struct ref_store *lookup_ref_store(const char *submodule) +{ + struct ref_store *refs; + + if (!submodule || !*submodule) + return main_ref_store; + + for (refs = submodule_ref_stores; refs; refs = refs->next) { + if (!strcmp(submodule, refs->submodule)) + return refs; + } + + return NULL; +} + +struct ref_store *get_ref_store(const char *submodule) +{ + struct ref_store *refs; + + 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); + } + } + + return refs; +} + +void assert_main_repository(struct ref_store *refs, const char *caller) +{ + if (*refs->submodule) + die("BUG: %s called for a submodule", caller); +} -- cgit v1.2.1 From 127b42a18618538438b811a29cd95e79c646eb70 Mon Sep 17 00:00:00 2001 From: Ronnie Sahlberg Date: Sun, 4 Sep 2016 18:08:16 +0200 Subject: refs: add a transaction_commit() method Signed-off-by: Ronnie Sahlberg Signed-off-by: David Turner Signed-off-by: Junio C Hamano Signed-off-by: Jeff King Signed-off-by: Michael Haggerty Signed-off-by: Junio C Hamano --- refs.c | 9 +++++++++ 1 file changed, 9 insertions(+) (limited to 'refs.c') diff --git a/refs.c b/refs.c index ca57a6e1e5..abccd7ebd7 100644 --- a/refs.c +++ b/refs.c @@ -1377,3 +1377,12 @@ void assert_main_repository(struct ref_store *refs, const char *caller) if (*refs->submodule) die("BUG: %s called for a submodule", caller); } + +/* backend functions */ +int ref_transaction_commit(struct ref_transaction *transaction, + struct strbuf *err) +{ + struct ref_store *refs = get_ref_store(NULL); + + return refs->be->transaction_commit(refs, transaction, err); +} -- cgit v1.2.1 From 34c7ad8ffc79c64d7f2261e6bcf6efd3adb16e7e Mon Sep 17 00:00:00 2001 From: Michael Haggerty Date: Sun, 4 Sep 2016 18:08:20 +0200 Subject: read_raw_ref(): take a (struct ref_store *) argument And make the function work for submodules. Signed-off-by: Michael Haggerty Signed-off-by: Junio C Hamano --- refs.c | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) (limited to 'refs.c') diff --git a/refs.c b/refs.c index abccd7ebd7..b3a775e640 100644 --- a/refs.c +++ b/refs.c @@ -1222,6 +1222,7 @@ const char *resolve_ref_unsafe(const char *refname, int resolve_flags, static struct strbuf sb_refname = STRBUF_INIT; int unused_flags; int symref_count; + struct ref_store *refs = get_ref_store(NULL); if (!flags) flags = &unused_flags; @@ -1249,7 +1250,8 @@ const char *resolve_ref_unsafe(const char *refname, int resolve_flags, for (symref_count = 0; symref_count < SYMREF_MAXDEPTH; symref_count++) { unsigned int read_flags = 0; - if (read_raw_ref(refname, sha1, &sb_refname, &read_flags)) { + if (read_raw_ref(refs, refname, + sha1, &sb_refname, &read_flags)) { *flags |= read_flags; if (errno != ENOENT || (resolve_flags & RESOLVE_REF_READING)) return NULL; -- cgit v1.2.1 From bd40dcda27cc7d6b8b247caa5b650992c5e397fb Mon Sep 17 00:00:00 2001 From: Michael Haggerty Date: Sun, 4 Sep 2016 18:08:21 +0200 Subject: resolve_ref_recursively(): new function Add a new function, resolve_ref_recursively(), which is basically like the old resolve_ref_unsafe() except that it takes a (ref_store *) argument and also works for submodules. Re-implement resolve_ref_unsafe() as a thin wrapper around resolve_ref_recursively(). Signed-off-by: Michael Haggerty Signed-off-by: Junio C Hamano --- refs.c | 14 +++++++++++--- 1 file changed, 11 insertions(+), 3 deletions(-) (limited to 'refs.c') diff --git a/refs.c b/refs.c index b3a775e640..464fe71928 100644 --- a/refs.c +++ b/refs.c @@ -1216,13 +1216,14 @@ int for_each_rawref(each_ref_fn fn, void *cb_data) } /* This function needs to return a meaningful errno on failure */ -const char *resolve_ref_unsafe(const char *refname, int resolve_flags, - unsigned char *sha1, int *flags) +static const char *resolve_ref_recursively(struct ref_store *refs, + const char *refname, + int resolve_flags, + unsigned char *sha1, int *flags) { static struct strbuf sb_refname = STRBUF_INIT; int unused_flags; int symref_count; - struct ref_store *refs = get_ref_store(NULL); if (!flags) flags = &unused_flags; @@ -1291,6 +1292,13 @@ const char *resolve_ref_unsafe(const char *refname, int resolve_flags, return NULL; } +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, + resolve_flags, sha1, flags); +} + /* A pointer to the ref_store for the main repository: */ static struct ref_store *main_ref_store; -- cgit v1.2.1 From 424dcc7683a37d1f14aa0dd485300001cb854f6c Mon Sep 17 00:00:00 2001 From: Michael Haggerty Date: Sun, 4 Sep 2016 18:08:22 +0200 Subject: resolve_gitlink_ref(): implement using resolve_ref_recursively() resolve_ref_recursively() can handle references in arbitrary files reference stores, so use it to resolve "gitlink" (i.e., submodule) references. Aside from removing redundant code, this allows submodule lookups to benefit from the much more robust code that we use for reading non-submodule references. And, since the code is now agnostic about reference backends, it will work for any future references backend (so move its definition to refs.c). Signed-off-by: Michael Haggerty Signed-off-by: Junio C Hamano --- refs.c | 24 ++++++++++++++++++++++++ 1 file changed, 24 insertions(+) (limited to 'refs.c') diff --git a/refs.c b/refs.c index 464fe71928..7b86b4eab5 100644 --- a/refs.c +++ b/refs.c @@ -1299,6 +1299,30 @@ const char *resolve_ref_unsafe(const char *refname, int resolve_flags, resolve_flags, sha1, flags); } +int resolve_gitlink_ref(const char *path, const char *refname, unsigned char *sha1) +{ + int len = strlen(path); + struct strbuf submodule = STRBUF_INIT; + struct ref_store *refs; + int flags; + + while (len && path[len-1] == '/') + len--; + if (!len) + return -1; + + strbuf_add(&submodule, path, len); + refs = get_ref_store(submodule.buf); + strbuf_release(&submodule); + if (!refs) + return -1; + + if (!resolve_ref_recursively(refs, refname, 0, sha1, &flags) || + is_null_sha1(sha1)) + return -1; + return 0; +} + /* A pointer to the ref_store for the main repository: */ static struct ref_store *main_ref_store; -- cgit v1.2.1 From 48a8475fd3f935d753cc2e0dd81562bc73f6d6d3 Mon Sep 17 00:00:00 2001 From: Michael Haggerty Date: Sun, 4 Sep 2016 18:08:23 +0200 Subject: resolve_gitlink_ref(): avoid memory allocation in many cases If we don't have to strip trailing '/' from the submodule path, then don't allocate and copy the submodule name. Signed-off-by: Michael Haggerty Signed-off-by: Junio C Hamano --- refs.c | 19 +++++++++++++------ 1 file changed, 13 insertions(+), 6 deletions(-) (limited to 'refs.c') diff --git a/refs.c b/refs.c index 7b86b4eab5..17f3497a0b 100644 --- a/refs.c +++ b/refs.c @@ -1301,19 +1301,26 @@ const char *resolve_ref_unsafe(const char *refname, int resolve_flags, int resolve_gitlink_ref(const char *path, const char *refname, unsigned char *sha1) { - int len = strlen(path); - struct strbuf submodule = STRBUF_INIT; + size_t len = strlen(path); struct ref_store *refs; int flags; - while (len && path[len-1] == '/') + while (len && path[len - 1] == '/') len--; + if (!len) return -1; - strbuf_add(&submodule, path, len); - refs = get_ref_store(submodule.buf); - strbuf_release(&submodule); + if (path[len]) { + /* We need to strip off one or more trailing slashes */ + char *stripped = xmemdupz(path, len); + + refs = get_ref_store(stripped); + free(stripped); + } else { + refs = get_ref_store(path); + } + if (!refs) return -1; -- cgit v1.2.1 From a8355bb717aaf2d5d9b3781aa78402d0053fa87a Mon Sep 17 00:00:00 2001 From: Michael Haggerty Date: Sun, 4 Sep 2016 18:08:24 +0200 Subject: resolve_gitlink_ref(): rename path parameter to submodule Signed-off-by: Michael Haggerty Signed-off-by: Junio C Hamano --- refs.c | 13 +++++++------ 1 file changed, 7 insertions(+), 6 deletions(-) (limited to 'refs.c') diff --git a/refs.c b/refs.c index 17f3497a0b..1a2a2bbbe7 100644 --- a/refs.c +++ b/refs.c @@ -1299,26 +1299,27 @@ const char *resolve_ref_unsafe(const char *refname, int resolve_flags, resolve_flags, sha1, flags); } -int resolve_gitlink_ref(const char *path, const char *refname, unsigned char *sha1) +int resolve_gitlink_ref(const char *submodule, const char *refname, + unsigned char *sha1) { - size_t len = strlen(path); + size_t len = strlen(submodule); struct ref_store *refs; int flags; - while (len && path[len - 1] == '/') + while (len && submodule[len - 1] == '/') len--; if (!len) return -1; - if (path[len]) { + if (submodule[len]) { /* We need to strip off one or more trailing slashes */ - char *stripped = xmemdupz(path, len); + char *stripped = xmemdupz(submodule, len); refs = get_ref_store(stripped); free(stripped); } else { - refs = get_ref_store(path); + refs = get_ref_store(submodule); } if (!refs) -- cgit v1.2.1 From e1e33b722c50c26546335fd5a709f89726c2ea2a Mon Sep 17 00:00:00 2001 From: Michael Haggerty Date: Sun, 4 Sep 2016 18:08:25 +0200 Subject: refs: make read_raw_ref() virtual Reference backends will be able to customize this function to implement reference reading. Signed-off-by: Michael Haggerty Signed-off-by: Junio C Hamano --- refs.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'refs.c') diff --git a/refs.c b/refs.c index 1a2a2bbbe7..775c54eb47 100644 --- a/refs.c +++ b/refs.c @@ -1251,8 +1251,8 @@ static const char *resolve_ref_recursively(struct ref_store *refs, for (symref_count = 0; symref_count < SYMREF_MAXDEPTH; symref_count++) { unsigned int read_flags = 0; - if (read_raw_ref(refs, refname, - sha1, &sb_refname, &read_flags)) { + if (refs->be->read_raw_ref(refs, refname, + sha1, &sb_refname, &read_flags)) { *flags |= read_flags; if (errno != ENOENT || (resolve_flags & RESOLVE_REF_READING)) return NULL; -- cgit v1.2.1 From 62665823d2ddbe69abdac4a9db399769c3e278b4 Mon Sep 17 00:00:00 2001 From: Michael Haggerty Date: Sun, 4 Sep 2016 18:08:26 +0200 Subject: refs: make verify_refname_available() virtual Signed-off-by: Michael Haggerty Signed-off-by: Junio C Hamano --- refs.c | 10 ++++++++++ 1 file changed, 10 insertions(+) (limited to 'refs.c') diff --git a/refs.c b/refs.c index 775c54eb47..a5c11088f2 100644 --- a/refs.c +++ b/refs.c @@ -1428,3 +1428,13 @@ int ref_transaction_commit(struct ref_transaction *transaction, 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) +{ + struct ref_store *refs = get_ref_store(NULL); + + return refs->be->verify_refname_available(refs, refname, extra, skip, err); +} -- cgit v1.2.1 From 8231527e1510127a5611a2e2f9660e6aef1c981e Mon Sep 17 00:00:00 2001 From: Michael Haggerty Date: Sun, 4 Sep 2016 18:08:27 +0200 Subject: refs: make pack_refs() virtual Signed-off-by: Michael Haggerty Signed-off-by: Junio C Hamano --- refs.c | 7 +++++++ 1 file changed, 7 insertions(+) (limited to 'refs.c') diff --git a/refs.c b/refs.c index a5c11088f2..cdd78b97ac 100644 --- a/refs.c +++ b/refs.c @@ -1421,6 +1421,13 @@ void assert_main_repository(struct ref_store *refs, const char *caller) } /* backend functions */ +int pack_refs(unsigned int flags) +{ + struct ref_store *refs = get_ref_store(NULL); + + return refs->be->pack_refs(refs, flags); +} + int ref_transaction_commit(struct ref_transaction *transaction, struct strbuf *err) { -- cgit v1.2.1 From 284689ba0ff7506d581bcee7481a2621492135ef Mon Sep 17 00:00:00 2001 From: Michael Haggerty Date: Sun, 4 Sep 2016 18:08:28 +0200 Subject: refs: make create_symref() virtual Signed-off-by: Michael Haggerty Signed-off-by: Junio C Hamano --- refs.c | 9 +++++++++ 1 file changed, 9 insertions(+) (limited to 'refs.c') diff --git a/refs.c b/refs.c index cdd78b97ac..312c76619f 100644 --- a/refs.c +++ b/refs.c @@ -1428,6 +1428,15 @@ int pack_refs(unsigned int flags) return refs->be->pack_refs(refs, flags); } +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); +} + int ref_transaction_commit(struct ref_transaction *transaction, struct strbuf *err) { -- cgit v1.2.1 From bd427cf27f561174fa8fa14e2c8c321d2df82c47 Mon Sep 17 00:00:00 2001 From: Michael Haggerty Date: Sun, 4 Sep 2016 18:08:29 +0200 Subject: refs: make peel_ref() virtual For now it only supports the main reference store. Signed-off-by: Michael Haggerty Signed-off-by: Junio C Hamano --- refs.c | 7 +++++++ 1 file changed, 7 insertions(+) (limited to 'refs.c') diff --git a/refs.c b/refs.c index 312c76619f..3130c0e019 100644 --- a/refs.c +++ b/refs.c @@ -1428,6 +1428,13 @@ int pack_refs(unsigned int flags) return refs->be->pack_refs(refs, flags); } +int peel_ref(const char *refname, unsigned char *sha1) +{ + struct ref_store *refs = get_ref_store(NULL); + + return refs->be->peel_ref(refs, refname, sha1); +} + int create_symref(const char *ref_target, const char *refs_heads_master, const char *logmsg) { -- cgit v1.2.1 From 37b6f6d5f41c493bc083b5ee4c54519f8dd6d46c Mon Sep 17 00:00:00 2001 From: Michael Haggerty Date: Sun, 4 Sep 2016 18:08:36 +0200 Subject: files_ref_iterator_begin(): take a ref_store argument Signed-off-by: Michael Haggerty Signed-off-by: Junio C Hamano --- refs.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'refs.c') diff --git a/refs.c b/refs.c index 3130c0e019..3d007ba022 100644 --- a/refs.c +++ b/refs.c @@ -1157,7 +1157,7 @@ static int do_for_each_ref(const char *submodule, const char *prefix, if (!refs) return 0; - iter = files_ref_iterator_begin(submodule, prefix, flags); + iter = files_ref_iterator_begin(refs, prefix, flags); iter = prefix_ref_iterator_begin(iter, prefix, trim); return do_for_each_ref_iterator(iter, fn, cb_data); -- cgit v1.2.1 From 1a769003c19c106063f4bf474b0d7ef56be8df25 Mon Sep 17 00:00:00 2001 From: Michael Haggerty Date: Sun, 4 Sep 2016 18:08:37 +0200 Subject: refs: add method iterator_begin Signed-off-by: Michael Haggerty Signed-off-by: Junio C Hamano --- refs.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'refs.c') diff --git a/refs.c b/refs.c index 3d007ba022..91174e60f7 100644 --- a/refs.c +++ b/refs.c @@ -1157,7 +1157,7 @@ static int do_for_each_ref(const char *submodule, const char *prefix, if (!refs) return 0; - iter = files_ref_iterator_begin(refs, prefix, flags); + iter = refs->be->iterator_begin(refs, prefix, flags); iter = prefix_ref_iterator_begin(iter, prefix, trim); return do_for_each_ref_iterator(iter, fn, cb_data); -- cgit v1.2.1 From e3688bd6cf159f6026a6bca7a6f53d0a22fe21a2 Mon Sep 17 00:00:00 2001 From: David Turner Date: Sun, 4 Sep 2016 18:08:38 +0200 Subject: refs: add methods for reflog In the file-based backend, the reflog piggybacks on the ref lock. Since other backends won't have the same sort of ref lock, ref backends must also handle reflogs. Signed-off-by: Ronnie Sahlberg Signed-off-by: David Turner Signed-off-by: Junio C Hamano Signed-off-by: Michael Haggerty Signed-off-by: Junio C Hamano --- refs.c | 63 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 63 insertions(+) (limited to 'refs.c') diff --git a/refs.c b/refs.c index 91174e60f7..47dcf494d4 100644 --- a/refs.c +++ b/refs.c @@ -1461,3 +1461,66 @@ int verify_refname_available(const char *refname, return refs->be->verify_refname_available(refs, refname, extra, skip, err); } + +int for_each_reflog(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); + + return do_for_each_ref_iterator(iter, 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->be->for_each_reflog_ent_reverse(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->be->for_each_reflog_ent(refs, refname, fn, cb_data); +} + +int reflog_exists(const char *refname) +{ + struct ref_store *refs = get_ref_store(NULL); + + return refs->be->reflog_exists(refs, refname); +} + +int safe_create_reflog(const char *refname, int force_create, + struct strbuf *err) +{ + struct ref_store *refs = get_ref_store(NULL); + + return refs->be->create_reflog(refs, refname, force_create, err); +} + +int delete_reflog(const char *refname) +{ + struct ref_store *refs = get_ref_store(NULL); + + return refs->be->delete_reflog(refs, refname); +} + +int reflog_expire(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) +{ + 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); +} -- cgit v1.2.1 From fc6814637d2e756029b45cb5fd952359bfec6f88 Mon Sep 17 00:00:00 2001 From: David Turner Date: Sun, 4 Sep 2016 18:08:39 +0200 Subject: refs: add method for initial ref transaction commit Signed-off-by: Ronnie Sahlberg Signed-off-by: David Turner Signed-off-by: Junio C Hamano Signed-off-by: Michael Haggerty Signed-off-by: Junio C Hamano --- refs.c | 8 ++++++++ 1 file changed, 8 insertions(+) (limited to 'refs.c') diff --git a/refs.c b/refs.c index 47dcf494d4..693d10fba7 100644 --- a/refs.c +++ b/refs.c @@ -1524,3 +1524,11 @@ int reflog_expire(const char *refname, const unsigned char *sha1, 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); + + return refs->be->initial_transaction_commit(refs, transaction, err); +} -- cgit v1.2.1 From a27dcf89b6867577bb714e181dd181cd1a1e6512 Mon Sep 17 00:00:00 2001 From: David Turner Date: Sun, 4 Sep 2016 18:08:40 +0200 Subject: refs: make delete_refs() virtual In the file-based backend, delete_refs has some special optimization to deal with packed refs. In other backends, we might be able to make ref deletion faster by putting all deletions into a single transaction. So we need a special backend function for this. Signed-off-by: David Turner Signed-off-by: Junio C Hamano Signed-off-by: Michael Haggerty Signed-off-by: Junio C Hamano --- refs.c | 7 +++++++ 1 file changed, 7 insertions(+) (limited to 'refs.c') diff --git a/refs.c b/refs.c index 693d10fba7..f26601dc0c 100644 --- a/refs.c +++ b/refs.c @@ -1532,3 +1532,10 @@ int initial_ref_transaction_commit(struct ref_transaction *transaction, return refs->be->initial_transaction_commit(refs, transaction, err); } + +int delete_refs(struct string_list *refnames, unsigned int flags) +{ + struct ref_store *refs = get_ref_store(NULL); + + return refs->be->delete_refs(refs, refnames, flags); +} -- cgit v1.2.1 From 6fb5acfd8f7102f53dedc887233313f233a65932 Mon Sep 17 00:00:00 2001 From: David Turner Date: Sun, 4 Sep 2016 18:08:41 +0200 Subject: refs: add methods to init refs db Alternate refs backends might not need the refs/heads directory and so on, so we make ref db initialization part of the backend. Signed-off-by: David Turner Signed-off-by: Junio C Hamano Signed-off-by: Michael Haggerty Signed-off-by: Junio C Hamano --- refs.c | 8 ++++++++ 1 file changed, 8 insertions(+) (limited to 'refs.c') diff --git a/refs.c b/refs.c index f26601dc0c..3b0a658c56 100644 --- a/refs.c +++ b/refs.c @@ -1292,6 +1292,14 @@ static const char *resolve_ref_recursively(struct ref_store *refs, return NULL; } +/* backend functions */ +int refs_init_db(struct strbuf *err) +{ + struct ref_store *refs = get_ref_store(NULL); + + return refs->be->init_db(refs, err); +} + const char *resolve_ref_unsafe(const char *refname, int resolve_flags, unsigned char *sha1, int *flags) { -- cgit v1.2.1 From 9b6b40d93a4c93d36225533ddc6717841b07d09d Mon Sep 17 00:00:00 2001 From: David Turner Date: Sun, 4 Sep 2016 18:08:42 +0200 Subject: refs: add method to rename refs This removes the last caller of function get_files_ref_store(), so remove it. Signed-off-by: David Turner Signed-off-by: Junio C Hamano Signed-off-by: Michael Haggerty Signed-off-by: Junio C Hamano --- refs.c | 7 +++++++ 1 file changed, 7 insertions(+) (limited to 'refs.c') diff --git a/refs.c b/refs.c index 3b0a658c56..60f518e004 100644 --- a/refs.c +++ b/refs.c @@ -1547,3 +1547,10 @@ int delete_refs(struct string_list *refnames, unsigned int flags) return refs->be->delete_refs(refs, refnames, flags); } + +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); +} -- cgit v1.2.1