1use reqwest;
10
11use crate::apis::ResponseContent;
12use super::{Error, configuration};
13
14#[derive(Clone, Debug, Default)]
16pub struct CreatePoolServerParams {
17    pub service_id: String,
19    pub pool_id: String,
21    pub weight: Option<i32>,
23    pub max_conn: Option<i32>,
25    pub port: Option<i32>,
27    pub address: Option<String>,
29    pub comment: Option<String>,
31    pub disabled: Option<bool>,
33    pub override_host: Option<String>
35}
36
37#[derive(Clone, Debug, Default)]
39pub struct DeletePoolServerParams {
40    pub service_id: String,
42    pub pool_id: String,
44    pub server_id: String
46}
47
48#[derive(Clone, Debug, Default)]
50pub struct GetPoolServerParams {
51    pub service_id: String,
53    pub pool_id: String,
55    pub server_id: String
57}
58
59#[derive(Clone, Debug, Default)]
61pub struct ListPoolServersParams {
62    pub service_id: String,
64    pub pool_id: String
66}
67
68#[derive(Clone, Debug, Default)]
70pub struct UpdatePoolServerParams {
71    pub service_id: String,
73    pub pool_id: String,
75    pub server_id: String,
77    pub weight: Option<i32>,
79    pub max_conn: Option<i32>,
81    pub port: Option<i32>,
83    pub address: Option<String>,
85    pub comment: Option<String>,
87    pub disabled: Option<bool>,
89    pub override_host: Option<String>
91}
92
93
94#[derive(Debug, Clone, Serialize, Deserialize)]
96#[serde(untagged)]
97pub enum CreatePoolServerError {
98    UnknownValue(serde_json::Value),
99}
100
101#[derive(Debug, Clone, Serialize, Deserialize)]
103#[serde(untagged)]
104pub enum DeletePoolServerError {
105    UnknownValue(serde_json::Value),
106}
107
108#[derive(Debug, Clone, Serialize, Deserialize)]
110#[serde(untagged)]
111pub enum GetPoolServerError {
112    UnknownValue(serde_json::Value),
113}
114
115#[derive(Debug, Clone, Serialize, Deserialize)]
117#[serde(untagged)]
118pub enum ListPoolServersError {
119    UnknownValue(serde_json::Value),
120}
121
122#[derive(Debug, Clone, Serialize, Deserialize)]
124#[serde(untagged)]
125pub enum UpdatePoolServerError {
126    UnknownValue(serde_json::Value),
127}
128
129
130pub async fn create_pool_server(configuration: &mut configuration::Configuration, params: CreatePoolServerParams) -> Result<crate::models::ServerResponse, Error<CreatePoolServerError>> {
132    let local_var_configuration = configuration;
133
134    let service_id = params.service_id;
136    let pool_id = params.pool_id;
137    let weight = params.weight;
138    let max_conn = params.max_conn;
139    let port = params.port;
140    let address = params.address;
141    let comment = params.comment;
142    let disabled = params.disabled;
143    let override_host = params.override_host;
144
145
146    let local_var_client = &local_var_configuration.client;
147
148    let local_var_uri_str = format!("{}/service/{service_id}/pool/{pool_id}/server", local_var_configuration.base_path, service_id=crate::apis::urlencode(service_id), pool_id=crate::apis::urlencode(pool_id));
149    let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
150
151    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
152        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
153    }
154    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
155        let local_var_key = local_var_apikey.key.clone();
156        let local_var_value = match local_var_apikey.prefix {
157            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
158            None => local_var_key,
159        };
160        local_var_req_builder = local_var_req_builder.header("Fastly-Key", local_var_value);
161    };
162    let mut local_var_form_params = std::collections::HashMap::new();
163    if let Some(local_var_param_value) = weight {
164        local_var_form_params.insert("weight", local_var_param_value.to_string());
165    }
166    if let Some(local_var_param_value) = max_conn {
167        local_var_form_params.insert("max_conn", local_var_param_value.to_string());
168    }
169    if let Some(local_var_param_value) = port {
170        local_var_form_params.insert("port", local_var_param_value.to_string());
171    }
172    if let Some(local_var_param_value) = address {
173        local_var_form_params.insert("address", local_var_param_value.to_string());
174    }
175    if let Some(local_var_param_value) = comment {
176        local_var_form_params.insert("comment", local_var_param_value.to_string());
177    }
178    if let Some(local_var_param_value) = disabled {
179        local_var_form_params.insert("disabled", local_var_param_value.to_string());
180    }
181    if let Some(local_var_param_value) = override_host {
182        local_var_form_params.insert("override_host", local_var_param_value.to_string());
183    }
184    local_var_req_builder = local_var_req_builder.form(&local_var_form_params);
185
186    let local_var_req = local_var_req_builder.build()?;
187    let local_var_resp = local_var_client.execute(local_var_req).await?;
188
189    if "POST" != "GET" && "POST" != "HEAD" {
190      let headers = local_var_resp.headers();
191      local_var_configuration.rate_limit_remaining = match headers.get("Fastly-RateLimit-Remaining") {
192          Some(v) => v.to_str().unwrap().parse().unwrap(),
193          None => configuration::DEFAULT_RATELIMIT,
194      };
195      local_var_configuration.rate_limit_reset = match headers.get("Fastly-RateLimit-Reset") {
196          Some(v) => v.to_str().unwrap().parse().unwrap(),
197          None => 0,
198      };
199    }
200
201    let local_var_status = local_var_resp.status();
202    let local_var_content = local_var_resp.text().await?;
203
204    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
205        serde_json::from_str(&local_var_content).map_err(Error::from)
206    } else {
207        let local_var_entity: Option<CreatePoolServerError> = serde_json::from_str(&local_var_content).ok();
208        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
209        Err(Error::ResponseError(local_var_error))
210    }
211}
212
213pub async fn delete_pool_server(configuration: &mut configuration::Configuration, params: DeletePoolServerParams) -> Result<crate::models::InlineResponse200, Error<DeletePoolServerError>> {
215    let local_var_configuration = configuration;
216
217    let service_id = params.service_id;
219    let pool_id = params.pool_id;
220    let server_id = params.server_id;
221
222
223    let local_var_client = &local_var_configuration.client;
224
225    let local_var_uri_str = format!("{}/service/{service_id}/pool/{pool_id}/server/{server_id}", local_var_configuration.base_path, service_id=crate::apis::urlencode(service_id), pool_id=crate::apis::urlencode(pool_id), server_id=crate::apis::urlencode(server_id));
226    let mut local_var_req_builder = local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
227
228    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
229        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
230    }
231    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
232        let local_var_key = local_var_apikey.key.clone();
233        let local_var_value = match local_var_apikey.prefix {
234            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
235            None => local_var_key,
236        };
237        local_var_req_builder = local_var_req_builder.header("Fastly-Key", local_var_value);
238    };
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 "DELETE" != "GET" && "DELETE" != "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<DeletePoolServerError> = 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 get_pool_server(configuration: &mut configuration::Configuration, params: GetPoolServerParams) -> Result<crate::models::ServerResponse, Error<GetPoolServerError>> {
269    let local_var_configuration = configuration;
270
271    let service_id = params.service_id;
273    let pool_id = params.pool_id;
274    let server_id = params.server_id;
275
276
277    let local_var_client = &local_var_configuration.client;
278
279    let local_var_uri_str = format!("{}/service/{service_id}/pool/{pool_id}/server/{server_id}", local_var_configuration.base_path, service_id=crate::apis::urlencode(service_id), pool_id=crate::apis::urlencode(pool_id), server_id=crate::apis::urlencode(server_id));
280    let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, 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 "GET" != "GET" && "GET" != "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<GetPoolServerError> = 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 list_pool_servers(configuration: &mut configuration::Configuration, params: ListPoolServersParams) -> Result<Vec<crate::models::ServerResponse>, Error<ListPoolServersError>> {
323    let local_var_configuration = configuration;
324
325    let service_id = params.service_id;
327    let pool_id = params.pool_id;
328
329
330    let local_var_client = &local_var_configuration.client;
331
332    let local_var_uri_str = format!("{}/service/{service_id}/pool/{pool_id}/servers", local_var_configuration.base_path, service_id=crate::apis::urlencode(service_id), pool_id=crate::apis::urlencode(pool_id));
333    let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
334
335    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
336        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
337    }
338    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
339        let local_var_key = local_var_apikey.key.clone();
340        let local_var_value = match local_var_apikey.prefix {
341            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
342            None => local_var_key,
343        };
344        local_var_req_builder = local_var_req_builder.header("Fastly-Key", local_var_value);
345    };
346
347    let local_var_req = local_var_req_builder.build()?;
348    let local_var_resp = local_var_client.execute(local_var_req).await?;
349
350    if "GET" != "GET" && "GET" != "HEAD" {
351      let headers = local_var_resp.headers();
352      local_var_configuration.rate_limit_remaining = match headers.get("Fastly-RateLimit-Remaining") {
353          Some(v) => v.to_str().unwrap().parse().unwrap(),
354          None => configuration::DEFAULT_RATELIMIT,
355      };
356      local_var_configuration.rate_limit_reset = match headers.get("Fastly-RateLimit-Reset") {
357          Some(v) => v.to_str().unwrap().parse().unwrap(),
358          None => 0,
359      };
360    }
361
362    let local_var_status = local_var_resp.status();
363    let local_var_content = local_var_resp.text().await?;
364
365    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
366        serde_json::from_str(&local_var_content).map_err(Error::from)
367    } else {
368        let local_var_entity: Option<ListPoolServersError> = serde_json::from_str(&local_var_content).ok();
369        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
370        Err(Error::ResponseError(local_var_error))
371    }
372}
373
374pub async fn update_pool_server(configuration: &mut configuration::Configuration, params: UpdatePoolServerParams) -> Result<crate::models::ServerResponse, Error<UpdatePoolServerError>> {
376    let local_var_configuration = configuration;
377
378    let service_id = params.service_id;
380    let pool_id = params.pool_id;
381    let server_id = params.server_id;
382    let weight = params.weight;
383    let max_conn = params.max_conn;
384    let port = params.port;
385    let address = params.address;
386    let comment = params.comment;
387    let disabled = params.disabled;
388    let override_host = params.override_host;
389
390
391    let local_var_client = &local_var_configuration.client;
392
393    let local_var_uri_str = format!("{}/service/{service_id}/pool/{pool_id}/server/{server_id}", local_var_configuration.base_path, service_id=crate::apis::urlencode(service_id), pool_id=crate::apis::urlencode(pool_id), server_id=crate::apis::urlencode(server_id));
394    let mut local_var_req_builder = local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
395
396    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
397        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
398    }
399    if let Some(ref local_var_apikey) = local_var_configuration.api_key {
400        let local_var_key = local_var_apikey.key.clone();
401        let local_var_value = match local_var_apikey.prefix {
402            Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
403            None => local_var_key,
404        };
405        local_var_req_builder = local_var_req_builder.header("Fastly-Key", local_var_value);
406    };
407    let mut local_var_form_params = std::collections::HashMap::new();
408    if let Some(local_var_param_value) = weight {
409        local_var_form_params.insert("weight", local_var_param_value.to_string());
410    }
411    if let Some(local_var_param_value) = max_conn {
412        local_var_form_params.insert("max_conn", local_var_param_value.to_string());
413    }
414    if let Some(local_var_param_value) = port {
415        local_var_form_params.insert("port", local_var_param_value.to_string());
416    }
417    if let Some(local_var_param_value) = address {
418        local_var_form_params.insert("address", local_var_param_value.to_string());
419    }
420    if let Some(local_var_param_value) = comment {
421        local_var_form_params.insert("comment", local_var_param_value.to_string());
422    }
423    if let Some(local_var_param_value) = disabled {
424        local_var_form_params.insert("disabled", local_var_param_value.to_string());
425    }
426    if let Some(local_var_param_value) = override_host {
427        local_var_form_params.insert("override_host", local_var_param_value.to_string());
428    }
429    local_var_req_builder = local_var_req_builder.form(&local_var_form_params);
430
431    let local_var_req = local_var_req_builder.build()?;
432    let local_var_resp = local_var_client.execute(local_var_req).await?;
433
434    if "PUT" != "GET" && "PUT" != "HEAD" {
435      let headers = local_var_resp.headers();
436      local_var_configuration.rate_limit_remaining = match headers.get("Fastly-RateLimit-Remaining") {
437          Some(v) => v.to_str().unwrap().parse().unwrap(),
438          None => configuration::DEFAULT_RATELIMIT,
439      };
440      local_var_configuration.rate_limit_reset = match headers.get("Fastly-RateLimit-Reset") {
441          Some(v) => v.to_str().unwrap().parse().unwrap(),
442          None => 0,
443      };
444    }
445
446    let local_var_status = local_var_resp.status();
447    let local_var_content = local_var_resp.text().await?;
448
449    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
450        serde_json::from_str(&local_var_content).map_err(Error::from)
451    } else {
452        let local_var_entity: Option<UpdatePoolServerError> = serde_json::from_str(&local_var_content).ok();
453        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
454        Err(Error::ResponseError(local_var_error))
455    }
456}
457