rust_eureka/response/amazonmetadata.rs
1//use serde::ser::{Serialize, Serializer, SerializeStruct};
2//use serde::de::{Deserialize, Deserializer, Visitor, Error as DeError, MapAccess};
3//use std::fmt;
4//
5//const AMI_LAUNCH_INDEX: &'static str = "ami-launch-index";
6//const LOCAL_HOSTNAME: &'static str = "local-hostname";
7//const AVAILABILITY_ZONE: &'static str = "availability-zone";
8//const INSTANCE_ID: &'static str = "instance-id";
9//const PUBLIC_IPV4: &'static str = "public-ipv4";
10//const PUBLIC_HOSTNAME: &'static str = "public-hostname";
11//const AMI_MANIFEST_PATH: &'static str = "ami-manifest-path";
12//const LOCAL_IPV4: &'static str = "local-ipv4";
13//const HOSTNAME: &'static str = "hostname";
14//const AMI_ID: &'static str = "ami-id";
15//const INSTANCE_TYPE: &'static str = "instance-type";
16//const JSON_FIELDS: &'static [&'static str] = &[AMI_LAUNCH_INDEX, LOCAL_HOSTNAME, AVAILABILITY_ZONE, INSTANCE_ID,
17// PUBLIC_IPV4, PUBLIC_HOSTNAME, AMI_MANIFEST_PATH, LOCAL_IPV4,
18// HOSTNAME, AMI_ID, INSTANCE_TYPE];
19//const RUST_FIELDS: &'static [&'static str] = &["ami_launch_index", "local_hostname", "availability_zone", "instance_id",
20// "public_ip4", "public_hostname", "ami_manifest_path", "local_ip4", "hostname", "ami_id", "instance_type"];
21//const AMAZON_META_DATA: &'static str = "AmazonMetaData";
22
23#[derive(Debug, PartialEq, Serialize, Deserialize)]
24#[serde(rename_all = "kebab-case")]
25pub struct AmazonMetaData {
26 pub ami_launch_index: String,
27 pub local_hostname: String,
28 pub availability_zone: String,
29 pub instance_id: String,
30 pub public_ipv4: String,
31 pub public_hostname: String,
32 pub ami_manifest_path: String,
33 pub local_ipv4: String,
34 pub hostname: String,
35 pub ami_id: String,
36 pub instance_type: String
37}
38
39//impl Serialize for AmazonMetaData {
40// fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
41// S: Serializer {
42// let mut s = serializer.serialize_struct(AMAZON_META_DATA, 11)?;
43// s.serialize_field(AMI_LAUNCH_INDEX, &self.ami_launch_index)?;
44// s.serialize_field(LOCAL_HOSTNAME, &self.local_hostname)?;
45// s.serialize_field(AVAILABILITY_ZONE, &self.availability_zone)?;
46// s.serialize_field(INSTANCE_ID, &self.instance_id)?;
47// s.serialize_field(PUBLIC_IPV4, &self.public_ip4)?;
48// s.serialize_field(PUBLIC_HOSTNAME, &self.public_hostname)?;
49// s.serialize_field(AMI_MANIFEST_PATH, &self.ami_manifest_path)?;
50// s.serialize_field(LOCAL_IPV4, &self.local_ip4)?;
51// s.serialize_field(HOSTNAME, &self.hostname)?;
52// s.serialize_field(AMI_ID, &self.ami_id)?;
53// s.serialize_field(INSTANCE_TYPE, &self.instance_type)?;
54// s.end()
55// }
56//}
57
58//impl<'de> Deserialize<'de> for AmazonMetaData {
59// fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
60// D: Deserializer<'de> {
61// enum Field { AmiLaunchIndex, LocalHostname, AvailabilityZone, InstanceId, PublicIp4, PublicHostname, AmiManifestPath, LocalIp4, Hostname, AmiId, InstanceType };
62//
63// impl<'de> Deserialize<'de> for Field {
64// fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
65// D: Deserializer<'de> {
66// struct FieldVisitor;
67//
68// impl<'de> Visitor<'de> for FieldVisitor {
69// type Value = Field;
70//
71// fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
72// formatter.write_str("An AmazonMetaData field (see schema)")
73// }
74//
75// fn visit_str<E>(self, v: &str) -> Result<Self::Value, E> where
76// E: DeError {
77// match v {
78// AMI_LAUNCH_INDEX => Ok(Field::AmiLaunchIndex),
79// LOCAL_HOSTNAME => Ok(Field::LocalHostname),
80// AVAILABILITY_ZONE => Ok(Field::AvailabilityZone),
81// INSTANCE_ID => Ok(Field::InstanceId),
82// PUBLIC_IPV4 => Ok(Field::PublicIp4),
83// PUBLIC_HOSTNAME => Ok(Field::PublicHostname),
84// AMI_MANIFEST_PATH => Ok(Field::AmiManifestPath),
85// LOCAL_IPV4 => Ok(Field::LocalIp4),
86// HOSTNAME => Ok(Field::Hostname),
87// AMI_ID => Ok(Field::AmiId),
88// INSTANCE_TYPE => Ok(Field::InstanceType),
89// _ => Err(DeError::unknown_field(v, JSON_FIELDS))
90// }
91// }
92// }
93//
94// deserializer.deserialize_identifier(FieldVisitor)
95// }
96// }
97//
98// struct AmazonMetaDataVisitor;
99//
100// impl<'de> Visitor<'de> for AmazonMetaDataVisitor {
101// type Value = AmazonMetaData;
102//
103// fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
104// formatter.write_str("struct AmazonMetaDataVisitor")
105// }
106//
107// fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error> where
108// A: MapAccess<'de> {
109// let mut maybe_ami_launch_index = None;
110// let mut maybe_local_hostname = None;
111// let mut maybe_availability_zone = None;
112// let mut maybe_instance_id = None;
113// let mut maybe_public_ip4 = None;
114// let mut maybe_public_hostname = None;
115// let mut maybe_ami_manifest_path = None;
116// let mut maybe_local_ip4 = None;
117// let mut maybe_hostname = None;
118// let mut maybe_ami_id = None;
119// let mut maybe_instance_type = None;
120//
121// while let Some(key) = map.next_key()? {
122// match key {
123// Field::AmiLaunchIndex => {
124// if maybe_ami_launch_index.is_some() {
125// return Err(DeError::duplicate_field(AMI_LAUNCH_INDEX));
126// }
127// maybe_ami_launch_index = Some(map.next_value()?)
128// },
129// Field::LocalHostname => {
130// if maybe_local_hostname.is_some() {
131// return Err(DeError::duplicate_field(LOCAL_HOSTNAME));
132// }
133// maybe_local_hostname = Some(map.next_value()?)
134// },
135// Field::AvailabilityZone => {
136// if maybe_availability_zone.is_some() {
137// return Err(DeError::duplicate_field(AVAILABILITY_ZONE));
138// }
139// maybe_availability_zone= Some(map.next_value()?)
140// },
141// Field::InstanceId => {
142// if maybe_instance_id.is_some() {
143// return Err(DeError::duplicate_field(INSTANCE_ID));
144// }
145// maybe_instance_id= Some(map.next_value()?)
146// },
147// Field::PublicIp4 => {
148// if maybe_public_ip4.is_some() {
149// return Err(DeError::duplicate_field(PUBLIC_IPV4));
150// }
151// maybe_public_ip4= Some(map.next_value()?)
152// },
153// Field::PublicHostname => {
154// if maybe_public_hostname.is_some() {
155// return Err(DeError::duplicate_field(PUBLIC_HOSTNAME));
156// }
157// maybe_public_hostname= Some(map.next_value()?)
158// },
159// Field::AmiManifestPath => {
160// if maybe_ami_manifest_path.is_some() {
161// return Err(DeError::duplicate_field(AMI_MANIFEST_PATH));
162// }
163// maybe_ami_manifest_path= Some(map.next_value()?)
164// },
165// Field::LocalIp4 => {
166// if maybe_local_ip4.is_some() {
167// return Err(DeError::duplicate_field(LOCAL_IPV4));
168// }
169// maybe_local_ip4= Some(map.next_value()?)
170// },
171// Field::Hostname => {
172// if maybe_hostname.is_some() {
173// return Err(DeError::duplicate_field(HOSTNAME));
174// }
175// maybe_hostname= Some(map.next_value()?)
176// },
177// Field::AmiId => {
178// if maybe_ami_id.is_some() {
179// return Err(DeError::duplicate_field(AMI_ID));
180// }
181// maybe_ami_id= Some(map.next_value()?)
182// },
183// Field::InstanceType => {
184// if maybe_instance_type.is_some() {
185// return Err(DeError::duplicate_field(INSTANCE_TYPE));
186// }
187// maybe_instance_type= Some(map.next_value()?)
188// }
189// }
190// }
191//
192// let ami_launch_index = maybe_ami_launch_index.ok_or_else(|| DeError::missing_field(AMI_LAUNCH_INDEX));
193// let local_hostname = maybe_local_hostname.ok_or_else(|| DeError::missing_field(LOCAL_HOSTNAME));
194// let availability_zone = maybe_availability_zone.ok_or_else(|| DeError::missing_field(AVAILABILITY_ZONE));
195// let instance_id = maybe_instance_id.ok_or_else(|| DeError::missing_field(INSTANCE_ID));
196// let public_ip4 = maybe_public_ip4.ok_or_else(|| DeError::missing_field(PUBLIC_IPV4));
197// let public_hostname = maybe_public_hostname.ok_or_else(|| DeError::missing_field(PUBLIC_HOSTNAME));
198// let ami_manifest_path = maybe_ami_manifest_path.ok_or_else(|| DeError::missing_field(AMI_MANIFEST_PATH));
199// let local_ip4 = maybe_local_ip4.ok_or_else(|| DeError::missing_field(LOCAL_IPV4));
200// let hostname = maybe_hostname.ok_or_else(|| DeError::missing_field(HOSTNAME));
201// let ami_id = maybe_ami_id.ok_or_else(|| DeError::missing_field(AMI_ID));
202// let instance_type = maybe_instance_type.ok_or_else(|| DeError::missing_field(INSTANCE_TYPE));
203//
204// Ok(AmazonMetaData {
205// ami_launch_index: ami_launch_index?,
206// local_hostname: local_hostname?,
207// availability_zone: availability_zone?,
208// instance_id: instance_id?,
209// public_ip4: public_ip4?,
210// public_hostname: public_hostname?,
211// ami_manifest_path: ami_manifest_path?,
212// local_ip4: local_ip4?,
213// hostname: hostname?,
214// ami_id: ami_id?,
215// instance_type: instance_type?
216// })
217// }
218// }
219// deserializer.deserialize_struct(AMAZON_META_DATA, RUST_FIELDS, AmazonMetaDataVisitor)
220// }
221//}
222
223#[cfg(test)]
224pub mod tests {
225 use super::*;
226 use serde_json;
227
228 #[test]
229 fn test_serialize_amazon_meta_data() {
230 let md = AmazonMetaData {
231 ami_launch_index: "001a".to_string(),
232 local_hostname: "localhost0".to_string(),
233 availability_zone: "US_East1a".to_string(),
234 instance_id: "instance1a".to_string(),
235 public_ipv4: "32.23.21.212".to_string(),
236 public_hostname: "foo.coma".to_string(),
237 ami_manifest_path: "/dev/nulla".to_string(),
238 local_ipv4: "127.0.0.12".to_string(),
239 hostname: "privatefoo.coma".to_string(),
240 ami_id: "ami0023".to_string(),
241 instance_type: "c4xlarged".to_string()
242 };
243 let json = sample_meta_data();
244
245 let result = serde_json::to_string(&md).unwrap();
246 assert_eq!(json, result);
247 }
248
249 #[test]
250 fn test_deserialize_amazon_meta_data() {
251 let md = AmazonMetaData {
252 ami_launch_index: "001a".to_string(),
253 local_hostname: "localhost0".to_string(),
254 availability_zone: "US_East1a".to_string(),
255 instance_id: "instance1a".to_string(),
256 public_ipv4: "32.23.21.212".to_string(),
257 public_hostname: "foo.coma".to_string(),
258 ami_manifest_path: "/dev/nulla".to_string(),
259 local_ipv4: "127.0.0.12".to_string(),
260 hostname: "privatefoo.coma".to_string(),
261 ami_id: "ami0023".to_string(),
262 instance_type: "c4xlarged".to_string()
263 };
264 let json = sample_meta_data();
265 let result = serde_json::from_str(&json).unwrap();
266 assert_eq!(md, result);
267 }
268
269 pub fn sample_meta_data() -> String {
270 r#"{ "ami-launch-index": "001a",
271 "local-hostname": "localhost0",
272 "availability-zone": "US_East1a",
273 "instance-id": "instance1a",
274 "public-ipv4": "32.23.21.212",
275 "public-hostname": "foo.coma",
276 "ami-manifest-path": "/dev/nulla",
277 "local-ipv4": "127.0.0.12",
278 "hostname": "privatefoo.coma",
279 "ami-id": "ami0023",
280 "instance-type": "c4xlarged" }"#
281 .to_string()
282 .replace(" ", "")
283 .replace("\n", "")
284 }
285}