openstack_sdk/api/network/v2/agent/
list.rs1use derive_builder::Builder;
38use http::{HeaderMap, HeaderName, HeaderValue};
39
40use crate::api::rest_endpoint_prelude::*;
41
42use std::borrow::Cow;
43
44use crate::api::Pageable;
45#[derive(Builder, Debug, Clone)]
46#[builder(setter(strip_option))]
47pub struct Request<'a> {
48 #[builder(default)]
50 admin_state_up: Option<bool>,
51
52 #[builder(default, setter(into))]
54 agent_type: Option<Cow<'a, str>>,
55
56 #[builder(default, setter(into))]
58 alive: Option<Cow<'a, str>>,
59
60 #[builder(default, setter(into))]
62 availability_zone: Option<Cow<'a, str>>,
63
64 #[builder(default, setter(into))]
66 binary: Option<Cow<'a, str>>,
67
68 #[builder(default, setter(into))]
70 description: Option<Cow<'a, str>>,
71
72 #[builder(default, setter(into))]
74 host: Option<Cow<'a, str>>,
75
76 #[builder(default, setter(into))]
78 id: Option<Cow<'a, str>>,
79
80 #[builder(default)]
85 limit: Option<u32>,
86
87 #[builder(default, setter(into))]
91 marker: Option<Cow<'a, str>>,
92
93 #[builder(default)]
95 page_reverse: Option<bool>,
96
97 #[builder(default, private, setter(name = "_sort_dir"))]
100 sort_dir: Option<Vec<Cow<'a, str>>>,
101
102 #[builder(default, private, setter(name = "_sort_key"))]
105 sort_key: Option<Vec<Cow<'a, str>>>,
106
107 #[builder(default, setter(into))]
109 topic: Option<Cow<'a, str>>,
110
111 #[builder(setter(name = "_headers"), default, private)]
112 _headers: Option<HeaderMap>,
113}
114impl<'a> Request<'a> {
115 pub fn builder() -> RequestBuilder<'a> {
117 RequestBuilder::default()
118 }
119}
120
121impl<'a> RequestBuilder<'a> {
122 pub fn sort_dir<I, T>(&mut self, iter: I) -> &mut Self
125 where
126 I: Iterator<Item = T>,
127 T: Into<Cow<'a, str>>,
128 {
129 self.sort_dir
130 .get_or_insert(None)
131 .get_or_insert_with(Vec::new)
132 .extend(iter.map(Into::into));
133 self
134 }
135
136 pub fn sort_key<I, T>(&mut self, iter: I) -> &mut Self
139 where
140 I: Iterator<Item = T>,
141 T: Into<Cow<'a, str>>,
142 {
143 self.sort_key
144 .get_or_insert(None)
145 .get_or_insert_with(Vec::new)
146 .extend(iter.map(Into::into));
147 self
148 }
149
150 pub fn header<K, V>(&mut self, header_name: K, header_value: V) -> &mut Self
152 where
153 K: Into<HeaderName>,
154 V: Into<HeaderValue>,
155 {
156 self._headers
157 .get_or_insert(None)
158 .get_or_insert_with(HeaderMap::new)
159 .insert(header_name.into(), header_value.into());
160 self
161 }
162
163 pub fn headers<I, T>(&mut self, iter: I) -> &mut Self
165 where
166 I: Iterator<Item = T>,
167 T: Into<(Option<HeaderName>, HeaderValue)>,
168 {
169 self._headers
170 .get_or_insert(None)
171 .get_or_insert_with(HeaderMap::new)
172 .extend(iter.map(Into::into));
173 self
174 }
175}
176
177impl RestEndpoint for Request<'_> {
178 fn method(&self) -> http::Method {
179 http::Method::GET
180 }
181
182 fn endpoint(&self) -> Cow<'static, str> {
183 "agents".to_string().into()
184 }
185
186 fn parameters(&self) -> QueryParams<'_> {
187 let mut params = QueryParams::default();
188 params.push_opt("admin_state_up", self.admin_state_up);
189 params.push_opt("agent_type", self.agent_type.as_ref());
190 params.push_opt("alive", self.alive.as_ref());
191 params.push_opt("availability_zone", self.availability_zone.as_ref());
192 params.push_opt("binary", self.binary.as_ref());
193 params.push_opt("description", self.description.as_ref());
194 params.push_opt("host", self.host.as_ref());
195 params.push_opt("id", self.id.as_ref());
196 params.push_opt("topic", self.topic.as_ref());
197 params.push_opt("limit", self.limit);
198 params.push_opt("marker", self.marker.as_ref());
199 params.push_opt("page_reverse", self.page_reverse);
200 if let Some(val) = &self.sort_dir {
201 params.extend(val.iter().map(|value| ("sort_dir", value)));
202 }
203 if let Some(val) = &self.sort_key {
204 params.extend(val.iter().map(|value| ("sort_key", value)));
205 }
206
207 params
208 }
209
210 fn service_type(&self) -> ServiceType {
211 ServiceType::Network
212 }
213
214 fn response_key(&self) -> Option<Cow<'static, str>> {
215 Some("agents".into())
216 }
217
218 fn request_headers(&self) -> Option<&HeaderMap> {
220 self._headers.as_ref()
221 }
222
223 fn api_version(&self) -> Option<ApiVersion> {
225 Some(ApiVersion::new(2, 0))
226 }
227}
228impl Pageable for Request<'_> {}
229
230#[cfg(test)]
231mod tests {
232 use super::*;
233 #[cfg(feature = "sync")]
234 use crate::api::Query;
235 use crate::test::client::FakeOpenStackClient;
236 use crate::types::ServiceType;
237 use http::{HeaderName, HeaderValue};
238 use httpmock::MockServer;
239 use serde_json::json;
240
241 #[test]
242 fn test_service_type() {
243 assert_eq!(
244 Request::builder().build().unwrap().service_type(),
245 ServiceType::Network
246 );
247 }
248
249 #[test]
250 fn test_response_key() {
251 assert_eq!(
252 Request::builder().build().unwrap().response_key().unwrap(),
253 "agents"
254 );
255 }
256
257 #[cfg(feature = "sync")]
258 #[test]
259 fn endpoint() {
260 let server = MockServer::start();
261 let client = FakeOpenStackClient::new(server.base_url());
262 let mock = server.mock(|when, then| {
263 when.method(httpmock::Method::GET)
264 .path("/agents".to_string());
265
266 then.status(200)
267 .header("content-type", "application/json")
268 .json_body(json!({ "agents": {} }));
269 });
270
271 let endpoint = Request::builder().build().unwrap();
272 let _: serde_json::Value = endpoint.query(&client).unwrap();
273 mock.assert();
274 }
275
276 #[cfg(feature = "sync")]
277 #[test]
278 fn endpoint_headers() {
279 let server = MockServer::start();
280 let client = FakeOpenStackClient::new(server.base_url());
281 let mock = server.mock(|when, then| {
282 when.method(httpmock::Method::GET)
283 .path("/agents".to_string())
284 .header("foo", "bar")
285 .header("not_foo", "not_bar");
286 then.status(200)
287 .header("content-type", "application/json")
288 .json_body(json!({ "agents": {} }));
289 });
290
291 let endpoint = Request::builder()
292 .headers(
293 [(
294 Some(HeaderName::from_static("foo")),
295 HeaderValue::from_static("bar"),
296 )]
297 .into_iter(),
298 )
299 .header(
300 HeaderName::from_static("not_foo"),
301 HeaderValue::from_static("not_bar"),
302 )
303 .build()
304 .unwrap();
305 let _: serde_json::Value = endpoint.query(&client).unwrap();
306 mock.assert();
307 }
308}