1use reqwest;
10
11use crate::apis::ResponseContent;
12use super::{Error, configuration};
13
14#[derive(Clone, Debug, Default)]
16pub struct CreateLogSplunkParams {
17 pub service_id: String,
19 pub version_id: i32,
21 pub name: Option<String>,
23 pub placement: Option<String>,
25 pub response_condition: Option<String>,
27 pub format: Option<String>,
29 pub format_version: Option<i32>,
31 pub tls_ca_cert: Option<String>,
33 pub tls_client_cert: Option<String>,
35 pub tls_client_key: Option<String>,
37 pub tls_hostname: Option<String>,
39 pub request_max_entries: Option<i32>,
41 pub request_max_bytes: Option<i32>,
43 pub url: Option<String>,
45 pub token: Option<String>,
47 pub use_tls: Option<crate::models::LoggingUseTlsString>
48}
49
50#[derive(Clone, Debug, Default)]
52pub struct DeleteLogSplunkParams {
53 pub service_id: String,
55 pub version_id: i32,
57 pub logging_splunk_name: String
59}
60
61#[derive(Clone, Debug, Default)]
63pub struct GetLogSplunkParams {
64 pub service_id: String,
66 pub version_id: i32,
68 pub logging_splunk_name: String
70}
71
72#[derive(Clone, Debug, Default)]
74pub struct ListLogSplunkParams {
75 pub service_id: String,
77 pub version_id: i32
79}
80
81#[derive(Clone, Debug, Default)]
83pub struct UpdateLogSplunkParams {
84 pub service_id: String,
86 pub version_id: i32,
88 pub logging_splunk_name: String,
90 pub name: Option<String>,
92 pub placement: Option<String>,
94 pub response_condition: Option<String>,
96 pub format: Option<String>,
98 pub format_version: Option<i32>,
100 pub tls_ca_cert: Option<String>,
102 pub tls_client_cert: Option<String>,
104 pub tls_client_key: Option<String>,
106 pub tls_hostname: Option<String>,
108 pub request_max_entries: Option<i32>,
110 pub request_max_bytes: Option<i32>,
112 pub url: Option<String>,
114 pub token: Option<String>,
116 pub use_tls: Option<crate::models::LoggingUseTlsString>
117}
118
119
120#[derive(Debug, Clone, Serialize, Deserialize)]
122#[serde(untagged)]
123pub enum CreateLogSplunkError {
124 UnknownValue(serde_json::Value),
125}
126
127#[derive(Debug, Clone, Serialize, Deserialize)]
129#[serde(untagged)]
130pub enum DeleteLogSplunkError {
131 UnknownValue(serde_json::Value),
132}
133
134#[derive(Debug, Clone, Serialize, Deserialize)]
136#[serde(untagged)]
137pub enum GetLogSplunkError {
138 UnknownValue(serde_json::Value),
139}
140
141#[derive(Debug, Clone, Serialize, Deserialize)]
143#[serde(untagged)]
144pub enum ListLogSplunkError {
145 UnknownValue(serde_json::Value),
146}
147
148#[derive(Debug, Clone, Serialize, Deserialize)]
150#[serde(untagged)]
151pub enum UpdateLogSplunkError {
152 UnknownValue(serde_json::Value),
153}
154
155
156pub async fn create_log_splunk(configuration: &mut configuration::Configuration, params: CreateLogSplunkParams) -> Result<crate::models::LoggingSplunkResponse, Error<CreateLogSplunkError>> {
158 let local_var_configuration = configuration;
159
160 let service_id = params.service_id;
162 let version_id = params.version_id;
163 let name = params.name;
164 let placement = params.placement;
165 let response_condition = params.response_condition;
166 let format = params.format;
167 let format_version = params.format_version;
168 let tls_ca_cert = params.tls_ca_cert;
169 let tls_client_cert = params.tls_client_cert;
170 let tls_client_key = params.tls_client_key;
171 let tls_hostname = params.tls_hostname;
172 let request_max_entries = params.request_max_entries;
173 let request_max_bytes = params.request_max_bytes;
174 let url = params.url;
175 let token = params.token;
176 let use_tls = params.use_tls;
177
178
179 let local_var_client = &local_var_configuration.client;
180
181 let local_var_uri_str = format!("{}/service/{service_id}/version/{version_id}/logging/splunk", local_var_configuration.base_path, service_id=crate::apis::urlencode(service_id), version_id=version_id);
182 let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
183
184 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
185 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
186 }
187 if let Some(ref local_var_apikey) = local_var_configuration.api_key {
188 let local_var_key = local_var_apikey.key.clone();
189 let local_var_value = match local_var_apikey.prefix {
190 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
191 None => local_var_key,
192 };
193 local_var_req_builder = local_var_req_builder.header("Fastly-Key", local_var_value);
194 };
195 let mut local_var_form_params = std::collections::HashMap::new();
196 if let Some(local_var_param_value) = name {
197 local_var_form_params.insert("name", local_var_param_value.to_string());
198 }
199 if let Some(local_var_param_value) = placement {
200 local_var_form_params.insert("placement", local_var_param_value.to_string());
201 }
202 if let Some(local_var_param_value) = response_condition {
203 local_var_form_params.insert("response_condition", local_var_param_value.to_string());
204 }
205 if let Some(local_var_param_value) = format {
206 local_var_form_params.insert("format", local_var_param_value.to_string());
207 }
208 if let Some(local_var_param_value) = format_version {
209 local_var_form_params.insert("format_version", local_var_param_value.to_string());
210 }
211 if let Some(local_var_param_value) = tls_ca_cert {
212 local_var_form_params.insert("tls_ca_cert", local_var_param_value.to_string());
213 }
214 if let Some(local_var_param_value) = tls_client_cert {
215 local_var_form_params.insert("tls_client_cert", local_var_param_value.to_string());
216 }
217 if let Some(local_var_param_value) = tls_client_key {
218 local_var_form_params.insert("tls_client_key", local_var_param_value.to_string());
219 }
220 if let Some(local_var_param_value) = tls_hostname {
221 local_var_form_params.insert("tls_hostname", local_var_param_value.to_string());
222 }
223 if let Some(local_var_param_value) = request_max_entries {
224 local_var_form_params.insert("request_max_entries", local_var_param_value.to_string());
225 }
226 if let Some(local_var_param_value) = request_max_bytes {
227 local_var_form_params.insert("request_max_bytes", local_var_param_value.to_string());
228 }
229 if let Some(local_var_param_value) = url {
230 local_var_form_params.insert("url", local_var_param_value.to_string());
231 }
232 if let Some(local_var_param_value) = token {
233 local_var_form_params.insert("token", local_var_param_value.to_string());
234 }
235 if let Some(local_var_param_value) = use_tls {
236 local_var_form_params.insert("use_tls", local_var_param_value.to_string());
237 }
238 local_var_req_builder = local_var_req_builder.form(&local_var_form_params);
239
240 let local_var_req = local_var_req_builder.build()?;
241 let local_var_resp = local_var_client.execute(local_var_req).await?;
242
243 if "POST" != "GET" && "POST" != "HEAD" {
244 let headers = local_var_resp.headers();
245 local_var_configuration.rate_limit_remaining = match headers.get("Fastly-RateLimit-Remaining") {
246 Some(v) => v.to_str().unwrap().parse().unwrap(),
247 None => configuration::DEFAULT_RATELIMIT,
248 };
249 local_var_configuration.rate_limit_reset = match headers.get("Fastly-RateLimit-Reset") {
250 Some(v) => v.to_str().unwrap().parse().unwrap(),
251 None => 0,
252 };
253 }
254
255 let local_var_status = local_var_resp.status();
256 let local_var_content = local_var_resp.text().await?;
257
258 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
259 serde_json::from_str(&local_var_content).map_err(Error::from)
260 } else {
261 let local_var_entity: Option<CreateLogSplunkError> = serde_json::from_str(&local_var_content).ok();
262 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
263 Err(Error::ResponseError(local_var_error))
264 }
265}
266
267pub async fn delete_log_splunk(configuration: &mut configuration::Configuration, params: DeleteLogSplunkParams) -> Result<crate::models::InlineResponse200, Error<DeleteLogSplunkError>> {
269 let local_var_configuration = configuration;
270
271 let service_id = params.service_id;
273 let version_id = params.version_id;
274 let logging_splunk_name = params.logging_splunk_name;
275
276
277 let local_var_client = &local_var_configuration.client;
278
279 let local_var_uri_str = format!("{}/service/{service_id}/version/{version_id}/logging/splunk/{logging_splunk_name}", local_var_configuration.base_path, service_id=crate::apis::urlencode(service_id), version_id=version_id, logging_splunk_name=crate::apis::urlencode(logging_splunk_name));
280 let mut local_var_req_builder = local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
281
282 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
283 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
284 }
285 if let Some(ref local_var_apikey) = local_var_configuration.api_key {
286 let local_var_key = local_var_apikey.key.clone();
287 let local_var_value = match local_var_apikey.prefix {
288 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
289 None => local_var_key,
290 };
291 local_var_req_builder = local_var_req_builder.header("Fastly-Key", local_var_value);
292 };
293
294 let local_var_req = local_var_req_builder.build()?;
295 let local_var_resp = local_var_client.execute(local_var_req).await?;
296
297 if "DELETE" != "GET" && "DELETE" != "HEAD" {
298 let headers = local_var_resp.headers();
299 local_var_configuration.rate_limit_remaining = match headers.get("Fastly-RateLimit-Remaining") {
300 Some(v) => v.to_str().unwrap().parse().unwrap(),
301 None => configuration::DEFAULT_RATELIMIT,
302 };
303 local_var_configuration.rate_limit_reset = match headers.get("Fastly-RateLimit-Reset") {
304 Some(v) => v.to_str().unwrap().parse().unwrap(),
305 None => 0,
306 };
307 }
308
309 let local_var_status = local_var_resp.status();
310 let local_var_content = local_var_resp.text().await?;
311
312 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
313 serde_json::from_str(&local_var_content).map_err(Error::from)
314 } else {
315 let local_var_entity: Option<DeleteLogSplunkError> = serde_json::from_str(&local_var_content).ok();
316 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
317 Err(Error::ResponseError(local_var_error))
318 }
319}
320
321pub async fn get_log_splunk(configuration: &mut configuration::Configuration, params: GetLogSplunkParams) -> Result<crate::models::LoggingSplunkResponse, Error<GetLogSplunkError>> {
323 let local_var_configuration = configuration;
324
325 let service_id = params.service_id;
327 let version_id = params.version_id;
328 let logging_splunk_name = params.logging_splunk_name;
329
330
331 let local_var_client = &local_var_configuration.client;
332
333 let local_var_uri_str = format!("{}/service/{service_id}/version/{version_id}/logging/splunk/{logging_splunk_name}", local_var_configuration.base_path, service_id=crate::apis::urlencode(service_id), version_id=version_id, logging_splunk_name=crate::apis::urlencode(logging_splunk_name));
334 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
335
336 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
337 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
338 }
339 if let Some(ref local_var_apikey) = local_var_configuration.api_key {
340 let local_var_key = local_var_apikey.key.clone();
341 let local_var_value = match local_var_apikey.prefix {
342 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
343 None => local_var_key,
344 };
345 local_var_req_builder = local_var_req_builder.header("Fastly-Key", local_var_value);
346 };
347
348 let local_var_req = local_var_req_builder.build()?;
349 let local_var_resp = local_var_client.execute(local_var_req).await?;
350
351 if "GET" != "GET" && "GET" != "HEAD" {
352 let headers = local_var_resp.headers();
353 local_var_configuration.rate_limit_remaining = match headers.get("Fastly-RateLimit-Remaining") {
354 Some(v) => v.to_str().unwrap().parse().unwrap(),
355 None => configuration::DEFAULT_RATELIMIT,
356 };
357 local_var_configuration.rate_limit_reset = match headers.get("Fastly-RateLimit-Reset") {
358 Some(v) => v.to_str().unwrap().parse().unwrap(),
359 None => 0,
360 };
361 }
362
363 let local_var_status = local_var_resp.status();
364 let local_var_content = local_var_resp.text().await?;
365
366 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
367 serde_json::from_str(&local_var_content).map_err(Error::from)
368 } else {
369 let local_var_entity: Option<GetLogSplunkError> = serde_json::from_str(&local_var_content).ok();
370 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
371 Err(Error::ResponseError(local_var_error))
372 }
373}
374
375pub async fn list_log_splunk(configuration: &mut configuration::Configuration, params: ListLogSplunkParams) -> Result<Vec<crate::models::LoggingSplunkResponse>, Error<ListLogSplunkError>> {
377 let local_var_configuration = configuration;
378
379 let service_id = params.service_id;
381 let version_id = params.version_id;
382
383
384 let local_var_client = &local_var_configuration.client;
385
386 let local_var_uri_str = format!("{}/service/{service_id}/version/{version_id}/logging/splunk", local_var_configuration.base_path, service_id=crate::apis::urlencode(service_id), version_id=version_id);
387 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
388
389 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
390 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
391 }
392 if let Some(ref local_var_apikey) = local_var_configuration.api_key {
393 let local_var_key = local_var_apikey.key.clone();
394 let local_var_value = match local_var_apikey.prefix {
395 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
396 None => local_var_key,
397 };
398 local_var_req_builder = local_var_req_builder.header("Fastly-Key", local_var_value);
399 };
400
401 let local_var_req = local_var_req_builder.build()?;
402 let local_var_resp = local_var_client.execute(local_var_req).await?;
403
404 if "GET" != "GET" && "GET" != "HEAD" {
405 let headers = local_var_resp.headers();
406 local_var_configuration.rate_limit_remaining = match headers.get("Fastly-RateLimit-Remaining") {
407 Some(v) => v.to_str().unwrap().parse().unwrap(),
408 None => configuration::DEFAULT_RATELIMIT,
409 };
410 local_var_configuration.rate_limit_reset = match headers.get("Fastly-RateLimit-Reset") {
411 Some(v) => v.to_str().unwrap().parse().unwrap(),
412 None => 0,
413 };
414 }
415
416 let local_var_status = local_var_resp.status();
417 let local_var_content = local_var_resp.text().await?;
418
419 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
420 serde_json::from_str(&local_var_content).map_err(Error::from)
421 } else {
422 let local_var_entity: Option<ListLogSplunkError> = serde_json::from_str(&local_var_content).ok();
423 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
424 Err(Error::ResponseError(local_var_error))
425 }
426}
427
428pub async fn update_log_splunk(configuration: &mut configuration::Configuration, params: UpdateLogSplunkParams) -> Result<crate::models::LoggingSplunkResponse, Error<UpdateLogSplunkError>> {
430 let local_var_configuration = configuration;
431
432 let service_id = params.service_id;
434 let version_id = params.version_id;
435 let logging_splunk_name = params.logging_splunk_name;
436 let name = params.name;
437 let placement = params.placement;
438 let response_condition = params.response_condition;
439 let format = params.format;
440 let format_version = params.format_version;
441 let tls_ca_cert = params.tls_ca_cert;
442 let tls_client_cert = params.tls_client_cert;
443 let tls_client_key = params.tls_client_key;
444 let tls_hostname = params.tls_hostname;
445 let request_max_entries = params.request_max_entries;
446 let request_max_bytes = params.request_max_bytes;
447 let url = params.url;
448 let token = params.token;
449 let use_tls = params.use_tls;
450
451
452 let local_var_client = &local_var_configuration.client;
453
454 let local_var_uri_str = format!("{}/service/{service_id}/version/{version_id}/logging/splunk/{logging_splunk_name}", local_var_configuration.base_path, service_id=crate::apis::urlencode(service_id), version_id=version_id, logging_splunk_name=crate::apis::urlencode(logging_splunk_name));
455 let mut local_var_req_builder = local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
456
457 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
458 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
459 }
460 if let Some(ref local_var_apikey) = local_var_configuration.api_key {
461 let local_var_key = local_var_apikey.key.clone();
462 let local_var_value = match local_var_apikey.prefix {
463 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
464 None => local_var_key,
465 };
466 local_var_req_builder = local_var_req_builder.header("Fastly-Key", local_var_value);
467 };
468 let mut local_var_form_params = std::collections::HashMap::new();
469 if let Some(local_var_param_value) = name {
470 local_var_form_params.insert("name", local_var_param_value.to_string());
471 }
472 if let Some(local_var_param_value) = placement {
473 local_var_form_params.insert("placement", local_var_param_value.to_string());
474 }
475 if let Some(local_var_param_value) = response_condition {
476 local_var_form_params.insert("response_condition", local_var_param_value.to_string());
477 }
478 if let Some(local_var_param_value) = format {
479 local_var_form_params.insert("format", local_var_param_value.to_string());
480 }
481 if let Some(local_var_param_value) = format_version {
482 local_var_form_params.insert("format_version", local_var_param_value.to_string());
483 }
484 if let Some(local_var_param_value) = tls_ca_cert {
485 local_var_form_params.insert("tls_ca_cert", local_var_param_value.to_string());
486 }
487 if let Some(local_var_param_value) = tls_client_cert {
488 local_var_form_params.insert("tls_client_cert", local_var_param_value.to_string());
489 }
490 if let Some(local_var_param_value) = tls_client_key {
491 local_var_form_params.insert("tls_client_key", local_var_param_value.to_string());
492 }
493 if let Some(local_var_param_value) = tls_hostname {
494 local_var_form_params.insert("tls_hostname", local_var_param_value.to_string());
495 }
496 if let Some(local_var_param_value) = request_max_entries {
497 local_var_form_params.insert("request_max_entries", local_var_param_value.to_string());
498 }
499 if let Some(local_var_param_value) = request_max_bytes {
500 local_var_form_params.insert("request_max_bytes", local_var_param_value.to_string());
501 }
502 if let Some(local_var_param_value) = url {
503 local_var_form_params.insert("url", local_var_param_value.to_string());
504 }
505 if let Some(local_var_param_value) = token {
506 local_var_form_params.insert("token", local_var_param_value.to_string());
507 }
508 if let Some(local_var_param_value) = use_tls {
509 local_var_form_params.insert("use_tls", local_var_param_value.to_string());
510 }
511 local_var_req_builder = local_var_req_builder.form(&local_var_form_params);
512
513 let local_var_req = local_var_req_builder.build()?;
514 let local_var_resp = local_var_client.execute(local_var_req).await?;
515
516 if "PUT" != "GET" && "PUT" != "HEAD" {
517 let headers = local_var_resp.headers();
518 local_var_configuration.rate_limit_remaining = match headers.get("Fastly-RateLimit-Remaining") {
519 Some(v) => v.to_str().unwrap().parse().unwrap(),
520 None => configuration::DEFAULT_RATELIMIT,
521 };
522 local_var_configuration.rate_limit_reset = match headers.get("Fastly-RateLimit-Reset") {
523 Some(v) => v.to_str().unwrap().parse().unwrap(),
524 None => 0,
525 };
526 }
527
528 let local_var_status = local_var_resp.status();
529 let local_var_content = local_var_resp.text().await?;
530
531 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
532 serde_json::from_str(&local_var_content).map_err(Error::from)
533 } else {
534 let local_var_entity: Option<UpdateLogSplunkError> = serde_json::from_str(&local_var_content).ok();
535 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
536 Err(Error::ResponseError(local_var_error))
537 }
538}
539