reftable: add code to facilitate consistency checks

The `git refs verify` command is used to run consistency checks on the
reference backends. This command is also invoked when users run 'git
fsck'. While the files-backend has some fsck checks added, the reftable
backend lacks such checks. Let's add the required infrastructure and a
check to test for the files present in the reftable directory.

Since the reftable library is treated as an independent library we
should ensure that the library code works independently without
knowledge about Git's internals. To do this, add both 'reftable/fsck.c'
and 'reftable/reftable-fsck.h'. Which provide an entry point
'reftable_fsck_check' for running fsck checks over a provided reftable
stack. The callee provides the function with callbacks to handle issue
and information reporting.

The added check, goes over all tables in the reftable stack validates
that they have a valid name. It not, it raises an error.

While here, move 'reftable/error.o' in the Makefile to retain
lexicographic ordering.

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

diff --git a/Makefile b/Makefile
index e11340c1ae77ba753cb02a39ec2de0e54b89e1f8..0867ab5179d0ffa5bdc1739a7cece76ebe0858d5 100644 (file)
--- a/Makefile
+++ b/Makefile
@@ -2729,9 +2729,10 @@ XDIFF_OBJS += xdiff/xutils.o
 xdiff-objs: $(XDIFF_OBJS)
 
 REFTABLE_OBJS += reftable/basics.o
-REFTABLE_OBJS += reftable/error.o
 REFTABLE_OBJS += reftable/block.o
 REFTABLE_OBJS += reftable/blocksource.o
+REFTABLE_OBJS += reftable/error.o
+REFTABLE_OBJS += reftable/fsck.o
 REFTABLE_OBJS += reftable/iter.o
 REFTABLE_OBJS += reftable/merged.o
 REFTABLE_OBJS += reftable/pq.o

diff --git a/meson.build b/meson.build
index 5dd299b4962d847fc85db656b76a94da15fa0699..82879fbfaa7cbee45375c417d70d95486e5c05c5 100644 (file)
--- a/meson.build
+++ b/meson.build
@@ -452,6 +452,7 @@ libgit_sources = [
   'reftable/error.c',
   'reftable/block.c',
   'reftable/blocksource.c',
+  'reftable/fsck.c',
   'reftable/iter.c',
   'reftable/merged.c',
   'reftable/pq.c',

diff --git a/reftable/fsck.c b/reftable/fsck.c
new file mode 100644 (file)
index 0000000..26b9115
--- /dev/null
+++ b/reftable/fsck.c
@@ -0,0 +1,100 @@
+#include "basics.h"
+#include "reftable-fsck.h"
+#include "reftable-table.h"
+#include "stack.h"
+
+static bool table_has_valid_name(const char *name)
+{
+       const char *ptr = name;
+       char *endptr;
+
+       /* strtoull doesn't set errno on success */
+       errno = 0;
+
+       strtoull(ptr, &endptr, 16);
+       if (errno)
+               return false;
+       ptr = endptr;
+
+       if (*ptr != '-')
+               return false;
+       ptr++;
+
+       strtoull(ptr, &endptr, 16);
+       if (errno)
+               return false;
+       ptr = endptr;
+
+       if (*ptr != '-')
+               return false;
+       ptr++;
+
+       strtoul(ptr, &endptr, 16);
+       if (errno)
+               return false;
+       ptr = endptr;
+
+       if (strcmp(ptr, ".ref") && strcmp(ptr, ".log"))
+               return false;
+
+       return true;
+}
+
+typedef int (*table_check_fn)(struct reftable_table *table,
+                             reftable_fsck_report_fn report_fn,
+                             void *cb_data);
+
+static int table_check_name(struct reftable_table *table,
+                           reftable_fsck_report_fn report_fn,
+                           void *cb_data)
+{
+       if (!table_has_valid_name(table->name)) {
+               struct reftable_fsck_info info;
+
+               info.error = REFTABLE_FSCK_ERROR_TABLE_NAME;
+               info.msg = "invalid reftable table name";
+               info.path = table->name;
+
+               return report_fn(&info, cb_data);
+       }
+
+       return 0;
+}
+
+static int table_checks(struct reftable_table *table,
+                       reftable_fsck_report_fn report_fn,
+                       reftable_fsck_verbose_fn verbose_fn UNUSED,
+                       void *cb_data)
+{
+       table_check_fn table_check_fns[] = {
+               table_check_name,
+               NULL,
+       };
+       int err = 0;
+
+       for (size_t i = 0; table_check_fns[i]; i++)
+               err |= table_check_fns[i](table, report_fn, cb_data);
+
+       return err;
+}
+
+int reftable_fsck_check(struct reftable_stack *stack,
+                       reftable_fsck_report_fn report_fn,
+                       reftable_fsck_verbose_fn verbose_fn,
+                       void *cb_data)
+{
+       struct reftable_buf msg = REFTABLE_BUF_INIT;
+       int err = 0;
+
+       for (size_t i = 0; i < stack->tables_len; i++) {
+               reftable_buf_reset(&msg);
+               reftable_buf_addstr(&msg, "Checking table: ");
+               reftable_buf_addstr(&msg, stack->tables[i]->name);
+               verbose_fn(msg.buf, cb_data);
+
+               err |= table_checks(stack->tables[i], report_fn, verbose_fn, cb_data);
+       }
+
+       reftable_buf_release(&msg);
+       return err;
+}

diff --git a/reftable/reftable-fsck.h b/reftable/reftable-fsck.h
new file mode 100644 (file)
index 0000000..007a392
--- /dev/null
+++ b/reftable/reftable-fsck.h
@@ -0,0 +1,40 @@
+#ifndef REFTABLE_FSCK_H
+#define REFTABLE_FSCK_H
+
+#include "reftable-stack.h"
+
+enum reftable_fsck_error {
+       /* Invalid table name */
+       REFTABLE_FSCK_ERROR_TABLE_NAME = 0,
+       /* Used for bounds checking, must be last */
+       REFTABLE_FSCK_MAX_VALUE,
+};
+
+/* Represents an individual error encountered during the FSCK checks. */
+struct reftable_fsck_info {
+       enum reftable_fsck_error error;
+       const char *msg;
+       const char *path;
+};
+
+typedef int reftable_fsck_report_fn(struct reftable_fsck_info *info,
+                                   void *cb_data);
+typedef void reftable_fsck_verbose_fn(const char *msg, void *cb_data);
+
+/*
+ * Given a reftable stack, perform consistency checks on the stack.
+ *
+ * If an issue is encountered, the issue is reported to the callee via the
+ * provided 'report_fn'. If the issue is non-recoverable the flow will not
+ * continue. If it is recoverable, the flow will continue and further issues
+ * will be reported as identified.
+ *
+ * The 'verbose_fn' will be invoked to provide verbose information about
+ * the progress and state of the consistency checks.
+ */
+int reftable_fsck_check(struct reftable_stack *stack,
+                       reftable_fsck_report_fn report_fn,
+                       reftable_fsck_verbose_fn verbose_fn,
+                       void *cb_data);
+
+#endif /* REFTABLE_FSCK_H */