quilt-rs 0.4.2

Rust library for accessing Quilt data packages.
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

//!
//! The Quilt4 Client maintains all the persistent state across invocations,
//! and is the main entry point for the API.
//! 
//! It's responsible for:
//! - authentication
//! - abstracting away the various data stores
//! - converting URIs into different resources
//! 
//! Initially, it also wraps Project 4F's local domain to support quilt-server.

use std::collections::HashMap;
use std::convert::TryFrom;
use serde::{Deserialize, Serialize};
use aws_sdk_s3::Error;
use aws_sdk_s3::Client as S3Client;
use aws_types::region::Region;

use crate::api::LocalDomain;
use crate::api::Manifest;
use crate::api::S3PackageURI;
use crate::api::browse_remote_package;

use super::{
    domain::Domain, namespace::Namespace, manifest::Manifest4, entry::Entry4
};
use aptos_openapi_link::impl_poem_type;
impl_poem_type!(Client, "object", ());

#[derive(Clone, Debug, Deserialize, Serialize)]
pub struct Client {
    #[serde(skip)]
    _s3_clients: HashMap<Region, S3Client>,
}

impl Client {

    pub fn domain3() -> LocalDomain {
        let cwd = std::env::current_dir().unwrap();
        LocalDomain::new(cwd)
    }

    pub async fn new() -> Self {
        Client {
            _s3_clients: HashMap::new(),
        }
    }


    pub fn to_string(&self) -> String {
        format!("Client({})", std::env::current_dir().unwrap().to_string_lossy())
    }        

    pub async fn manifest3_from_uri(&self, uri_string: String) -> Result<Manifest, Error> {
        let uri = S3PackageURI::try_from(uri_string.as_str()).expect("Failed to parse URI");
        let local = Client::domain3().into();
        let manifest: Manifest = browse_remote_package(local, uri)
            .await
            .expect("Failed to browse remote package");
        println!("manifest: {:#?}", manifest);
        Ok(manifest)
    }

    pub async fn domain_from_key(_registry_uri: &str) -> Option<Domain> {
        // Implementation goes here
        unimplemented!()
    }

    pub async fn domain_keys(&self) -> Vec<String> {
        // Implementation goes here
        unimplemented!()
    }

    pub async fn domain_objects(&self) -> Vec<Domain> {
        // Implementation goes here
        unimplemented!()
    }

    pub async fn domain_from_uri(_uri: &str) -> Option<Domain> {
        // Implementation goes here
        unimplemented!()
    }

    pub async fn namespace_from_uri(_uri: &str) -> Option<Namespace> {
        // Implementation goes here
        unimplemented!()
    }

    pub async fn manifest_from_uri(_uri: &str) -> Option<Manifest4> {
        // Implementation goes here
        unimplemented!()
    }

    pub async fn entry_from_uri(_uri: &str) -> Option<Entry4> {
        // Implementation goes here
        unimplemented!()
    }
}

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

    #[tokio::test]
    async fn test_client_new() {
        assert!(Client::new().await.to_string().contains("Client"));
    }
}