copyrite 0.4.0

A CLI tool for efficient checksum and copy operations across object stores
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118

//! File-based sums file logic.
//!

use crate::checksum::file::SumsFile;
use crate::error::Error::ParseError;
use crate::error::{ApiError, Result};
use crate::io::sums::ObjectSums;
use std::collections::HashSet;
use std::path::PathBuf;
use tokio::fs;
use tokio::io::{AsyncRead, AsyncReadExt};

/// Build a file based sums object.
#[derive(Debug, Default)]
pub struct FileBuilder {
    file: Option<String>,
}

impl FileBuilder {
    /// Set the file location.
    pub fn with_file(mut self, file: String) -> Self {
        self.file = Some(file);
        self
    }

    fn get_components(self) -> Result<String> {
        self.file
            .ok_or_else(|| ParseError("file is required for `FileBuilder`".to_string()))
    }

    /// Build using the file name.
    pub fn build(self) -> Result<File> {
        Ok(self.get_components()?.into())
    }
}

impl From<String> for File {
    fn from(file: String) -> Self {
        Self::new(file)
    }
}

/// A file object.
#[derive(Debug, Clone)]
pub struct File {
    file: String,
}

impl File {
    /// Create a new file.
    pub fn new(file: String) -> Self {
        Self { file }
    }

    /// Get an existing sums file.
    pub async fn get_existing_sums(&self) -> Result<Option<SumsFile>> {
        let path = SumsFile::format_sums_file(&self.file);

        if !PathBuf::from(&path).exists() {
            return Ok(None);
        }

        let mut file = fs::File::open(&path).await?;
        let mut buf = vec![];
        file.read_to_end(&mut buf).await?;

        let sums = SumsFile::read_from_slice(&buf).await?;
        Ok(Some(sums))
    }

    /// Get the reader to the sums file.
    pub async fn sums_reader(&self) -> Result<impl AsyncRead + 'static> {
        let path = SumsFile::format_target_file(&self.file);
        Ok(fs::File::open(&path).await?)
    }

    /// Get the size of the target file.
    pub async fn size(&self) -> Result<Option<u64>> {
        Ok(fs::metadata(SumsFile::format_target_file(&self.file))
            .await
            .ok()
            .map(|metadata| metadata.len()))
    }

    /// Write the sums file to the configured location.
    pub async fn write_sums(&self, sums_file: &SumsFile) -> Result<()> {
        let path = SumsFile::format_sums_file(&self.file);
        fs::write(&path, sums_file.to_json_string()?).await?;
        Ok(())
    }
}

#[async_trait::async_trait]
impl ObjectSums for File {
    async fn sums_file(&mut self) -> Result<Option<SumsFile>> {
        Ok(self.get_existing_sums().await?)
    }

    async fn reader(&mut self) -> Result<Box<dyn AsyncRead + Unpin + Send + 'static>> {
        Ok(Box::new(self.sums_reader().await?))
    }

    async fn file_size(&mut self) -> Result<Option<u64>> {
        self.size().await
    }

    async fn write_sums_file(&self, sums_file: &SumsFile) -> Result<()> {
        self.write_sums(sums_file).await
    }

    fn location(&self) -> String {
        self.file.to_string()
    }

    fn api_errors(&self) -> HashSet<ApiError> {
        HashSet::new()
    }
}