func vlan_2_0(source map[string]interface{}) (*vlan, error) {
fields := schema.Fields{
"id": schema.ForceInt(),
"resource_uri": schema.String(),
"name": schema.OneOf(schema.Nil(""), schema.String()),
"fabric": schema.String(),
"vid": schema.ForceInt(),
"mtu": schema.ForceInt(),
"dhcp_on": schema.Bool(),
// racks are not always set.
"primary_rack": schema.OneOf(schema.Nil(""), schema.String()),
"secondary_rack": schema.OneOf(schema.Nil(""), schema.String()),
}
checker := schema.FieldMap(fields, nil)
coerced, err := checker.Coerce(source, nil)
if err != nil {
return nil, errors.Annotatef(err, "vlan 2.0 schema check failed")
}
valid := coerced.(map[string]interface{})
// From here we know that the map returned from the schema coercion
// contains fields of the right type.
// Since the primary and secondary racks are optional, we use the two
// part cast assignment. If the case fails, then we get the default value
// we care about, which is the empty string.
primary_rack, _ := valid["primary_rack"].(string)
secondary_rack, _ := valid["secondary_rack"].(string)
name, _ := valid["name"].(string)
result := &vlan{
resourceURI: valid["resource_uri"].(string),
id: valid["id"].(int),
name: name,
fabric: valid["fabric"].(string),
vid: valid["vid"].(int),
mtu: valid["mtu"].(int),
dhcp: valid["dhcp_on"].(bool),
primaryRack: primary_rack,
secondaryRack: secondary_rack,
}
return result, nil
}
func subnet_2_0(source map[string]interface{}) (*subnet, error) {
fields := schema.Fields{
"resource_uri": schema.String(),
"id": schema.ForceInt(),
"name": schema.String(),
"space": schema.String(),
"gateway_ip": schema.OneOf(schema.Nil(""), schema.String()),
"cidr": schema.String(),
"vlan": schema.StringMap(schema.Any()),
"dns_servers": schema.OneOf(schema.Nil(""), schema.List(schema.String())),
}
checker := schema.FieldMap(fields, nil) // no defaults
coerced, err := checker.Coerce(source, nil)
if err != nil {
return nil, errors.Annotatef(err, "subnet 2.0 schema check failed")
}
valid := coerced.(map[string]interface{})
// From here we know that the map returned from the schema coercion
// contains fields of the right type.
vlan, err := vlan_2_0(valid["vlan"].(map[string]interface{}))
if err != nil {
return nil, errors.Trace(err)
}
// Since the gateway_ip is optional, we use the two part cast assignment. If
// the cast fails, then we get the default value we care about, which is the
// empty string.
gateway, _ := valid["gateway_ip"].(string)
result := &subnet{
resourceURI: valid["resource_uri"].(string),
id: valid["id"].(int),
name: valid["name"].(string),
space: valid["space"].(string),
vlan: vlan,
gateway: gateway,
cidr: valid["cidr"].(string),
dnsServers: convertToStringSlice(valid["dns_servers"]),
}
return result, nil
}
func partition_2_0(source map[string]interface{}) (*partition, error) {
fields := schema.Fields{
"resource_uri": schema.String(),
"id": schema.ForceInt(),
"path": schema.String(),
"uuid": schema.String(),
"used_for": schema.String(),
"size": schema.ForceUint(),
"filesystem": schema.OneOf(schema.Nil(""), schema.StringMap(schema.Any())),
}
checker := schema.FieldMap(fields, nil)
coerced, err := checker.Coerce(source, nil)
if err != nil {
return nil, WrapWithDeserializationError(err, "partition 2.0 schema check failed")
}
valid := coerced.(map[string]interface{})
// From here we know that the map returned from the schema coercion
// contains fields of the right type.
var filesystem *filesystem
if fsSource := valid["filesystem"]; fsSource != nil {
filesystem, err = filesystem2_0(fsSource.(map[string]interface{}))
if err != nil {
return nil, errors.Trace(err)
}
}
result := &partition{
resourceURI: valid["resource_uri"].(string),
id: valid["id"].(int),
path: valid["path"].(string),
uuid: valid["uuid"].(string),
usedFor: valid["used_for"].(string),
size: valid["size"].(uint64),
filesystem: filesystem,
}
return result, nil
}
func fabric_2_0(source map[string]interface{}) (*fabric, error) {
fields := schema.Fields{
"resource_uri": schema.String(),
"id": schema.ForceInt(),
"name": schema.String(),
"class_type": schema.OneOf(schema.Nil(""), schema.String()),
"vlans": schema.List(schema.StringMap(schema.Any())),
}
checker := schema.FieldMap(fields, nil) // no defaults
coerced, err := checker.Coerce(source, nil)
if err != nil {
return nil, errors.Annotatef(err, "fabric 2.0 schema check failed")
}
valid := coerced.(map[string]interface{})
// From here we know that the map returned from the schema coercion
// contains fields of the right type.
vlans, err := readVLANList(valid["vlans"].([]interface{}), vlan_2_0)
if err != nil {
return nil, errors.Trace(err)
}
// Since the class_type is optional, we use the two part cast assignment. If
// the cast fails, then we get the default value we care about, which is the
// empty string.
classType, _ := valid["class_type"].(string)
result := &fabric{
resourceURI: valid["resource_uri"].(string),
id: valid["id"].(int),
name: valid["name"].(string),
classType: classType,
vlans: vlans,
}
return result, nil
}