Implement Deref for FSRepository

Allow some places to not have to write `fs_impl`.

Signed-off-by: J Robert Ray <[email protected]>

Author: jrray

crates/spfs/src/clean_test.rs

@@ -487,7 +487,7 @@ async fn test_clean_manifest_renders(tmpdir: tempfile::TempDir) {
         .await
         .unwrap();
 
-    let files = list_files(fs_repo.fs_impl.objects.root());
+    let files = list_files(fs_repo.objects.root());
     assert!(!files.is_empty(), "should have stored data");
 
     let cleaner = Cleaner::new(&tmprepo).with_reporter(TracingCleanReporter);
@@ -497,7 +497,7 @@ async fn test_clean_manifest_renders(tmpdir: tempfile::TempDir) {
         .expect("failed to clean repo");
     println!("{result:#?}");
 
-    let files = list_files(fs_repo.fs_impl.renders.as_ref().unwrap().renders.root());
+    let files = list_files(fs_repo.renders.as_ref().unwrap().renders.root());
     assert_eq!(
         files,
         Vec::<String>::new(),

crates/spfs/src/runtime/storage.rs

@@ -1185,7 +1185,7 @@ impl Storage {
     pub async fn durable_path(&self, name: String) -> Result<PathBuf> {
         match &*self.inner {
             RepositoryHandle::FS(repo) => {
-                let mut upper_root_path = repo.fs_impl.root();
+                let mut upper_root_path = repo.root();
                 upper_root_path.push(DURABLE_EDITS_DIR);
                 upper_root_path.push(name);
                 Ok(upper_root_path)

crates/spfs/src/storage/fallback/repository.rs

@@ -387,12 +387,12 @@ impl Address for FallbackProxy {
 impl LocalRepository for FallbackProxy {
     #[inline]
     fn payloads(&self) -> &FsHashStore {
-        self.primary.fs_impl.payloads()
+        self.primary.payloads()
     }
 
     #[inline]
     fn render_store(&self) -> Result<&RenderStore> {
-        self.primary.fs_impl.render_store()
+        self.primary.render_store()
     }
 }
 

crates/spfs/src/storage/fallback/repository_test.rs

@@ -36,7 +36,7 @@ async fn test_proxy_payload_repair(tmpdir: tempfile::TempDir) {
         .unwrap();
 
     // Delete the payload file from the primary repo.
-    let payload_path = primary.fs_impl.payloads.build_digest_path(&digest);
+    let payload_path = primary.payloads.build_digest_path(&digest);
     tokio::fs::remove_file(payload_path).await.unwrap();
 
     // Loading the payload from the primary should fail.

crates/spfs/src/storage/fs/database.rs

@@ -82,12 +82,12 @@ impl graph::DatabaseExt for super::MaybeOpenFsRepository {
 #[async_trait::async_trait]
 impl DatabaseView for super::OpenFsRepository {
     async fn has_object(&self, digest: encoding::Digest) -> bool {
-        let filepath = self.fs_impl.objects.build_digest_path(&digest);
+        let filepath = self.objects.build_digest_path(&digest);
         tokio::fs::symlink_metadata(filepath).await.is_ok()
     }
 
     async fn read_object(&self, digest: encoding::Digest) -> Result<graph::Object> {
-        let filepath = self.fs_impl.objects.build_digest_path(&digest);
+        let filepath = self.objects.build_digest_path(&digest);
         let mut file =
             tokio::io::BufReader::new(tokio::fs::File::open(&filepath).await.map_err(|err| {
                 match err.kind() {
@@ -109,7 +109,7 @@ impl DatabaseView for super::OpenFsRepository {
         &self,
         search_criteria: graph::DigestSearchCriteria,
     ) -> Pin<Box<dyn Stream<Item = Result<encoding::Digest>> + Send>> {
-        Box::pin(self.fs_impl.objects.find(search_criteria))
+        Box::pin(self.objects.find(search_criteria))
     }
 
     fn iter_objects(&self) -> graph::DatabaseIterator<'_> {
@@ -124,14 +124,14 @@ impl DatabaseView for super::OpenFsRepository {
         &self,
         partial: &encoding::PartialDigest,
     ) -> Result<encoding::Digest> {
-        self.fs_impl.objects.resolve_full_digest(partial).await
+        self.objects.resolve_full_digest(partial).await
     }
 }
 
 #[async_trait::async_trait]
 impl graph::Database for super::OpenFsRepository {
     async fn remove_object(&self, digest: encoding::Digest) -> crate::Result<()> {
-        let filepath = self.fs_impl.objects.build_digest_path(&digest);
+        let filepath = self.objects.build_digest_path(&digest);
 
         // this might fail but we don't consider that fatal just yet
         #[cfg(unix)]
@@ -156,7 +156,7 @@ impl graph::Database for super::OpenFsRepository {
         older_than: DateTime<Utc>,
         digest: encoding::Digest,
     ) -> crate::Result<bool> {
-        let filepath = self.fs_impl.objects.build_digest_path(&digest);
+        let filepath = self.objects.build_digest_path(&digest);
 
         // this might fail but we don't consider that fatal just yet
         #[cfg(unix)]
@@ -203,7 +203,7 @@ impl graph::Database for super::OpenFsRepository {
 impl graph::DatabaseExt for super::OpenFsRepository {
     async fn write_object<T: ObjectProto>(&self, obj: &graph::FlatObject<T>) -> Result<()> {
         let digest = obj.digest()?;
-        let filepath = self.fs_impl.objects.build_digest_path(&digest);
+        let filepath = self.objects.build_digest_path(&digest);
         if filepath.exists() {
             tracing::trace!(%digest, kind=%std::any::type_name::<T>(), "object already exists");
             return Ok(());
@@ -214,8 +214,8 @@ impl graph::DatabaseExt for super::OpenFsRepository {
         // other processes don't try to read our incomplete
         // object from the database
         let uuid = uuid::Uuid::new_v4().to_string();
-        let working_file = self.fs_impl.objects.workdir().join(uuid);
-        self.fs_impl.objects.ensure_base_dir(&working_file)?;
+        let working_file = self.objects.workdir().join(uuid);
+        self.objects.ensure_base_dir(&working_file)?;
         let mut encoded = Vec::new();
         obj.encode(&mut encoded)?;
         let mut writer = tokio::io::BufWriter::new(
@@ -258,7 +258,7 @@ impl graph::DatabaseExt for super::OpenFsRepository {
         }
         #[cfg(unix)]
         {
-            let perms = std::fs::Permissions::from_mode(self.fs_impl.objects.file_permissions);
+            let perms = std::fs::Permissions::from_mode(self.objects.file_permissions);
             if let Err(err) = tokio::fs::set_permissions(&working_file, perms).await {
                 let _ = tokio::fs::remove_file(&working_file).await;
                 return Err(Error::StorageWriteError(
@@ -268,7 +268,7 @@ impl graph::DatabaseExt for super::OpenFsRepository {
                 ));
             }
         }
-        self.fs_impl.objects.ensure_base_dir(&filepath)?;
+        self.objects.ensure_base_dir(&filepath)?;
         match tokio::fs::rename(&working_file, &filepath).await {
             Ok(_) => Ok(()),
             Err(err) => {

crates/spfs/src/storage/fs/payloads.rs

@@ -54,26 +54,26 @@ impl crate::storage::PayloadStorage for MaybeOpenFsRepository {
 #[async_trait::async_trait]
 impl crate::storage::PayloadStorage for OpenFsRepository {
     async fn has_payload(&self, digest: encoding::Digest) -> bool {
-        let path = self.fs_impl.payloads.build_digest_path(&digest);
+        let path = self.payloads.build_digest_path(&digest);
         tokio::fs::symlink_metadata(path).await.is_ok()
     }
 
     fn iter_payload_digests(&self) -> Pin<Box<dyn Stream<Item = Result<encoding::Digest>> + Send>> {
-        Box::pin(self.fs_impl.payloads.iter())
+        Box::pin(self.payloads.iter())
     }
 
     async unsafe fn write_data(
         &self,
         reader: Pin<Box<dyn BlobRead>>,
     ) -> Result<(encoding::Digest, u64)> {
-        self.fs_impl.payloads.write_data(reader).await
+        self.payloads.write_data(reader).await
     }
 
     async fn open_payload(
         &self,
         digest: encoding::Digest,
     ) -> Result<(Pin<Box<dyn BlobRead>>, std::path::PathBuf)> {
-        let path = self.fs_impl.payloads.build_digest_path(&digest);
+        let path = self.payloads.build_digest_path(&digest);
         match tokio::fs::File::open(&path).await {
             Ok(file) => Ok((Box::pin(tokio::io::BufReader::new(file)), path)),
             Err(err) => match err.kind() {
@@ -97,7 +97,7 @@ impl crate::storage::PayloadStorage for OpenFsRepository {
     }
 
     async fn remove_payload(&self, digest: encoding::Digest) -> Result<()> {
-        let path = self.fs_impl.payloads.build_digest_path(&digest);
+        let path = self.payloads.build_digest_path(&digest);
         match tokio::fs::remove_file(&path).await {
             Ok(()) => Ok(()),
             Err(err) => match err.kind() {

crates/spfs/src/storage/fs/renderer.rs

@@ -49,14 +49,14 @@ pub enum RenderType {
 
 impl OpenFsRepository {
     fn get_render_storage(&self) -> Result<&crate::storage::fs::FsHashStore> {
-        match &self.fs_impl.renders {
+        match &self.renders {
             Some(render_store) => Ok(&render_store.renders),
             None => Err(Error::NoRenderStorage(self.address().into_owned())),
         }
     }
 
     pub async fn has_rendered_manifest(&self, digest: encoding::Digest) -> bool {
-        let renders = match &self.fs_impl.renders {
+        let renders = match &self.renders {
             Some(render_store) => &render_store.renders,
             None => return false,
         };
@@ -84,7 +84,7 @@ impl OpenFsRepository {
 
     /// Remove the identified render from this storage.
     pub async fn remove_rendered_manifest(&self, digest: crate::encoding::Digest) -> Result<()> {
-        let renders = match &self.fs_impl.renders {
+        let renders = match &self.renders {
             Some(render_store) => &render_store.renders,
             None => return Ok(()),
         };
@@ -123,7 +123,7 @@ impl OpenFsRepository {
         older_than: DateTime<Utc>,
         digest: encoding::Digest,
     ) -> Result<bool> {
-        let renders = match &self.fs_impl.renders {
+        let renders = match &self.renders {
             Some(render_store) => &render_store.renders,
             None => return Ok(false),
         };

crates/spfs/src/storage/fs/repository.rs

@@ -189,6 +189,15 @@ pub struct FsRepository<FS> {
     pub(crate) fs_impl: Arc<FS>,
 }
 
+impl<FS> std::ops::Deref for FsRepository<FS> {
+    type Target = FS;
+
+    #[inline]
+    fn deref(&self) -> &Self::Target {
+        &self.fs_impl
+    }
+}
+
 #[async_trait::async_trait]
 impl<FS> FsRepositoryOps for FsRepository<FS>
 where

crates/spfs/src/storage/fs/tag.rs

@@ -156,7 +156,7 @@ impl MaybeOpenFsRepository {
 
 impl OpenFsRepository {
     fn tags_root_in_namespace(&self, namespace: Option<&TagNamespace>) -> PathBuf {
-        let mut tags_root = self.fs_impl.root().join("tags");
+        let mut tags_root = self.root().join("tags");
         if let Some(tag_namespace) = namespace {
             for component in tag_namespace.as_rel_path().components() {
                 // Assuming the tag namespace is only made up of `Normal`