Merge pull request #22 from kruserr/2024-05-26-0

2024 05 26 0

rapiddb/src/db/mmav_db/mmav.rs

@@ -1,5 +1,5 @@
 use crate::db::mmav_db::mmav_unit::MMAVUnit;
-use crate::errors::MMAVError;
+use crate::errors::Error;
 
 /// Memory Mapped Append-only Vector
 ///
@@ -148,12 +148,15 @@ impl MMAV {
  return unit_map[&index].len();
  }
 
- let unit = MMAVUnit::new(&format!("{id}/{index}"), size, data_start_index);
- let result = unit.len();
+ let mut result: usize = Default::default();
 
- unit_map.insert(index, unit);
+ let _ = MMAVUnit::new(&format!("{id}/{index}"), size, data_start_index)
+ .map(|unit| {
+ result = unit.len();
+ unit_map.insert(index, unit);
+ });
 
- result
+ return result;
  }
 
  /// Load unit that contains `index`
@@ -231,11 +234,11 @@ impl MMAV {
  pub fn push(&mut self, value: &[u8]) {
  self.unit_map.get_mut(&self.index).unwrap().push(value).unwrap_or_else(
  |error| match error {
- MMAVError::ArrayFull => {
+ Error::ArrayFull => {
  self.expand();
  self.push(value);
  }
- MMAVError::FileFull => {
+ Error::FileFull => {
  self.expand();
  self.push(value);
  }

rapiddb/src/db/mmav_db/mmav_async_database.rs

@@ -107,6 +107,7 @@ impl MMAVAsyncDatabase {
  .read(true)
  .write(true)
  .create(true)
+ .truncate(false)
  .open(&file_name)
  .unwrap_or_else(|error| {
  if error.kind() == std::io::ErrorKind::NotFound {
@@ -126,6 +127,7 @@ impl MMAVAsyncDatabase {
  .read(true)
  .write(true)
  .create(true)
+ .truncate(false)
  .open(file_name)
  .unwrap()
  });
@@ -155,7 +157,7 @@ impl Default for MMAVAsyncDatabase {
 #[async_trait::async_trait]
 impl IAsyncDatabase for MMAVAsyncDatabase {
  async fn contains(&self, id: &str) -> bool {
- self.sensors.get(id).is_some()
+ self.sensors.contains_key(id)
  }
 
  async fn get(&mut self, id: &str, rec_id: usize) -> Vec<u8> {
@@ -215,6 +217,7 @@ impl IAsyncDatabase for MMAVAsyncDatabase {
  .read(true)
  .write(true)
  .create(true)
+ .truncate(false)
  .open(&file_name)
  .unwrap_or_else(|error| {
  if error.kind() == std::io::ErrorKind::NotFound {
@@ -234,6 +237,7 @@ impl IAsyncDatabase for MMAVAsyncDatabase {
  .read(true)
  .write(true)
  .create(true)
+ .truncate(false)
  .open(file_name)
  .unwrap()
  });
@@ -243,7 +247,7 @@ impl IAsyncDatabase for MMAVAsyncDatabase {
  }
 
  async fn get_aggregates(&self, id: &str) -> Vec<u8> {
- if self.aggregates.get(id).is_none() {
+ if !self.aggregates.contains_key(id) {
  return Default::default();
  }
 

rapiddb/src/db/mmav_db/mmav_database.rs

@@ -107,6 +107,7 @@ impl MMAVDatabase {
  .read(true)
  .write(true)
  .create(true)
+ .truncate(false)
  .open(&file_name)
  .unwrap_or_else(|error| {
  if error.kind() == std::io::ErrorKind::NotFound {
@@ -126,6 +127,7 @@ impl MMAVDatabase {
  .read(true)
  .write(true)
  .create(true)
+ .truncate(false)
  .open(file_name)
  .unwrap()
  });
@@ -154,7 +156,7 @@ impl Default for MMAVDatabase {
 }
 impl IDatabase for MMAVDatabase {
  fn contains(&self, id: &str) -> bool {
- self.sensors.get(id).is_some()
+ self.sensors.contains_key(id)
  }
 
  fn get(&mut self, id: &str, rec_id: usize) -> Vec<u8> {
@@ -214,6 +216,7 @@ impl IDatabase for MMAVDatabase {
  .read(true)
  .write(true)
  .create(true)
+ .truncate(false)
  .open(&file_name)
  .unwrap_or_else(|error| {
  if error.kind() == std::io::ErrorKind::NotFound {
@@ -233,6 +236,7 @@ impl IDatabase for MMAVDatabase {
  .read(true)
  .write(true)
  .create(true)
+ .truncate(false)
  .open(file_name)
  .unwrap()
  });
@@ -242,7 +246,7 @@ impl IDatabase for MMAVDatabase {
  }
 
  fn get_aggregates(&self, id: &str) -> Vec<u8> {
- if self.aggregates.get(id).is_none() {
+ if !self.aggregates.contains_key(id) {
  return Default::default();
  }
 

rapiddb/src/db/mmav_db/mmav_unit.rs

@@ -1,4 +1,4 @@
-use crate::errors::MMAVError;
+use crate::errors::Error;
 
 /// Memory Mapped Append-only Vector Unit
 ///
@@ -24,7 +24,6 @@ impl MMAVUnit {
  /// Memory Mapped Append-only Vector Unit Constructor
  ///
  /// ## Default params:
- ///
  /// `size` = 4000000
  ///
  /// `data_start_index` = 80008
@@ -37,59 +36,53 @@ impl MMAVUnit {
  /// unit.push(data).unwrap_or_default();
  /// assert_eq!(unit.last(), data);
  /// ```
- pub fn new(file_name: &str, size: usize, data_start_index: usize) -> Self {
- let file_did_exist = std::path::Path::new(file_name).exists();
+ pub fn new(
+ file_name: &str,
+ size: usize,
+ data_start_index: usize,
+ ) -> Result<Self, Error> {
+ let file_path = std::path::Path::new(file_name);
+ let file_exists = file_path.exists();
+
+ if (!file_exists) {
+ file_path.parent().map(std::fs::create_dir_all);
+ }
 
  let file = std::fs::OpenOptions::new()
  .read(true)
  .write(true)
  .create(true)
- .open(file_name)
- .unwrap_or_else(|error| {
- if error.kind() == std::io::ErrorKind::NotFound {
- std::fs::create_dir(file_name.split('/').collect::<Vec<_>>()[0])
- .unwrap_or_default();
- }
-
- std::fs::OpenOptions::new()
- .read(true)
- .write(true)
- .create(true)
- .open(file_name)
- .unwrap()
- });
-
- file.set_len(size as u64).unwrap_or_default();
-
- let mut mmap = unsafe { memmap2::MmapMut::map_mut(&file).unwrap() };
+ .truncate(false)
+ .open(file_name)?;
+
+ file.set_len(size as u64)?;
+
+ let mut mmap = unsafe { memmap2::MmapMut::map_mut(&file)? };
  mmap.advise(memmap2::Advice::Random).unwrap_or_default();
 
  let mut seek = data_start_index;
- if file_did_exist {
- seek = u32::from_ne_bytes(mmap[0..4].try_into().unwrap()) as usize;
+ if (file_exists) {
+ seek = u32::from_ne_bytes(mmap[0..4].try_into()?) as usize;
 
  if seek > mmap.len() {
- panic!(
- "seek_index must be between {data_start_index} and {}",
- mmap.len()
- );
+ return Err(Error::IndexOutOfRange);
  }
  }
 
  let mut seek_index = 8;
- if file_did_exist {
- seek_index = u32::from_ne_bytes(mmap[4..8].try_into().unwrap()) as usize;
+ if (file_exists) {
+ seek_index = u32::from_ne_bytes(mmap[4..8].try_into()?) as usize;
 
  if seek_index > data_start_index {
- panic!("seek_index must be between 8 and {data_start_index}");
+ return Err(Error::IndexOutOfRange);
  }
  }
 
- if mmap[seek] == 0 {
+ if (mmap[seek] == 0) {
  mmap[seek] = 0;
  }
 
- Self { seek, seek_index, mmap, data_start_index }
+ return Ok(Self { seek, seek_index, mmap, data_start_index });
  }
 
  /// Set seek to `len`
@@ -116,12 +109,6 @@ impl MMAVUnit {
 
  /// Push `value` to vector
  ///
- /// ## Errors
- /// ```ignore
- /// MMAVError::ArrayFull
- /// MMAVError::FileFull
- /// ```
- ///
  /// ## Examples
  /// ```ignore
  /// let mut unit = MMAVUnit::new("test-0/0", 4000000, 80008);
@@ -130,13 +117,13 @@ impl MMAVUnit {
  /// unit.push(data).unwrap_or_default();
  /// assert_eq!(unit.last(), data);
  /// ```
- pub fn push(&mut self, value: &[u8]) -> Result<(), MMAVError> {
+ pub fn push(&mut self, value: &[u8]) -> Result<(), Error> {
  if self.len() > 9999 {
- return Err(MMAVError::ArrayFull);
+ return Err(Error::ArrayFull);
  }
 
  if self.seek + value.len() > self.mmap.len() {
- return Err(MMAVError::FileFull);
+ return Err(Error::FileFull);
  }
 
  self.mmap[self.seek..self.seek + value.len()].clone_from_slice(value);
@@ -147,13 +134,6 @@ impl MMAVUnit {
 
  /// Get `index` from vector
  ///
- /// ## Errors
- /// ```ignore
- /// MMAVError::ArrayEmpty
- /// MMAVError::IndexOutOfRange
- /// MMAVError::IndexOutOfBounds
- /// ```
- ///
  /// ## Examples
  /// ```ignore
  /// let mut unit = MMAVUnit::new("test-0/0", 4000000, 80008);
@@ -162,32 +142,30 @@ impl MMAVUnit {
  /// unit.push(data).unwrap_or_default();
  /// assert_eq!(unit.get(0), data);
  /// ```
- pub fn get(&self, index: usize) -> Result<Vec<u8>, MMAVError> {
+ pub fn get(&self, index: usize) -> Result<Vec<u8>, Error> {
  if self.seek_index == 8 {
- return Err(MMAVError::ArrayEmpty);
+ return Err(Error::ArrayEmpty);
  }
 
  if index > 9999 {
- return Err(MMAVError::IndexOutOfRange);
+ return Err(Error::IndexOutOfRange);
  }
 
  if index > self.len() - 1 {
- return Err(MMAVError::IndexOutOfBounds);
+ return Err(Error::IndexOutOfBounds);
  }
 
  let i = 8 * index + 8;
 
- let start =
- u32::from_ne_bytes(self.mmap[i..i + 4].try_into().unwrap()) as usize;
- let end =
- u32::from_ne_bytes(self.mmap[i + 4..i + 8].try_into().unwrap()) as usize;
+ let start = u32::from_ne_bytes(self.mmap[i..i + 4].try_into()?) as usize;
+ let end = u32::from_ne_bytes(self.mmap[i + 4..i + 8].try_into()?) as usize;
 
  if start < self.data_start_index || start > self.mmap.len() {
- return Err(MMAVError::IndexOutOfRange);
+ return Err(Error::IndexOutOfRange);
  }
 
  if end < self.data_start_index || end > self.mmap.len() {
- return Err(MMAVError::IndexOutOfRange);
+ return Err(Error::IndexOutOfRange);
  }
 
  Ok((self.mmap[start..end]).to_vec())