darinm223 / disk-utils Goto Github PK

Right now tests are in the same file as the modules tested but the tests itself are large so they should be separated into a separate directory.

Also right now the code is using panic::catch_unwind in order to reliably remove test files when the code panics but it causes a lot of code bloat in each test case. Should look into either creating own temporary file wrapper (overloading Drop to remove the file) or using an existing temporary file library like:

https://github.com/Stebalien/tempfile

Building the API docs and flipping between disk_utils::wal::undo_log::UndoLog and disk_utils::wal::redo_log::RedoLog they have the same API. What exactly are the differences between these two log implementations? Thanks!

Log records are supposed to use crc checksums in order to detect corruptions. The crc algorithm needs to be implemented and the record test cases need to be modified to test for corruptions on read.

Add tests for the redo log similar to that of the undo log except that they test more exactly what changes are flushed to disk on recover. One way is by making a store implementation that uses flush() and flush_change() to log all changes made in memory and on disk so that they can be tested against.

Right now there are only mutexes to allow a single UndoLog instance to be shared among multiple threads but there is nothing to prevent other processes from tampering with the log files. Look into file level locking to hopefully allow multiple processes to write to the same log without race conditions.

Right now this code doesn't set the tid of the latest committed transaction when recovery mode is set.

Needs to be modified so that the iterator reads backward until it finds a COMMIT or ABORT record and sets the latest tid to the tid of that record.

Right now the undo log has no checkpointing feature, so nonquiescent checkpointing should be implemented since it allows for checkpointing without refusing new transactions.

List of changes needed:

1. Create BeginCheckpoint and EndCheckpoint implementing Serializable and add it for UndoLogEntry.
2. In the start() function of UndoLog, keep track of every new transaction started.
3. Create a checkpoint function that adds BeginCheckpoint with the currently active transaction ids to the log and flushes to disk. Keep track of the current checkpoint and if there already is a current checkpoint, refuse to create a new one until the current one has finished.
4. Add code to commit() and abort() so that it removes the committed or aborted transaction from the active transactions and then checks the current checkpoint if all transactions in the checkpoint have finished (not in the active transactions).
5. If all transactions have finished, add EndCheckpoint to the log and flush the log to disk.
6. TODO: Handle recovery

Right now the undo log only allows for one transaction at a time. Update the api so that it allows for multiple transactions. What is necessary is:

1. Update start() to return the tid of the transaction started.
2. Update write() to take in the tid of the transaction to write to.
3. Update commit() and abort() to take in the tid of the transaction to commit or abort.
4. Rename tid to last_tid and also store a HashSet of currently active tids.