avl-storage 0.1.0

AVL Storage - S3-compatible object storage optimized for Brazil and LATAM
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

//! Storage client implementation

use crate::{Error, GetObjectResponse, ObjectInfo, PutObjectRequest, PutObjectResponse, Result};

/// AVL Storage client
#[derive(Debug, Clone)]
pub struct StorageClient {
    endpoint: String,
    // Internal HTTP client would go here
}

impl StorageClient {
    /// Connect to AVL Storage
    pub async fn connect(endpoint: &str) -> Result<Self> {
        Ok(Self {
            endpoint: endpoint.to_string(),
        })
    }

    /// Create a bucket
    pub async fn create_bucket(&self, bucket: &str) -> Result<()> {
        // TODO: Validate bucket name
        // TODO: Send CREATE BUCKET request
        Ok(())
    }

    /// List buckets
    pub async fn list_buckets(&self) -> Result<Vec<String>> {
        // TODO: Send LIST BUCKETS request
        Ok(vec![])
    }

    /// Delete a bucket
    pub async fn delete_bucket(&self, bucket: &str) -> Result<()> {
        // TODO: Send DELETE BUCKET request
        Ok(())
    }

    /// Upload an object
    ///
    /// # Example
    ///
    /// ```no_run
    /// # use avl_storage::{StorageClient, PutObjectRequest};
    /// # async fn example(client: StorageClient) -> avl_storage::Result<()> {
    /// client.put_object(PutObjectRequest {
    ///     bucket: "my-bucket".to_string(),
    ///     key: "file.txt".to_string(),
    ///     body: b"Hello!".to_vec(),
    ///     content_type: Some("text/plain".to_string()),
    ///     ..Default::default()
    /// }).await?;
    /// # Ok(())
    /// # }
    /// ```
    pub async fn put_object(&self, req: PutObjectRequest) -> Result<PutObjectResponse> {
        // TODO: Validate bucket and key
        // TODO: Compress with avila-compress
        // TODO: Send PUT request
        // TODO: Calculate ETag

        Ok(PutObjectResponse {
            etag: "dummy-etag".to_string(),
            version_id: None,
        })
    }

    /// Download an object
    pub async fn get_object(&self, bucket: &str, key: &str) -> Result<GetObjectResponse> {
        // TODO: Send GET request
        // TODO: Decompress with avila-compress

        Err(Error::ObjectNotFound {
            bucket: bucket.to_string(),
            key: key.to_string(),
        })
    }

    /// List objects in a bucket
    pub async fn list_objects(
        &self,
        bucket: &str,
        prefix: Option<&str>,
    ) -> Result<Vec<ObjectInfo>> {
        // TODO: Send LIST OBJECTS request
        Ok(vec![])
    }

    /// Delete an object
    pub async fn delete_object(&self, bucket: &str, key: &str) -> Result<()> {
        // TODO: Send DELETE request
        Ok(())
    }

    /// Copy an object
    pub async fn copy_object(
        &self,
        source_bucket: &str,
        source_key: &str,
        dest_bucket: &str,
        dest_key: &str,
    ) -> Result<()> {
        // TODO: Send COPY request
        Ok(())
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[tokio::test]
    async fn test_client_connect() {
        let client = StorageClient::connect("https://storage.avila.cloud").await;
        assert!(client.is_ok());
    }
}