1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
//! Deals entirely with schema analysis for the purpose of creating output structs + members
use crate::{OutputMember, OutputStruct};
use anyhow::{bail, Result};
use k8s_openapi::apiextensions_apiserver::pkg::apis::apiextensions::v1::{
JSONSchemaProps, JSONSchemaPropsOrArray, JSONSchemaPropsOrBool,
};
use std::collections::{BTreeMap, HashMap};
const IGNORED_KEYS: [&str; 3] = ["metadata", "apiVersion", "kind"];
/// Scan a schema for structs and members, and recurse to find all structs
///
/// schema: root schema / sub schema
/// current: current key name (or empty string for first call) - must capitalize first letter
/// stack: stacked concat of kind + current_{n-1} + ... + current (used to create dedup names/types)
/// level: recursion level (start at 0)
/// results: multable list of generated structs (not deduplicated)
pub fn analyze(
schema: JSONSchemaProps,
current: &str,
stack: &str,
level: u8,
results: &mut Vec<OutputStruct>,
) -> Result<()> {
let props = schema.properties.clone().unwrap_or_default();
let mut array_recurse_level: HashMap<String, u8> = Default::default();
// first generate the object if it is one
let current_type = schema.type_.clone().unwrap_or_default();
if current_type == "object" {
// we can have additionalProperties XOR properties
// https://kubernetes.io/docs/tasks/extend-kubernetes/custom-resources/custom-resource-definitions/#validation
if let Some(JSONSchemaPropsOrBool::Schema(s)) = schema.additional_properties.as_ref() {
let dict_type = s.type_.clone().unwrap_or_default();
// object with additionalProperties == map
if let Some(extra_props) = &s.properties {
// map values is an object with properties
debug!("Generating map struct for {} (under {})", current, stack);
let new_result =
analyze_object_properties(&extra_props, stack, &mut array_recurse_level, level, &schema)?;
results.extend(new_result);
} else if !dict_type.is_empty() {
warn!("not generating type {} - using {} map", current, dict_type);
return Ok(()); // no members here - it'll be inlined
}
} else {
// else, regular properties only
debug!("Generating struct for {} (under {})", current, stack);
// initial analysis of properties (we do not recurse here, we need to find members first)
let new_result =
analyze_object_properties(&props, stack, &mut array_recurse_level, level, &schema)?;
results.extend(new_result);
}
}
// Start recursion for properties
for (key, value) in props {
if level == 0 && IGNORED_KEYS.contains(&(key.as_ref())) {
debug!("not recursing into ignored {}", key); // handled elsewhere
continue;
}
let next_key = uppercase_first_letter(&key);
let next_stack = format!("{}{}", stack, next_key);
let value_type = value.type_.clone().unwrap_or_default();
match value_type.as_ref() {
"object" => {
// objects, maps
let mut handled_inner = false;
if let Some(JSONSchemaPropsOrBool::Schema(s)) = &value.additional_properties {
let dict_type = s.type_.clone().unwrap_or_default();
if dict_type == "array" {
// unpack the inner object from the array wrap
if let Some(JSONSchemaPropsOrArray::Schema(items)) = &s.as_ref().items {
analyze(*items.clone(), &next_key, &next_stack, level + 1, results)?;
handled_inner = true;
}
}
// TODO: not sure if these nested recurses are necessary - cluster test case does not have enough data
//if let Some(extra_props) = &s.properties {
// for (_key, value) in extra_props {
// debug!("nested recurse into {} {} - key: {}", next_key, next_stack, _key);
// analyze(value.clone(), &next_key, &next_stack, level +1, results)?;
// }
//}
}
if !handled_inner {
// normal object recurse
analyze(value, &next_key, &next_stack, level + 1, results)?;
}
}
"array" => {
if let Some(recurse) = array_recurse_level.get(&key).cloned() {
let mut inner = value.clone();
for _i in 0..recurse {
debug!("recursing into props for {}", key);
if let Some(sub) = inner.items {
match sub {
JSONSchemaPropsOrArray::Schema(s) => {
//info!("got inner: {}", serde_json::to_string_pretty(&s)?);
inner = *s.clone();
}
_ => bail!("only handling single type in arrays"),
}
} else {
bail!("could not recurse into vec");
}
}
analyze(inner, &next_key, &next_stack, level + 1, results)?;
}
}
"" => {
if value.x_kubernetes_int_or_string.is_some() {
debug!("not recursing into IntOrString {}", key)
} else {
debug!("not recursing into unknown empty type {}", key)
}
}
x => debug!("not recursing into {} (not a container - {})", key, x),
}
}
Ok(())
}
// helper to figure out what output structs (returned) and embedded members are contained in the current object schema
fn analyze_object_properties(
props: &BTreeMap<String, JSONSchemaProps>,
stack: &str,
array_recurse_level: &mut HashMap<String, u8>,
level: u8,
schema: &JSONSchemaProps,
) -> Result<Vec<OutputStruct>, anyhow::Error> {
let mut results = vec![];
let mut members = vec![];
let reqs = schema.required.clone().unwrap_or_default();
for (key, value) in props {
let value_type = value.type_.clone().unwrap_or_default();
let rust_type = match value_type.as_ref() {
"object" => {
let mut dict_key = None;
if let Some(additional) = &value.additional_properties {
debug!("got additional: {}", serde_json::to_string(&additional)?);
if let JSONSchemaPropsOrBool::Schema(s) = additional {
// This case is for maps. It is generally String -> Something, depending on the type key:
let dict_type = s.type_.clone().unwrap_or_default();
dict_key = match dict_type.as_ref() {
"string" => Some("String".into()),
// We are not 100% sure the array and object subcases here are correct but they pass tests atm.
// authoratative, but more detailed sources than crd validation docs below are welcome
// https://kubernetes.io/docs/tasks/extend-kubernetes/custom-resources/custom-resource-definitions/#validation
"array" => {
// agent test with `validationInfo` uses this spec format
Some(format!("{}{}", stack, uppercase_first_letter(key)))
}
"object" => {
// cluster test with `failureDomains` uses this spec format
Some(format!("{}{}", stack, uppercase_first_letter(key)))
}
"" => {
if s.x_kubernetes_int_or_string.is_some() {
warn!("coercing presumed IntOrString {} to String", key);
Some("String".into())
} else {
bail!("unknown empty dict type for {}", key)
}
}
// think the type we get is the value type
x => Some(uppercase_first_letter(x)), // best guess
};
}
}
if let Some(dict) = dict_key {
format!("BTreeMap<String, {}>", dict)
} else {
format!("{}{}", stack, uppercase_first_letter(key))
}
}
"string" => "String".to_string(),
"boolean" => "bool".to_string(),
"date" => extract_date_type(value)?,
"number" => extract_number_type(value)?,
"integer" => extract_integer_type(value)?,
"array" => {
// recurse through repeated arrays until we find a concrete type (keep track of how deep we went)
let (array_type, recurse_level) = array_recurse_for_type(value, stack, key, 1)?;
debug!(
"got array type {} for {} in level {}",
array_type, key, recurse_level
);
array_recurse_level.insert(key.clone(), recurse_level);
array_type
}
"" => {
if value.x_kubernetes_int_or_string.is_some() {
warn!("coercing presumed IntOrString {} to String", key);
"String".into()
} else {
bail!("unknown empty dict type for {}", key)
}
}
x => bail!("unknown type {}", x),
};
// Create member and wrap types correctly
let member_doc = value.description.clone();
if reqs.contains(key) {
debug!("with required member {} of type {}", key, rust_type);
members.push(OutputMember {
type_: rust_type,
name: key.to_string(),
field_annot: None,
docs: member_doc,
})
} else {
// option wrapping possibly needed if not required
debug!("with optional member {} of type {}", key, rust_type);
if rust_type.starts_with("BTreeMap") {
members.push(OutputMember {
type_: rust_type,
name: key.to_string(),
field_annot: Some(
r#"#[serde(default, skip_serializing_if = "BTreeMap::is_empty")]"#.into(),
),
docs: member_doc,
})
} else if rust_type.starts_with("Vec") {
members.push(OutputMember {
type_: rust_type,
name: key.to_string(),
field_annot: Some(r#"#[serde(default, skip_serializing_if = "Vec::is_empty")]"#.into()),
docs: member_doc,
})
} else {
members.push(OutputMember {
type_: format!("Option<{}>", rust_type),
name: key.to_string(),
field_annot: None,
docs: member_doc,
})
}
}
}
results.push(OutputStruct {
name: stack.to_string(),
members,
level,
docs: schema.description.clone(),
});
Ok(results)
}
// recurse into an array type to find its nested type
// this recursion is intialised and ended within a single step of the outer recursion
fn array_recurse_for_type(
value: &JSONSchemaProps,
stack: &str,
key: &str,
level: u8,
) -> Result<(String, u8)> {
if let Some(items) = &value.items {
match items {
JSONSchemaPropsOrArray::Schema(s) => {
let inner_array_type = s.type_.clone().unwrap_or_default();
return match inner_array_type.as_ref() {
"object" => {
let structsuffix = uppercase_first_letter(key);
Ok((format!("Vec<{}{}>", stack, structsuffix), level))
}
"string" => Ok(("Vec<String>".into(), level)),
"boolean" => Ok(("Vec<bool>".into(), level)),
"date" => Ok((format!("Vec<{}>", extract_date_type(value)?), level)),
"number" => Ok((format!("Vec<{}>", extract_number_type(value)?), level)),
"integer" => Ok((format!("Vec<{}>", extract_integer_type(value)?), level)),
"array" => Ok(array_recurse_for_type(s, stack, key, level + 1)?),
x => {
bail!("unsupported recursive array type {} for {}", x, key)
}
};
}
// maybe fallback to serde_json::Value
_ => bail!("only support single schema in array {}", key),
}
} else {
bail!("missing items in array type")
}
}
// ----------------------------------------------------------------------------
// helpers
fn extract_date_type(value: &JSONSchemaProps) -> Result<String> {
Ok(if let Some(f) = &value.format {
// NB: these need chrono feature on serde
match f.as_ref() {
// Not sure if the first actually works properly..
// might need a Date<Utc> but chrono docs advocated for NaiveDate
"date" => "NaiveDate".to_string(),
"date-time" => "DateTime<Utc>".to_string(),
x => {
bail!("unknown date {}", x);
}
}
} else {
"String".to_string()
})
}
fn extract_number_type(value: &JSONSchemaProps) -> Result<String> {
// TODO: byte / password here?
Ok(if let Some(f) = &value.format {
match f.as_ref() {
"float" => "f32".to_string(),
"double" => "f64".to_string(),
x => {
bail!("unknown number {}", x);
}
}
} else {
"f64".to_string()
})
}
fn extract_integer_type(value: &JSONSchemaProps) -> Result<String> {
// Think kubernetes go types just do signed ints, but set a minimum to zero..
// rust will set uint, so emitting that when possbile
Ok(if let Some(f) = &value.format {
match f.as_ref() {
"int8" => "i8".to_string(),
"int16" => "i16".to_string(),
"int32" => "i32".to_string(),
"int64" => "i64".to_string(),
"int128" => "i128".to_string(),
"uint8" => "u8".to_string(),
"uint16" => "u16".to_string(),
"uint32" => "u32".to_string(),
"uint64" => "u64".to_string(),
"uint128" => "u128".to_string(),
x => {
bail!("unknown integer {}", x);
}
}
} else {
"i64".to_string()
})
}
fn uppercase_first_letter(s: &str) -> String {
let mut c = s.chars();
match c.next() {
None => String::new(),
Some(f) => f.to_uppercase().collect::<String>() + c.as_str(),
}
}