snix_castore/object_store/
aws.rs1use std::sync::{Arc, RwLock};
5use tonic::async_trait;
6
7#[derive(Debug)]
10struct AwsConfigCredentialProvider<T: aws_credential_types::provider::ProvideCredentials> {
11 inner: T,
12
13 credential: std::sync::RwLock<
15 Option<(
16 Arc<object_store::aws::AwsCredential>,
17 Option<std::time::SystemTime>,
18 )>,
19 >,
20}
21
22impl<T> AwsConfigCredentialProvider<T>
23where
24 T: aws_credential_types::provider::ProvideCredentials,
25{
26 pub fn new(aws_credential_provider: T) -> Self {
27 Self {
28 inner: aws_credential_provider,
29 credential: RwLock::new(None),
30 }
31 }
32
33 async fn get_new_creds(
34 &self,
35 ) -> object_store::Result<(
36 Arc<object_store::aws::AwsCredential>,
37 Option<std::time::SystemTime>,
38 )> {
39 let credentials =
40 self.inner
41 .provide_credentials()
42 .await
43 .map_err(|err| object_store::Error::Generic {
44 store: "S3",
45 source: Box::new(err),
46 })?;
47
48 let object_store_credentials = Arc::new(object_store::aws::AwsCredential {
49 key_id: credentials.access_key_id().to_owned(),
50 secret_key: credentials.secret_access_key().to_owned(),
51 token: credentials.session_token().map(|s| s.to_owned()),
52 });
53 let expiry = credentials.expiry();
54
55 Ok((object_store_credentials, expiry))
56 }
57}
58
59#[async_trait]
60impl<T> object_store::CredentialProvider for AwsConfigCredentialProvider<T>
61where
62 T: aws_credential_types::provider::ProvideCredentials,
63{
64 type Credential = object_store::aws::AwsCredential;
65
66 async fn get_credential(&self) -> object_store::Result<Arc<Self::Credential>> {
67 if let Some(credential) = self.credential.read().expect("poisoned").as_ref() {
68 match credential.1 {
69 Some(expiry) if expiry <= std::time::SystemTime::now() => {}
71 Some(_) | None => {
73 return Ok(credential.0.clone());
74 }
75 }
76 }
77
78 let (object_store_credential, expiry) = self.get_new_creds().await?;
80
81 let mut c = self.credential.write().expect("poisoned");
82 *c = Some((object_store_credential.clone(), expiry));
83
84 Ok(object_store_credential)
85 }
86}
87
88pub async fn setup_aws_object_store<I, K, V>(
104 url: &url::Url,
105 opts: I,
106) -> Result<object_store::aws::AmazonS3, Box<dyn std::error::Error + Send + Sync + 'static>>
107where
108 I: IntoIterator<Item = (K, V)>,
109 K: AsRef<str>,
110 V: Into<String> + AsRef<str>,
111{
112 let bucket_name = url
113 .host_str()
114 .ok_or_else(|| Box::new(std::io::Error::other("no bucket name set")))?;
115
116 let mut config_loader = aws_config::from_env();
118
119 let mut aws_access_key_id: Option<String> = None;
120 let mut aws_secret_access_key: Option<String> = None;
121 let mut allow_http = false;
122 let mut user_agent = Some(crate::USER_AGENT.to_owned());
123
124 for (k, v) in opts.into_iter() {
125 match k.as_ref() {
126 "aws_access_key_id" => {
127 aws_access_key_id = Some(v.into());
128 }
129 "aws_secret_access_key" => {
130 aws_secret_access_key = Some(v.into());
131 }
132 "aws_region" => {
133 config_loader = config_loader.region(aws_config::Region::new(v.into()));
134 }
135 "aws_allow_http" => {
136 let v = v.as_ref();
137 if v == "1" || v == "true" {
138 allow_http = true;
139 }
140 }
141 "aws_endpoint_url" => {
142 config_loader = config_loader.endpoint_url(v.into());
143 }
144 "aws_profile" => {
145 config_loader = config_loader.profile_name(v.into());
146 }
147 "user_agent" => {
148 user_agent = Some(v.into());
149 }
150 _ => {
151 return Err(Box::new(std::io::Error::new(
152 std::io::ErrorKind::InvalidInput,
153 format!("unexpected param: {}", k.as_ref()),
154 )));
155 }
156 }
157 }
158
159 match (aws_access_key_id, aws_secret_access_key) {
160 (None, None) => {}
161 (None, Some(_)) | (Some(_), None) => {
162 return Err(Box::new(std::io::Error::new(
163 std::io::ErrorKind::InvalidInput,
164 "specified only one of `aws_access_key_id`, `aws_secret_access_key`, need to specify both or none",
165 )));
166 }
167 (Some(aws_access_key_id), Some(aws_secret_access_key)) => {
168 config_loader =
169 config_loader.credentials_provider(aws_credential_types::Credentials::new(
170 aws_access_key_id,
171 aws_secret_access_key,
172 None,
173 None,
174 "url-params",
175 ));
176 }
177 }
178
179 let sdk_config = config_loader.load().await;
181
182 let sdk_credentials_provider = sdk_config.credentials_provider().ok_or_else(|| {
183 Box::new(std::io::Error::new(
184 std::io::ErrorKind::PermissionDenied,
185 "couldn't discover AWS credential provider",
186 ))
187 })?;
188
189 let mut store_builder = object_store::aws::AmazonS3Builder::new()
190 .with_credentials(Arc::new(AwsConfigCredentialProvider::new(
191 sdk_credentials_provider,
192 )))
193 .with_bucket_name(bucket_name)
194 .with_allow_http(allow_http)
195 .with_client_options({
196 let mut client_options = object_store::ClientOptions::new().with_allow_http(allow_http);
197
198 if let Some(user_agent) = user_agent {
199 client_options = client_options
200 .with_user_agent(object_store::HeaderValue::from_str(&user_agent)?);
201 }
202
203 client_options
204 });
205
206 if let Some(region) = sdk_config.region() {
207 store_builder = store_builder.with_region(region.to_string());
208 }
209
210 if let Some(endpoint_url) = sdk_config.endpoint_url() {
211 store_builder = store_builder.with_endpoint(endpoint_url);
212 }
213
214 Ok(store_builder.build()?)
215}