fastly_api/apis/
logging_s3_api.rs

1/*
2 * Fastly API
3 *
4 * Via the Fastly API you can perform any of the operations that are possible within the management console,  including creating services, domains, and backends, configuring rules or uploading your own application code, as well as account operations such as user administration and billing reports. The API is organized into collections of endpoints that allow manipulation of objects related to Fastly services and accounts. For the most accurate and up-to-date API reference content, visit our [Developer Hub](https://www.fastly.com/documentation/reference/api/) 
5 *
6 */
7
8
9use reqwest;
10
11use crate::apis::ResponseContent;
12use super::{Error, configuration};
13
14/// struct for passing parameters to the method [`create_log_aws_s3`]
15#[derive(Clone, Debug, Default)]
16pub struct CreateLogAwsS3Params {
17    /// Alphanumeric string identifying the service.
18    pub service_id: String,
19    /// Integer identifying a service version.
20    pub version_id: i32,
21    /// The name for the real-time logging configuration.
22    pub name: Option<String>,
23    /// Where in the generated VCL the logging call should be placed. If not set, endpoints with `format_version` of 2 are placed in `vcl_log` and those with `format_version` of 1 are placed in `vcl_deliver`. 
24    pub placement: Option<String>,
25    /// The name of an existing condition in the configured endpoint, or leave blank to always execute.
26    pub response_condition: Option<String>,
27    /// A Fastly [log format string](https://docs.fastly.com/en/guides/custom-log-formats).
28    pub format: Option<String>,
29    /// The version of the custom logging format used for the configured endpoint. The logging call gets placed by default in `vcl_log` if `format_version` is set to `2` and in `vcl_deliver` if `format_version` is set to `1`. 
30    pub format_version: Option<i32>,
31    /// How the message should be formatted.
32    pub message_type: Option<String>,
33    /// A timestamp format
34    pub timestamp_format: Option<String>,
35    /// The codec used for compressing your logs. Valid values are `zstd`, `snappy`, and `gzip`. Specifying both `compression_codec` and `gzip_level` in the same API request will result in an error.
36    pub compression_codec: Option<String>,
37    /// How frequently log files are finalized so they can be available for reading (in seconds).
38    pub period: Option<i32>,
39    /// The level of gzip encoding when sending logs (default `0`, no compression). Specifying both `compression_codec` and `gzip_level` in the same API request will result in an error.
40    pub gzip_level: Option<i32>,
41    /// The access key for your S3 account. Not required if `iam_role` is provided.
42    pub access_key: Option<String>,
43    /// The access control list (ACL) specific request header. See the AWS documentation for [Access Control List (ACL) Specific Request Headers](https://docs.aws.amazon.com/AmazonS3/latest/API/mpUploadInitiate.html#initiate-mpu-acl-specific-request-headers) for more information.
44    pub acl: Option<String>,
45    /// The bucket name for S3 account.
46    pub bucket_name: Option<String>,
47    /// The domain of the Amazon S3 endpoint.
48    pub domain: Option<String>,
49    /// The Amazon Resource Name (ARN) for the IAM role granting Fastly access to S3. Not required if `access_key` and `secret_key` are provided.
50    pub iam_role: Option<String>,
51    /// The path to upload logs to.
52    pub path: Option<String>,
53    /// A PGP public key that Fastly will use to encrypt your log files before writing them to disk.
54    pub public_key: Option<String>,
55    /// The S3 redundancy level.
56    pub redundancy: Option<String>,
57    /// The secret key for your S3 account. Not required if `iam_role` is provided.
58    pub secret_key: Option<String>,
59    /// Optional server-side KMS Key Id. Must be set if `server_side_encryption` is set to `aws:kms` or `AES256`.
60    pub server_side_encryption_kms_key_id: Option<String>,
61    /// Set this to `AES256` or `aws:kms` to enable S3 Server Side Encryption.
62    pub server_side_encryption: Option<String>,
63    /// The maximum number of bytes for each uploaded file. A value of 0 can be used to indicate there is no limit on the size of uploaded files, otherwise the minimum value is 1048576 bytes (1 MiB.)
64    pub file_max_bytes: Option<i32>
65}
66
67/// struct for passing parameters to the method [`delete_log_aws_s3`]
68#[derive(Clone, Debug, Default)]
69pub struct DeleteLogAwsS3Params {
70    /// Alphanumeric string identifying the service.
71    pub service_id: String,
72    /// Integer identifying a service version.
73    pub version_id: i32,
74    /// The name for the real-time logging configuration.
75    pub logging_s3_name: String
76}
77
78/// struct for passing parameters to the method [`get_log_aws_s3`]
79#[derive(Clone, Debug, Default)]
80pub struct GetLogAwsS3Params {
81    /// Alphanumeric string identifying the service.
82    pub service_id: String,
83    /// Integer identifying a service version.
84    pub version_id: i32,
85    /// The name for the real-time logging configuration.
86    pub logging_s3_name: String
87}
88
89/// struct for passing parameters to the method [`list_log_aws_s3`]
90#[derive(Clone, Debug, Default)]
91pub struct ListLogAwsS3Params {
92    /// Alphanumeric string identifying the service.
93    pub service_id: String,
94    /// Integer identifying a service version.
95    pub version_id: i32
96}
97
98/// struct for passing parameters to the method [`update_log_aws_s3`]
99#[derive(Clone, Debug, Default)]
100pub struct UpdateLogAwsS3Params {
101    /// Alphanumeric string identifying the service.
102    pub service_id: String,
103    /// Integer identifying a service version.
104    pub version_id: i32,
105    /// The name for the real-time logging configuration.
106    pub logging_s3_name: String,
107    /// The name for the real-time logging configuration.
108    pub name: Option<String>,
109    /// Where in the generated VCL the logging call should be placed. If not set, endpoints with `format_version` of 2 are placed in `vcl_log` and those with `format_version` of 1 are placed in `vcl_deliver`. 
110    pub placement: Option<String>,
111    /// The name of an existing condition in the configured endpoint, or leave blank to always execute.
112    pub response_condition: Option<String>,
113    /// A Fastly [log format string](https://docs.fastly.com/en/guides/custom-log-formats).
114    pub format: Option<String>,
115    /// The version of the custom logging format used for the configured endpoint. The logging call gets placed by default in `vcl_log` if `format_version` is set to `2` and in `vcl_deliver` if `format_version` is set to `1`. 
116    pub format_version: Option<i32>,
117    /// How the message should be formatted.
118    pub message_type: Option<String>,
119    /// A timestamp format
120    pub timestamp_format: Option<String>,
121    /// The codec used for compressing your logs. Valid values are `zstd`, `snappy`, and `gzip`. Specifying both `compression_codec` and `gzip_level` in the same API request will result in an error.
122    pub compression_codec: Option<String>,
123    /// How frequently log files are finalized so they can be available for reading (in seconds).
124    pub period: Option<i32>,
125    /// The level of gzip encoding when sending logs (default `0`, no compression). Specifying both `compression_codec` and `gzip_level` in the same API request will result in an error.
126    pub gzip_level: Option<i32>,
127    /// The access key for your S3 account. Not required if `iam_role` is provided.
128    pub access_key: Option<String>,
129    /// The access control list (ACL) specific request header. See the AWS documentation for [Access Control List (ACL) Specific Request Headers](https://docs.aws.amazon.com/AmazonS3/latest/API/mpUploadInitiate.html#initiate-mpu-acl-specific-request-headers) for more information.
130    pub acl: Option<String>,
131    /// The bucket name for S3 account.
132    pub bucket_name: Option<String>,
133    /// The domain of the Amazon S3 endpoint.
134    pub domain: Option<String>,
135    /// The Amazon Resource Name (ARN) for the IAM role granting Fastly access to S3. Not required if `access_key` and `secret_key` are provided.
136    pub iam_role: Option<String>,
137    /// The path to upload logs to.
138    pub path: Option<String>,
139    /// A PGP public key that Fastly will use to encrypt your log files before writing them to disk.
140    pub public_key: Option<String>,
141    /// The S3 redundancy level.
142    pub redundancy: Option<String>,
143    /// The secret key for your S3 account. Not required if `iam_role` is provided.
144    pub secret_key: Option<String>,
145    /// Optional server-side KMS Key Id. Must be set if `server_side_encryption` is set to `aws:kms` or `AES256`.
146    pub server_side_encryption_kms_key_id: Option<String>,
147    /// Set this to `AES256` or `aws:kms` to enable S3 Server Side Encryption.
148    pub server_side_encryption: Option<String>,
149    /// The maximum number of bytes for each uploaded file. A value of 0 can be used to indicate there is no limit on the size of uploaded files, otherwise the minimum value is 1048576 bytes (1 MiB.)
150    pub file_max_bytes: Option<i32>
151}
152
153
154/// struct for typed errors of method [`create_log_aws_s3`]
155#[derive(Debug, Clone, Serialize, Deserialize)]
156#[serde(untagged)]
157pub enum CreateLogAwsS3Error {
158    UnknownValue(serde_json::Value),
159}
160
161/// struct for typed errors of method [`delete_log_aws_s3`]
162#[derive(Debug, Clone, Serialize, Deserialize)]
163#[serde(untagged)]
164pub enum DeleteLogAwsS3Error {
165    UnknownValue(serde_json::Value),
166}
167
168/// struct for typed errors of method [`get_log_aws_s3`]
169#[derive(Debug, Clone, Serialize, Deserialize)]
170#[serde(untagged)]
171pub enum GetLogAwsS3Error {
172    UnknownValue(serde_json::Value),
173}
174
175/// struct for typed errors of method [`list_log_aws_s3`]
176#[derive(Debug, Clone, Serialize, Deserialize)]
177#[serde(untagged)]
178pub enum ListLogAwsS3Error {
179    UnknownValue(serde_json::Value),
180}
181
182/// struct for typed errors of method [`update_log_aws_s3`]
183#[derive(Debug, Clone, Serialize, Deserialize)]
184#[serde(untagged)]
185pub enum UpdateLogAwsS3Error {
186    UnknownValue(serde_json::Value),
187}
188
189
190/// Create a S3 for a particular service and version.
191pub async fn create_log_aws_s3(configuration: &mut configuration::Configuration, params: CreateLogAwsS3Params) -> Result<crate::models::LoggingS3Response, Error<CreateLogAwsS3Error>> {
192    let local_var_configuration = configuration;
193
194    // unbox the parameters
195    let service_id = params.service_id;
196    let version_id = params.version_id;
197    let name = params.name;
198    let placement = params.placement;
199    let response_condition = params.response_condition;
200    let format = params.format;
201    let format_version = params.format_version;
202    let message_type = params.message_type;
203    let timestamp_format = params.timestamp_format;
204    let compression_codec = params.compression_codec;
205    let period = params.period;
206    let gzip_level = params.gzip_level;
207    let access_key = params.access_key;
208    let acl = params.acl;
209    let bucket_name = params.bucket_name;
210    let domain = params.domain;
211    let iam_role = params.iam_role;
212    let path = params.path;
213    let public_key = params.public_key;
214    let redundancy = params.redundancy;
215    let secret_key = params.secret_key;
216    let server_side_encryption_kms_key_id = params.server_side_encryption_kms_key_id;
217    let server_side_encryption = params.server_side_encryption;
218    let file_max_bytes = params.file_max_bytes;
219
220
221    let local_var_client = &local_var_configuration.client;
222
223    let local_var_uri_str = format!("{}/service/{service_id}/version/{version_id}/logging/s3", local_var_configuration.base_path, service_id=crate::apis::urlencode(service_id), version_id=version_id);
224    let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
225
226    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
227        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
228    }
229    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
230        let local_var_key = local_var_apikey.key.clone();
231        let local_var_value = match local_var_apikey.prefix {
232            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
233            None => local_var_key,
234        };
235        local_var_req_builder = local_var_req_builder.header("Fastly-Key", local_var_value);
236    };
237    let mut local_var_form_params = std::collections::HashMap::new();
238    if let Some(local_var_param_value) = name {
239        local_var_form_params.insert("name", local_var_param_value.to_string());
240    }
241    if let Some(local_var_param_value) = placement {
242        local_var_form_params.insert("placement", local_var_param_value.to_string());
243    }
244    if let Some(local_var_param_value) = response_condition {
245        local_var_form_params.insert("response_condition", local_var_param_value.to_string());
246    }
247    if let Some(local_var_param_value) = format {
248        local_var_form_params.insert("format", local_var_param_value.to_string());
249    }
250    if let Some(local_var_param_value) = format_version {
251        local_var_form_params.insert("format_version", local_var_param_value.to_string());
252    }
253    if let Some(local_var_param_value) = message_type {
254        local_var_form_params.insert("message_type", local_var_param_value.to_string());
255    }
256    if let Some(local_var_param_value) = timestamp_format {
257        local_var_form_params.insert("timestamp_format", local_var_param_value.to_string());
258    }
259    if let Some(local_var_param_value) = compression_codec {
260        local_var_form_params.insert("compression_codec", local_var_param_value.to_string());
261    }
262    if let Some(local_var_param_value) = period {
263        local_var_form_params.insert("period", local_var_param_value.to_string());
264    }
265    if let Some(local_var_param_value) = gzip_level {
266        local_var_form_params.insert("gzip_level", local_var_param_value.to_string());
267    }
268    if let Some(local_var_param_value) = access_key {
269        local_var_form_params.insert("access_key", local_var_param_value.to_string());
270    }
271    if let Some(local_var_param_value) = acl {
272        local_var_form_params.insert("acl", local_var_param_value.to_string());
273    }
274    if let Some(local_var_param_value) = bucket_name {
275        local_var_form_params.insert("bucket_name", local_var_param_value.to_string());
276    }
277    if let Some(local_var_param_value) = domain {
278        local_var_form_params.insert("domain", local_var_param_value.to_string());
279    }
280    if let Some(local_var_param_value) = iam_role {
281        local_var_form_params.insert("iam_role", local_var_param_value.to_string());
282    }
283    if let Some(local_var_param_value) = path {
284        local_var_form_params.insert("path", local_var_param_value.to_string());
285    }
286    if let Some(local_var_param_value) = public_key {
287        local_var_form_params.insert("public_key", local_var_param_value.to_string());
288    }
289    if let Some(local_var_param_value) = redundancy {
290        local_var_form_params.insert("redundancy", local_var_param_value.to_string());
291    }
292    if let Some(local_var_param_value) = secret_key {
293        local_var_form_params.insert("secret_key", local_var_param_value.to_string());
294    }
295    if let Some(local_var_param_value) = server_side_encryption_kms_key_id {
296        local_var_form_params.insert("server_side_encryption_kms_key_id", local_var_param_value.to_string());
297    }
298    if let Some(local_var_param_value) = server_side_encryption {
299        local_var_form_params.insert("server_side_encryption", local_var_param_value.to_string());
300    }
301    if let Some(local_var_param_value) = file_max_bytes {
302        local_var_form_params.insert("file_max_bytes", local_var_param_value.to_string());
303    }
304    local_var_req_builder = local_var_req_builder.form(&local_var_form_params);
305
306    let local_var_req = local_var_req_builder.build()?;
307    let local_var_resp = local_var_client.execute(local_var_req).await?;
308
309    if "POST" != "GET" && "POST" != "HEAD" {
310      let headers = local_var_resp.headers();
311      local_var_configuration.rate_limit_remaining = match headers.get("Fastly-RateLimit-Remaining") {
312          Some(v) => v.to_str().unwrap().parse().unwrap(),
313          None => configuration::DEFAULT_RATELIMIT,
314      };
315      local_var_configuration.rate_limit_reset = match headers.get("Fastly-RateLimit-Reset") {
316          Some(v) => v.to_str().unwrap().parse().unwrap(),
317          None => 0,
318      };
319    }
320
321    let local_var_status = local_var_resp.status();
322    let local_var_content = local_var_resp.text().await?;
323
324    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
325        serde_json::from_str(&local_var_content).map_err(Error::from)
326    } else {
327        let local_var_entity: Option<CreateLogAwsS3Error> = serde_json::from_str(&local_var_content).ok();
328        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
329        Err(Error::ResponseError(local_var_error))
330    }
331}
332
333/// Delete the S3 for a particular service and version.
334pub async fn delete_log_aws_s3(configuration: &mut configuration::Configuration, params: DeleteLogAwsS3Params) -> Result<crate::models::InlineResponse200, Error<DeleteLogAwsS3Error>> {
335    let local_var_configuration = configuration;
336
337    // unbox the parameters
338    let service_id = params.service_id;
339    let version_id = params.version_id;
340    let logging_s3_name = params.logging_s3_name;
341
342
343    let local_var_client = &local_var_configuration.client;
344
345    let local_var_uri_str = format!("{}/service/{service_id}/version/{version_id}/logging/s3/{logging_s3_name}", local_var_configuration.base_path, service_id=crate::apis::urlencode(service_id), version_id=version_id, logging_s3_name=crate::apis::urlencode(logging_s3_name));
346    let mut local_var_req_builder = local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
347
348    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
349        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
350    }
351    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
352        let local_var_key = local_var_apikey.key.clone();
353        let local_var_value = match local_var_apikey.prefix {
354            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
355            None => local_var_key,
356        };
357        local_var_req_builder = local_var_req_builder.header("Fastly-Key", local_var_value);
358    };
359
360    let local_var_req = local_var_req_builder.build()?;
361    let local_var_resp = local_var_client.execute(local_var_req).await?;
362
363    if "DELETE" != "GET" && "DELETE" != "HEAD" {
364      let headers = local_var_resp.headers();
365      local_var_configuration.rate_limit_remaining = match headers.get("Fastly-RateLimit-Remaining") {
366          Some(v) => v.to_str().unwrap().parse().unwrap(),
367          None => configuration::DEFAULT_RATELIMIT,
368      };
369      local_var_configuration.rate_limit_reset = match headers.get("Fastly-RateLimit-Reset") {
370          Some(v) => v.to_str().unwrap().parse().unwrap(),
371          None => 0,
372      };
373    }
374
375    let local_var_status = local_var_resp.status();
376    let local_var_content = local_var_resp.text().await?;
377
378    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
379        serde_json::from_str(&local_var_content).map_err(Error::from)
380    } else {
381        let local_var_entity: Option<DeleteLogAwsS3Error> = serde_json::from_str(&local_var_content).ok();
382        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
383        Err(Error::ResponseError(local_var_error))
384    }
385}
386
387/// Get the S3 for a particular service and version.
388pub async fn get_log_aws_s3(configuration: &mut configuration::Configuration, params: GetLogAwsS3Params) -> Result<crate::models::LoggingS3Response, Error<GetLogAwsS3Error>> {
389    let local_var_configuration = configuration;
390
391    // unbox the parameters
392    let service_id = params.service_id;
393    let version_id = params.version_id;
394    let logging_s3_name = params.logging_s3_name;
395
396
397    let local_var_client = &local_var_configuration.client;
398
399    let local_var_uri_str = format!("{}/service/{service_id}/version/{version_id}/logging/s3/{logging_s3_name}", local_var_configuration.base_path, service_id=crate::apis::urlencode(service_id), version_id=version_id, logging_s3_name=crate::apis::urlencode(logging_s3_name));
400    let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
401
402    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
403        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
404    }
405    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
406        let local_var_key = local_var_apikey.key.clone();
407        let local_var_value = match local_var_apikey.prefix {
408            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
409            None => local_var_key,
410        };
411        local_var_req_builder = local_var_req_builder.header("Fastly-Key", local_var_value);
412    };
413
414    let local_var_req = local_var_req_builder.build()?;
415    let local_var_resp = local_var_client.execute(local_var_req).await?;
416
417    if "GET" != "GET" && "GET" != "HEAD" {
418      let headers = local_var_resp.headers();
419      local_var_configuration.rate_limit_remaining = match headers.get("Fastly-RateLimit-Remaining") {
420          Some(v) => v.to_str().unwrap().parse().unwrap(),
421          None => configuration::DEFAULT_RATELIMIT,
422      };
423      local_var_configuration.rate_limit_reset = match headers.get("Fastly-RateLimit-Reset") {
424          Some(v) => v.to_str().unwrap().parse().unwrap(),
425          None => 0,
426      };
427    }
428
429    let local_var_status = local_var_resp.status();
430    let local_var_content = local_var_resp.text().await?;
431
432    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
433        serde_json::from_str(&local_var_content).map_err(Error::from)
434    } else {
435        let local_var_entity: Option<GetLogAwsS3Error> = serde_json::from_str(&local_var_content).ok();
436        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
437        Err(Error::ResponseError(local_var_error))
438    }
439}
440
441/// List all of the S3s for a particular service and version.
442pub async fn list_log_aws_s3(configuration: &mut configuration::Configuration, params: ListLogAwsS3Params) -> Result<Vec<crate::models::LoggingS3Response>, Error<ListLogAwsS3Error>> {
443    let local_var_configuration = configuration;
444
445    // unbox the parameters
446    let service_id = params.service_id;
447    let version_id = params.version_id;
448
449
450    let local_var_client = &local_var_configuration.client;
451
452    let local_var_uri_str = format!("{}/service/{service_id}/version/{version_id}/logging/s3", local_var_configuration.base_path, service_id=crate::apis::urlencode(service_id), version_id=version_id);
453    let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
454
455    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
456        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
457    }
458    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
459        let local_var_key = local_var_apikey.key.clone();
460        let local_var_value = match local_var_apikey.prefix {
461            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
462            None => local_var_key,
463        };
464        local_var_req_builder = local_var_req_builder.header("Fastly-Key", local_var_value);
465    };
466
467    let local_var_req = local_var_req_builder.build()?;
468    let local_var_resp = local_var_client.execute(local_var_req).await?;
469
470    if "GET" != "GET" && "GET" != "HEAD" {
471      let headers = local_var_resp.headers();
472      local_var_configuration.rate_limit_remaining = match headers.get("Fastly-RateLimit-Remaining") {
473          Some(v) => v.to_str().unwrap().parse().unwrap(),
474          None => configuration::DEFAULT_RATELIMIT,
475      };
476      local_var_configuration.rate_limit_reset = match headers.get("Fastly-RateLimit-Reset") {
477          Some(v) => v.to_str().unwrap().parse().unwrap(),
478          None => 0,
479      };
480    }
481
482    let local_var_status = local_var_resp.status();
483    let local_var_content = local_var_resp.text().await?;
484
485    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
486        serde_json::from_str(&local_var_content).map_err(Error::from)
487    } else {
488        let local_var_entity: Option<ListLogAwsS3Error> = serde_json::from_str(&local_var_content).ok();
489        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
490        Err(Error::ResponseError(local_var_error))
491    }
492}
493
494/// Update the S3 for a particular service and version.
495pub async fn update_log_aws_s3(configuration: &mut configuration::Configuration, params: UpdateLogAwsS3Params) -> Result<crate::models::LoggingS3Response, Error<UpdateLogAwsS3Error>> {
496    let local_var_configuration = configuration;
497
498    // unbox the parameters
499    let service_id = params.service_id;
500    let version_id = params.version_id;
501    let logging_s3_name = params.logging_s3_name;
502    let name = params.name;
503    let placement = params.placement;
504    let response_condition = params.response_condition;
505    let format = params.format;
506    let format_version = params.format_version;
507    let message_type = params.message_type;
508    let timestamp_format = params.timestamp_format;
509    let compression_codec = params.compression_codec;
510    let period = params.period;
511    let gzip_level = params.gzip_level;
512    let access_key = params.access_key;
513    let acl = params.acl;
514    let bucket_name = params.bucket_name;
515    let domain = params.domain;
516    let iam_role = params.iam_role;
517    let path = params.path;
518    let public_key = params.public_key;
519    let redundancy = params.redundancy;
520    let secret_key = params.secret_key;
521    let server_side_encryption_kms_key_id = params.server_side_encryption_kms_key_id;
522    let server_side_encryption = params.server_side_encryption;
523    let file_max_bytes = params.file_max_bytes;
524
525
526    let local_var_client = &local_var_configuration.client;
527
528    let local_var_uri_str = format!("{}/service/{service_id}/version/{version_id}/logging/s3/{logging_s3_name}", local_var_configuration.base_path, service_id=crate::apis::urlencode(service_id), version_id=version_id, logging_s3_name=crate::apis::urlencode(logging_s3_name));
529    let mut local_var_req_builder = local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
530
531    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
532        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
533    }
534    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
535        let local_var_key = local_var_apikey.key.clone();
536        let local_var_value = match local_var_apikey.prefix {
537            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
538            None => local_var_key,
539        };
540        local_var_req_builder = local_var_req_builder.header("Fastly-Key", local_var_value);
541    };
542    let mut local_var_form_params = std::collections::HashMap::new();
543    if let Some(local_var_param_value) = name {
544        local_var_form_params.insert("name", local_var_param_value.to_string());
545    }
546    if let Some(local_var_param_value) = placement {
547        local_var_form_params.insert("placement", local_var_param_value.to_string());
548    }
549    if let Some(local_var_param_value) = response_condition {
550        local_var_form_params.insert("response_condition", local_var_param_value.to_string());
551    }
552    if let Some(local_var_param_value) = format {
553        local_var_form_params.insert("format", local_var_param_value.to_string());
554    }
555    if let Some(local_var_param_value) = format_version {
556        local_var_form_params.insert("format_version", local_var_param_value.to_string());
557    }
558    if let Some(local_var_param_value) = message_type {
559        local_var_form_params.insert("message_type", local_var_param_value.to_string());
560    }
561    if let Some(local_var_param_value) = timestamp_format {
562        local_var_form_params.insert("timestamp_format", local_var_param_value.to_string());
563    }
564    if let Some(local_var_param_value) = compression_codec {
565        local_var_form_params.insert("compression_codec", local_var_param_value.to_string());
566    }
567    if let Some(local_var_param_value) = period {
568        local_var_form_params.insert("period", local_var_param_value.to_string());
569    }
570    if let Some(local_var_param_value) = gzip_level {
571        local_var_form_params.insert("gzip_level", local_var_param_value.to_string());
572    }
573    if let Some(local_var_param_value) = access_key {
574        local_var_form_params.insert("access_key", local_var_param_value.to_string());
575    }
576    if let Some(local_var_param_value) = acl {
577        local_var_form_params.insert("acl", local_var_param_value.to_string());
578    }
579    if let Some(local_var_param_value) = bucket_name {
580        local_var_form_params.insert("bucket_name", local_var_param_value.to_string());
581    }
582    if let Some(local_var_param_value) = domain {
583        local_var_form_params.insert("domain", local_var_param_value.to_string());
584    }
585    if let Some(local_var_param_value) = iam_role {
586        local_var_form_params.insert("iam_role", local_var_param_value.to_string());
587    }
588    if let Some(local_var_param_value) = path {
589        local_var_form_params.insert("path", local_var_param_value.to_string());
590    }
591    if let Some(local_var_param_value) = public_key {
592        local_var_form_params.insert("public_key", local_var_param_value.to_string());
593    }
594    if let Some(local_var_param_value) = redundancy {
595        local_var_form_params.insert("redundancy", local_var_param_value.to_string());
596    }
597    if let Some(local_var_param_value) = secret_key {
598        local_var_form_params.insert("secret_key", local_var_param_value.to_string());
599    }
600    if let Some(local_var_param_value) = server_side_encryption_kms_key_id {
601        local_var_form_params.insert("server_side_encryption_kms_key_id", local_var_param_value.to_string());
602    }
603    if let Some(local_var_param_value) = server_side_encryption {
604        local_var_form_params.insert("server_side_encryption", local_var_param_value.to_string());
605    }
606    if let Some(local_var_param_value) = file_max_bytes {
607        local_var_form_params.insert("file_max_bytes", local_var_param_value.to_string());
608    }
609    local_var_req_builder = local_var_req_builder.form(&local_var_form_params);
610
611    let local_var_req = local_var_req_builder.build()?;
612    let local_var_resp = local_var_client.execute(local_var_req).await?;
613
614    if "PUT" != "GET" && "PUT" != "HEAD" {
615      let headers = local_var_resp.headers();
616      local_var_configuration.rate_limit_remaining = match headers.get("Fastly-RateLimit-Remaining") {
617          Some(v) => v.to_str().unwrap().parse().unwrap(),
618          None => configuration::DEFAULT_RATELIMIT,
619      };
620      local_var_configuration.rate_limit_reset = match headers.get("Fastly-RateLimit-Reset") {
621          Some(v) => v.to_str().unwrap().parse().unwrap(),
622          None => 0,
623      };
624    }
625
626    let local_var_status = local_var_resp.status();
627    let local_var_content = local_var_resp.text().await?;
628
629    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
630        serde_json::from_str(&local_var_content).map_err(Error::from)
631    } else {
632        let local_var_entity: Option<UpdateLogAwsS3Error> = serde_json::from_str(&local_var_content).ok();
633        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
634        Err(Error::ResponseError(local_var_error))
635    }
636}
637