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 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 (s *S) TestOneOf(c *gc.C) {
s.sch = schema.OneOf(schema.Const("foo"), schema.Const(42))
out, err := s.sch.Coerce("foo", aPath)
c.Assert(err, gc.IsNil)
c.Assert(out, gc.Equals, "foo")
out, err = s.sch.Coerce(42, aPath)
c.Assert(err, gc.IsNil)
c.Assert(out, gc.Equals, 42)
out, err = s.sch.Coerce("bar", aPath)
c.Assert(out, gc.IsNil)
c.Assert(err, gc.ErrorMatches, `<path>: unexpected value "bar"`)
}
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
}
defaultPools := []*storage.Config{
ebsssdPool,
}
poolmanager.RegisterDefaultStoragePools(defaultPools)
}
// ebsProvider creates volume sources which use AWS EBS volumes.
type ebsProvider struct{}
var _ storage.Provider = (*ebsProvider)(nil)
var ebsConfigFields = schema.Fields{
EBS_VolumeType: schema.OneOf(
schema.Const(volumeTypeMagnetic),
schema.Const(volumeTypeSsd),
schema.Const(volumeTypeProvisionedIops),
schema.Const(volumeTypeStandard),
schema.Const(volumeTypeGp2),
schema.Const(volumeTypeIo1),
),
EBS_IOPS: schema.ForceInt(),
EBS_Encrypted: schema.Bool(),
}
var ebsConfigChecker = schema.FieldMap(
ebsConfigFields,
schema.Defaults{
EBS_VolumeType: volumeTypeMagnetic,
EBS_IOPS: schema.Omit,
EBS_Encrypted: false,
},
)
v, err = mapC.Coerce(v, path)
if err != nil {
return
}
m := v.(map[string]interface{})
if _, ok := m["limit"]; !ok {
m["limit"] = c.limit
}
return ifaceSchema.Coerce(m, path)
}
var ifaceSchema = schema.FieldMap(
schema.Fields{
"interface": schema.String(),
"limit": schema.OneOf(schema.Const(nil), schema.Int()),
"scope": schema.OneOf(schema.Const(string(ScopeGlobal)), schema.Const(string(ScopeContainer))),
"optional": schema.Bool(),
},
schema.Defaults{
"scope": string(ScopeGlobal),
"optional": false,
},
)
var charmSchema = schema.FieldMap(
schema.Fields{
"name": schema.String(),
"summary": schema.String(),
"description": schema.String(),
"peers": schema.StringMap(ifaceExpander(int64(1))),
}
// StorageProvider implements storage.ProviderRegistry.
func (*maasEnviron) StorageProvider(t storage.ProviderType) (storage.Provider, error) {
if t == maasStorageProviderType {
return maasStorageProvider{}, nil
}
return nil, errors.NotFoundf("storage provider %q", t)
}
// maasStorageProvider allows volumes to be specified when a node is acquired.
type maasStorageProvider struct{}
var storageConfigFields = schema.Fields{
tagsAttribute: schema.OneOf(
schema.List(schema.String()),
schema.String(),
),
}
var storageConfigChecker = schema.FieldMap(
storageConfigFields,
schema.Defaults{
tagsAttribute: schema.Omit,
},
)
type storageConfig struct {
tags []string
}
func newStorageConfig(attrs map[string]interface{}) (*storageConfig, error) {