scmstore: TreeStore & FileStore pyrevisionstore constructor integration

Summary: Modifies `treescmstore` and `filescmstore` to also construct `TreeStore` and `FileStore` respectively. Currently these newly constructed stores are not used anywhere, no application code behavior should change as a result of this.

Reviewed By: DurhamG

Differential Revision: D28237680

fbshipit-source-id: 2bf3fd4b96be8c26e5c1e55cfd2e865f98e6ba91

eden/scm/edenscmnative/bindings/modules/pyrevisionstore/src/lib.rs

@@ -33,8 +33,9 @@ use pyprogress::PyProgressFactory;
 use revisionstore::{
     repack,
     scmstore::{
-        util::file_to_async_key_stream, BoxedReadStore, FileScmStoreBuilder, LegacyDatastore,
+        util::file_to_async_key_stream, BoxedReadStore, FileScmStoreBuilder, FileStore,
-        StoreFile, StoreTree, TreeScmStoreBuilder,
+        FileStoreBuilder, LegacyDatastore, StoreFile, StoreTree, TreeScmStoreBuilder, TreeStore,
+        TreeStoreBuilder,
     },
     ContentStore, ContentStoreBuilder, CorruptionPolicy, DataPack, DataPackStore, DataPackVersion,
     Delta, EdenApiFileStore, EdenApiTreeStore, ExtStoredPolicy, HgIdDataStore, HgIdHistoryStore,
@@ -1148,45 +1149,83 @@ fn make_filescmstore<'a>(
     edenapi_filestore: Option<Arc<EdenApiFileStore>>,
     suffix: Option<String>,
     correlator: Option<String>,
-) -> Result<(BoxedReadStore<Key, StoreFile>, Arc<ContentStore>)> {
+) -> Result<(
-    let mut builder = ContentStoreBuilder::new(&config).correlator(correlator);
+    Arc<FileStore>,
+    BoxedReadStore<Key, StoreFile>,
+    Arc<ContentStore>,
+)> {
+    let mut builder = ContentStoreBuilder::new(&config).correlator(correlator.clone());
     let mut scmstore_builder = FileScmStoreBuilder::new(&config);
+    let mut filestore_builder = FileStoreBuilder::new(&config);
+
+    if let Some(correlator) = correlator {
+        filestore_builder = filestore_builder.correlator(correlator);
+    }
 
     builder = if let Some(path) = path {
+        filestore_builder = filestore_builder.local_path(path);
         builder.local_path(path)
     } else {
         builder.no_local_store()
     };
 
-    builder = if let Some(memcache) = memcache {
+    if let Some(memcache) = memcache {
-        builder.memcachestore(memcache)
+        filestore_builder = filestore_builder.memcache(memcache.clone());
-    } else {
+        builder = builder.memcachestore(memcache)
-        builder
     };
 
     if let Some(ref suffix) = suffix {
         builder = builder.suffix(suffix);
         scmstore_builder = scmstore_builder.suffix(suffix);
+        filestore_builder = filestore_builder.suffix(suffix);
     }
 
     builder = if let Some(edenapi) = edenapi_filestore {
         scmstore_builder = scmstore_builder.shared_edenapi(edenapi.clone());
+        filestore_builder = filestore_builder.edenapi(edenapi.clone());
         builder.remotestore(edenapi)
     } else {
         builder.remotestore(remote)
     };
 
-    builder = builder.shared_indexedlog(scmstore_builder.build_shared_indexedlog()?);
+    let indexedlog_local = filestore_builder.build_indexedlog_local()?;
+    let indexedlog_cache = filestore_builder.build_indexedlog_cache()?;
+    let lfs_local = filestore_builder.build_lfs_local()?;
+    let lfs_cache = filestore_builder.build_lfs_cache()?;
+
+    if let Some(indexedlog_local) = indexedlog_local {
+        filestore_builder = filestore_builder.indexedlog_local(indexedlog_local.clone());
+        builder = builder.shared_indexedlog_local(indexedlog_local);
+    }
+
+    filestore_builder = filestore_builder.indexedlog_cache(indexedlog_cache.clone());
+    builder = builder.shared_indexedlog_shared(indexedlog_cache.clone());
+    scmstore_builder = scmstore_builder.shared_indexedlog(indexedlog_cache);
+
+    if let Some(lfs_local) = lfs_local {
+        filestore_builder = filestore_builder.lfs_local(lfs_local.clone());
+        builder = builder.shared_lfs_local(lfs_local);
+    }
+
+    if let Some(lfs_cache) = lfs_cache {
+        filestore_builder = filestore_builder.lfs_cache(lfs_cache.clone());
+        builder = builder.shared_lfs_shared(lfs_cache);
+    }
+
     let contentstore = Arc::new(builder.build()?);
 
     scmstore_builder = scmstore_builder.legacy_fallback(LegacyDatastore(contentstore.clone()));
-    let scmstore = scmstore_builder.build()?;
+    filestore_builder = filestore_builder.contentstore(contentstore.clone());
 
-    Ok((scmstore, contentstore))
+    let scmstore = scmstore_builder.build()?;
+    let filestore = Arc::new(filestore_builder.build()?);
+
+    Ok((filestore, scmstore, contentstore))
 }
 
 py_class!(pub class filescmstore |py| {
-    data store: BoxedReadStore<Key, StoreFile>;
+    data store: Arc<FileStore>;
+    data oldscmstore: BoxedReadStore<Key, StoreFile>;
     data contentstore: Arc<ContentStore>;
 
     def __new__(_cls,
@@ -1205,9 +1244,9 @@ py_class!(pub class filescmstore |py| {
         let memcache = memcache.map(|v| v.extract_inner(py));
         let edenapi = edenapi.map(|v| v.extract_inner(py));
 
-        let (scmstore, contentstore) = make_filescmstore(path, &config, remote, memcache, edenapi, suffix, correlator).map_pyerr(py)?;
+        let (filestore, oldscmstore, contentstore) = make_filescmstore(path, &config, remote, memcache, edenapi, suffix, correlator).map_pyerr(py)?;
 
-        filescmstore::create_instance(py, scmstore, contentstore)
+        filescmstore::create_instance(py, filestore, oldscmstore, contentstore)
     }
 
     def get_contentstore(&self) -> PyResult<contentstore> {
@@ -1216,7 +1255,7 @@ py_class!(pub class filescmstore |py| {
 
     def test_fetch(&self, path: PyPathBuf) -> PyResult<PyNone> {
         let keys = block_on(file_to_async_key_stream(path.to_path_buf())).map_pyerr(py)?;
-        let store = self.store(py).clone();
+        let store = self.oldscmstore(py).clone();
 
         let io = IO::main().map_pyerr(py)?;
         let mut stdout = io.output();
@@ -1235,7 +1274,7 @@ impl ExtractInnerRef for filescmstore {
     type Inner = BoxedReadStore<Key, StoreFile>;
 
     fn extract_inner_ref<'a>(&'a self, py: Python<'a>) -> &'a Self::Inner {
-        self.store(py)
+        self.oldscmstore(py)
     }
 }
 
@@ -1251,25 +1290,31 @@ fn make_treescmstore<'a>(
     edenapi_treestore: Option<Arc<EdenApiTreeStore>>,
     suffix: Option<String>,
     correlator: Option<String>,
-) -> Result<(BoxedReadStore<Key, StoreTree>, Arc<ContentStore>)> {
+) -> Result<(
+    Arc<TreeStore>,
+    BoxedReadStore<Key, StoreTree>,
+    Arc<ContentStore>,
+)> {
     let mut builder = ContentStoreBuilder::new(&config).correlator(correlator);
     let mut scmstore_builder = TreeScmStoreBuilder::new(&config);
+    let mut treestore_builder = TreeStoreBuilder::new(&config);
 
     builder = if let Some(path) = path {
+        treestore_builder = treestore_builder.local_path(path);
         builder.local_path(path)
     } else {
         builder.no_local_store()
     };
 
-    builder = if let Some(memcache) = memcache {
+    if let Some(memcache) = memcache {
-        builder.memcachestore(memcache)
+        builder = builder.memcachestore(memcache.clone());
-    } else {
+        treestore_builder = treestore_builder.memcache(memcache);
-        builder
     };
 
     if let Some(ref suffix) = suffix {
         builder = builder.suffix(suffix);
         scmstore_builder = scmstore_builder.suffix(suffix);
+        treestore_builder = treestore_builder.suffix(suffix);
     }
 
     // Match behavior of treemanifest contentstore construction (never include EdenApi)
@@ -1277,20 +1322,36 @@ fn make_treescmstore<'a>(
 
     // Extract EdenApiAdapter for scmstore construction later on
     if let Some(edenapi) = edenapi_treestore {
-        scmstore_builder = scmstore_builder.shared_edenapi(edenapi);
+        scmstore_builder = scmstore_builder.shared_edenapi(edenapi.clone());
+        treestore_builder = treestore_builder.edenapi(edenapi);
     }
 
-    builder = builder.shared_indexedlog(scmstore_builder.build_shared_indexedlog()?);
+    let indexedlog_local = treestore_builder.build_indexedlog_local()?;
+    let indexedlog_cache = treestore_builder.build_indexedlog_cache()?;
+
+    if let Some(indexedlog_local) = indexedlog_local {
+        treestore_builder = treestore_builder.indexedlog_local(indexedlog_local.clone());
+        builder = builder.shared_indexedlog_local(indexedlog_local);
+    }
+
+    treestore_builder = treestore_builder.indexedlog_cache(indexedlog_cache.clone());
+    builder = builder.shared_indexedlog_shared(indexedlog_cache.clone());
+    scmstore_builder = scmstore_builder.shared_indexedlog(indexedlog_cache);
 
     let contentstore = Arc::new(builder.build()?);
-    scmstore_builder = scmstore_builder.legacy_fallback(LegacyDatastore(contentstore.clone()));
-    let scmstore = scmstore_builder.build()?;
 
-    Ok((scmstore, contentstore))
+    treestore_builder = treestore_builder.contentstore(contentstore.clone());
+    scmstore_builder = scmstore_builder.legacy_fallback(LegacyDatastore(contentstore.clone()));
+
+    let scmstore = scmstore_builder.build()?;
+    let treestore = Arc::new(treestore_builder.build()?);
+
+    Ok((treestore, scmstore, contentstore))
 }
 
 py_class!(pub class treescmstore |py| {
-    data store: BoxedReadStore<Key, StoreTree>;
+    data store: Arc<TreeStore>;
+    data oldscmstore: BoxedReadStore<Key, StoreTree>;
     data contentstore: Arc<ContentStore>;
 
     def __new__(_cls,
@@ -1309,9 +1370,9 @@ py_class!(pub class treescmstore |py| {
         let memcache = memcache.map(|v| v.extract_inner(py));
         let edenapi = edenapi.map(|v| v.extract_inner(py));
 
-        let (scmstore, contentstore) = make_treescmstore(path, &config, remote, memcache, edenapi, suffix, correlator).map_pyerr(py)?;
+        let (treestore, oldscmstore, contentstore) = make_treescmstore(path, &config, remote, memcache, edenapi, suffix, correlator).map_pyerr(py)?;
 
-        treescmstore::create_instance(py, scmstore, contentstore)
+        treescmstore::create_instance(py, treestore, oldscmstore, contentstore)
     }
 
     def get_contentstore(&self) -> PyResult<contentstore> {
@@ -1320,7 +1381,7 @@ py_class!(pub class treescmstore |py| {
 
     def test_fetch(&self, path: PyPathBuf) -> PyResult<PyNone> {
         let keys = block_on(file_to_async_key_stream(path.to_path_buf())).map_pyerr(py)?;
-        let store = self.store(py).clone();
+        let store = self.oldscmstore(py).clone();
 
         let io = IO::main().map_pyerr(py)?;
         let mut stdout = io.output();
@@ -1339,6 +1400,6 @@ impl ExtractInnerRef for treescmstore {
     type Inner = BoxedReadStore<Key, StoreTree>;
 
     fn extract_inner_ref<'a>(&'a self, py: Python<'a>) -> &'a Self::Inner {
-        self.store(py)
+        self.oldscmstore(py)
     }
 }

eden/scm/lib/revisionstore/src/contentstore.rs

@@ -254,7 +254,10 @@ pub struct ContentStoreBuilder<'a> {
     suffix: Option<PathBuf>,
     memcachestore: Option<Arc<MemcacheStore>>,
     correlator: Option<String>,
-    shared_indexedlog: Option<Arc<IndexedLogHgIdDataStore>>,
+    shared_indexedlog_local: Option<Arc<IndexedLogHgIdDataStore>>,
+    shared_indexedlog_shared: Option<Arc<IndexedLogHgIdDataStore>>,
+    shared_lfs_local: Option<Arc<LfsStore>>,
+    shared_lfs_shared: Option<Arc<LfsStore>>,
 }
 
 impl<'a> ContentStoreBuilder<'a> {
@@ -267,7 +270,10 @@ impl<'a> ContentStoreBuilder<'a> {
             memcachestore: None,
             suffix: None,
             correlator: None,
-            shared_indexedlog: None,
+            shared_indexedlog_shared: None,
+            shared_indexedlog_local: None,
+            shared_lfs_shared: None,
+            shared_lfs_local: None,
         }
     }
 
@@ -306,8 +312,23 @@ impl<'a> ContentStoreBuilder<'a> {
         self
     }
 
-    pub fn shared_indexedlog(mut self, indexedlog: Arc<IndexedLogHgIdDataStore>) -> Self {
+    pub fn shared_indexedlog_local(mut self, indexedlog: Arc<IndexedLogHgIdDataStore>) -> Self {
-        self.shared_indexedlog = Some(indexedlog);
+        self.shared_indexedlog_local = Some(indexedlog);
+        self
+    }
+
+    pub fn shared_indexedlog_shared(mut self, indexedlog: Arc<IndexedLogHgIdDataStore>) -> Self {
+        self.shared_indexedlog_shared = Some(indexedlog);
+        self
+    }
+
+    pub fn shared_lfs_local(mut self, lfs: Arc<LfsStore>) -> Self {
+        self.shared_lfs_local = Some(lfs);
+        self
+    }
+
+    pub fn shared_lfs_shared(mut self, lfs: Arc<LfsStore>) -> Self {
+        self.shared_lfs_shared = Some(lfs);
         self
     }
 
@@ -359,16 +380,17 @@ impl<'a> ContentStoreBuilder<'a> {
             max_bytes,
             extstored_policy,
         )?);
-        let shared_indexedlogdatastore = if let Some(shared_indexedlog) = self.shared_indexedlog {
+        let shared_indexedlogdatastore =
-            shared_indexedlog
+            if let Some(shared_indexedlog_shared) = self.shared_indexedlog_shared {
-        } else {
+                shared_indexedlog_shared
-            Arc::new(IndexedLogHgIdDataStore::new(
+            } else {
-                get_indexedlogdatastore_path(&cache_path)?,
+                Arc::new(IndexedLogHgIdDataStore::new(
-                extstored_policy,
+                    get_indexedlogdatastore_path(&cache_path)?,
-                self.config,
+                    extstored_policy,
-                IndexedLogDataStoreType::Shared,
+                    self.config,
-            )?)
+                    IndexedLogDataStoreType::Shared,
-        };
+                )?)
+            };
 
         // The shared stores should precede the local one since we expect both the number of blobs,
         // and the number of requests satisfied by the shared cache to be significantly higher than
@@ -380,7 +402,11 @@ impl<'a> ContentStoreBuilder<'a> {
             None
         };
 
-        let shared_lfs_store = Arc::new(LfsStore::shared(&cache_path, self.config)?);
+        let shared_lfs_store = if let Some(shared_lfs_shared) = self.shared_lfs_shared {
+            shared_lfs_shared
+        } else {
+            Arc::new(LfsStore::shared(&cache_path, self.config)?)
+        };
         blob_stores.add(shared_lfs_store.clone());
 
         let primary: Arc<dyn HgIdMutableDeltaStore> =
@@ -421,12 +447,17 @@ impl<'a> ContentStoreBuilder<'a> {
                     None,
                     extstored_policy,
                 )?);
-                let local_indexedlogdatastore = Arc::new(IndexedLogHgIdDataStore::new(
+                let local_indexedlogdatastore =
-                    get_indexedlogdatastore_path(local_path.as_ref().unwrap())?,
+                    if let Some(shared_indexedlog_local) = self.shared_indexedlog_local {
-                    extstored_policy,
+                        shared_indexedlog_local
-                    self.config,
+                    } else {
-                    IndexedLogDataStoreType::Local,
+                        Arc::new(IndexedLogHgIdDataStore::new(
-                )?);
+                            get_indexedlogdatastore_path(local_path.as_ref().unwrap())?,
+                            extstored_policy,
+                            self.config,
+                            IndexedLogDataStoreType::Local,
+                        )?)
+                    };
 
                 let primary: Arc<dyn HgIdMutableDeltaStore> =
                     if self
@@ -443,7 +474,11 @@ impl<'a> ContentStoreBuilder<'a> {
                         local_pack_store
                     };
 
-                let local_lfs_store = Arc::new(LfsStore::local(&local_path.unwrap(), self.config)?);
+                let local_lfs_store = if let Some(shared_lfs_local) = self.shared_lfs_local {
+                    shared_lfs_local
+                } else {
+                    Arc::new(LfsStore::local(&local_path.unwrap(), self.config)?)
+                };
                 blob_stores.add(local_lfs_store.clone());
                 datastore.add(local_lfs_store.clone());
 

eden/scm/lib/revisionstore/src/scmstore/builder.rs

@@ -139,13 +139,9 @@ impl<'a> FileScmStoreBuilder<'a> {
         )?))
     }
 
-    /// Return an Arc<IndexedLogHgIdDataStore> for another datastore to use and use this
+    pub fn shared_indexedlog(mut self, shared_indexedlog: Arc<IndexedLogHgIdDataStore>) -> Self {
-    /// same IndexedLog object internally, so that both datastores share the same in-memory
+        self.shared_indexedlog = Some(shared_indexedlog);
-    /// cache and will immediately see each other's writes reflected.
+        self
-    pub fn build_shared_indexedlog(&mut self) -> Result<Arc<IndexedLogHgIdDataStore>> {
-        let indexedlog = self.build_indexedlog()?;
-        self.shared_indexedlog = Some(indexedlog.clone());
-        Ok(indexedlog)
     }
 
     pub fn build(self) -> Result<BoxedReadStore<Key, StoreFile>> {
@@ -275,13 +271,9 @@ impl<'a> TreeScmStoreBuilder<'a> {
         )?))
     }
 
-    /// Return an Arc<IndexedLogHgIdDataStore> for another datastore to use and use this
+    pub fn shared_indexedlog(mut self, shared_indexedlog: Arc<IndexedLogHgIdDataStore>) -> Self {
-    /// same IndexedLog object internally, so that both datastores share the same in-memory
+        self.shared_indexedlog = Some(shared_indexedlog);
-    /// cache and will immediately see each other's writes reflected.
+        self
-    pub fn build_shared_indexedlog(&mut self) -> Result<Arc<IndexedLogHgIdDataStore>> {
-        let indexedlog = self.build_indexedlog()?;
-        self.shared_indexedlog = Some(indexedlog.clone());
-        Ok(indexedlog)
     }
 
     pub fn build(self) -> Result<BoxedReadStore<Key, StoreTree>> {

eden/scm/lib/revisionstore/src/scmstore/specialized/builder.rs

@@ -25,7 +25,7 @@ use crate::{
 pub struct FileStoreBuilder<'a> {
     config: &'a ConfigSet,
     local_path: Option<PathBuf>,
-    suffix: Option<&'a Path>,
+    suffix: Option<PathBuf>,
     correlator: Option<String>,
 
     indexedlog_local: Option<Arc<IndexedLogHgIdDataStore>>,
@@ -61,8 +61,8 @@ impl<'a> FileStoreBuilder<'a> {
         self
     }
 
-    pub fn suffix(mut self, suffix: &'a Path) -> Self {
+    pub fn suffix(mut self, suffix: impl AsRef<Path>) -> Self {
-        self.suffix = Some(suffix);
+        self.suffix = Some(suffix.as_ref().to_path_buf());
         self
     }
 
@@ -151,34 +151,50 @@ impl<'a> FileStoreBuilder<'a> {
         Ok(EdenApiFileStore::new(reponame, client, None))
     }
 
-    fn build_indexedlog_local(&self, path: PathBuf) -> Result<Arc<IndexedLogHgIdDataStore>> {
+    pub fn build_indexedlog_local(&self) -> Result<Option<Arc<IndexedLogHgIdDataStore>>> {
-        let local_path = get_local_path(path, &self.suffix)?;
+        Ok(if let Some(local_path) = self.local_path.clone() {
-        Ok(Arc::new(IndexedLogHgIdDataStore::new(
+            let local_path = get_local_path(local_path, &self.suffix)?;
-            get_indexedlogdatastore_path(&local_path)?,
+            Some(Arc::new(IndexedLogHgIdDataStore::new(
-            ExtStoredPolicy::Use,
+                get_indexedlogdatastore_path(&local_path)?,
-            self.config,
+                self.get_extstored_policy()?,
-            IndexedLogDataStoreType::Local,
+                self.config,
-        )?))
+                IndexedLogDataStoreType::Local,
+            )?))
+        } else {
+            None
+        })
     }
 
-    fn build_indexedlog_cache(&self) -> Result<Arc<IndexedLogHgIdDataStore>> {
+    pub fn build_indexedlog_cache(&self) -> Result<Arc<IndexedLogHgIdDataStore>> {
         let cache_path = get_cache_path(self.config, &self.suffix)?;
         Ok(Arc::new(IndexedLogHgIdDataStore::new(
             get_indexedlogdatastore_path(&cache_path)?,
-            ExtStoredPolicy::Use,
+            self.get_extstored_policy()?,
             self.config,
             IndexedLogDataStoreType::Shared,
         )?))
     }
 
-    fn build_lfs_local(&self, path: PathBuf) -> Result<Arc<LfsStore>> {
+    pub fn build_lfs_local(&self) -> Result<Option<Arc<LfsStore>>> {
-        let local_path = get_local_path(path, &self.suffix)?;
+        if !self.use_lfs()? {
-        Ok(Arc::new(LfsStore::local(&local_path, self.config)?))
+            return Ok(None);
+        }
+
+        Ok(if let Some(local_path) = self.local_path.clone() {
+            let local_path = get_local_path(local_path, &self.suffix)?;
+            Some(Arc::new(LfsStore::local(&local_path, self.config)?))
+        } else {
+            None
+        })
     }
 
-    fn build_lfs_cache(&self) -> Result<Arc<LfsStore>> {
+    pub fn build_lfs_cache(&self) -> Result<Option<Arc<LfsStore>>> {
+        if !self.use_lfs()? {
+            return Ok(None);
+        }
+
         let cache_path = get_cache_path(self.config, &self.suffix)?;
-        Ok(Arc::new(LfsStore::shared(&cache_path, self.config)?))
+        Ok(Some(Arc::new(LfsStore::shared(&cache_path, self.config)?)))
     }
 
     pub fn build(mut self) -> Result<FileStore> {
@@ -190,14 +206,10 @@ impl<'a> FileStoreBuilder<'a> {
         let extstored_policy = self.get_extstored_policy()?;
         let lfs_threshold_bytes = self.get_lfs_threshold()?.map(|b| b.value());
 
-        let indexedlog_local = if let Some(local_path) = self.local_path.clone() {
+        let indexedlog_local = if let Some(indexedlog_local) = self.indexedlog_local.take() {
-            if let Some(indexedlog_local) = self.indexedlog_local.take() {
+            Some(indexedlog_local)
-                Some(indexedlog_local)
-            } else {
-                Some(self.build_indexedlog_local(local_path)?)
-            }
         } else {
-            None
+            self.build_indexedlog_local()?
         };
 
         let indexedlog_cache = if let Some(indexedlog_cache) = self.indexedlog_cache.take() {
@@ -206,28 +218,16 @@ impl<'a> FileStoreBuilder<'a> {
             Some(self.build_indexedlog_cache()?)
         };
 
-        let lfs_local = if self.use_lfs()? {
+        let lfs_local = if let Some(lfs_local) = self.lfs_local.take() {
-            if let Some(local_path) = self.local_path.clone() {
+            Some(lfs_local)
-                if let Some(lfs_local) = self.lfs_local.take() {
-                    Some(lfs_local)
-                } else {
-                    Some(self.build_lfs_local(local_path)?)
-                }
-            } else {
-                None
-            }
         } else {
-            None
+            self.build_lfs_local()?
         };
 
-        let lfs_cache = if self.use_lfs()? {
+        let lfs_cache = if let Some(lfs_cache) = self.lfs_cache.take() {
-            if let Some(lfs_cache) = self.lfs_cache.take() {
+            Some(lfs_cache)
-                Some(lfs_cache)
-            } else {
-                Some(self.build_lfs_cache()?)
-            }
         } else {
-            None
+            self.build_lfs_cache()?
         };
 
         let lfs_remote = if self.use_lfs()? {
@@ -285,7 +285,7 @@ impl<'a> FileStoreBuilder<'a> {
 pub struct TreeStoreBuilder<'a> {
     config: &'a ConfigSet,
     local_path: Option<PathBuf>,
-    suffix: Option<&'a Path>,
+    suffix: Option<PathBuf>,
 
     indexedlog_local: Option<Arc<IndexedLogHgIdDataStore>>,
     indexedlog_cache: Option<Arc<IndexedLogHgIdDataStore>>,
@@ -318,8 +318,8 @@ impl<'a> TreeStoreBuilder<'a> {
     // caller pass in, or is it just hardcoded elsewhere and we should hardcode it here?
     /// Cache path suffix for the associated indexedlog. For files, this will not be given.
     /// For trees, it will be "manifests".
-    pub fn suffix(mut self, suffix: &'a Path) -> Self {
+    pub fn suffix(mut self, suffix: impl AsRef<Path>) -> Self {
-        self.suffix = Some(suffix);
+        self.suffix = Some(suffix.as_ref().to_path_buf());
         self
     }
 
@@ -359,17 +359,21 @@ impl<'a> TreeStoreBuilder<'a> {
         Ok(EdenApiTreeStore::new(reponame, client, None))
     }
 
-    fn build_indexedlog_local(&self, path: PathBuf) -> Result<Arc<IndexedLogHgIdDataStore>> {
+    pub fn build_indexedlog_local(&self) -> Result<Option<Arc<IndexedLogHgIdDataStore>>> {
-        let local_path = get_local_path(path, &self.suffix)?;
+        Ok(if let Some(local_path) = self.local_path.clone() {
-        Ok(Arc::new(IndexedLogHgIdDataStore::new(
+            let local_path = get_local_path(local_path, &self.suffix)?;
-            get_indexedlogdatastore_path(&local_path)?,
+            Some(Arc::new(IndexedLogHgIdDataStore::new(
-            ExtStoredPolicy::Use,
+                get_indexedlogdatastore_path(&local_path)?,
-            self.config,
+                ExtStoredPolicy::Use,
-            IndexedLogDataStoreType::Local,
+                self.config,
-        )?))
+                IndexedLogDataStoreType::Local,
+            )?))
+        } else {
+            None
+        })
     }
 
-    fn build_indexedlog_cache(&self) -> Result<Arc<IndexedLogHgIdDataStore>> {
+    pub fn build_indexedlog_cache(&self) -> Result<Arc<IndexedLogHgIdDataStore>> {
         let cache_path = get_cache_path(self.config, &self.suffix)?;
         Ok(Arc::new(IndexedLogHgIdDataStore::new(
             get_indexedlogdatastore_path(&cache_path)?,
@@ -387,14 +391,10 @@ impl<'a> TreeStoreBuilder<'a> {
             check_cache_buster(&self.config, &cache_path);
         }
 
-        let indexedlog_local = if let Some(local_path) = self.local_path.take() {
+        let indexedlog_local = if let Some(indexedlog_local) = self.indexedlog_local.take() {
-            if let Some(indexedlog_local) = self.indexedlog_local.take() {
+            Some(indexedlog_local)
-                Some(indexedlog_local)
-            } else {
-                Some(self.build_indexedlog_local(local_path)?)
-            }
         } else {
-            None
+            self.build_indexedlog_local()?
         };
 
         let indexedlog_cache = if let Some(indexedlog_cache) = self.indexedlog_cache.take() {