1 files changed, 24 insertions, 23 deletions

diff --git a/src/suite.rs b/src/suite.rs
index 90ecf37..e900330 100644
--- a/src/suite.rs
+++ b/src/suite.rs
@@ -1,6 +1,6 @@
+use crate::client::{ObnamClient, ObnamClientError};
 use crate::daemon::DaemonManager;
 use crate::junk::junk;
-use crate::obnam::{Obnam, ObnamError};
 use crate::result::{Measurement, OpMeasurements, Operation};
 use crate::server::{ObnamServer, ObnamServerError};
 use crate::specification::{Create, FileCount};
@@ -9,6 +9,7 @@ use log::{debug, info};
 use std::fs::File;
 use std::path::{Path, PathBuf};
 use std::time::Instant;
+use tempfile::{tempdir, TempDir};
 use walkdir::WalkDir;
 
 /// A running benchmark suite.
@@ -39,9 +40,9 @@ pub enum SuiteError {
     #[error("Error looking up file metadata: {0}: {1}")]
     FileMeta(PathBuf, walkdir::Error),
 
-    /// Error managing an Obnam system.
+    /// Error using an Obnam client.
     #[error(transparent)]
-    Obnam(#[from] ObnamError),
+    Client(#[from] ObnamClientError),
 
     /// Error managing an Obnam server.
     #[error(transparent)]
@@ -60,8 +61,8 @@ impl Suite {
     ///
     /// Return a measurement of the step.
     pub fn execute(&mut self, step: &Step) -> Result<OpMeasurements, SuiteError> {
-        debug!("executing step {:?}", step);
         let time = Instant::now();
+        eprintln!("step: {:?}", step);
         let mut om = match step {
             Step::Start(name) => {
                 assert!(self.benchmark.is_none());
@@ -111,19 +112,21 @@ impl Suite {
 
 struct Benchmark {
     name: String,
-    // We store an Obnam in an Option so that we can destroy the
-    // Obnam, and thereby delete any temporary files. We want to do
-    // that intentionally, so that it can be measured.
-    obnam: Option<Obnam>,
-    server: Option<ObnamServer>,
+    client: ObnamClient,
+    server: ObnamServer,
+    live: TempDir,
 }
 
 impl Benchmark {
     fn new(name: &str, manager: &DaemonManager) -> Result<Self, SuiteError> {
+        let server = ObnamServer::new(manager)?;
+        let live = tempdir().map_err(SuiteError::TempDir)?;
+        let client = ObnamClient::new(server.url(), live.path().to_path_buf())?;
         Ok(Self {
             name: name.to_string(),
-            obnam: Some(Obnam::new()?),
-            server: Some(ObnamServer::new(manager)?),
+            client,
+            server,
+            live,
         })
     }
 
@@ -131,29 +134,27 @@ impl Benchmark {
         &self.name
     }
 
-    fn obnam(&mut self) -> &mut Obnam {
-        self.obnam.as_mut().unwrap()
+    fn live(&self) -> PathBuf {
+        self.live.path().to_path_buf()
     }
 
     fn start(&mut self) -> Result<OpMeasurements, SuiteError> {
         info!("starting benchmark {}", self.name());
-        self.obnam().start_server()?;
+        self.client
+            .run(&["init", "--insecure-passphrase=hunter2"])?;
         Ok(OpMeasurements::new(self.name(), Operation::Start))
     }
 
     fn stop(&mut self) -> Result<OpMeasurements, SuiteError> {
         info!("ending benchmark {}", self.name);
-        self.obnam().stop_server()?;
-        self.obnam.take().unwrap(); // This destroys the Obnam
-        self.server.as_mut().unwrap().stop();
+        self.server.stop();
         Ok(OpMeasurements::new(self.name(), Operation::Stop))
     }
 
     fn create(&mut self, create: &Create) -> Result<OpMeasurements, SuiteError> {
-        info!("creating {} test data files", create.files);
-        let root = self.obnam().root();
-        debug!(
-            "creating {} files of {} bytes in {}",
+        let root = self.live();
+        info!(
+            "creating {} files of {} bytes each in {}",
             create.files,
             create.file_size,
             root.display()
@@ -161,7 +162,6 @@ impl Benchmark {
 
         for i in 0..create.files {
             let filename = root.join(format!("{}", i));
-            debug!("creating {}", filename.display());
             let mut f =
                 File::create(&filename).map_err(|err| SuiteError::CreateFile(filename, err))?;
             junk(&mut f, create.file_size)?;
@@ -182,8 +182,9 @@ impl Benchmark {
 
     fn backup(&mut self, n: usize) -> Result<OpMeasurements, SuiteError> {
         info!("making backup {} in benchmark {}", n, self.name());
+        self.client.run(&["backup"])?;
         let mut om = OpMeasurements::new(self.name(), Operation::Backup);
-        let stats = filestats(self.obnam().root())?;
+        let stats = filestats(&self.live())?;
         om.push(Measurement::TotalFiles(stats.count));
         om.push(Measurement::TotalData(stats.size));
         Ok(om)