Fixed the error handling to properly handle the index not existing at…

… the beginning.

src/engine/io/block_layer/file_manager2.rs

@@ -115,24 +115,34 @@ impl FileManager2 {
         let file_number = offset.get_file_number();
         let file_handles = self.file_handles.clone();
 
-        let chunk = self
+        let chunk = match self
             .page_cache
             .get_or_try_insert_with((page_id, offset), async move {
                 let file_handle = file_handles
                     .get_or_try_insert_with((page_id, file_number), async move {
                         let handle =
                             FileOperations::open_path(&data_dir, &page_id, file_number).await?;
-                        Ok::<Arc<Mutex<File>>, FileManager2Error>(Arc::new(Mutex::const_new(
+                        Ok::<Arc<Mutex<File>>, FileOperationsError>(Arc::new(Mutex::const_new(
                             handle,
                         )))
                     })
                     .await?;
                 let mut file = file_handle.lock().await;
 
                 let chunk = FileOperations::read_chunk(file.deref_mut(), &offset).await?;
-                Ok::<Bytes, FileManager2Error>(chunk)
+                Ok::<Bytes, FileOperationsError>(chunk)
             })
-            .await?;
+            .await
+        {
+            Ok(s) => s,
+            Err(e) => {
+                if let FileOperationsError::FileTooSmall(_, _) = e.as_ref() {
+                    return Err(FileManager2Error::PageDoesNotExist(offset));
+                } else {
+                    return Err(FileManager2Error::ArcFileOperationsError(e));
+                }
+            }
+        };
 
         Ok((chunk, read_lock))
     }
@@ -150,24 +160,34 @@ impl FileManager2 {
         let file_number = offset.get_file_number();
         let file_handles = self.file_handles.clone();
 
-        let chunk = self
+        let chunk = match self
             .page_cache
             .get_or_try_insert_with((page_id, offset), async move {
                 let file_handle = file_handles
                     .get_or_try_insert_with((page_id, file_number), async move {
                         let handle =
                             FileOperations::open_path(&data_dir, &page_id, file_number).await?;
-                        Ok::<Arc<Mutex<File>>, FileManager2Error>(Arc::new(Mutex::const_new(
+                        Ok::<Arc<Mutex<File>>, FileOperationsError>(Arc::new(Mutex::const_new(
                             handle,
                         )))
                     })
                     .await?;
                 let mut file = file_handle.lock().await;
 
                 let chunk = FileOperations::read_chunk(file.deref_mut(), &offset).await?;
-                Ok::<Bytes, FileManager2Error>(chunk)
+                Ok::<Bytes, FileOperationsError>(chunk)
             })
-            .await?;
+            .await
+        {
+            Ok(s) => s,
+            Err(e) => {
+                if let FileOperationsError::FileTooSmall(_, _) = e.as_ref() {
+                    return Err(FileManager2Error::PageDoesNotExist(offset));
+                } else {
+                    return Err(FileManager2Error::ArcFileOperationsError(e));
+                }
+            }
+        };
 
         Ok((chunk, write_lock))
     }
@@ -309,10 +329,14 @@ pub enum FileManager2Error {
     FileManager2Error(#[from] Arc<FileManager2Error>),
     #[error(transparent)]
     FileOperationsError(#[from] FileOperationsError),
+    #[error(transparent)]
+    ArcFileOperationsError(#[from] Arc<FileOperationsError>),
     #[error("Incorrect page size of {0} on file {1} found. System cannot function")]
     IncorrectPageSize(u64, PathBuf),
     #[error(transparent)]
     IOError(#[from] std::io::Error),
+    #[error("Page {0} does not exist")]
+    PageDoesNotExist(PageOffset),
     #[error("Need a directory to store the data. Got ({0}) may be stripped of non Unicode chars.")]
     NeedDirectory(String),
     #[error(transparent)]

src/engine/io/block_layer/file_operations.rs

@@ -4,6 +4,7 @@ use bytes::{Bytes, BytesMut};
 use std::convert::TryFrom;
 use std::num::TryFromIntError;
 use std::path::PathBuf;
+use std::sync::Arc;
 use std::{io::SeekFrom, path::Path};
 use thiserror::Error;
 use tokio::fs;
@@ -119,6 +120,8 @@ impl FileOperations {
 
 #[derive(Debug, Error)]
 pub enum FileOperationsError {
+    #[error(transparent)]
+    FileOperationsError(#[from] Arc<FileOperationsError>),
     #[error("Read {0} bytes instead of a page, the buffer has {1}")]
     IncompleteRead(usize, usize),
     #[error(transparent)]

src/engine/io/index_manager.rs

@@ -190,7 +190,15 @@ impl IndexManager {
         };
 
         let (mut first_page, _first_guard) =
-            self.file_manager.get_page(&page_id, &PageOffset(0)).await?;
+            match self.file_manager.get_page(&page_id, &PageOffset(0)).await {
+                Ok(s) => s,
+                Err(FileManager2Error::PageDoesNotExist(_)) => {
+                    return Ok(None);
+                }
+                Err(e) => {
+                    return Err(IndexManagerError::FileManager2Error(e));
+                }
+            };
         let first_node = BTreeFirstPage::parse(&mut first_page)?;
 
         let mut current_offset = first_node.root_offset;