freshlybakedca.ke
Git fork
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>
authored by
Patrick Steinhardt
and committed by
Junio C Hamano
178c5885
6fb1d819
+4
-4
refs/reftable-backend.c
+4
-4
refs/reftable-backend.c
···
1960
1960
ret = backend_for(&arg.be, refs, newrefname, &newrefname, 1);
1961
1961
if (ret)
1962
1962
goto done;
1963
-
ret = reftable_stack_add(arg.be->stack, &write_copy_table, &arg);
1963
+
ret = reftable_stack_add(arg.be->stack, &write_copy_table, &arg, 0);
1964
1964
1965
1965
done:
1966
1966
assert(ret != REFTABLE_API_ERROR);
···
1989
1989
ret = backend_for(&arg.be, refs, newrefname, &newrefname, 1);
1990
1990
if (ret)
1991
1991
goto done;
1992
-
ret = reftable_stack_add(arg.be->stack, &write_copy_table, &arg);
1992
+
ret = reftable_stack_add(arg.be->stack, &write_copy_table, &arg, 0);
1993
1993
1994
1994
done:
1995
1995
assert(ret != REFTABLE_API_ERROR);
···
2360
2360
goto done;
2361
2361
arg.stack = be->stack;
2362
2362
2363
-
ret = reftable_stack_add(be->stack, &write_reflog_existence_table, &arg);
2363
+
ret = reftable_stack_add(be->stack, &write_reflog_existence_table, &arg, 0);
2364
2364
2365
2365
done:
2366
2366
return ret;
···
2431
2431
return ret;
2432
2432
arg.stack = be->stack;
2433
2433
2434
-
ret = reftable_stack_add(be->stack, &write_reflog_delete_table, &arg);
2434
+
ret = reftable_stack_add(be->stack, &write_reflog_delete_table, &arg, 0);
2435
2435
2436
2436
assert(ret != REFTABLE_API_ERROR);
2437
2437
return ret;
+6
-3
reftable/reftable-stack.h
+6
-3
reftable/reftable-stack.h
···
68
68
* transaction. Releases the lock if held. */
69
69
void reftable_addition_destroy(struct reftable_addition *add);
70
70
71
-
/* add a new table to the stack. The write_table function must call
72
-
* reftable_writer_set_limits, add refs and return an error value. */
71
+
/*
72
+
* Add a new table to the stack. The write_table function must call
73
+
* reftable_writer_set_limits, add refs and return an error value.
74
+
* The flags are passed through to `reftable_stack_new_addition()`.
75
+
*/
73
76
int reftable_stack_add(struct reftable_stack *st,
74
77
int (*write_table)(struct reftable_writer *wr,
75
78
void *write_arg),
76
-
void *write_arg);
79
+
void *write_arg, unsigned flags);
77
80
78
81
struct reftable_iterator;
79
82
+4
-4
reftable/stack.c
+4
-4
reftable/stack.c
···
736
736
static int stack_try_add(struct reftable_stack *st,
737
737
int (*write_table)(struct reftable_writer *wr,
738
738
void *arg),
739
-
void *arg)
739
+
void *arg, unsigned flags)
740
740
{
741
741
struct reftable_addition add;
742
742
int err;
743
743
744
-
err = reftable_stack_init_addition(&add, st, 0);
744
+
err = reftable_stack_init_addition(&add, st, flags);
745
745
if (err < 0)
746
746
goto done;
747
747
···
757
757
758
758
int reftable_stack_add(struct reftable_stack *st,
759
759
int (*write)(struct reftable_writer *wr, void *arg),
760
-
void *arg)
760
+
void *arg, unsigned flags)
761
761
{
762
-
int err = stack_try_add(st, write, arg);
762
+
int err = stack_try_add(st, write, arg, flags);
763
763
if (err < 0) {
764
764
if (err == REFTABLE_OUTDATED_ERROR) {
765
765
/* Ignore error return, we want to propagate
+25
-25
t/unit-tests/t-reftable-stack.c
+25
-25
t/unit-tests/t-reftable-stack.c
···
128
128
ref.refname = buf;
129
129
t_reftable_set_hash(ref.value.val1, i, REFTABLE_HASH_SHA1);
130
130
131
-
err = reftable_stack_add(st, &write_test_ref, &ref);
131
+
err = reftable_stack_add(st, &write_test_ref, &ref, 0);
132
132
check(!err);
133
133
}
134
134
···
170
170
err = reftable_new_stack(&st, dir, &opts);
171
171
check(!err);
172
172
173
-
err = reftable_stack_add(st, write_test_ref, &ref);
173
+
err = reftable_stack_add(st, write_test_ref, &ref, 0);
174
174
check(!err);
175
175
176
176
err = reftable_stack_read_ref(st, ref.refname, &dest);
···
235
235
err = reftable_new_stack(&st2, dir, &opts);
236
236
check(!err);
237
237
238
-
err = reftable_stack_add(st1, write_test_ref, &ref1);
238
+
err = reftable_stack_add(st1, write_test_ref, &ref1, 0);
239
239
check(!err);
240
240
241
-
err = reftable_stack_add(st2, write_test_ref, &ref2);
241
+
err = reftable_stack_add(st2, write_test_ref, &ref2, 0);
242
242
check_int(err, ==, REFTABLE_OUTDATED_ERROR);
243
243
244
244
err = reftable_stack_reload(st2);
245
245
check(!err);
246
246
247
-
err = reftable_stack_add(st2, write_test_ref, &ref2);
247
+
err = reftable_stack_add(st2, write_test_ref, &ref2, 0);
248
248
check(!err);
249
249
reftable_stack_destroy(st1);
250
250
reftable_stack_destroy(st2);
···
428
428
err = reftable_new_stack(&st, dir, &opts);
429
429
check(!err);
430
430
431
-
err = reftable_stack_add(st, write_test_ref, &ref);
431
+
err = reftable_stack_add(st, write_test_ref, &ref, 0);
432
432
check(!err);
433
433
check_int(st->merged->tables_len, ==, 1);
434
434
check_int(st->stats.attempts, ==, 0);
···
446
446
write_file_buf(table_path.buf, "", 0);
447
447
448
448
ref.update_index = 2;
449
-
err = reftable_stack_add(st, write_test_ref, &ref);
449
+
err = reftable_stack_add(st, write_test_ref, &ref, 0);
450
450
check(!err);
451
451
check_int(st->merged->tables_len, ==, 2);
452
452
check_int(st->stats.attempts, ==, 1);
···
484
484
err = reftable_new_stack(&st, dir, &opts);
485
485
check(!err);
486
486
487
-
err = reftable_stack_add(st, write_test_ref, &ref1);
487
+
err = reftable_stack_add(st, write_test_ref, &ref1, 0);
488
488
check(!err);
489
489
490
-
err = reftable_stack_add(st, write_test_ref, &ref2);
490
+
err = reftable_stack_add(st, write_test_ref, &ref2, 0);
491
491
check_int(err, ==, REFTABLE_API_ERROR);
492
492
reftable_stack_destroy(st);
493
493
clear_dir(dir);
···
503
503
err = reftable_new_stack(&st, dir, &opts);
504
504
check(!err);
505
505
for (i = -1; i != REFTABLE_EMPTY_TABLE_ERROR; i--) {
506
-
err = reftable_stack_add(st, write_error, &i);
506
+
err = reftable_stack_add(st, write_error, &i, 0);
507
507
check_int(err, ==, i);
508
508
}
509
509
···
546
546
}
547
547
548
548
for (i = 0; i < N; i++) {
549
-
int err = reftable_stack_add(st, write_test_ref, &refs[i]);
549
+
int err = reftable_stack_add(st, write_test_ref, &refs[i], 0);
550
550
check(!err);
551
551
}
552
552
···
555
555
.log = &logs[i],
556
556
.update_index = reftable_stack_next_update_index(st),
557
557
};
558
-
int err = reftable_stack_add(st, write_test_log, &arg);
558
+
int err = reftable_stack_add(st, write_test_log, &arg, 0);
559
559
check(!err);
560
560
}
561
561
···
639
639
}
640
640
641
641
for (i = 0; i < N; i++) {
642
-
err = reftable_stack_add(st, write_test_ref, &refs[i]);
642
+
err = reftable_stack_add(st, write_test_ref, &refs[i], 0);
643
643
check(!err);
644
644
}
645
645
···
649
649
.update_index = reftable_stack_next_update_index(st),
650
650
};
651
651
652
-
err = reftable_stack_add(st, write_test_log, &arg);
652
+
err = reftable_stack_add(st, write_test_log, &arg, 0);
653
653
check(!err);
654
654
}
655
655
···
725
725
check(!err);
726
726
727
727
input.value.update.message = (char *) "one\ntwo";
728
-
err = reftable_stack_add(st, write_test_log, &arg);
728
+
err = reftable_stack_add(st, write_test_log, &arg, 0);
729
729
check_int(err, ==, REFTABLE_API_ERROR);
730
730
731
731
input.value.update.message = (char *) "one";
732
-
err = reftable_stack_add(st, write_test_log, &arg);
732
+
err = reftable_stack_add(st, write_test_log, &arg, 0);
733
733
check(!err);
734
734
735
735
err = reftable_stack_read_log(st, input.refname, &dest);
···
738
738
739
739
input.value.update.message = (char *) "two\n";
740
740
arg.update_index = 2;
741
-
err = reftable_stack_add(st, write_test_log, &arg);
741
+
err = reftable_stack_add(st, write_test_log, &arg, 0);
742
742
check(!err);
743
743
err = reftable_stack_read_log(st, input.refname, &dest);
744
744
check(!err);
···
792
792
}
793
793
}
794
794
for (i = 0; i < N; i++) {
795
-
int err = reftable_stack_add(st, write_test_ref, &refs[i]);
795
+
int err = reftable_stack_add(st, write_test_ref, &refs[i], 0);
796
796
check(!err);
797
797
}
798
798
···
801
801
.log = &logs[i],
802
802
.update_index = reftable_stack_next_update_index(st),
803
803
};
804
-
int err = reftable_stack_add(st, write_test_log, &arg);
804
+
int err = reftable_stack_add(st, write_test_log, &arg, 0);
805
805
check(!err);
806
806
}
807
807
···
855
855
err = reftable_new_stack(&st, dir, &opts);
856
856
check(!err);
857
857
858
-
err = reftable_stack_add(st, write_test_ref, &ref);
858
+
err = reftable_stack_add(st, write_test_ref, &ref, 0);
859
859
check(!err);
860
860
861
861
/* can't read it with the wrong hash ID. */
···
927
927
.log = &logs[i],
928
928
.update_index = reftable_stack_next_update_index(st),
929
929
};
930
-
int err = reftable_stack_add(st, write_test_log, &arg);
930
+
int err = reftable_stack_add(st, write_test_log, &arg, 0);
931
931
check(!err);
932
932
}
933
933
···
978
978
err = reftable_new_stack(&st, dir, &opts);
979
979
check(!err);
980
980
981
-
err = reftable_stack_add(st, write_nothing, NULL);
981
+
err = reftable_stack_add(st, write_nothing, NULL, 0);
982
982
check(!err);
983
983
984
984
err = reftable_new_stack(&st2, dir, &opts);
···
1021
1021
};
1022
1022
snprintf(name, sizeof(name), "branch%04"PRIuMAX, (uintmax_t)i);
1023
1023
1024
-
err = reftable_stack_add(st, write_test_ref, &ref);
1024
+
err = reftable_stack_add(st, write_test_ref, &ref, 0);
1025
1025
check(!err);
1026
1026
1027
1027
err = reftable_stack_auto_compact(st);
···
1058
1058
};
1059
1059
xsnprintf(name, sizeof(name), "branch%04"PRIuMAX, (uintmax_t)i);
1060
1060
1061
-
err = reftable_stack_add(st, &write_test_ref, &ref);
1061
+
err = reftable_stack_add(st, &write_test_ref, &ref, 0);
1062
1062
check(!err);
1063
1063
1064
1064
check(i < 5 || st->merged->tables_len < 5 * fastlogN(i, 5));
···
1140
1140
snprintf(buf, sizeof(buf), "branch-%04"PRIuMAX, (uintmax_t)i);
1141
1141
ref.refname = buf;
1142
1142
1143
-
err = reftable_stack_add(st, write_test_ref, &ref);
1143
+
err = reftable_stack_add(st, write_test_ref, &ref, 0);
1144
1144
check(!err);
1145
1145
1146
1146
/*