Introduce a fsck check for the reftable backend, which checks if the
tables in 'tables.list' contain sequential update index. The tables in
the reftable backend should contain sequential update index. This fsck
check ensures that.
We must note that the reftable backend itself doesn't check to ensure
this and it also doesn't check to ensure that the index in the table
name matches the index in the header or the table. The latter is not
implemented in this fsck check either and will be added in a future
patch where we add fsck checks for internals of a table.
Signed-off-by: Karthik Nayak <karthik.188@xxxxxxxxx>
---
Documentation/fsck-msgids.adoc | 3 ++
fsck.h | 1 +
refs/reftable-backend.c | 3 ++
reftable/fsck.c | 14 +++++++++-
reftable/reftable-fsck.h | 2 ++
t/t0614-reftable-fsck.sh | 62 ++++++++++++++++++++++++++++++++++++++++++
6 files changed, 84 insertions(+), 1 deletion(-)
diff --git a/Documentation/fsck-msgids.adoc b/Documentation/fsck-msgids.adoc
index 1432b1de06..982d51876c 100644
--- a/Documentation/fsck-msgids.adoc
+++ b/Documentation/fsck-msgids.adoc
@@ -47,6 +47,9 @@
`badReftableTableName`::
(ERROR) A reftable table has an invalid name.
+`badReftableUpdateIndex`::
+ (ERROR) Incorrect update index found for table.
+
`badTagName`::
(INFO) A tag has an invalid format.
diff --git a/fsck.h b/fsck.h
index 33432bae79..60e9b84183 100644
--- a/fsck.h
+++ b/fsck.h
@@ -37,6 +37,7 @@ enum fsck_msg_type {
FUNC(BAD_REFTABLE_STACK_COUNT, ERROR) \
FUNC(BAD_REFTABLE_STACK_LIST_NEWLINE, ERROR) \
FUNC(BAD_REFTABLE_TABLE_NAME, ERROR) \
+ FUNC(BAD_REFTABLE_UPDATE_INDEX, ERROR) \
FUNC(BAD_REF_CONTENT, ERROR) \
FUNC(BAD_REF_FILETYPE, ERROR) \
FUNC(BAD_REF_NAME, ERROR) \
diff --git a/refs/reftable-backend.c b/refs/reftable-backend.c
index 0087afa3ac..d5993238db 100644
--- a/refs/reftable-backend.c
+++ b/refs/reftable-backend.c
@@ -2701,6 +2701,9 @@ static int reftable_fsck_error_handler(struct reftable_fsck_info info,
case REFTABLE_FSCK_ERROR_STACK_LIST_MISSING_NEWLINE:
msg_id = FSCK_MSG_BAD_REFTABLE_STACK_LIST_NEWLINE;
break;
+ case REFTABLE_FSCK_ERROR_UPDATE_INDEX:
+ msg_id = FSCK_MSG_BAD_REFTABLE_UPDATE_INDEX;
+ break;
default:
BUG("unknown fsck error: %d", info.error);
}
diff --git a/reftable/fsck.c b/reftable/fsck.c
index b4898fd2cd..a6551b9a3c 100644
--- a/reftable/fsck.c
+++ b/reftable/fsck.c
@@ -53,8 +53,8 @@ int reftable_fsck_check(struct reftable_stack *stack,
reftable_fsck_verbose_fn verbose_fn,
void *cb_data)
{
+ uint64_t min, max, prev_max = 0;
char **names = NULL;
- uint64_t min, max;
int err = 0;
if (stack == NULL)
@@ -85,9 +85,21 @@ int reftable_fsck_check(struct reftable_stack *stack,
err = report_fn(info, cb_data);
}
+ if (min != (prev_max + 1) || max < min) {
+ struct reftable_fsck_info info = {
+ .error = REFTABLE_FSCK_ERROR_UPDATE_INDEX,
+ .path = names[i],
+ .msg = "incorrect update index in table name"
+ };
+
+ err = report_fn(info, cb_data);
+ }
+
if (strcmp(tail, ".ref")) {
err = report_fn(info, cb_data);
}
+
+ prev_max = max;
}
verbose_fn("Checking trailing newline in stack list", cb_data);
diff --git a/reftable/reftable-fsck.h b/reftable/reftable-fsck.h
index 8e6cb6c7d2..49437280bb 100644
--- a/reftable/reftable-fsck.h
+++ b/reftable/reftable-fsck.h
@@ -10,6 +10,8 @@ enum reftable_fsck_error {
REFTABLE_FSCK_ERROR_STACK_COUNT = -2,
/* Newline missing at the end of the stack list */
REFTABLE_FSCK_ERROR_STACK_LIST_MISSING_NEWLINE = -3,
+ /* Incorrect update index for table */
+ REFTABLE_FSCK_ERROR_UPDATE_INDEX = -4,
};
/* Represents an individual error encounctered during the FSCK checks. */
diff --git a/t/t0614-reftable-fsck.sh b/t/t0614-reftable-fsck.sh
index 937c5dd37a..bdcbd65a9f 100755
--- a/t/t0614-reftable-fsck.sh
+++ b/t/t0614-reftable-fsck.sh
@@ -73,4 +73,66 @@ test_expect_success 'stack list must contain trailing newline' '
)
'
+test_expect_success 'table update index should be sequential between tables' '
+ test_when_finished "rm -rf repo" &&
+ git init repo &&
+ (
+ cd repo &&
+ git commit --allow-empty -m initial &&
+
+ # Lock the existing table to disable auto-compaction
+ CUR_TABLE=$(cat .git/reftable/tables.list | tail -n1) &&
+ touch .git/reftable/${CUR_TABLE}.lock &&
+ git update-ref refs/heads/sample @ &&
+ rm .git/reftable/${CUR_TABLE}.lock &&
+
+ git refs verify 2>err &&
+ test_must_be_empty err &&
+
+ TABLE_NAME=$(cat .git/reftable/tables.list | tail -n1) &&
+ NEW_TABLE_NAME=$(echo ${TABLE_NAME} | sed "s/0003/0009/g") &&
+
+ sed "2s/.*/${NEW_TABLE_NAME}/" .git/reftable/tables.list >.git/reftable/tables.list.tmp &&
+ mv .git/reftable/tables.list.tmp .git/reftable/tables.list &&
+ mv .git/reftable/${TABLE_NAME} .git/reftable/${NEW_TABLE_NAME} &&
+
+ test_must_fail git refs verify 2>err &&
+ cat >expect <<-EOF &&
+ error: ${NEW_TABLE_NAME}: badReftableUpdateIndex: incorrect update index in table name
+ EOF
+ test_cmp expect err
+ )
+'
+
+test_expect_success 'table update index should be sequential within a table' '
+ test_when_finished "rm -rf repo" &&
+ git init repo &&
+ (
+ cd repo &&
+ git commit --allow-empty -m initial &&
+
+ # Lock the existing table to disable auto-compaction
+ CUR_TABLE=$(cat .git/reftable/tables.list | tail -n1) &&
+ touch .git/reftable/${CUR_TABLE}.lock &&
+ git update-ref refs/heads/sample @ &&
+ rm .git/reftable/${CUR_TABLE}.lock &&
+
+ git refs verify 2>err &&
+ test_must_be_empty err &&
+
+ TABLE_NAME=$(cat .git/reftable/tables.list | tail -n1) &&
+ NEW_TABLE_NAME=$(echo ${TABLE_NAME} | sed "s/\(.*\)0003/\10002/") &&
+
+ sed "2s/.*/${NEW_TABLE_NAME}/" .git/reftable/tables.list >.git/reftable/tables.list.tmp &&
+ mv .git/reftable/tables.list.tmp .git/reftable/tables.list &&
+ mv .git/reftable/${TABLE_NAME} .git/reftable/${NEW_TABLE_NAME} &&
+
+ test_must_fail git refs verify 2>err &&
+ cat >expect <<-EOF &&
+ error: ${NEW_TABLE_NAME}: badReftableUpdateIndex: incorrect update index in table name
+ EOF
+ test_cmp expect err
+ )
+'
+
test_done
--
2.50.1
