mirror of https://github.com/zkat/cacache-rs.git
285 lines
8.1 KiB
Rust
285 lines
8.1 KiB
Rust
//! Functions for removing things from the cache.
|
|
use std::fs;
|
|
use std::path::Path;
|
|
|
|
use async_std::fs as afs;
|
|
|
|
use ssri::Integrity;
|
|
|
|
use crate::content::rm;
|
|
use crate::errors::Error;
|
|
use crate::index;
|
|
|
|
/// Removes an individual index entry. The associated content will be left
|
|
/// intact.
|
|
///
|
|
/// ## Example
|
|
/// ```no_run
|
|
/// # use async_std::prelude::*;
|
|
/// # use async_std::task;
|
|
/// # fn main() -> Result<(), cacache::Error> {
|
|
/// # task::block_on(async {
|
|
/// # example().await.unwrap();
|
|
/// # });
|
|
/// # Ok(())
|
|
/// # }
|
|
/// #
|
|
/// # async fn example() -> Result<(), cacache::Error> {
|
|
/// let sri = cacache::put::data("./my-cache", "my-key", b"hello").await?;
|
|
///
|
|
/// cacache::rm::entry("./my-cache", "my-key").await?;
|
|
///
|
|
/// // This fails:
|
|
/// cacache::get::data("./my-cache", "my-key").await?;
|
|
///
|
|
/// // But this succeeds:
|
|
/// cacache::get::data_hash("./my-cache", &sri).await?;
|
|
/// # Ok(())
|
|
/// # }
|
|
/// ```
|
|
pub async fn entry<P: AsRef<Path>>(cache: P, key: &str) -> Result<(), Error> {
|
|
index::delete_async(cache.as_ref(), &key).await
|
|
}
|
|
|
|
/// Removes an individual content entry. Any index entries pointing to this
|
|
/// content will become invalidated.
|
|
///
|
|
/// ## Example
|
|
/// ```no_run
|
|
/// # use async_std::prelude::*;
|
|
/// # use async_std::task;
|
|
/// # fn main() -> Result<(), cacache::Error> {
|
|
/// # task::block_on(async {
|
|
/// # example().await.unwrap();
|
|
/// # });
|
|
/// # Ok(())
|
|
/// # }
|
|
/// #
|
|
/// # async fn example() -> Result<(), cacache::Error> {
|
|
/// let sri = cacache::put::data("./my-cache", "my-key", b"hello").await?;
|
|
///
|
|
/// cacache::rm::entry("./my-cache", "my-key").await?;
|
|
///
|
|
/// // These fail:
|
|
/// cacache::get::data("./my-cache", "my-key").await?;
|
|
/// cacache::get::data_hash("./my-cache", &sri).await?;
|
|
///
|
|
/// // But this succeeds:
|
|
/// cacache::get::entry("./my-cache", "my-key").await?;
|
|
/// # Ok(())
|
|
/// # }
|
|
/// ```
|
|
pub async fn content<P: AsRef<Path>>(cache: P, sri: &Integrity) -> Result<(), Error> {
|
|
rm::rm_async(cache.as_ref(), &sri).await
|
|
}
|
|
|
|
/// Removes entire contents of the cache, including temporary files, the entry
|
|
/// index, and all content data.
|
|
///
|
|
/// ## Example
|
|
/// ```no_run
|
|
/// # use async_std::prelude::*;
|
|
/// # use async_std::task;
|
|
/// # fn main() -> Result<(), cacache::Error> {
|
|
/// # task::block_on(async {
|
|
/// # example().await.unwrap();
|
|
/// # });
|
|
/// # Ok(())
|
|
/// # }
|
|
/// #
|
|
/// # async fn example() -> Result<(), cacache::Error> {
|
|
/// let sri = cacache::put::data("./my-cache", "my-key", b"hello").await?;
|
|
///
|
|
/// cacache::rm::entry("./my-cache", "my-key").await?;
|
|
///
|
|
/// // These all fail:
|
|
/// cacache::get::data("./my-cache", "my-key").await?;
|
|
/// cacache::get::entry("./my-cache", "my-key").await?;
|
|
/// cacache::get::data_hash("./my-cache", &sri).await?;
|
|
/// # Ok(())
|
|
/// # }
|
|
/// ```
|
|
pub async fn all<P: AsRef<Path>>(cache: P) -> Result<(), Error> {
|
|
for entry in cache.as_ref().read_dir()? {
|
|
if let Ok(entry) = entry {
|
|
afs::remove_dir_all(entry.path()).await?;
|
|
}
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
/// Removes an individual index entry synchronously. The associated content
|
|
/// will be left intact.
|
|
///
|
|
/// ## Example
|
|
/// ```no_run
|
|
/// # fn main() -> Result<(), cacache::Error> {
|
|
/// # use std::io::Read;
|
|
/// let sri = cacache::put::data_sync("./my-cache", "my-key", b"hello")?;
|
|
///
|
|
/// cacache::rm::entry_sync("./my-cache", "my-key")?;
|
|
///
|
|
/// // This fails:
|
|
/// cacache::get::data_sync("./my-cache", "my-key")?;
|
|
///
|
|
/// // But this succeeds:
|
|
/// cacache::get::data_hash_sync("./my-cache", &sri)?;
|
|
/// # Ok(())
|
|
/// # }
|
|
/// ```
|
|
pub fn entry_sync<P: AsRef<Path>>(cache: P, key: &str) -> Result<(), Error> {
|
|
index::delete(cache.as_ref(), &key)
|
|
}
|
|
|
|
/// Removes an individual content entry synchronously. Any index entries
|
|
/// pointing to this content will become invalidated.
|
|
///
|
|
/// ## Example
|
|
/// ```no_run
|
|
/// # fn main() -> Result<(), cacache::Error> {
|
|
/// # use std::io::Read;
|
|
/// let sri = cacache::put::data_sync("./my-cache", "my-key", b"hello")?;
|
|
///
|
|
/// cacache::rm::entry_sync("./my-cache", "my-key")?;
|
|
///
|
|
/// // These fail:
|
|
/// cacache::get::data_sync("./my-cache", "my-key")?;
|
|
/// cacache::get::data_hash_sync("./my-cache", &sri)?;
|
|
///
|
|
/// // But this succeeds:
|
|
/// cacache::get::entry_sync("./my-cache", "my-key")?;
|
|
/// # Ok(())
|
|
/// # }
|
|
/// ```
|
|
pub fn content_sync<P: AsRef<Path>>(cache: P, sri: &Integrity) -> Result<(), Error> {
|
|
rm::rm(cache.as_ref(), &sri)
|
|
}
|
|
|
|
/// Removes entire contents of the cache synchronously, including temporary
|
|
/// files, the entry index, and all content data.
|
|
///
|
|
/// ## Example
|
|
/// ```no_run
|
|
/// # fn main() -> Result<(), cacache::Error> {
|
|
/// # use std::io::Read;
|
|
/// let sri = cacache::put::data_sync("./my-cache", "my-key", b"hello")?;
|
|
///
|
|
/// cacache::rm::entry_sync("./my-cache", "my-key")?;
|
|
///
|
|
/// // These all fail:
|
|
/// cacache::get::data_sync("./my-cache", "my-key")?;
|
|
/// cacache::get::data_hash_sync("./my-cache", &sri)?;
|
|
/// cacache::get::entry_sync("./my-cache", "my-key")?;
|
|
/// # Ok(())
|
|
/// # }
|
|
/// ```
|
|
pub fn all_sync<P: AsRef<Path>>(cache: P) -> Result<(), Error> {
|
|
for entry in cache.as_ref().read_dir()? {
|
|
if let Ok(entry) = entry {
|
|
fs::remove_dir_all(entry.path())?;
|
|
}
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use async_std::task;
|
|
|
|
#[test]
|
|
fn entry() {
|
|
task::block_on(async {
|
|
let tmp = tempfile::tempdir().unwrap();
|
|
let dir = tmp.path().to_owned();
|
|
let sri = crate::put::data(&dir, "key", b"my-data").await.unwrap();
|
|
|
|
crate::rm::entry(&dir, "key").await.unwrap();
|
|
|
|
let entry = crate::get::entry(&dir, "key").await.unwrap();
|
|
assert_eq!(entry, None);
|
|
|
|
let data_exists = crate::get::hash_exists(&dir, &sri).await;
|
|
assert_eq!(data_exists, true);
|
|
});
|
|
}
|
|
|
|
#[test]
|
|
fn content() {
|
|
task::block_on(async {
|
|
let tmp = tempfile::tempdir().unwrap();
|
|
let dir = tmp.path().to_owned();
|
|
let sri = crate::put::data(&dir, "key", b"my-data").await.unwrap();
|
|
|
|
crate::rm::content(&dir, &sri).await.unwrap();
|
|
|
|
let entry = crate::get::entry(&dir, "key").await.unwrap();
|
|
assert_eq!(entry.is_some(), true);
|
|
|
|
let data_exists = crate::get::hash_exists(&dir, &sri).await;
|
|
assert_eq!(data_exists, false);
|
|
});
|
|
}
|
|
|
|
#[test]
|
|
fn all() {
|
|
task::block_on(async {
|
|
let tmp = tempfile::tempdir().unwrap();
|
|
let dir = tmp.path().to_owned();
|
|
let sri = crate::put::data(&dir, "key", b"my-data").await.unwrap();
|
|
|
|
crate::rm::all(&dir).await.unwrap();
|
|
|
|
let entry = crate::get::entry(&dir, "key").await.unwrap();
|
|
assert_eq!(entry.is_some(), false);
|
|
|
|
let data_exists = crate::get::hash_exists(&dir, &sri).await;
|
|
assert_eq!(data_exists, false);
|
|
});
|
|
}
|
|
|
|
#[test]
|
|
fn entry_sync() {
|
|
let tmp = tempfile::tempdir().unwrap();
|
|
let dir = tmp.path().to_owned();
|
|
let sri = crate::put::data_sync(&dir, "key", b"my-data").unwrap();
|
|
|
|
crate::rm::entry_sync(&dir, "key").unwrap();
|
|
|
|
let new_entry = crate::get::entry_sync(&dir, "key").unwrap();
|
|
assert_eq!(new_entry, None);
|
|
|
|
let data_exists = crate::get::hash_exists_sync(&dir, &sri);
|
|
assert_eq!(data_exists, true);
|
|
}
|
|
|
|
#[test]
|
|
fn content_sync() {
|
|
let tmp = tempfile::tempdir().unwrap();
|
|
let dir = tmp.path().to_owned();
|
|
let sri = crate::put::data_sync(&dir, "key", b"my-data").unwrap();
|
|
|
|
crate::rm::content_sync(&dir, &sri).unwrap();
|
|
|
|
let new_entry = crate::get::entry_sync(&dir, "key").unwrap();
|
|
assert_eq!(new_entry.is_some(), true);
|
|
|
|
let data_exists = crate::get::hash_exists_sync(&dir, &sri);
|
|
assert_eq!(data_exists, false);
|
|
}
|
|
|
|
#[test]
|
|
fn all_sync() {
|
|
let tmp = tempfile::tempdir().unwrap();
|
|
let dir = tmp.path().to_owned();
|
|
let sri = crate::put::data_sync(&dir, "key", b"my-data").unwrap();
|
|
|
|
crate::rm::all_sync(&dir).unwrap();
|
|
|
|
let new_entry = crate::get::entry_sync(&dir, "key").unwrap();
|
|
assert_eq!(new_entry, None);
|
|
|
|
let data_exists = crate::get::hash_exists_sync(&dir, &sri);
|
|
assert_eq!(data_exists, false);
|
|
}
|
|
}
|