Commit ⋅ tglman/persy

Showing 4 of 4 files from the diff.

92.08% 76.92% +2.57%

src/transaction.rs changed.

93.18% 100.00% -0.15%

src/config.rs changed.

97.47% 100.00% ø

src/id.rs changed.

92.79% 86.96% +0.45%

src/journal.rs changed.

@@ -18,21 +18,21 @@

    vec::{self, IntoIter},
};

#[derive(Clone)]
#[derive(Clone, Default)]
pub struct NewSegmentPage {
    pub segment: u32,
    pub page: u64,
    pub previous: u64,
}

#[derive(Clone)]
#[derive(Clone, Default)]
pub struct InsertRecord {
    pub segment: u32,
    pub recref: RecRef,
    pub record_page: u64,
}

#[derive(Clone)]
#[derive(Clone, Default)]
pub struct UpdateRecord {
    pub segment: u32,
    pub recref: RecRef,

@@ -40,46 +40,51 @@

    pub version: u16,
}

#[derive(Clone)]
#[derive(Clone, Default)]
pub struct ReadRecord {
    pub segment: u32,
    pub recref: RecRef,
    pub version: u16,
}

#[derive(Clone)]
#[derive(Clone, Default)]
pub struct DeleteRecord {
    pub segment: u32,
    pub recref: RecRef,
    pub version: u16,
}

#[derive(Clone)]
#[derive(Clone, Default)]
pub struct CreateSegment {
    pub name: String,
    pub segment_id: u32,
    pub first_page: u64,
}

#[derive(Clone)]
#[derive(Clone, Default)]
pub struct DropSegment {
    pub name: String,
    pub segment_id: u32,
}

#[derive(Clone, PartialEq, Debug, PartialOrd, Ord, Eq)]
#[derive(Clone, PartialEq, Debug, PartialOrd, Ord, Eq, Default)]
pub struct FreedPage {
    pub page: u64,
}

#[derive(Default)]
pub struct PrepareCommit {}

#[derive(Default)]
pub struct Commit {}

#[derive(Default)]
pub struct Cleanup {}

#[derive(Default)]
pub struct Rollback {}

#[derive(Default)]
pub struct Metadata {
    pub strategy: TxStrategy,
    pub meta_id: Vec<u8>,

@@ -23,6 +23,11 @@

    ///
    VersionOnRead,
}
impl Default for TxStrategy {
    fn default() -> Self {
        TxStrategy::LastWin
    }
}

impl TxStrategy {
    pub fn value(&self) -> u8 {

@@ -28,7 +28,7 @@

    Ok(u32_vdec(&bytes).map_err(|_| PersyError::InvalidId(String::from(s)))?.0)
}

#[derive(PartialEq, Eq, PartialOrd, Ord, Hash, Clone, Debug)]
#[derive(PartialEq, Eq, PartialOrd, Ord, Hash, Clone, Debug, Default)]
pub struct RecRef {
    pub page: u64,
    pub pos: u32,

@@ -5,10 +5,9 @@

use crate::{
    allocator::Allocator,
    config::TxStrategy,
    discref::{Page, PageOps, PAGE_METADATA_SIZE},
    discref::{Page, PageOps, ReadPage, PAGE_METADATA_SIZE},
    error::PRes,
    flush_checksum::{double_buffer_check, prepare_buffer_flush},
    id::RecRef,
    io::{read_u64, write_u64, InfallibleRead, InfallibleReadFormat, InfallibleWrite, InfallibleWriteFormat},
    persy::RecoverStatus,
};

@@ -115,6 +114,15 @@

    pos: u32,
}

fn recover_entry<T>(entry: &mut dyn JournalEntry, page: &mut ReadPage, found: &mut T, id: &JournalId) -> PRes<u32>
where
    T: FnMut(&dyn JournalEntry, &JournalId),
{
    let read_size = entry.read(page)?;
    found(entry, id);
    Ok(read_size)
}

impl Journal {
    pub fn new(all: &Arc<Allocator>, page: u64) -> PRes<Journal> {
        let first_page;

@@ -324,72 +332,27 @@

                cur_cursor = JOURNAL_PAGE_CONTENT_OFFSET;
                jr.last_page = cur_page;
            } else {
                let mut read_size = 0;
                let page_id = page.read_u64();
                let pos = page.read_u32();
                let mut recover_entry = |entry: &mut dyn JournalEntry| -> PRes<()> {
                    read_size = entry.read(&mut page)?;
                    found(entry, &JournalId::new(page_id, pos));
                    Ok(())
                };
                match tp {
                    1 => {
                        let mut entry = Start::new();
                        read_size = entry.read(&mut page)?;
                        //The Start entry has no valid id, should not be recovered
                    }
                    2 => {
                        let mut entry = InsertRecord::new(0, &RecRef::new(0, 0), 0);
                        recover_entry(&mut entry)?;
                    }
                    3 => {
                        let mut entry = PrepareCommit::new();
                        recover_entry(&mut entry)?;
                    }
                    4 => {
                        let mut entry = Commit::new();
                        recover_entry(&mut entry)?;
                    }
                    5 => {
                        let mut entry = UpdateRecord::new(0, &RecRef::new(0, 0), 0, 0);
                        recover_entry(&mut entry)?;
                    }
                    6 => {
                        let mut entry = DeleteRecord::new(0, &RecRef::new(0, 0), 0);
                        recover_entry(&mut entry)?;
                    }
                    7 => {
                        let mut entry = Rollback::new();
                        recover_entry(&mut entry)?;
                    }
                    8 => {
                        let mut entry = CreateSegment::new("", 0, 0);
                        recover_entry(&mut entry)?;
                    }
                    9 => {
                        let mut entry = DropSegment::new("", 0);
                        recover_entry(&mut entry)?;
                    }
                    10 => {
                        let mut entry = ReadRecord::new(0, &RecRef::new(0, 0), 0);
                        recover_entry(&mut entry)?;
                    }
                    11 => {
                        let mut entry = Metadata::new(&TxStrategy::LastWin, Vec::new());
                        recover_entry(&mut entry)?;
                    }
                    12 => {
                        let mut entry = FreedPage::new(0);
                        recover_entry(&mut entry)?;
                    }
                    13 => {
                        let mut entry = NewSegmentPage::new(0, 0, 0);
                        recover_entry(&mut entry)?;
                    }
                    14 => {
                        let mut entry = Cleanup::new();
                        recover_entry(&mut entry)?;
                    }
                let id = JournalId::new(page_id, pos);
                let ref_page = &mut page;
                let ref_found = &mut found;
                let read_size = match tp {
                    //The Start entry has no valid id, should not be recovered
                    1 => Start::new().read(&mut page)?,
                    2 => recover_entry(&mut InsertRecord::default(), ref_page, ref_found, &id)?,
                    3 => recover_entry(&mut PrepareCommit::default(), ref_page, ref_found, &id)?,
                    4 => recover_entry(&mut Commit::default(), ref_page, ref_found, &id)?,
                    5 => recover_entry(&mut UpdateRecord::default(), ref_page, ref_found, &id)?,
                    6 => recover_entry(&mut DeleteRecord::default(), ref_page, ref_found, &id)?,
                    7 => recover_entry(&mut Rollback::default(), ref_page, ref_found, &id)?,
                    8 => recover_entry(&mut CreateSegment::default(), ref_page, ref_found, &id)?,
                    9 => recover_entry(&mut DropSegment::default(), ref_page, ref_found, &id)?,
                    10 => recover_entry(&mut ReadRecord::default(), ref_page, ref_found, &id)?,
                    11 => recover_entry(&mut Metadata::default(), ref_page, ref_found, &id)?,
                    12 => recover_entry(&mut FreedPage::default(), ref_page, ref_found, &id)?,
                    13 => recover_entry(&mut NewSegmentPage::default(), ref_page, ref_found, &id)?,
                    14 => recover_entry(&mut Cleanup::default(), ref_page, ref_found, &id)?,
                    _ => panic!(" wrong log entry {} ", tp),
                };
                cur_cursor = read_size + cur_cursor + 13;

Files		•	•	Coverage
src	7,439	6,929	510	93.14%
tests	1,668	1,644	24	98.56%
Project Totals (29 files)	9,107	8,573	534	94.14%

Notifications are pending CI completion. Waiting for GitLab's status webhook to queue notifications. Push notifications now.

View CI Build Download

coverage:
  status:
    project:
      default:
        target: 80%
        threshold: 1.0%
    patch: off

Read the docs

Interact now

The inner-most circle is the entire project, moving away from the center are folders then, finally, a single file. The size and color of each slice is representing the number of statements and the coverage, respectively.

SVG

The top section represents the entire project. Proceeding with folders and finally individual files. The size and color of each slice is representing the number of statements and the coverage, respectively.

SVG

Each block represents a single file in the project. The size and color of each block is represented by the number of statements and the coverage, respectively.

SVG

Learn more about the coverage sunburst graph

115	114		pos: u32,
116	115		}
117	116
	117	+	fn recover_entry<T>(entry: &mut dyn JournalEntry, page: &mut ReadPage, found: &mut T, id: &JournalId) -> PRes<u32>
	118	+	where
	119	+	T: FnMut(&dyn JournalEntry, &JournalId),
	120	+	{
	121	+	let read_size = entry.read(page)?;
	122	+	found(entry, id);
	123	+	Ok(read_size)
	124	+	}
	125	+
118	126		impl Journal {
119	127		pub fn new(all: &Arc<Allocator>, page: u64) -> PRes<Journal> {
120	128		let first_page;

324	332		cur_cursor = JOURNAL_PAGE_CONTENT_OFFSET;
325	333		jr.last_page = cur_page;
326	334		} else {
327		-	let mut read_size = 0;
328	335		let page_id = page.read_u64();
329	336		let pos = page.read_u32();
330		-	let mut recover_entry = \|entry: &mut dyn JournalEntry\| -> PRes<()> {
331		-	read_size = entry.read(&mut page)?;
332		-	found(entry, &JournalId::new(page_id, pos));
333		-	Ok(())
334		-	};
335		-	match tp {
336		-	1 => {
337		-	let mut entry = Start::new();
338		-	read_size = entry.read(&mut page)?;
339		-	//The Start entry has no valid id, should not be recovered
340		-	}
341		-	2 => {
342		-	let mut entry = InsertRecord::new(0, &RecRef::new(0, 0), 0);
343		-	recover_entry(&mut entry)?;
344		-	}
345		-	3 => {
346		-	let mut entry = PrepareCommit::new();
347		-	recover_entry(&mut entry)?;
348		-	}
349		-	4 => {
350		-	let mut entry = Commit::new();
351		-	recover_entry(&mut entry)?;
352		-	}
353		-	5 => {
354		-	let mut entry = UpdateRecord::new(0, &RecRef::new(0, 0), 0, 0);
355		-	recover_entry(&mut entry)?;
356		-	}
357		-	6 => {
358		-	let mut entry = DeleteRecord::new(0, &RecRef::new(0, 0), 0);
359		-	recover_entry(&mut entry)?;
360		-	}
361		-	7 => {
362		-	let mut entry = Rollback::new();
363		-	recover_entry(&mut entry)?;
364		-	}
365		-	8 => {
366		-	let mut entry = CreateSegment::new("", 0, 0);
367		-	recover_entry(&mut entry)?;
368		-	}
369		-	9 => {
370		-	let mut entry = DropSegment::new("", 0);
371		-	recover_entry(&mut entry)?;
372		-	}
373		-	10 => {
374		-	let mut entry = ReadRecord::new(0, &RecRef::new(0, 0), 0);
375		-	recover_entry(&mut entry)?;
376		-	}
377		-	11 => {
378		-	let mut entry = Metadata::new(&TxStrategy::LastWin, Vec::new());
379		-	recover_entry(&mut entry)?;
380		-	}
381		-	12 => {
382		-	let mut entry = FreedPage::new(0);
383		-	recover_entry(&mut entry)?;
384		-	}
385		-	13 => {
386		-	let mut entry = NewSegmentPage::new(0, 0, 0);
387		-	recover_entry(&mut entry)?;
388		-	}
389		-	14 => {
390		-	let mut entry = Cleanup::new();
391		-	recover_entry(&mut entry)?;
392		-	}
	337	+	let id = JournalId::new(page_id, pos);
	338	+	let ref_page = &mut page;
	339	+	let ref_found = &mut found;
	340	+	let read_size = match tp {
	341	+	//The Start entry has no valid id, should not be recovered
	342	+	1 => Start::new().read(&mut page)?,
	343	+	2 => recover_entry(&mut InsertRecord::default(), ref_page, ref_found, &id)?,
	344	+	3 => recover_entry(&mut PrepareCommit::default(), ref_page, ref_found, &id)?,
	345	+	4 => recover_entry(&mut Commit::default(), ref_page, ref_found, &id)?,
	346	+	5 => recover_entry(&mut UpdateRecord::default(), ref_page, ref_found, &id)?,
	347	+	6 => recover_entry(&mut DeleteRecord::default(), ref_page, ref_found, &id)?,
	348	+	7 => recover_entry(&mut Rollback::default(), ref_page, ref_found, &id)?,
	349	+	8 => recover_entry(&mut CreateSegment::default(), ref_page, ref_found, &id)?,
	350	+	9 => recover_entry(&mut DropSegment::default(), ref_page, ref_found, &id)?,
	351	+	10 => recover_entry(&mut ReadRecord::default(), ref_page, ref_found, &id)?,
	352	+	11 => recover_entry(&mut Metadata::default(), ref_page, ref_found, &id)?,
	353	+	12 => recover_entry(&mut FreedPage::default(), ref_page, ref_found, &id)?,
	354	+	13 => recover_entry(&mut NewSegmentPage::default(), ref_page, ref_found, &id)?,
	355	+	14 => recover_entry(&mut Cleanup::default(), ref_page, ref_found, &id)?,
393	356		_ => panic!(" wrong log entry {} ", tp),
394	357		};
395	358		cur_cursor = read_size + cur_cursor + 13;

Navigation	Overlay
`t` Navigate files	`h` Toggle hits
`y` Change url to tip of branch	`m` Toggle misses
`b / v` Jump to prev/next hit line	`p` Toggle partial
`z / x` Jump to prev/next missed or partial line	`1..9` Toggle flags
`shift + o` Open current page in GitLab	`a` Toggle all on
`/ or ?` Show keyboard shortcuts dialog	`c` Toggle context lines or commits

18	18		vec::{self, IntoIter},
19	19		};
20	20
21		-	#[derive(Clone)]
	21	+	#[derive(Clone, Default)]
22	22		pub struct NewSegmentPage {
23	23		pub segment: u32,
24	24		pub page: u64,
25	25		pub previous: u64,
26	26		}
27	27
28		-	#[derive(Clone)]
	28	+	#[derive(Clone, Default)]
29	29		pub struct InsertRecord {
30	30		pub segment: u32,
31	31		pub recref: RecRef,
32	32		pub record_page: u64,
33	33		}
34	34
35		-	#[derive(Clone)]
	35	+	#[derive(Clone, Default)]
36	36		pub struct UpdateRecord {
37	37		pub segment: u32,
38	38		pub recref: RecRef,

40	40		pub version: u16,
41	41		}
42	42
43		-	#[derive(Clone)]
	43	+	#[derive(Clone, Default)]
44	44		pub struct ReadRecord {
45	45		pub segment: u32,
46	46		pub recref: RecRef,
47	47		pub version: u16,
48	48		}
49	49
50		-	#[derive(Clone)]
	50	+	#[derive(Clone, Default)]
51	51		pub struct DeleteRecord {
52	52		pub segment: u32,
53	53		pub recref: RecRef,
54	54		pub version: u16,
55	55		}
56	56
57		-	#[derive(Clone)]
	57	+	#[derive(Clone, Default)]
58	58		pub struct CreateSegment {
59	59		pub name: String,
60	60		pub segment_id: u32,
61	61		pub first_page: u64,
62	62		}
63	63
64		-	#[derive(Clone)]
	64	+	#[derive(Clone, Default)]
65	65		pub struct DropSegment {
66	66		pub name: String,
67	67		pub segment_id: u32,
68	68		}
69	69
70		-	#[derive(Clone, PartialEq, Debug, PartialOrd, Ord, Eq)]
	70	+	#[derive(Clone, PartialEq, Debug, PartialOrd, Ord, Eq, Default)]
71	71		pub struct FreedPage {
72	72		pub page: u64,
73	73		}
74	74
	75	+	#[derive(Default)]
75	76		pub struct PrepareCommit {}
76	77
	78	+	#[derive(Default)]
77	79		pub struct Commit {}
78	80
	81	+	#[derive(Default)]
79	82		pub struct Cleanup {}
80	83
	84	+	#[derive(Default)]
81	85		pub struct Rollback {}
82	86
	87	+	#[derive(Default)]
83	88		pub struct Metadata {
84	89		pub strategy: TxStrategy,
85	90		pub meta_id: Vec<u8>,

23	23		///
24	24		VersionOnRead,
25	25		}
	26	+	impl Default for TxStrategy {
	27	+	fn default() -> Self {
	28	+	TxStrategy::LastWin
	29	+	}
	30	+	}
26	31
27	32		impl TxStrategy {
28	33		pub fn value(&self) -> u8 {

28	28		Ok(u32_vdec(&bytes).map_err(\|_\| PersyError::InvalidId(String::from(s)))?.0)
29	29		}
30	30
31		-	#[derive(PartialEq, Eq, PartialOrd, Ord, Hash, Clone, Debug)]
	31	+	#[derive(PartialEq, Eq, PartialOrd, Ord, Hash, Clone, Debug, Default)]
32	32		pub struct RecRef {
33	33		pub page: u64,
34	34		pub pos: u32,

5	5		use crate::{
6	6		allocator::Allocator,
7	7		config::TxStrategy,
8		-	discref::{Page, PageOps, PAGE_METADATA_SIZE},
	8	+	discref::{Page, PageOps, ReadPage, PAGE_METADATA_SIZE},
9	9		error::PRes,
10	10		flush_checksum::{double_buffer_check, prepare_buffer_flush},
11		-	id::RecRef,
12	11		io::{read_u64, write_u64, InfallibleRead, InfallibleReadFormat, InfallibleWrite, InfallibleWriteFormat},
13	12		persy::RecoverStatus,
14	13		};

1	coverage:
2	status:
3	project:
4	default:
5	target: 80%
6	threshold: 1.0%
7	patch: off