reftable/stack: allow passing flags to `reftable_stack_add()`

The `reftable_stack_add()` function is a simple wrapper to lock the
stack, add records to it via a callback and then commit the
result. One problem with it though is that it doesn't accept any flags
for creating the addition. This makes it impossible to automatically
reload the stack in case it was modified before we managed to lock the
stack.

Add a `flags` field to plug this gap and pass it through accordingly.
For now this new flag won't be used by us, but it will be used by
libgit2.

Signed-off-by: Patrick Steinhardt <ps@pks.im>
Signed-off-by: Junio C Hamano <gitster@pobox.com>

diff --git a/refs/reftable-backend.c b/refs/reftable-backend.c
index 4c3817f4ec1a887aa6e6feed2a1336ed2b29cbe2..3f0deab338c2883754d9df2f8a29bb04872f2ed7 100644 (file)
--- a/refs/reftable-backend.c
+++ b/refs/reftable-backend.c
@@ -1960,7 +1960,7 @@ static int reftable_be_rename_ref(struct ref_store *ref_store,
        ret = backend_for(&arg.be, refs, newrefname, &newrefname, 1);
        if (ret)
                goto done;
-       ret = reftable_stack_add(arg.be->stack, &write_copy_table, &arg);
+       ret = reftable_stack_add(arg.be->stack, &write_copy_table, &arg, 0);
 
 done:
        assert(ret != REFTABLE_API_ERROR);
@@ -1989,7 +1989,7 @@ static int reftable_be_copy_ref(struct ref_store *ref_store,
        ret = backend_for(&arg.be, refs, newrefname, &newrefname, 1);
        if (ret)
                goto done;
-       ret = reftable_stack_add(arg.be->stack, &write_copy_table, &arg);
+       ret = reftable_stack_add(arg.be->stack, &write_copy_table, &arg, 0);
 
 done:
        assert(ret != REFTABLE_API_ERROR);
@@ -2360,7 +2360,7 @@ static int reftable_be_create_reflog(struct ref_store *ref_store,
                goto done;
        arg.stack = be->stack;
 
-       ret = reftable_stack_add(be->stack, &write_reflog_existence_table, &arg);
+       ret = reftable_stack_add(be->stack, &write_reflog_existence_table, &arg, 0);
 
 done:
        return ret;
@@ -2431,7 +2431,7 @@ static int reftable_be_delete_reflog(struct ref_store *ref_store,
                return ret;
        arg.stack = be->stack;
 
-       ret = reftable_stack_add(be->stack, &write_reflog_delete_table, &arg);
+       ret = reftable_stack_add(be->stack, &write_reflog_delete_table, &arg, 0);
 
        assert(ret != REFTABLE_API_ERROR);
        return ret;

diff --git a/reftable/reftable-stack.h b/reftable/reftable-stack.h
index 910ec6ef3a2f570efbe3ae6e29443f833580d199..d70fcb705dcffe554b8a7c31df56299b70653a20 100644 (file)
--- a/reftable/reftable-stack.h
+++ b/reftable/reftable-stack.h
@@ -68,12 +68,15 @@ int reftable_addition_commit(struct reftable_addition *add);
  * transaction. Releases the lock if held. */
 void reftable_addition_destroy(struct reftable_addition *add);
 
-/* add a new table to the stack. The write_table function must call
- * reftable_writer_set_limits, add refs and return an error value. */
+/*
+ * Add a new table to the stack. The write_table function must call
+ * reftable_writer_set_limits, add refs and return an error value.
+ * The flags are passed through to `reftable_stack_new_addition()`.
+ */
 int reftable_stack_add(struct reftable_stack *st,
                       int (*write_table)(struct reftable_writer *wr,
                                          void *write_arg),
-                      void *write_arg);
+                      void *write_arg, unsigned flags);
 
 struct reftable_iterator;
 

diff --git a/reftable/stack.c b/reftable/stack.c
index 9db90cf4ed0f8d88299d77e7069336a152aef269..1ce4d90cb8214d4f89a9a7463713cb59dfdf5be4 100644 (file)
--- a/reftable/stack.c
+++ b/reftable/stack.c
@@ -736,12 +736,12 @@ done:
 static int stack_try_add(struct reftable_stack *st,
                         int (*write_table)(struct reftable_writer *wr,
                                            void *arg),
-                        void *arg)
+                        void *arg, unsigned flags)
 {
        struct reftable_addition add;
        int err;
 
-       err = reftable_stack_init_addition(&add, st, 0);
+       err = reftable_stack_init_addition(&add, st, flags);
        if (err < 0)
                goto done;
 
@@ -757,9 +757,9 @@ done:
 
 int reftable_stack_add(struct reftable_stack *st,
                       int (*write)(struct reftable_writer *wr, void *arg),
-                      void *arg)
+                      void *arg, unsigned flags)
 {
-       int err = stack_try_add(st, write, arg);
+       int err = stack_try_add(st, write, arg, flags);
        if (err < 0) {
                if (err == REFTABLE_OUTDATED_ERROR) {
                        /* Ignore error return, we want to propagate

diff --git a/t/unit-tests/t-reftable-stack.c b/t/unit-tests/t-reftable-stack.c
index 2f49c9751948f1f344c595f1c14b56d60e403241..ce10247903c5f3c00833ebbea0e81dfab9d6397c 100644 (file)
--- a/t/unit-tests/t-reftable-stack.c
+++ b/t/unit-tests/t-reftable-stack.c
@@ -128,7 +128,7 @@ static void write_n_ref_tables(struct reftable_stack *st,
                ref.refname = buf;
                t_reftable_set_hash(ref.value.val1, i, REFTABLE_HASH_SHA1);
 
-               err = reftable_stack_add(st, &write_test_ref, &ref);
+               err = reftable_stack_add(st, &write_test_ref, &ref, 0);
                check(!err);
        }
 
@@ -170,7 +170,7 @@ static void t_reftable_stack_add_one(void)
        err = reftable_new_stack(&st, dir, &opts);
        check(!err);
 
-       err = reftable_stack_add(st, write_test_ref, &ref);
+       err = reftable_stack_add(st, write_test_ref, &ref, 0);
        check(!err);
 
        err = reftable_stack_read_ref(st, ref.refname, &dest);
@@ -235,16 +235,16 @@ static void t_reftable_stack_uptodate(void)
        err = reftable_new_stack(&st2, dir, &opts);
        check(!err);
 
-       err = reftable_stack_add(st1, write_test_ref, &ref1);
+       err = reftable_stack_add(st1, write_test_ref, &ref1, 0);
        check(!err);
 
-       err = reftable_stack_add(st2, write_test_ref, &ref2);
+       err = reftable_stack_add(st2, write_test_ref, &ref2, 0);
        check_int(err, ==, REFTABLE_OUTDATED_ERROR);
 
        err = reftable_stack_reload(st2);
        check(!err);
 
-       err = reftable_stack_add(st2, write_test_ref, &ref2);
+       err = reftable_stack_add(st2, write_test_ref, &ref2, 0);
        check(!err);
        reftable_stack_destroy(st1);
        reftable_stack_destroy(st2);
@@ -428,7 +428,7 @@ static void t_reftable_stack_auto_compaction_fails_gracefully(void)
        err = reftable_new_stack(&st, dir, &opts);
        check(!err);
 
-       err = reftable_stack_add(st, write_test_ref, &ref);
+       err = reftable_stack_add(st, write_test_ref, &ref, 0);
        check(!err);
        check_int(st->merged->tables_len, ==, 1);
        check_int(st->stats.attempts, ==, 0);
@@ -446,7 +446,7 @@ static void t_reftable_stack_auto_compaction_fails_gracefully(void)
        write_file_buf(table_path.buf, "", 0);
 
        ref.update_index = 2;
-       err = reftable_stack_add(st, write_test_ref, &ref);
+       err = reftable_stack_add(st, write_test_ref, &ref, 0);
        check(!err);
        check_int(st->merged->tables_len, ==, 2);
        check_int(st->stats.attempts, ==, 1);
@@ -484,10 +484,10 @@ static void t_reftable_stack_update_index_check(void)
        err = reftable_new_stack(&st, dir, &opts);
        check(!err);
 
-       err = reftable_stack_add(st, write_test_ref, &ref1);
+       err = reftable_stack_add(st, write_test_ref, &ref1, 0);
        check(!err);
 
-       err = reftable_stack_add(st, write_test_ref, &ref2);
+       err = reftable_stack_add(st, write_test_ref, &ref2, 0);
        check_int(err, ==, REFTABLE_API_ERROR);
        reftable_stack_destroy(st);
        clear_dir(dir);
@@ -503,7 +503,7 @@ static void t_reftable_stack_lock_failure(void)
        err = reftable_new_stack(&st, dir, &opts);
        check(!err);
        for (i = -1; i != REFTABLE_EMPTY_TABLE_ERROR; i--) {
-               err = reftable_stack_add(st, write_error, &i);
+               err = reftable_stack_add(st, write_error, &i, 0);
                check_int(err, ==, i);
        }
 
@@ -546,7 +546,7 @@ static void t_reftable_stack_add(void)
        }
 
        for (i = 0; i < N; i++) {
-               int err = reftable_stack_add(st, write_test_ref, &refs[i]);
+               int err = reftable_stack_add(st, write_test_ref, &refs[i], 0);
                check(!err);
        }
 
@@ -555,7 +555,7 @@ static void t_reftable_stack_add(void)
                        .log = &logs[i],
                        .update_index = reftable_stack_next_update_index(st),
                };
-               int err = reftable_stack_add(st, write_test_log, &arg);
+               int err = reftable_stack_add(st, write_test_log, &arg, 0);
                check(!err);
        }
 
@@ -639,7 +639,7 @@ static void t_reftable_stack_iterator(void)
        }
 
        for (i = 0; i < N; i++) {
-               err = reftable_stack_add(st, write_test_ref, &refs[i]);
+               err = reftable_stack_add(st, write_test_ref, &refs[i], 0);
                check(!err);
        }
 
@@ -649,7 +649,7 @@ static void t_reftable_stack_iterator(void)
                        .update_index = reftable_stack_next_update_index(st),
                };
 
-               err = reftable_stack_add(st, write_test_log, &arg);
+               err = reftable_stack_add(st, write_test_log, &arg, 0);
                check(!err);
        }
 
@@ -725,11 +725,11 @@ static void t_reftable_stack_log_normalize(void)
        check(!err);
 
        input.value.update.message = (char *) "one\ntwo";
-       err = reftable_stack_add(st, write_test_log, &arg);
+       err = reftable_stack_add(st, write_test_log, &arg, 0);
        check_int(err, ==, REFTABLE_API_ERROR);
 
        input.value.update.message = (char *) "one";
-       err = reftable_stack_add(st, write_test_log, &arg);
+       err = reftable_stack_add(st, write_test_log, &arg, 0);
        check(!err);
 
        err = reftable_stack_read_log(st, input.refname, &dest);
@@ -738,7 +738,7 @@ static void t_reftable_stack_log_normalize(void)
 
        input.value.update.message = (char *) "two\n";
        arg.update_index = 2;
-       err = reftable_stack_add(st, write_test_log, &arg);
+       err = reftable_stack_add(st, write_test_log, &arg, 0);
        check(!err);
        err = reftable_stack_read_log(st, input.refname, &dest);
        check(!err);
@@ -792,7 +792,7 @@ static void t_reftable_stack_tombstone(void)
                }
        }
        for (i = 0; i < N; i++) {
-               int err = reftable_stack_add(st, write_test_ref, &refs[i]);
+               int err = reftable_stack_add(st, write_test_ref, &refs[i], 0);
                check(!err);
        }
 
@@ -801,7 +801,7 @@ static void t_reftable_stack_tombstone(void)
                        .log = &logs[i],
                        .update_index = reftable_stack_next_update_index(st),
                };
-               int err = reftable_stack_add(st, write_test_log, &arg);
+               int err = reftable_stack_add(st, write_test_log, &arg, 0);
                check(!err);
        }
 
@@ -855,7 +855,7 @@ static void t_reftable_stack_hash_id(void)
        err = reftable_new_stack(&st, dir, &opts);
        check(!err);
 
-       err = reftable_stack_add(st, write_test_ref, &ref);
+       err = reftable_stack_add(st, write_test_ref, &ref, 0);
        check(!err);
 
        /* can't read it with the wrong hash ID. */
@@ -927,7 +927,7 @@ static void t_reflog_expire(void)
                        .log = &logs[i],
                        .update_index = reftable_stack_next_update_index(st),
                };
-               int err = reftable_stack_add(st, write_test_log, &arg);
+               int err = reftable_stack_add(st, write_test_log, &arg, 0);
                check(!err);
        }
 
@@ -978,7 +978,7 @@ static void t_empty_add(void)
        err = reftable_new_stack(&st, dir, &opts);
        check(!err);
 
-       err = reftable_stack_add(st, write_nothing, NULL);
+       err = reftable_stack_add(st, write_nothing, NULL, 0);
        check(!err);
 
        err = reftable_new_stack(&st2, dir, &opts);
@@ -1021,7 +1021,7 @@ static void t_reftable_stack_auto_compaction(void)
                };
                snprintf(name, sizeof(name), "branch%04"PRIuMAX, (uintmax_t)i);
 
-               err = reftable_stack_add(st, write_test_ref, &ref);
+               err = reftable_stack_add(st, write_test_ref, &ref, 0);
                check(!err);
 
                err = reftable_stack_auto_compact(st);
@@ -1058,7 +1058,7 @@ static void t_reftable_stack_auto_compaction_factor(void)
                };
                xsnprintf(name, sizeof(name), "branch%04"PRIuMAX, (uintmax_t)i);
 
-               err = reftable_stack_add(st, &write_test_ref, &ref);
+               err = reftable_stack_add(st, &write_test_ref, &ref, 0);
                check(!err);
 
                check(i < 5 || st->merged->tables_len < 5 * fastlogN(i, 5));
@@ -1140,7 +1140,7 @@ static void t_reftable_stack_add_performs_auto_compaction(void)
                snprintf(buf, sizeof(buf), "branch-%04"PRIuMAX, (uintmax_t)i);
                ref.refname = buf;
 
-               err = reftable_stack_add(st, write_test_ref, &ref);
+               err = reftable_stack_add(st, write_test_ref, &ref, 0);
                check(!err);
 
                /*