1 files changed, 41 insertions, 1 deletions
diff --git a/src/suite.rs b/src/suite.rs
index b4e8abb..224238a 100644
--- a/src/suite.rs
+++ b/src/suite.rs
@@ -42,6 +42,10 @@ pub enum SuiteError {
     #[error("Error looking up file metadata: {0}: {1}")]
     FileMeta(PathBuf, walkdir::Error),
 
+    /// Error removing restored data.
+    #[error("Error removing temporary directory: {0}: {1}")]
+    RemoveRestored(PathBuf, std::io::Error),
+
     /// Error using an Obnam client.
     #[error(transparent)]
     Client(#[from] ObnamClientError),
@@ -148,6 +152,8 @@ struct Benchmark {
     client: ObnamClient,
     server: ObnamServer,
     live: TempDir,
+    restored: TempDir,
+    gen_ids: HashMap<usize, String>,
     manifests: HashMap<usize, String>,
 }
 
@@ -155,12 +161,15 @@ impl Benchmark {
     fn new(name: &str, manager: &DaemonManager) -> Result<Self, SuiteError> {
         let server = ObnamServer::new(manager)?;
         let live = tempdir().map_err(SuiteError::TempDir)?;
+        let restored = tempdir().map_err(SuiteError::TempDir)?;
         let client = ObnamClient::new(server.url(), live.path().to_path_buf())?;
         Ok(Self {
             name: name.to_string(),
             client,
             server,
             live,
+            restored,
+            gen_ids: HashMap::new(),
             manifests: HashMap::new(),
         })
     }
@@ -173,6 +182,10 @@ impl Benchmark {
         self.live.path().to_path_buf()
     }
 
+    fn restored(&self) -> PathBuf {
+        self.restored.path().join("restored")
+    }
+
     fn start(&mut self) -> Result<OpMeasurements, SuiteError> {
         info!("starting benchmark {}", self.name());
         self.client
@@ -218,6 +231,15 @@ impl Benchmark {
     fn backup(&mut self, n: usize) -> Result<OpMeasurements, SuiteError> {
         info!("making backup {} in benchmark {}", n, self.name());
         self.client.run(&["backup"])?;
+        let gen_id = self
+            .client
+            .run(&["resolve", "latest"])?
+            .strip_suffix('\n')
+            .or(Some(""))
+            .unwrap()
+            .to_string();
+        debug!("backed up generation {}", gen_id);
+        self.gen_ids.insert(n, gen_id);
         let mut om = OpMeasurements::new(self.name(), Operation::Backup);
         let stats = filestats(&self.live())?;
         om.push(Measurement::TotalFiles(stats.count));
@@ -227,6 +249,15 @@ impl Benchmark {
 
     fn restore(&mut self, n: usize) -> Result<OpMeasurements, SuiteError> {
         info!("restoring backup {} in benchmark {}", n, self.name());
+        debug!("first removing all data from restore directory");
+        let restored = self.restored();
+        if restored.exists() {
+            std::fs::remove_dir_all(&restored)
+                .map_err(|err| SuiteError::RemoveRestored(restored, err))?;
+        }
+        let gen_id = self.gen_ids.get(&n).unwrap();
+        let path = self.restored().display().to_string();
+        self.client.run(&["restore", gen_id, &path])?;
         Ok(OpMeasurements::new(self.name(), Operation::Restore))
     }
 
@@ -245,7 +276,16 @@ impl Benchmark {
         if self.manifests.contains_key(&id) {
             return Err(SuiteError::ManifestExists(id));
         }
-        self.manifests.insert(id, "dummy".to_string());
+        debug!("self.restored()={}", self.restored().display());
+        let restored = format!(
+            "{}{}",
+            self.restored().display(),
+            self.live.path().display()
+        );
+        let restored = Path::new(&restored);
+        debug!("restored directory is {}", restored.display());
+        let m = summain(restored).map_err(SuiteError::Summain)?;
+        self.manifests.insert(id, m);
         Ok(OpMeasurements::new(self.name(), Operation::ManifestLive))
     }