Add a delete_all command to the API client.

service/kbupd_api/src/entities.rs

@@ -102,10 +102,6 @@ pub struct KeyBackupResponse {
     pub mac: [u8; 16],
 }
 
-#[derive(Deserialize, Serialize, Clone, Debug, Eq, PartialEq)]
-pub struct DeleteBackupsRequest {
-}
-
 //
 // BackupId impls
 //

service/kbupd_api_client/src/lib.rs

@@ -68,6 +68,25 @@ impl KeyBackupApiClient {
         response.into()
     }
 
+    pub fn delete_backups(
+        &self,
+        credentials: &KeyBackupApiCredentials
+    ) -> impl Future<Item = (), Error = failure::Error> + Send + 'static
+    {
+        let mut uri_parts = self.base_uri.clone().into_parts();
+        let uri_path_and_query = try_future!(
+                "/v1/backup"
+                .parse::<http::uri::PathAndQuery>()
+                .context("error creating request path")
+        );
+        uri_parts.path_and_query = Some(uri_path_and_query);
+        let uri = try_future!(Uri::from_parts(uri_parts).context("error creating request uri"));
+        let response_with_parts = self.delete_request(uri, credentials);
+        let response = response_with_parts.map(|(_parts, response)| response);
+
+        response.into()
+    }
+
     pub fn backup_request(
         &self,
         credentials: &KeyBackupApiCredentials,
@@ -211,6 +230,25 @@ impl KeyBackupApiClient {
         decoded_response
     }
 
+    fn delete_request<ResponseTy>(
+        &self,
+        uri: Uri,
+        credentials: &KeyBackupApiCredentials,
+    ) -> impl Future<Item = (response::Parts, ResponseTy), Error = failure::Error> + Send + 'static
+        where
+            ResponseTy: for<'de> Deserialize<'de> + Send + 'static,
+    {
+        let mut hyper_request = Request::new(Body::empty());
+
+        *hyper_request.method_mut() = Method::DELETE;
+        *hyper_request.uri_mut() = uri;
+        hyper_request.headers_mut().insert("Authorization", credentials.into());
+
+        let response = self.client.request(hyper_request).map_err(failure::Error::from);
+        let decoded_response = response.and_then(Self::decode_response);
+        decoded_response
+    }
+
     fn put_request<RequestTy, ResponseTy>(
         &self,
         uri: Uri,

service/kbupd_api_client/src/main.rs

@@ -22,6 +22,7 @@ use kbupd_api::entities::*;
 use kbupd_api_client::*;
 use log::debug;
 use rand::RngCore;
+use tokio::prelude::future::Loop;
 
 fn main() -> Result<(), failure::Error> {
     let arguments = parse_arguments();
@@ -120,6 +121,36 @@ fn main() -> Result<(), failure::Error> {
 
             runtime.block_on(responses)?;
         }
+        "delete_all" => {
+            let request_count =
+                u64::from_str(arguments.value_of("request_count").unwrap_or_default()).context("invalid --request-count")?;
+            let max_parallel = u64::from_str(arguments.value_of("max_parallel").unwrap_or("1")).context("invalid --max-parallel")?;
+            let username = username.unwrap_or_else(rand_username);
+            let credentials = calculate_credentials(username, password, &token_secret);
+
+            let parallel_count = max_parallel.min(request_count);
+            let requested = Arc::new(AtomicU64::new(0));
+
+            let request_loop = move |()| {
+                if requested.fetch_add(1, atomic::Ordering::SeqCst) + 1 > request_count {
+                    return future::Either::A(Ok(future::Loop::Break(())).into_future());
+                }
+
+                let response = client
+                    .delete_backups(&credentials)
+                    .map_err(|error| error.context("error during delete request").into())
+                    .and_then(|_| -> Result<Loop<_, ()>, failure::Error> {
+                        debug!("server response: ok");
+                        Ok(future::Loop::Continue(()))
+                    });
+
+                future::Either::B(response)
+            };
+            let futures = (0..parallel_count).map(move |_| future::loop_fn((), request_loop.clone()));
+            let responses = futures::stream::futures_unordered(futures).for_each(|_response: ()| Ok(()));
+
+            runtime.block_on(responses)?;
+        }
         "backup" | "restore" => {
             let enclave_name = leak_argument(subcommand_arguments.value_of("enclave_name").unwrap_or_default());
             let service_id = leak_argument(
@@ -400,6 +431,9 @@ fn parse_arguments() -> clap::ArgMatches<'static> {
         .arg(backup_id_argument.clone())
         .about("Key Backup Service HTTP API Client - Delete");
 
+    let delete_all_subcommand = clap::SubCommand::with_name("delete_all")
+        .about("Key Backup Service HTTP API Client - Delete all for user");
+
     let service_id_argument = clap::Arg::with_name("service_id")
         .takes_value(true)
         .long("service-id")
@@ -509,6 +543,7 @@ fn parse_arguments() -> clap::ArgMatches<'static> {
         .arg(max_parallel_argument)
         .arg(debug_argument)
         .subcommand(delete_subcommand)
+        .subcommand(delete_all_subcommand)
         .subcommand(backup_subcommand)
         .subcommand(restore_subcommand)
         .get_matches()