Oregami
Repositories/oxedyne/fe2o3

fe2o3_o3db_sync/tests/durable_mark.rs

13 operations, oldest first

created by r1870400018:70848, which is this file's identity for as long as the history lasts, whatever it is later renamed to

read the file · who wrote it · compare two states

An operation carries no clock of its own. Each row is therefore dated by the first mark written after it by the same replica, which is one copy of the repository, and that mark is where the command that wrote the operation ended.

+ signed and verified, ? signed by a key this forge does not carry, - unsigned

OperationAuthorWhatWhen
+r1870400018:70848replica 1870400018created fe2o3_o3db_sync/tests/durable_mark.rs40 days ago under "fe2o3_o3db_sync: a failed cut back whose fault record cannot be written is held by the refusal marker alone, which carries its cut, and clearing the marker folds the cut into the record so the next open cuts the pair back -- a test now pins that path of the round-2 marker; and the torn-append error no longer carries a run of spaces from a string continued without its backslash (Ozone APPENDSEEK, rebase onto round 2)"
+r1870400018:70849replica 1870400018inserted 34.8 KiB40 days ago under "fe2o3_o3db_sync: a failed cut back whose fault record cannot be written is held by the refusal marker alone, which carries its cut, and clearing the marker folds the cut into the record so the next open cuts the pair back -- a test now pins that path of the round-2 marker; and the torn-append error no longer carries a run of spaces from a string continued without its backslash (Ozone APPENDSEEK, rebase onto round 2)"
+r1870400018:72497replica 1870400018replaced 43 bytes with 60 bytes40 days ago under "fe2o3_o3db_sync: review fixes to the interrupted delete at open -- F1: a failed unlink or directory sync while completing the delete now names the index, the data file and the phase, and says no record was changed; F3: settle no longer reads every value in the store to tell whether a lone chunk is named, since a chunked write stamps its head and every chunk with one Meta, so it asks each cache bot for the heads carrying the lone chunks' stamps (OzoneMsg::HeadsStamped, Cache::heads_stamped) and reads only those, so an unreadable value elsewhere no longer blocks the open while an unreadable head of the chunk's own write still refuses; legacy set ids: the builds of 2026-09 took the chunk set id from the key alone, so a torn same-length rewrite left the first write's head naming the second write's chunks under another stamp, and heads_stamped and settle now also match a head whose key's legacy set id is the chunk's (legacy_chunk_set_id, free fn in api.rs); F2: no Ozone user writes a Tup5u64 key, noted at the judgement; new test hooks set_delete_cut (the old data-first unlink order with an abort after the nth whole-file delete) and set_head_drop (a store drops its head after its chunks); tests/lone_index.rs gains the F1, F3, guard and two legacy tests and runs serially since the hooks are process-wide; tests/lone_index_campaign.rs re-executes a child per crash cut (16 cut images, 0 failures); red on 9f64d2fc for F1 and F3, mutants: the full-value scan reddens F3, dropping the legacy match reddens the torn legacy rewrite (Ozone interrupted GC at open, review F1-F3 + legacy set ids)"
+r1870400018:72498replica 1870400018replaced 9 bytes with 6 bytes40 days ago under "fe2o3_o3db_sync: review fixes to the interrupted delete at open -- F1: a failed unlink or directory sync while completing the delete now names the index, the data file and the phase, and says no record was changed; F3: settle no longer reads every value in the store to tell whether a lone chunk is named, since a chunked write stamps its head and every chunk with one Meta, so it asks each cache bot for the heads carrying the lone chunks' stamps (OzoneMsg::HeadsStamped, Cache::heads_stamped) and reads only those, so an unreadable value elsewhere no longer blocks the open while an unreadable head of the chunk's own write still refuses; legacy set ids: the builds of 2026-09 took the chunk set id from the key alone, so a torn same-length rewrite left the first write's head naming the second write's chunks under another stamp, and heads_stamped and settle now also match a head whose key's legacy set id is the chunk's (legacy_chunk_set_id, free fn in api.rs); F2: no Ozone user writes a Tup5u64 key, noted at the judgement; new test hooks set_delete_cut (the old data-first unlink order with an abort after the nth whole-file delete) and set_head_drop (a store drops its head after its chunks); tests/lone_index.rs gains the F1, F3, guard and two legacy tests and runs serially since the hooks are process-wide; tests/lone_index_campaign.rs re-executes a child per crash cut (16 cut images, 0 failures); red on 9f64d2fc for F1 and F3, mutants: the full-value scan reddens F3, dropping the legacy match reddens the torn legacy rewrite (Ozone interrupted GC at open, review F1-F3 + legacy set ids)"
+r1870400018:72501replica 1870400018replaced 1.1 KiB with 50 bytes40 days ago under "fe2o3_o3db_sync: review fixes to the interrupted delete at open -- F1: a failed unlink or directory sync while completing the delete now names the index, the data file and the phase, and says no record was changed; F3: settle no longer reads every value in the store to tell whether a lone chunk is named, since a chunked write stamps its head and every chunk with one Meta, so it asks each cache bot for the heads carrying the lone chunks' stamps (OzoneMsg::HeadsStamped, Cache::heads_stamped) and reads only those, so an unreadable value elsewhere no longer blocks the open while an unreadable head of the chunk's own write still refuses; legacy set ids: the builds of 2026-09 took the chunk set id from the key alone, so a torn same-length rewrite left the first write's head naming the second write's chunks under another stamp, and heads_stamped and settle now also match a head whose key's legacy set id is the chunk's (legacy_chunk_set_id, free fn in api.rs); F2: no Ozone user writes a Tup5u64 key, noted at the judgement; new test hooks set_delete_cut (the old data-first unlink order with an abort after the nth whole-file delete) and set_head_drop (a store drops its head after its chunks); tests/lone_index.rs gains the F1, F3, guard and two legacy tests and runs serially since the hooks are process-wide; tests/lone_index_campaign.rs re-executes a child per crash cut (16 cut images, 0 failures); red on 9f64d2fc for F1 and F3, mutants: the full-value scan reddens F3, dropping the legacy match reddens the torn legacy rewrite (Ozone interrupted GC at open, review F1-F3 + legacy set ids)"
+r1870400018:74525replica 1870400018replaced 8 bytes with 43 bytes33 days ago under "fe2o3_o3db_sync: a due period barrier is never starved by a long put's chunks; R1 test made sensitive (Ozone chunk barriers, QA B A1 A3) -- under Interval a plain record that lands with the period not due is covered by the syncer's timer alone, and a syncer lagging its writer through a long put always found a chunk waiting, so the timer never ran out and the record waited for the put's own SyncNow (A1). Syncer::run now checks owed_in() after each item it takes in, not after each batch, since one batch can be a long put's every chunk; the old held-discard check is folded into it. New hook test::hooks::set_syncer_chunk_delay; new tests/chunk_period.rs cuts 800 ms after a plain record's ack while a 1,500-chunk put holds a lagging syncer: red on 4e5869b5 (record lost), green after; removing the new check reddens it again. A3: chunk_barriers asserts each barriered writer is in a distinct zone and gains chunk_phase_every_n; head_hold's comment says it covers one put at a time. QA A F-1/F-2: durable_mark::a_head_never_outlives_its_chunks rebuilt with 1 MiB data files, a 900 ms barrier delay and a cut at the head hold, over every policy at 1x1, 1x4 and 2x2, counting exactly the one store's new chunk keys: under M8 (chunk answers unheld) it fails 9/9 non-EveryWrite cases (8 of 8 chunks missing), green on the real code. Targeted gate 41/41 (chunk_barriers 6, chunk_hold 6, chunk_period 1, durable_mark 14, durable_mark_races 4, lone_index 10); full package, --features dist and the workspace build not yet run on this commit."
+r1870400018:74526replica 1870400018inserted 12 bytes33 days ago under "fe2o3_o3db_sync: a due period barrier is never starved by a long put's chunks; R1 test made sensitive (Ozone chunk barriers, QA B A1 A3) -- under Interval a plain record that lands with the period not due is covered by the syncer's timer alone, and a syncer lagging its writer through a long put always found a chunk waiting, so the timer never ran out and the record waited for the put's own SyncNow (A1). Syncer::run now checks owed_in() after each item it takes in, not after each batch, since one batch can be a long put's every chunk; the old held-discard check is folded into it. New hook test::hooks::set_syncer_chunk_delay; new tests/chunk_period.rs cuts 800 ms after a plain record's ack while a 1,500-chunk put holds a lagging syncer: red on 4e5869b5 (record lost), green after; removing the new check reddens it again. A3: chunk_barriers asserts each barriered writer is in a distinct zone and gains chunk_phase_every_n; head_hold's comment says it covers one put at a time. QA A F-1/F-2: durable_mark::a_head_never_outlives_its_chunks rebuilt with 1 MiB data files, a 900 ms barrier delay and a cut at the head hold, over every policy at 1x1, 1x4 and 2x2, counting exactly the one store's new chunk keys: under M8 (chunk answers unheld) it fails 9/9 non-EveryWrite cases (8 of 8 chunks missing), green on the real code. Targeted gate 41/41 (chunk_barriers 6, chunk_hold 6, chunk_period 1, durable_mark 14, durable_mark_races 4, lone_index 10); full package, --features dist and the workspace build not yet run on this commit."
+r1870400018:74527replica 1870400018inserted 79 bytes33 days ago under "fe2o3_o3db_sync: a due period barrier is never starved by a long put's chunks; R1 test made sensitive (Ozone chunk barriers, QA B A1 A3) -- under Interval a plain record that lands with the period not due is covered by the syncer's timer alone, and a syncer lagging its writer through a long put always found a chunk waiting, so the timer never ran out and the record waited for the put's own SyncNow (A1). Syncer::run now checks owed_in() after each item it takes in, not after each batch, since one batch can be a long put's every chunk; the old held-discard check is folded into it. New hook test::hooks::set_syncer_chunk_delay; new tests/chunk_period.rs cuts 800 ms after a plain record's ack while a 1,500-chunk put holds a lagging syncer: red on 4e5869b5 (record lost), green after; removing the new check reddens it again. A3: chunk_barriers asserts each barriered writer is in a distinct zone and gains chunk_phase_every_n; head_hold's comment says it covers one put at a time. QA A F-1/F-2: durable_mark::a_head_never_outlives_its_chunks rebuilt with 1 MiB data files, a 900 ms barrier delay and a cut at the head hold, over every policy at 1x1, 1x4 and 2x2, counting exactly the one store's new chunk keys: under M8 (chunk answers unheld) it fails 9/9 non-EveryWrite cases (8 of 8 chunks missing), green on the real code. Targeted gate 41/41 (chunk_barriers 6, chunk_hold 6, chunk_period 1, durable_mark 14, durable_mark_races 4, lone_index 10); full package, --features dist and the workspace build not yet run on this commit."
+r1870400018:74528replica 1870400018replaced 1 byte with 1 byte33 days ago under "fe2o3_o3db_sync: a due period barrier is never starved by a long put's chunks; R1 test made sensitive (Ozone chunk barriers, QA B A1 A3) -- under Interval a plain record that lands with the period not due is covered by the syncer's timer alone, and a syncer lagging its writer through a long put always found a chunk waiting, so the timer never ran out and the record waited for the put's own SyncNow (A1). Syncer::run now checks owed_in() after each item it takes in, not after each batch, since one batch can be a long put's every chunk; the old held-discard check is folded into it. New hook test::hooks::set_syncer_chunk_delay; new tests/chunk_period.rs cuts 800 ms after a plain record's ack while a 1,500-chunk put holds a lagging syncer: red on 4e5869b5 (record lost), green after; removing the new check reddens it again. A3: chunk_barriers asserts each barriered writer is in a distinct zone and gains chunk_phase_every_n; head_hold's comment says it covers one put at a time. QA A F-1/F-2: durable_mark::a_head_never_outlives_its_chunks rebuilt with 1 MiB data files, a 900 ms barrier delay and a cut at the head hold, over every policy at 1x1, 1x4 and 2x2, counting exactly the one store's new chunk keys: under M8 (chunk answers unheld) it fails 9/9 non-EveryWrite cases (8 of 8 chunks missing), green on the real code. Targeted gate 41/41 (chunk_barriers 6, chunk_hold 6, chunk_period 1, durable_mark 14, durable_mark_races 4, lone_index 10); full package, --features dist and the workspace build not yet run on this commit."
+r1870400018:74529replica 1870400018inserted 506 bytes33 days ago under "fe2o3_o3db_sync: a due period barrier is never starved by a long put's chunks; R1 test made sensitive (Ozone chunk barriers, QA B A1 A3) -- under Interval a plain record that lands with the period not due is covered by the syncer's timer alone, and a syncer lagging its writer through a long put always found a chunk waiting, so the timer never ran out and the record waited for the put's own SyncNow (A1). Syncer::run now checks owed_in() after each item it takes in, not after each batch, since one batch can be a long put's every chunk; the old held-discard check is folded into it. New hook test::hooks::set_syncer_chunk_delay; new tests/chunk_period.rs cuts 800 ms after a plain record's ack while a 1,500-chunk put holds a lagging syncer: red on 4e5869b5 (record lost), green after; removing the new check reddens it again. A3: chunk_barriers asserts each barriered writer is in a distinct zone and gains chunk_phase_every_n; head_hold's comment says it covers one put at a time. QA A F-1/F-2: durable_mark::a_head_never_outlives_its_chunks rebuilt with 1 MiB data files, a 900 ms barrier delay and a cut at the head hold, over every policy at 1x1, 1x4 and 2x2, counting exactly the one store's new chunk keys: under M8 (chunk answers unheld) it fails 9/9 non-EveryWrite cases (8 of 8 chunks missing), green on the real code. Targeted gate 41/41 (chunk_barriers 6, chunk_hold 6, chunk_period 1, durable_mark 14, durable_mark_races 4, lone_index 10); full package, --features dist and the workspace build not yet run on this commit."
+r1870400018:74530replica 1870400018replaced 167 bytes with 552 bytes33 days ago under "fe2o3_o3db_sync: a due period barrier is never starved by a long put's chunks; R1 test made sensitive (Ozone chunk barriers, QA B A1 A3) -- under Interval a plain record that lands with the period not due is covered by the syncer's timer alone, and a syncer lagging its writer through a long put always found a chunk waiting, so the timer never ran out and the record waited for the put's own SyncNow (A1). Syncer::run now checks owed_in() after each item it takes in, not after each batch, since one batch can be a long put's every chunk; the old held-discard check is folded into it. New hook test::hooks::set_syncer_chunk_delay; new tests/chunk_period.rs cuts 800 ms after a plain record's ack while a 1,500-chunk put holds a lagging syncer: red on 4e5869b5 (record lost), green after; removing the new check reddens it again. A3: chunk_barriers asserts each barriered writer is in a distinct zone and gains chunk_phase_every_n; head_hold's comment says it covers one put at a time. QA A F-1/F-2: durable_mark::a_head_never_outlives_its_chunks rebuilt with 1 MiB data files, a 900 ms barrier delay and a cut at the head hold, over every policy at 1x1, 1x4 and 2x2, counting exactly the one store's new chunk keys: under M8 (chunk answers unheld) it fails 9/9 non-EveryWrite cases (8 of 8 chunks missing), green on the real code. Targeted gate 41/41 (chunk_barriers 6, chunk_hold 6, chunk_period 1, durable_mark 14, durable_mark_races 4, lone_index 10); full package, --features dist and the workspace build not yet run on this commit."
+r1870400018:74531replica 1870400018replaced 382 bytes with 2.8 KiB33 days ago under "fe2o3_o3db_sync: a due period barrier is never starved by a long put's chunks; R1 test made sensitive (Ozone chunk barriers, QA B A1 A3) -- under Interval a plain record that lands with the period not due is covered by the syncer's timer alone, and a syncer lagging its writer through a long put always found a chunk waiting, so the timer never ran out and the record waited for the put's own SyncNow (A1). Syncer::run now checks owed_in() after each item it takes in, not after each batch, since one batch can be a long put's every chunk; the old held-discard check is folded into it. New hook test::hooks::set_syncer_chunk_delay; new tests/chunk_period.rs cuts 800 ms after a plain record's ack while a 1,500-chunk put holds a lagging syncer: red on 4e5869b5 (record lost), green after; removing the new check reddens it again. A3: chunk_barriers asserts each barriered writer is in a distinct zone and gains chunk_phase_every_n; head_hold's comment says it covers one put at a time. QA A F-1/F-2: durable_mark::a_head_never_outlives_its_chunks rebuilt with 1 MiB data files, a 900 ms barrier delay and a cut at the head hold, over every policy at 1x1, 1x4 and 2x2, counting exactly the one store's new chunk keys: under M8 (chunk answers unheld) it fails 9/9 non-EveryWrite cases (8 of 8 chunks missing), green on the real code. Targeted gate 41/41 (chunk_barriers 6, chunk_hold 6, chunk_period 1, durable_mark 14, durable_mark_races 4, lone_index 10); full package, --features dist and the workspace build not yet run on this commit."
+r1870400018:74532replica 1870400018replaced 401 bytes with 69 bytes33 days ago under "fe2o3_o3db_sync: a due period barrier is never starved by a long put's chunks; R1 test made sensitive (Ozone chunk barriers, QA B A1 A3) -- under Interval a plain record that lands with the period not due is covered by the syncer's timer alone, and a syncer lagging its writer through a long put always found a chunk waiting, so the timer never ran out and the record waited for the put's own SyncNow (A1). Syncer::run now checks owed_in() after each item it takes in, not after each batch, since one batch can be a long put's every chunk; the old held-discard check is folded into it. New hook test::hooks::set_syncer_chunk_delay; new tests/chunk_period.rs cuts 800 ms after a plain record's ack while a 1,500-chunk put holds a lagging syncer: red on 4e5869b5 (record lost), green after; removing the new check reddens it again. A3: chunk_barriers asserts each barriered writer is in a distinct zone and gains chunk_phase_every_n; head_hold's comment says it covers one put at a time. QA A F-1/F-2: durable_mark::a_head_never_outlives_its_chunks rebuilt with 1 MiB data files, a 900 ms barrier delay and a cut at the head hold, over every policy at 1x1, 1x4 and 2x2, counting exactly the one store's new chunk keys: under M8 (chunk answers unheld) it fails 9/9 non-EveryWrite cases (8 of 8 chunks missing), green on the real code. Targeted gate 41/41 (chunk_barriers 6, chunk_hold 6, chunk_period 1, durable_mark 14, durable_mark_races 4, lone_index 10); full package, --features dist and the workspace build not yet run on this commit."