tigerbeetle-node 0.11.9 → 0.11.11

package/src/tigerbeetle/src/vsr/superblock_fuzz.zig

@@ -22,7 +22,7 @@ const StorageFaultAtlas = @import("../testing/storage.zig").ClusterFaultAtlas;
 const MessagePool = @import("../message_pool.zig").MessagePool;
 const superblock_zone_size = @import("superblock.zig").superblock_zone_size;
 const data_file_size_min = @import("superblock.zig").data_file_size_min;
-const VSRState = @import("superblock.zig").SuperBlockSector.VSRState;
+const VSRState = @import("superblock.zig").SuperBlockHeader.VSRState;
 const SuperBlockType = @import("superblock.zig").SuperBlockType;
 const SuperBlock = SuperBlockType(Storage);
 const fuzz = @import("../testing/fuzz.zig");
@@ -151,9 +151,10 @@ const Environment = struct {
     /// Indexed by sequence.
     const SequenceStates = std.ArrayList(struct {
         vsr_state: VSRState,
+        vsr_headers: vsr.ViewChangeHeaders.BoundedArray,
         /// Track the expected `checksum(free_set)`.
         /// Note that this is a checksum of the decoded free set; it is not the same as
-        /// `SuperBlockSector.free_set_checksum`.
+        /// `SuperBlockHeader.free_set_checksum`.
         free_set: u128,
     });
 
@@ -166,7 +167,7 @@ const Environment = struct {
     latest_sequence: u64 = 0,
     latest_checksum: u128 = 0,
     latest_parent: u128 = 0,
-    latest_vsr_state: VSRState = std.mem.zeroInit(VSRState, .{}),
+    latest_vsr_state: VSRState = std.mem.zeroes(VSRState),
 
     context_format: SuperBlock.Context = undefined,
     context_open: SuperBlock.Context = undefined,
@@ -232,7 +233,7 @@ const Environment = struct {
             if (env.latest_checksum != 0) {
                 if (env.latest_sequence + 1 == env.superblock_verify.working.sequence) {
                     // After a checkpoint() or view_change(), the parent points to the previous
-                    // working sector.
+                    // working header.
                     assert(env.superblock_verify.working.parent == env.latest_checksum);
                 }
             }
@@ -268,10 +269,14 @@ const Environment = struct {
             .replica = 0,
         });
 
+        var vsr_headers = vsr.ViewChangeHeaders.BoundedArray{ .buffer = undefined };
+        vsr_headers.appendAssumeCapacity(vsr.Header.root_prepare(cluster));
+
         assert(env.sequence_states.items.len == 0);
         try env.sequence_states.append(undefined); // skip sequence=0
         try env.sequence_states.append(.{
             .vsr_state = VSRState.root(cluster),
+            .vsr_headers = vsr_headers,
             .free_set = checksum_free_set(env.superblock),
         });
     }
@@ -310,14 +315,29 @@ const Environment = struct {
             .view = env.superblock.staging.vsr_state.view + 5,
         };
 
+        var vsr_headers = vsr.ViewChangeHeaders.BoundedArray{ .buffer = undefined };
+        var vsr_head = std.mem.zeroInit(vsr.Header, .{
+            .command = .prepare,
+            .op = env.superblock.staging.vsr_state.commit_min,
+        });
+        vsr_head.set_checksum_body(&.{});
+        vsr_head.set_checksum();
+        vsr_headers.appendAssumeCapacity(vsr_head);
+
         assert(env.sequence_states.items.len == env.superblock.staging.sequence + 1);
         try env.sequence_states.append(.{
             .vsr_state = vsr_state,
+            .vsr_headers = vsr_headers,
             .free_set = env.sequence_states.items[env.sequence_states.items.len - 1].free_set,
         });
 
         env.pending.insert(.view_change);
-        env.superblock.view_change(view_change_callback, &env.context_view_change, vsr_state);
+        env.superblock.view_change(view_change_callback, &env.context_view_change, .{
+            .commit_max = vsr_state.commit_max,
+            .log_view = vsr_state.log_view,
+            .view = vsr_state.view,
+            .headers = vsr_headers,
+        });
     }
 
     fn view_change_callback(context: *SuperBlock.Context) void {
@@ -334,18 +354,25 @@ const Environment = struct {
             .commit_min_checksum = env.superblock.staging.vsr_state.commit_min_checksum + 1,
             .commit_min = env.superblock.staging.vsr_state.commit_min + 1,
             .commit_max = env.superblock.staging.vsr_state.commit_max + 1,
-            .log_view = env.superblock.staging.vsr_state.log_view + 1,
-            .view = env.superblock.staging.vsr_state.view + 1,
+            .log_view = env.superblock.staging.vsr_state.log_view,
+            .view = env.superblock.staging.vsr_state.view,
         };
 
         assert(env.sequence_states.items.len == env.superblock.staging.sequence + 1);
         try env.sequence_states.append(.{
             .vsr_state = vsr_state,
+            .vsr_headers = vsr.ViewChangeHeaders.BoundedArray.fromSlice(
+                env.superblock.staging.vsr_headers().slice,
+            ) catch unreachable,
             .free_set = checksum_free_set(env.superblock),
         });
 
         env.pending.insert(.checkpoint);
-        env.superblock.checkpoint(checkpoint_callback, &env.context_checkpoint, vsr_state);
+        env.superblock.checkpoint(checkpoint_callback, &env.context_checkpoint, .{
+            .commit_min_checksum = vsr_state.commit_min_checksum,
+            .commit_min = vsr_state.commit_min,
+            .commit_max = vsr_state.commit_max,
+        });
     }
 
     fn checkpoint_callback(context: *SuperBlock.Context) void {

package/src/tigerbeetle/src/vsr/superblock_quorums.zig

@@ -3,7 +3,7 @@ const assert = std.debug.assert;
 const log = std.log.scoped(.superblock_quorums);
 
 const superblock = @import("./superblock.zig");
-const SuperBlockSector = superblock.SuperBlockSector;
+const SuperBlockHeader = superblock.SuperBlockHeader;
 const SuperBlockVersion = superblock.SuperBlockVersion;
 const fuzz = @import("./superblock_quorums_fuzz.zig");
 
@@ -16,10 +16,10 @@ pub fn QuorumsType(comptime options: Options) type {
         const Quorums = @This();
 
         const Quorum = struct {
-            sector: *const SuperBlockSector,
+            header: *const SuperBlockHeader,
             valid: bool = false,
             /// Track which copies are a member of the quorum.
-            /// Used to ignore duplicate copies of a sector when determining a quorum.
+            /// Used to ignore duplicate copies of a header when determining a quorum.
             copies: QuorumCount = QuorumCount.initEmpty(),
             /// An integer value indicates the copy index found in the corresponding slot.
             /// A `null` value indicates that the copy is invalid or not a member of the working
@@ -86,7 +86,7 @@ pub fn QuorumsType(comptime options: Options) type {
         ///   trailers may be damaged.
         pub fn working(
             quorums: *Quorums,
-            copies: []SuperBlockSector,
+            copies: []SuperBlockHeader,
             threshold: Threshold,
         ) Error!Quorum {
             assert(copies.len == options.superblock_copies);
@@ -102,17 +102,17 @@ pub fn QuorumsType(comptime options: Options) type {
             for (quorums.slice()) |quorum| {
                 if (quorum.copies.count() == options.superblock_copies) {
                     log.debug("quorum: checksum={x} parent={x} sequence={} count={} valid={}", .{
-                        quorum.sector.checksum,
-                        quorum.sector.parent,
-                        quorum.sector.sequence,
+                        quorum.header.checksum,
+                        quorum.header.parent,
+                        quorum.header.sequence,
                         quorum.copies.count(),
                         quorum.valid,
                     });
                 } else {
                     log.warn("quorum: checksum={x} parent={x} sequence={} count={} valid={}", .{
-                        quorum.sector.checksum,
-                        quorum.sector.parent,
-                        quorum.sector.sequence,
+                        quorum.header.checksum,
+                        quorum.header.parent,
+                        quorum.header.sequence,
                         quorum.copies.count(),
                         quorum.valid,
                     });
@@ -128,7 +128,7 @@ pub fn QuorumsType(comptime options: Options) type {
             // Verify that the remaining quorums are correctly sorted:
             for (quorums.slice()[1..]) |a| {
                 assert(sort_priority_descending({}, b, a));
-                assert(a.sector.valid_checksum());
+                assert(a.header.valid_checksum());
             }
 
             // Even the best copy with the most quorum still has inadequate quorum.
@@ -140,61 +140,61 @@ pub fn QuorumsType(comptime options: Options) type {
             // - a lost or misdirected write
             // - a latent sector error that prevented a write
             for (quorums.slice()[1..]) |a| {
-                if (a.sector.cluster != b.sector.cluster) {
+                if (a.header.cluster != b.header.cluster) {
                     log.warn("superblock copy={} has cluster={} instead of {}", .{
-                        a.sector.copy,
-                        a.sector.cluster,
-                        b.sector.cluster,
+                        a.header.copy,
+                        a.header.cluster,
+                        b.header.cluster,
                     });
                     continue;
                 }
 
-                if (a.sector.replica != b.sector.replica) {
+                if (a.header.replica != b.header.replica) {
                     log.warn("superblock copy={} has replica={} instead of {}", .{
-                        a.sector.copy,
-                        a.sector.replica,
-                        b.sector.replica,
+                        a.header.copy,
+                        a.header.replica,
+                        b.header.replica,
                     });
                     continue;
                 }
 
-                if (a.sector.sequence == b.sector.sequence) {
+                if (a.header.sequence == b.header.sequence) {
                     // Two quorums, same cluster+replica+sequence, but different checksums.
                     // This shouldn't ever happen — but if it does, we can't safely repair.
-                    assert(a.sector.checksum != b.sector.checksum);
+                    assert(a.header.checksum != b.header.checksum);
                     return error.Fork;
                 }
 
-                if (a.sector.sequence > b.sector.sequence + 1) {
+                if (a.header.sequence > b.header.sequence + 1) {
                     // We read sequences such as (2,2,2,4) — 2 isn't safe to use, but there isn't a
                     // valid quorum for 4 either.
                     return error.ParentSkipped;
                 }
 
-                if (a.sector.sequence + 1 == b.sector.sequence) {
-                    assert(a.sector.checksum != b.sector.checksum);
-                    assert(a.sector.cluster == b.sector.cluster);
-                    assert(a.sector.replica == b.sector.replica);
+                if (a.header.sequence + 1 == b.header.sequence) {
+                    assert(a.header.checksum != b.header.checksum);
+                    assert(a.header.cluster == b.header.cluster);
+                    assert(a.header.replica == b.header.replica);
 
-                    if (a.sector.checksum != b.sector.parent) {
+                    if (a.header.checksum != b.header.parent) {
                         return error.ParentNotConnected;
-                    } else if (!a.sector.vsr_state.monotonic(b.sector.vsr_state)) {
+                    } else if (!a.header.vsr_state.monotonic(b.header.vsr_state)) {
                         return error.VSRStateNotMonotonic;
                     } else {
-                        assert(b.sector.valid_checksum());
+                        assert(b.header.valid_checksum());
 
                         return b;
                     }
                 }
             }
 
-            assert(b.sector.valid_checksum());
+            assert(b.header.valid_checksum());
             return b;
         }
 
         fn count_copy(
             quorums: *Quorums,
-            copy: *const SuperBlockSector,
+            copy: *const SuperBlockHeader,
             slot: usize,
             threshold: Threshold,
         ) void {
@@ -240,12 +240,12 @@ pub fn QuorumsType(comptime options: Options) type {
             }
 
             var quorum = quorums.find_or_insert_quorum_for_copy(copy);
-            assert(quorum.sector.checksum == copy.checksum);
-            assert(quorum.sector.equal(copy));
+            assert(quorum.header.checksum == copy.checksum);
+            assert(quorum.header.equal(copy));
 
             if (copy.copy >= options.superblock_copies) {
-                // This sector is a valid member of the quorum, but with an unexpected copy number.
-                // The "SuperBlockSector.copy" field is not protected by the checksum, so if that byte
+                // This header is a valid member of the quorum, but with an unexpected copy number.
+                // The "SuperBlockHeader.copy" field is not protected by the checksum, so if that byte
                 // (and only that byte) is corrupted, the superblock is still valid — but we don't know
                 // for certain which copy this was supposed to be.
                 // We make the assumption that this was not a double-fault (corrupt + misdirect) —
@@ -262,13 +262,13 @@ pub fn QuorumsType(comptime options: Options) type {
             quorum.valid = quorum.copies.count() >= threshold.count();
         }
 
-        fn find_or_insert_quorum_for_copy(quorums: *Quorums, copy: *const SuperBlockSector) *Quorum {
+        fn find_or_insert_quorum_for_copy(quorums: *Quorums, copy: *const SuperBlockHeader) *Quorum {
             assert(copy.valid_checksum());
 
             for (quorums.array[0..quorums.count]) |*quorum| {
-                if (copy.checksum == quorum.sector.checksum) return quorum;
+                if (copy.checksum == quorum.header.checksum) return quorum;
             } else {
-                quorums.array[quorums.count] = Quorum{ .sector = copy };
+                quorums.array[quorums.count] = Quorum{ .header = copy };
                 quorums.count += 1;
 
                 return &quorums.array[quorums.count - 1];
@@ -280,26 +280,26 @@ pub fn QuorumsType(comptime options: Options) type {
         }
 
         fn sort_priority_descending(_: void, a: Quorum, b: Quorum) bool {
-            assert(a.sector.checksum != b.sector.checksum);
+            assert(a.header.checksum != b.header.checksum);
 
             if (a.valid and !b.valid) return true;
             if (b.valid and !a.valid) return false;
 
-            if (a.sector.sequence > b.sector.sequence) return true;
-            if (b.sector.sequence > a.sector.sequence) return false;
+            if (a.header.sequence > b.header.sequence) return true;
+            if (b.header.sequence > a.header.sequence) return false;
 
             if (a.copies.count() > b.copies.count()) return true;
             if (b.copies.count() > a.copies.count()) return false;
 
             // The sort order must be stable and deterministic:
-            return a.sector.checksum > b.sector.checksum;
+            return a.header.checksum > b.header.checksum;
         }
 
         /// Repair a quorum's copies in the safest known order.
         /// Repair is complete when every copy is on-disk (not necessarily in its home slot).
         ///
-        /// We must be careful when repairing superblock sectors to avoid endangering our quorum if
-        /// an additional fault occurs. We primarily guard against torn sector writes — preventing a
+        /// We must be careful when repairing superblock headers to avoid endangering our quorum if
+        /// an additional fault occurs. We primarily guard against torn header writes — preventing a
         /// misdirected write from derailing repair is far more expensive and complex — but they are
         /// likewise far less likely to occur.
         ///
@@ -342,9 +342,9 @@ pub fn QuorumsType(comptime options: Options) type {
                 }
 
                 // In descending order, our priorities for repair are:
-                // 1. The slot holds no sector, and the copy was not found anywhere.
-                // 2. The slot holds no sector, but its copy was found elsewhere.
-                // 3. The slot holds a misdirected sector, but that copy is in another slot as well.
+                // 1. The slot holds no header, and the copy was not found anywhere.
+                // 2. The slot holds no header, but its copy was found elsewhere.
+                // 3. The slot holds a misdirected header, but that copy is in another slot as well.
                 var a: ?u8 = null;
                 var b: ?u8 = null;
                 var c: ?u8 = null;
@@ -388,7 +388,7 @@ test "Quorum.repairs" {
     defer std.testing.log_level = level;
 
     try fuzz.fuzz_quorum_repairs(prng.random(), .{ .superblock_copies = 4 });
-    // TODO: Enable these once SuperBlockSector is generic over its Constants.
+    // TODO: Enable these once SuperBlockHeader is generic over its Constants.
     // try fuzz.fuzz_quorum_repairs(prng.random(), .{ .superblock_copies = 6 });
     // try fuzz.fuzz_quorum_repairs(prng.random(), .{ .superblock_copies = 8 });
 }

package/src/tigerbeetle/src/vsr/superblock_quorums_fuzz.zig

@@ -3,7 +3,7 @@ const assert = std.debug.assert;
 const log = std.log.scoped(.fuzz_vsr_superblock_quorums);
 
 const superblock = @import("./superblock.zig");
-const SuperBlockSector = superblock.SuperBlockSector;
+const SuperBlockHeader = superblock.SuperBlockHeader;
 const SuperBlockVersion = superblock.SuperBlockVersion;
 
 const fuzz = @import("../testing/fuzz.zig");
@@ -21,7 +21,7 @@ pub fn main() !void {
     try fuzz_quorums_working(prng.random());
 
     try fuzz_quorum_repairs(prng.random(), .{ .superblock_copies = 4 });
-    // TODO: Enable these once SuperBlockSector is generic over its Constants.
+    // TODO: Enable these once SuperBlockHeader is generic over its Constants.
     // try fuzz_quorum_repairs(prng.random(), .{ .superblock_copies = 6 });
     // try fuzz_quorum_repairs(prng.random(), .{ .superblock_copies = 8 });
 }
@@ -108,18 +108,18 @@ fn test_quorums_working(
     const Quorums = QuorumsType(.{ .superblock_copies = 4 });
     const misdirect = random.boolean(); // true:cluster false:replica
     var quorums: Quorums = undefined;
-    var sectors: [4]SuperBlockSector = undefined;
+    var headers: [4]SuperBlockHeader = undefined;
     // TODO(Zig): Ideally this would be a [6]?u128 and the access would be
     // "checksums[i] orelse random.int(u128)", but that currently causes the compiler to segfault
     // during code generation.
     var checksums: [6]u128 = undefined;
     for (checksums) |*c| c.* = random.int(u128);
 
-    // Create sectors in ascending-sequence order to build the checksum/parent hash chain.
+    // Create headers in ascending-sequence order to build the checksum/parent hash chain.
     std.sort.sort(CopyTemplate, copies, {}, CopyTemplate.less_than);
 
-    for (sectors) |*sector, i| {
-        sector.* = std.mem.zeroInit(SuperBlockSector, .{
+    for (headers) |*header, i| {
+        header.* = std.mem.zeroInit(SuperBlockHeader, .{
             .copy = @intCast(u8, i),
             .version = SuperBlockVersion,
             .replica = 1,
@@ -131,32 +131,32 @@ fn test_quorums_working(
         var checksum: ?u128 = null;
         switch (copies[i].variant) {
             .valid => {},
-            .valid_high_copy => sector.copy = 4,
+            .valid_high_copy => header.copy = 4,
             .invalid_broken => {
                 if (random.boolean() and i > 0) {
-                    // Error: duplicate sector (if available).
-                    sector.* = sectors[random.uintLessThanBiased(usize, i)];
+                    // Error: duplicate header (if available).
+                    header.* = headers[random.uintLessThanBiased(usize, i)];
                     checksum = random.int(u128);
                 } else {
                     // Error: invalid checksum.
                     checksum = random.int(u128);
                 }
             },
-            .invalid_fork => sector.storage_size_max += 1, // Ensure we have a different checksum.
-            .invalid_parent => sector.parent += 1,
+            .invalid_fork => header.storage_size_max += 1, // Ensure we have a different checksum.
+            .invalid_parent => header.parent += 1,
             .invalid_misdirect => {
                 if (misdirect) {
-                    sector.cluster += 1;
+                    header.cluster += 1;
                 } else {
-                    sector.replica += 1;
+                    header.replica += 1;
                 }
             },
-            .invalid_vsr_state => sector.vsr_state.view += 1,
+            .invalid_vsr_state => header.vsr_state.view += 1,
         }
-        sector.checksum = checksum orelse sector.calculate_checksum();
+        header.checksum = checksum orelse header.calculate_checksum();
 
         if (copies[i].variant == .valid or copies[i].variant == .invalid_vsr_state) {
-            checksums[sector.sequence] = sector.checksum;
+            checksums[header.sequence] = header.checksum;
         }
     }
 
@@ -165,7 +165,7 @@ fn test_quorums_working(
     } else {
         // Shuffling copies can only change the working quorum when we have a corrupt copy index,
         // because we guess that the true index is the slot.
-        random.shuffle(SuperBlockSector, &sectors);
+        random.shuffle(SuperBlockHeader, &headers);
     }
 
     const threshold = switch (threshold_count) {
@@ -175,8 +175,8 @@ fn test_quorums_working(
     };
     assert(threshold.count() == threshold_count);
 
-    if (quorums.working(&sectors, threshold)) |working| {
-        try std.testing.expectEqual(result, working.sector.sequence);
+    if (quorums.working(&headers, threshold)) |working| {
+        try std.testing.expectEqual(result, working.header.sequence);
     } else |err| {
         try std.testing.expectEqual(result, err);
     }
@@ -238,7 +238,7 @@ pub const CopyTemplate = struct {
     }
 };
 
-// Verify that a torn sector write during repair never compromises the existing quorum.
+// Verify that a torn header write during repair never compromises the existing quorum.
 pub fn fuzz_quorum_repairs(
     random: std.rand.Random,
     comptime options: superblock_quorums.Options,
@@ -249,66 +249,66 @@ pub fn fuzz_quorum_repairs(
     var q1: Quorums = undefined;
     var q2: Quorums = undefined;
 
-    const sectors_valid = blk: {
-        var sectors: [superblock_copies]SuperBlockSector = undefined;
-        for (&sectors) |*sector, i| {
-            sector.* = std.mem.zeroInit(SuperBlockSector, .{
+    const headers_valid = blk: {
+        var headers: [superblock_copies]SuperBlockHeader = undefined;
+        for (&headers) |*header, i| {
+            header.* = std.mem.zeroInit(SuperBlockHeader, .{
                 .copy = @intCast(u8, i),
                 .version = SuperBlockVersion,
                 .replica = 1,
                 .storage_size_max = superblock.data_file_size_min,
                 .sequence = 123,
             });
-            sector.set_checksum();
+            header.set_checksum();
         }
-        break :blk sectors;
+        break :blk headers;
     };
 
-    const sector_invalid = blk: {
-        var sector = sectors_valid[0];
-        sector.checksum = 456;
-        break :blk sector;
+    const header_invalid = blk: {
+        var header = headers_valid[0];
+        header.checksum = 456;
+        break :blk header;
     };
 
     // Generate a random valid 2/4 quorum.
-    // 1 bits indicate valid sectors.
-    // 0 bits indicate invalid sectors.
+    // 1 bits indicate valid headers.
+    // 0 bits indicate invalid headers.
     var valid = std.bit_set.IntegerBitSet(superblock_copies).initEmpty();
     while (valid.count() < Quorums.Threshold.open.count() or random.boolean()) {
         valid.set(random.uintLessThan(usize, superblock_copies));
     }
 
-    var working_sectors: [superblock_copies]SuperBlockSector = undefined;
-    for (&working_sectors) |*sector, i| {
-        sector.* = if (valid.isSet(i)) sectors_valid[i] else sector_invalid;
+    var working_headers: [superblock_copies]SuperBlockHeader = undefined;
+    for (&working_headers) |*header, i| {
+        header.* = if (valid.isSet(i)) headers_valid[i] else header_invalid;
     }
-    random.shuffle(SuperBlockSector, &working_sectors);
-    var repair_sectors = working_sectors;
+    random.shuffle(SuperBlockHeader, &working_headers);
+    var repair_headers = working_headers;
 
-    const working_quorum = q1.working(&working_sectors, .open) catch unreachable;
+    const working_quorum = q1.working(&working_headers, .open) catch unreachable;
     var quorum_repairs = working_quorum.repairs();
     while (quorum_repairs.next()) |repair_copy| {
         {
-            // Simulate a torn sector write, crash, recover sequence.
-            var damaged_sectors = repair_sectors;
-            damaged_sectors[repair_copy] = sector_invalid;
-            const damaged_quorum = q2.working(&damaged_sectors, .open) catch unreachable;
-            assert(damaged_quorum.sector.checksum == working_quorum.sector.checksum);
+            // Simulate a torn header write, crash, recover sequence.
+            var damaged_headers = repair_headers;
+            damaged_headers[repair_copy] = header_invalid;
+            const damaged_quorum = q2.working(&damaged_headers, .open) catch unreachable;
+            assert(damaged_quorum.header.checksum == working_quorum.header.checksum);
         }
 
         // "Finish" the write so that we can test the next repair.
-        repair_sectors[repair_copy] = sectors_valid[repair_copy];
+        repair_headers[repair_copy] = headers_valid[repair_copy];
 
-        const quorum_repaired = q2.working(&repair_sectors, .open) catch unreachable;
-        assert(quorum_repaired.sector.checksum == working_quorum.sector.checksum);
+        const quorum_repaired = q2.working(&repair_headers, .open) catch unreachable;
+        assert(quorum_repaired.header.checksum == working_quorum.header.checksum);
     }
 
     // At the end of all repairs, we expect to have every copy of the superblock.
     // They do not need to be in their home slot.
     var copies = Quorums.QuorumCount.initEmpty();
-    for (repair_sectors) |repair_sector| {
-        assert(repair_sector.checksum == working_quorum.sector.checksum);
-        copies.set(repair_sector.copy);
+    for (repair_headers) |repair_header| {
+        assert(repair_header.checksum == working_quorum.header.checksum);
+        copies.set(repair_header.copy);
     }
-    assert(repair_sectors.len == copies.count());
+    assert(repair_headers.len == copies.count());
 }