refs: remove `create_symref` and associated dead code

In the previous commits, we converted `refs_create_symref()` to utilize
transactions to perform symref updates. Earlier `refs_create_symref()`
used `create_symref()` to do the same.

We can now remove `create_symref()` and any code associated with it
which is no longer used. We remove `create_symref()` code from all the
reference backends and also remove it entirely from the `ref_storage_be`
struct.

Signed-off-by: Karthik Nayak <karthik.188@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>

diff --git a/refs/debug.c b/refs/debug.c
index c7531b17f096c329353caf1fd456c726cded5ab8..8be316bb6724899f4684cdd5100ad334c7c4f9ff 100644 (file)
--- a/refs/debug.c
+++ b/refs/debug.c
@@ -131,18 +131,6 @@ static int debug_pack_refs(struct ref_store *ref_store, struct pack_refs_opts *o
        return res;
 }
 
-static int debug_create_symref(struct ref_store *ref_store,
-                              const char *ref_name, const char *target,
-                              const char *logmsg)
-{
-       struct debug_ref_store *drefs = (struct debug_ref_store *)ref_store;
-       int res = drefs->refs->be->create_symref(drefs->refs, ref_name, target,
-                                                logmsg);
-       trace_printf_key(&trace_refs, "create_symref: %s -> %s \"%s\": %d\n", ref_name,
-               target, logmsg, res);
-       return res;
-}
-
 static int debug_rename_ref(struct ref_store *ref_store, const char *oldref,
                            const char *newref, const char *logmsg)
 {
@@ -441,7 +429,6 @@ struct ref_storage_be refs_be_debug = {
        .initial_transaction_commit = debug_initial_transaction_commit,
 
        .pack_refs = debug_pack_refs,
-       .create_symref = debug_create_symref,
        .rename_ref = debug_rename_ref,
        .copy_ref = debug_copy_ref,
 

diff --git a/refs/files-backend.c b/refs/files-backend.c
index 2d1525b240ec8d5ce73c06f0413dab04f948e0cc..3957bfa5795af70ecb46c014b801978db88ced46 100644 (file)
--- a/refs/files-backend.c
+++ b/refs/files-backend.c
@@ -1903,23 +1903,6 @@ static int create_ref_symlink(struct ref_lock *lock, const char *target)
        return ret;
 }
 
-static void update_symref_reflog(struct files_ref_store *refs,
-                                struct ref_lock *lock, const char *refname,
-                                const char *target, const char *logmsg)
-{
-       struct strbuf err = STRBUF_INIT;
-       struct object_id new_oid;
-
-       if (logmsg &&
-           refs_resolve_ref_unsafe(&refs->base, target,
-                                   RESOLVE_REF_READING, &new_oid, NULL) &&
-           files_log_ref_write(refs, refname, &lock->old_oid,
-                               &new_oid, logmsg, 0, &err)) {
-               error("%s", err.buf);
-               strbuf_release(&err);
-       }
-}
-
 static int create_symref_lock(struct files_ref_store *refs,
                              struct ref_lock *lock, const char *refname,
                              const char *target, struct strbuf *err)
@@ -1939,55 +1922,6 @@ static int create_symref_lock(struct files_ref_store *refs,
        return 0;
 }
 
-static int create_and_commit_symref(struct files_ref_store *refs,
-                                   struct ref_lock *lock, const char *refname,
-                                   const char *target, const char *logmsg)
-{
-       struct strbuf err = STRBUF_INIT;
-       int ret;
-
-       if (prefer_symlink_refs && !create_ref_symlink(lock, target)) {
-               update_symref_reflog(refs, lock, refname, target, logmsg);
-               return 0;
-       }
-
-       ret = create_symref_lock(refs, lock, refname, target, &err);
-       if (!ret) {
-               update_symref_reflog(refs, lock, refname, target, logmsg);
-
-               if (commit_ref(lock) < 0)
-                       return error("unable to write symref for %s: %s", refname,
-                                    strerror(errno));
-       } else {
-               return error("%s", err.buf);
-       }
-
-       return ret;
-}
-
-static int files_create_symref(struct ref_store *ref_store,
-                              const char *refname, const char *target,
-                              const char *logmsg)
-{
-       struct files_ref_store *refs =
-               files_downcast(ref_store, REF_STORE_WRITE, "create_symref");
-       struct strbuf err = STRBUF_INIT;
-       struct ref_lock *lock;
-       int ret;
-
-       lock = lock_ref_oid_basic(refs, refname, &err);
-       if (!lock) {
-               error("%s", err.buf);
-               strbuf_release(&err);
-               return -1;
-       }
-
-       ret = create_and_commit_symref(refs, lock, refname, target, logmsg);
-
-       unlock_ref(lock);
-       return ret;
-}
-
 static int files_reflog_exists(struct ref_store *ref_store,
                               const char *refname)
 {
@@ -3374,7 +3308,6 @@ struct ref_storage_be refs_be_files = {
        .initial_transaction_commit = files_initial_transaction_commit,
 
        .pack_refs = files_pack_refs,
-       .create_symref = files_create_symref,
        .rename_ref = files_rename_ref,
        .copy_ref = files_copy_ref,
 

diff --git a/refs/packed-backend.c b/refs/packed-backend.c
index 4e826c05ff2b34986a5844cd40734b10b0298204..a937e7dbfc00426abcdc9d14889423d0464ce547 100644 (file)
--- a/refs/packed-backend.c
+++ b/refs/packed-backend.c
@@ -1714,7 +1714,6 @@ struct ref_storage_be refs_be_packed = {
        .initial_transaction_commit = packed_initial_transaction_commit,
 
        .pack_refs = packed_pack_refs,
-       .create_symref = NULL,
        .rename_ref = NULL,
        .copy_ref = NULL,
 

diff --git a/refs/refs-internal.h b/refs/refs-internal.h
index 819157256e95e4e35466aa8add703884ba50d728..53a6c5d84200a9b5efc80d4dfcf649aa86d1747e 100644 (file)
--- a/refs/refs-internal.h
+++ b/refs/refs-internal.h
@@ -566,10 +566,6 @@ typedef int ref_transaction_commit_fn(struct ref_store *refs,
 
 typedef int pack_refs_fn(struct ref_store *ref_store,
                         struct pack_refs_opts *opts);
-typedef int create_symref_fn(struct ref_store *ref_store,
-                            const char *ref_target,
-                            const char *refs_heads_master,
-                            const char *logmsg);
 typedef int rename_ref_fn(struct ref_store *ref_store,
                          const char *oldref, const char *newref,
                          const char *logmsg);
@@ -690,7 +686,6 @@ struct ref_storage_be {
        ref_transaction_commit_fn *initial_transaction_commit;
 
        pack_refs_fn *pack_refs;
-       create_symref_fn *create_symref;
        rename_ref_fn *rename_ref;
        copy_ref_fn *copy_ref;
 

diff --git a/refs/reftable-backend.c b/refs/reftable-backend.c
index 4ad0d8137164ab141fe4d25ca2bdee413adaec77..8f5165c4ba34193fc170df648bfbd555d246bf80 100644 (file)
--- a/refs/reftable-backend.c
+++ b/refs/reftable-backend.c
@@ -1256,91 +1256,6 @@ struct write_create_symref_arg {
        const char *logmsg;
 };
 
-static int write_create_symref_table(struct reftable_writer *writer, void *cb_data)
-{
-       struct write_create_symref_arg *create = cb_data;
-       uint64_t ts = reftable_stack_next_update_index(create->stack);
-       struct reftable_ref_record ref = {
-               .refname = (char *)create->refname,
-               .value_type = REFTABLE_REF_SYMREF,
-               .value.symref = (char *)create->target,
-               .update_index = ts,
-       };
-       struct reftable_log_record log = {0};
-       struct object_id new_oid;
-       struct object_id old_oid;
-       int ret;
-
-       reftable_writer_set_limits(writer, ts, ts);
-
-       ret = reftable_writer_add_ref(writer, &ref);
-       if (ret)
-               return ret;
-
-       /*
-        * Note that it is important to try and resolve the reference before we
-        * write the log entry. This is because `should_write_log()` will munge
-        * `core.logAllRefUpdates`, which is undesirable when we create a new
-        * repository because it would be written into the config. As HEAD will
-        * not resolve for new repositories this ordering will ensure that this
-        * never happens.
-        */
-       if (!create->logmsg ||
-           !refs_resolve_ref_unsafe(&create->refs->base, create->target,
-                                    RESOLVE_REF_READING, &new_oid, NULL) ||
-           !should_write_log(&create->refs->base, create->refname))
-               return 0;
-
-       fill_reftable_log_record(&log);
-       log.refname = xstrdup(create->refname);
-       log.update_index = ts;
-       log.value.update.message = xstrndup(create->logmsg,
-                                           create->refs->write_options.block_size / 2);
-       memcpy(log.value.update.new_hash, new_oid.hash, GIT_MAX_RAWSZ);
-       if (refs_resolve_ref_unsafe(&create->refs->base, create->refname,
-                                   RESOLVE_REF_READING, &old_oid, NULL))
-               memcpy(log.value.update.old_hash, old_oid.hash, GIT_MAX_RAWSZ);
-
-       ret = reftable_writer_add_log(writer, &log);
-       reftable_log_record_release(&log);
-       return ret;
-}
-
-static int reftable_be_create_symref(struct ref_store *ref_store,
-                                    const char *refname,
-                                    const char *target,
-                                    const char *logmsg)
-{
-       struct reftable_ref_store *refs =
-               reftable_be_downcast(ref_store, REF_STORE_WRITE, "create_symref");
-       struct reftable_stack *stack = stack_for(refs, refname, &refname);
-       struct write_create_symref_arg arg = {
-               .refs = refs,
-               .stack = stack,
-               .refname = refname,
-               .target = target,
-               .logmsg = logmsg,
-       };
-       int ret;
-
-       ret = refs->err;
-       if (ret < 0)
-               goto done;
-
-       ret = reftable_stack_reload(stack);
-       if (ret)
-               goto done;
-
-       ret = reftable_stack_add(stack, &write_create_symref_table, &arg);
-
-done:
-       assert(ret != REFTABLE_API_ERROR);
-       if (ret)
-               error("unable to write symref for %s: %s", refname,
-                     reftable_error_str(ret));
-       return ret;
-}
-
 struct write_copy_arg {
        struct reftable_ref_store *refs;
        struct reftable_stack *stack;
@@ -2248,7 +2163,6 @@ struct ref_storage_be refs_be_reftable = {
        .initial_transaction_commit = reftable_be_initial_transaction_commit,
 
        .pack_refs = reftable_be_pack_refs,
-       .create_symref = reftable_be_create_symref,
        .rename_ref = reftable_be_rename_ref,
        .copy_ref = reftable_be_copy_ref,