func parseAllocateConstraintsResponse(source interface{}, machine *machine) (ConstraintMatches, error) {
var empty ConstraintMatches
matchFields := schema.Fields{
"storage": schema.StringMap(schema.ForceInt()),
"interfaces": schema.StringMap(schema.ForceInt()),
}
matchDefaults := schema.Defaults{
"storage": schema.Omit,
"interfaces": schema.Omit,
}
fields := schema.Fields{
"constraints_by_type": schema.FieldMap(matchFields, matchDefaults),
}
checker := schema.FieldMap(fields, nil) // no defaults
coerced, err := checker.Coerce(source, nil)
if err != nil {
return empty, WrapWithDeserializationError(err, "allocation constraints response schema check failed")
}
valid := coerced.(map[string]interface{})
constraintsMap := valid["constraints_by_type"].(map[string]interface{})
result := ConstraintMatches{
Interfaces: make(map[string]Interface),
Storage: make(map[string]BlockDevice),
}
if interfaceMatches, found := constraintsMap["interfaces"]; found {
for label, value := range interfaceMatches.(map[string]interface{}) {
id := value.(int)
iface := machine.Interface(id)
if iface == nil {
return empty, NewDeserializationError("constraint match interface %q: %d does not match an interface for the machine", label, id)
}
result.Interfaces[label] = iface
}
}
if storageMatches, found := constraintsMap["storage"]; found {
for label, value := range storageMatches.(map[string]interface{}) {
id := value.(int)
blockDevice := machine.PhysicalBlockDevice(id)
if blockDevice == nil {
return empty, NewDeserializationError("constraint match storage %q: %d does not match a physical block device for the machine", label, id)
}
result.Storage[label] = blockDevice
}
}
return result, nil
}
func importAgentToolsV1(source map[string]interface{}) (*agentTools, error) {
fields := schema.Fields{
"tools-version": schema.String(),
"url": schema.String(),
"sha256": schema.String(),
"size": schema.Int(),
}
checker := schema.FieldMap(fields, nil) // no defaults
coerced, err := checker.Coerce(source, nil)
if err != nil {
return nil, errors.Annotatef(err, "agentTools v1 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.
verString := valid["tools-version"].(string)
toolsVersion, err := version.ParseBinary(verString)
if err != nil {
return nil, errors.Annotatef(err, "agentTools tools-version")
}
return &agentTools{
Version_: 1,
ToolsVersion_: toolsVersion,
URL_: valid["url"].(string),
SHA256_: valid["sha256"].(string),
Size_: valid["size"].(int64),
}, nil
}
func importStorageV1(source map[string]interface{}) (*storage, error) {
fields := schema.Fields{
"id": schema.String(),
"kind": schema.String(),
"owner": schema.String(),
"name": schema.String(),
"attachments": schema.List(schema.String()),
}
// Normally a list would have defaults, but in this case storage
// should always have at least one attachment.
checker := schema.FieldMap(fields, nil) // no defaults
coerced, err := checker.Coerce(source, nil)
if err != nil {
return nil, errors.Annotatef(err, "storage v1 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.
result := &storage{
ID_: valid["id"].(string),
Kind_: valid["kind"].(string),
Owner_: valid["owner"].(string),
Name_: valid["name"].(string),
Attachments_: convertToStringSlice(valid["attachments"]),
}
return result, nil
}
func importPayloadV1(source map[string]interface{}) (*payload, error) {
fields := schema.Fields{
"name": schema.String(),
"type": schema.String(),
"raw-id": schema.String(),
"state": schema.String(),
"labels": schema.List(schema.String()),
}
// Some values don't have to be there.
defaults := schema.Defaults{
"labels": schema.Omit,
}
checker := schema.FieldMap(fields, defaults)
coerced, err := checker.Coerce(source, nil)
if err != nil {
return nil, errors.Annotatef(err, "payload v1 schema check failed")
}
valid := coerced.(map[string]interface{})
return &payload{
Name_: valid["name"].(string),
Type_: valid["type"].(string),
RawID_: valid["raw-id"].(string),
State_: valid["state"].(string),
Labels_: convertToStringSlice(valid["labels"]),
}, nil
}
func versionedEmbeddedChecker(name string) schema.Checker {
fields := schema.Fields{
"version": schema.Int(),
}
fields[name] = schema.StringMap(schema.Any())
return schema.FieldMap(fields, nil) // no defaults
}
func importSpaceV1(source map[string]interface{}) (*space, error) {
fields := schema.Fields{
"name": schema.String(),
"public": schema.Bool(),
"provider-id": schema.String(),
}
// Some values don't have to be there.
defaults := schema.Defaults{
"provider-id": "",
}
checker := schema.FieldMap(fields, defaults)
coerced, err := checker.Coerce(source, nil)
if err != nil {
return nil, errors.Annotatef(err, "space v1 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.
return &space{
Name_: valid["name"].(string),
Public_: valid["public"].(bool),
ProviderID_: valid["provider-id"].(string),
}, nil
}
func importAddressV1(source map[string]interface{}) (*address, error) {
fields := schema.Fields{
"value": schema.String(),
"type": schema.String(),
"scope": schema.String(),
"origin": schema.String(),
}
// Some values don't have to be there.
defaults := schema.Defaults{
"scope": "",
"origin": "",
}
checker := schema.FieldMap(fields, defaults)
coerced, err := checker.Coerce(source, nil)
if err != nil {
return nil, errors.Annotatef(err, "address v1 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.
return &address{
Version: 1,
Value_: valid["value"].(string),
Type_: valid["type"].(string),
Scope_: valid["scope"].(string),
Origin_: valid["origin"].(string),
}, nil
}
func importRelationV1(source map[string]interface{}) (*relation, error) {
fields := schema.Fields{
"id": schema.Int(),
"key": schema.String(),
"endpoints": 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, "relation v1 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.
result := &relation{
Id_: int(valid["id"].(int64)),
Key_: valid["key"].(string),
}
endpoints, err := importEndpoints(valid["endpoints"].(map[string]interface{}))
if err != nil {
return nil, errors.Trace(err)
}
result.setEndpoints(endpoints)
return result, nil
}
func importFilesystemAttachmentV1(source map[string]interface{}) (*filesystemAttachment, error) {
fields := schema.Fields{
"machine-id": schema.String(),
"provisioned": schema.Bool(),
"read-only": schema.Bool(),
"mount-point": schema.String(),
}
defaults := schema.Defaults{
"mount-point": "",
}
checker := schema.FieldMap(fields, defaults)
coerced, err := checker.Coerce(source, nil)
if err != nil {
return nil, errors.Annotatef(err, "filesystemAttachment v1 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.
result := &filesystemAttachment{
MachineID_: valid["machine-id"].(string),
Provisioned_: valid["provisioned"].(bool),
ReadOnly_: valid["read-only"].(bool),
MountPoint_: valid["mount-point"].(string),
}
return result, nil
}
func space_2_0(source map[string]interface{}) (*space, error) {
fields := schema.Fields{
"resource_uri": schema.String(),
"id": schema.ForceInt(),
"name": schema.String(),
"subnets": 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, "space 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.
subnets, err := readSubnetList(valid["subnets"].([]interface{}), subnet_2_0)
if err != nil {
return nil, errors.Trace(err)
}
result := &space{
resourceURI: valid["resource_uri"].(string),
id: valid["id"].(int),
name: valid["name"].(string),
subnets: subnets,
}
return result, nil
}
func importStatusV1(source map[string]interface{}) (StatusPoint_, error) {
fields := schema.Fields{
"value": schema.String(),
"message": schema.String(),
"data": schema.StringMap(schema.Any()),
"updated": schema.Time(),
}
// Some values don't have to be there.
defaults := schema.Defaults{
"message": "",
"data": schema.Omit,
}
checker := schema.FieldMap(fields, defaults)
coerced, err := checker.Coerce(source, nil)
if err != nil {
return StatusPoint_{}, errors.Annotatef(err, "status v1 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 data map[string]interface{}
if sourceData, set := valid["data"]; set {
data = sourceData.(map[string]interface{})
}
return StatusPoint_{
Value_: valid["value"].(string),
Message_: valid["message"].(string),
Data_: data,
Updated_: valid["updated"].(time.Time),
}, nil
}
func bootResource_2_0(source map[string]interface{}) (*bootResource, error) {
fields := schema.Fields{
"resource_uri": schema.String(),
"id": schema.ForceInt(),
"name": schema.String(),
"type": schema.String(),
"architecture": schema.String(),
"subarches": schema.String(),
"kflavor": schema.String(),
}
checker := schema.FieldMap(fields, nil) // no defaults
coerced, err := checker.Coerce(source, nil)
if err != nil {
return nil, WrapWithDeserializationError(err, "boot resource 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.
result := &bootResource{
resourceURI: valid["resource_uri"].(string),
id: valid["id"].(int),
name: valid["name"].(string),
type_: valid["type"].(string),
architecture: valid["architecture"].(string),
subArches: valid["subarches"].(string),
kernelFlavor: valid["kflavor"].(string),
}
return result, nil
}
func (s *S) TestFieldMapBasic(c *gc.C) {
fields := schema.Fields{
"a": schema.Const("A"),
"b": schema.Const("B"),
"c": schema.Const("C"),
}
defaults := schema.Defaults{
"b": schema.Omit,
"c": "C",
}
s.sch = schema.FieldMap(fields, defaults)
assertFieldMap(c, s.sch)
out, err := s.sch.Coerce(map[string]interface{}{"a": "A", "b": "B", "d": "D"}, aPath)
c.Assert(err, gc.IsNil)
c.Assert(out, gc.DeepEquals, map[string]interface{}{"a": "A", "b": "B", "c": "C"})
out, err = s.sch.Coerce(map[string]interface{}{"a": "A", "d": "D"}, aPath)
c.Assert(err, gc.IsNil)
c.Assert(out, gc.DeepEquals, map[string]interface{}{"a": "A", "c": "C"})
out, err = s.sch.Coerce(123, aPath)
c.Assert(err, gc.ErrorMatches, `<path>: expected map, got int\(123\)`)
c.Assert(out, gc.Equals, nil)
out, err = s.sch.Coerce(map[int]string{}, aPath)
c.Assert(err, gc.ErrorMatches, `<path>: expected map\[string], got map\[int]string\(map\[int]string{}\)`)
c.Assert(out, gc.Equals, nil)
type strKey string
out, err = s.sch.Coerce(map[strKey]string{"a": "A"}, aPath)
c.Assert(err, gc.ErrorMatches, `<path>: expected map\[string], got map\[schema_test\.strKey]string\(map\[schema_test.strKey]string{"a":"A"}\)`)
c.Assert(out, gc.Equals, nil)
}
func importOpenedPortsV1(source map[string]interface{}) (*openedPorts, error) {
fields := schema.Fields{
"subnet-id": schema.String(),
"opened-ports": 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, "opened-ports v1 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.
ports, err := importPortRanges(valid["opened-ports"].(map[string]interface{}))
if err != nil {
return nil, errors.Trace(err)
}
result := &openedPorts{
SubnetID_: valid["subnet-id"].(string),
}
result.setOpenedPorts(ports)
return result, nil
}
func file_2_0(source map[string]interface{}) (*file, error) {
fields := schema.Fields{
"resource_uri": schema.String(),
"filename": schema.String(),
"anon_resource_uri": schema.String(),
"content": schema.String(),
}
defaults := schema.Defaults{
"content": "",
}
checker := schema.FieldMap(fields, defaults)
coerced, err := checker.Coerce(source, nil)
if err != nil {
return nil, WrapWithDeserializationError(err, "file 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.
anonURI, err := url.ParseRequestURI(valid["anon_resource_uri"].(string))
if err != nil {
return nil, NewUnexpectedError(err)
}
result := &file{
resourceURI: valid["resource_uri"].(string),
filename: valid["filename"].(string),
anonymousURI: anonURI,
content: valid["content"].(string),
}
return result, nil
}
func importVolumeAttachmentV1(source map[string]interface{}) (*volumeAttachment, error) {
fields := schema.Fields{
"machine-id": schema.String(),
"provisioned": schema.Bool(),
"read-only": schema.Bool(),
"device-name": schema.String(),
"device-link": schema.String(),
"bus-address": schema.String(),
}
checker := schema.FieldMap(fields, nil) // no defaults
coerced, err := checker.Coerce(source, nil)
if err != nil {
return nil, errors.Annotatef(err, "volumeAttachment v1 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.
result := &volumeAttachment{
MachineID_: valid["machine-id"].(string),
Provisioned_: valid["provisioned"].(bool),
ReadOnly_: valid["read-only"].(bool),
DeviceName_: valid["device-name"].(string),
DeviceLink_: valid["device-link"].(string),
BusAddress_: valid["bus-address"].(string),
}
return result, nil
}
func (c *controller) readAPIVersion(apiVersion version.Number) (set.Strings, version.Number, error) {
parsed, err := c.get("version")
if err != nil {
return nil, apiVersion, errors.Trace(err)
}
// As we care about other fields, add them.
fields := schema.Fields{
"capabilities": schema.List(schema.String()),
}
checker := schema.FieldMap(fields, nil) // no defaults
coerced, err := checker.Coerce(parsed, nil)
if err != nil {
return nil, apiVersion, WrapWithDeserializationError(err, "version response")
}
// For now, we don't append any subversion, but as it becomes used, we
// should parse and check.
valid := coerced.(map[string]interface{})
// From here we know that the map returned from the schema coercion
// contains fields of the right type.
capabilities := set.NewStrings()
capabilityValues := valid["capabilities"].([]interface{})
for _, value := range capabilityValues {
capabilities.Add(value.(string))
}
return capabilities, apiVersion, nil
}
func importPortRangeV1(source map[string]interface{}) (*portRange, error) {
fields := schema.Fields{
"unit-name": schema.String(),
"from-port": schema.Int(),
"to-port": schema.Int(),
"protocol": schema.String(),
}
checker := schema.FieldMap(fields, nil) // no defaults
coerced, err := checker.Coerce(source, nil)
if err != nil {
return nil, errors.Annotatef(err, "port-range v1 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.
return &portRange{
UnitName_: valid["unit-name"].(string),
FromPort_: int(valid["from-port"].(int64)),
ToPort_: int(valid["to-port"].(int64)),
Protocol_: valid["protocol"].(string),
}, nil
}
func importLinkLayerDeviceV1(source map[string]interface{}) (*linklayerdevice, error) {
fields := schema.Fields{
"provider-id": schema.String(),
"machine-id": schema.String(),
"name": schema.String(),
"mtu": schema.Int(),
"type": schema.String(),
"mac-address": schema.String(),
"is-autostart": schema.Bool(),
"is-up": schema.Bool(),
"parent-name": schema.String(),
}
// Some values don't have to be there.
defaults := schema.Defaults{
"provider-id": "",
}
checker := schema.FieldMap(fields, defaults)
coerced, err := checker.Coerce(source, nil)
if err != nil {
return nil, errors.Annotatef(err, "linklayerdevice v1 schema check failed")
}
valid := coerced.(map[string]interface{})
return &linklayerdevice{
ProviderID_: valid["provider-id"].(string),
MachineID_: valid["machine-id"].(string),
Name_: valid["name"].(string),
MTU_: uint(valid["mtu"].(int64)),
Type_: valid["type"].(string),
MACAddress_: valid["mac-address"].(string),
IsAutoStart_: valid["is-autostart"].(bool),
IsUp_: valid["is-up"].(bool),
ParentName_: valid["parent-name"].(string),
}, nil
}
func versionedChecker(name string) schema.Checker {
fields := schema.Fields{
"version": schema.Int(),
}
if name != "" {
fields[name] = schema.List(schema.StringMap(schema.Any()))
}
return schema.FieldMap(fields, nil) // no defaults
}
func (s *S) TestSchemaMap(c *gc.C) {
fields1 := schema.FieldMap(schema.Fields{
"type": schema.Const(1),
"a": schema.Const(2),
}, nil)
fields2 := schema.FieldMap(schema.Fields{
"type": schema.Const(3),
"b": schema.Const(4),
}, nil)
s.sch = schema.FieldMapSet("type", []schema.Checker{fields1, fields2})
out, err := s.sch.Coerce(map[string]int{"type": 1, "a": 2}, aPath)
c.Assert(err, gc.IsNil)
c.Assert(out, gc.DeepEquals, map[string]interface{}{"type": 1, "a": 2})
out, err = s.sch.Coerce(map[string]int{"type": 3, "b": 4}, aPath)
c.Assert(err, gc.IsNil)
c.Assert(out, gc.DeepEquals, map[string]interface{}{"type": 3, "b": 4})
out, err = s.sch.Coerce(map[string]int{}, aPath)
c.Assert(out, gc.IsNil)
c.Assert(err, gc.ErrorMatches, `<path>\.type: expected supported selector, got nothing`)
out, err = s.sch.Coerce(map[string]int{"type": 2}, aPath)
c.Assert(out, gc.IsNil)
c.Assert(err, gc.ErrorMatches, `<path>\.type: expected supported selector, got int\(2\)`)
out, err = s.sch.Coerce(map[string]int{"type": 3, "b": 5}, aPath)
c.Assert(out, gc.IsNil)
c.Assert(err, gc.ErrorMatches, `<path>\.b: expected 4, got int\(5\)`)
out, err = s.sch.Coerce(42, aPath)
c.Assert(out, gc.IsNil)
c.Assert(err, gc.ErrorMatches, `<path>: expected map, got int\(42\)`)
out, err = s.sch.Coerce(nil, aPath)
c.Assert(out, gc.IsNil)
c.Assert(err, gc.ErrorMatches, `<path>: expected map, got nothing`)
// First path entry shouldn't have dots in an error message.
out, err = s.sch.Coerce(map[string]int{"a": 1}, nil)
c.Assert(out, gc.IsNil)
c.Assert(err, gc.ErrorMatches, `type: expected supported selector, got nothing`)
}
func (s *S) TestFieldMapDefaultInvalid(c *gc.C) {
fields := schema.Fields{
"a": schema.Const("A"),
}
defaults := schema.Defaults{
"a": "B",
}
s.sch = schema.FieldMap(fields, defaults)
_, err := s.sch.Coerce(map[string]interface{}{}, aPath)
c.Assert(err, gc.ErrorMatches, `<path>.a: expected "A", got string\("B"\)`)
}
func (s *S) TestFieldMapInterfaceKey(c *gc.C) {
fields := schema.Fields{
"a": schema.Const("A"),
}
s.sch = schema.FieldMap(fields, nil)
out, err := s.sch.Coerce(map[interface{}]interface{}{"a": "A"}, aPath)
c.Assert(err, gc.IsNil)
c.Check(out, gc.DeepEquals, map[string]interface{}{"a": "A"})
_, err = s.sch.Coerce(map[interface{}]interface{}{1: "A"}, aPath)
c.Check(err, gc.ErrorMatches, `<path>: expected map\[string], got map\[interface {}]interface {}\(map\[interface {}]interface {}{1:"A"}\)`)
}
func importConstraintsV1(source map[string]interface{}) (*constraints, error) {
fields := schema.Fields{
"architecture": schema.String(),
"container": schema.String(),
"cpu-cores": schema.Uint(),
"cpu-power": schema.Uint(),
"instance-type": schema.String(),
"memory": schema.Uint(),
"root-disk": schema.Uint(),
"spaces": schema.List(schema.String()),
"tags": schema.List(schema.String()),
}
// Some values don't have to be there.
defaults := schema.Defaults{
"architecture": "",
"container": "",
"cpu-cores": uint64(0),
"cpu-power": uint64(0),
"instance-type": "",
"memory": uint64(0),
"root-disk": uint64(0),
"spaces": schema.Omit,
"tags": schema.Omit,
}
checker := schema.FieldMap(fields, defaults)
coerced, err := checker.Coerce(source, nil)
if err != nil {
return nil, errors.Annotatef(err, "constraints v1 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.
return &constraints{
Version: 1,
Architecture_: valid["architecture"].(string),
Container_: valid["container"].(string),
CpuCores_: valid["cpu-cores"].(uint64),
CpuPower_: valid["cpu-power"].(uint64),
InstanceType_: valid["instance-type"].(string),
Memory_: valid["memory"].(uint64),
RootDisk_: valid["root-disk"].(uint64),
Spaces_: convertToStringSlice(valid["spaces"]),
Tags_: convertToStringSlice(valid["tags"]),
}, nil
}
func importCloudImageMetadataV1(source map[string]interface{}) (*cloudimagemetadata, error) {
fields := schema.Fields{
"stream": schema.String(),
"region": schema.String(),
"version": schema.String(),
"series": schema.String(),
"arch": schema.String(),
"virt-type": schema.String(),
"root-storage-type": schema.String(),
"root-storage-size": schema.Uint(),
"date-created": schema.Int(),
"source": schema.String(),
"priority": schema.Int(),
"image-id": schema.String(),
}
// Some values don't have to be there.
defaults := schema.Defaults{
"root-storage-size": schema.Omit,
}
checker := schema.FieldMap(fields, defaults)
coerced, err := checker.Coerce(source, nil)
if err != nil {
return nil, errors.Annotatef(err, "cloudimagemetadata v1 schema check failed")
}
valid := coerced.(map[string]interface{})
_, ok := valid["root-storage-size"]
var pointerSize *uint64
if ok {
rootStorageSize := valid["root-storage-size"].(uint64)
pointerSize = &rootStorageSize
}
cloudimagemetadata := &cloudimagemetadata{
Stream_: valid["stream"].(string),
Region_: valid["region"].(string),
Version_: valid["version"].(string),
Series_: valid["series"].(string),
Arch_: valid["arch"].(string),
VirtType_: valid["virt-type"].(string),
RootStorageType_: valid["root-storage-type"].(string),
RootStorageSize_: pointerSize,
DateCreated_: valid["date-created"].(int64),
Source_: valid["source"].(string),
Priority_: int(valid["priority"].(int64)),
ImageId_: valid["image-id"].(string),
}
return cloudimagemetadata, nil
}
func blockdevice_2_0(source map[string]interface{}) (*blockdevice, error) {
fields := schema.Fields{
"resource_uri": schema.String(),
"id": schema.ForceInt(),
"name": schema.String(),
"model": schema.String(),
"path": schema.String(),
"used_for": schema.String(),
"tags": schema.List(schema.String()),
"block_size": schema.ForceUint(),
"used_size": schema.ForceUint(),
"size": schema.ForceUint(),
"partitions": schema.List(schema.StringMap(schema.Any())),
}
checker := schema.FieldMap(fields, nil)
coerced, err := checker.Coerce(source, nil)
if err != nil {
return nil, WrapWithDeserializationError(err, "blockdevice 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.
partitions, err := readPartitionList(valid["partitions"].([]interface{}), partition_2_0)
if err != nil {
return nil, errors.Trace(err)
}
result := &blockdevice{
resourceURI: valid["resource_uri"].(string),
id: valid["id"].(int),
name: valid["name"].(string),
model: valid["model"].(string),
path: valid["path"].(string),
usedFor: valid["used_for"].(string),
tags: convertToStringSlice(valid["tags"]),
blockSize: valid["block_size"].(uint64),
usedSize: valid["used_size"].(uint64),
size: valid["size"].(uint64),
partitions: partitions,
}
return result, nil
}
func importActionV1(source map[string]interface{}) (*action, error) {
fields := schema.Fields{
"receiver": schema.String(),
"name": schema.String(),
"parameters": schema.StringMap(schema.Any()),
"enqueued": schema.Time(),
"started": schema.Time(),
"completed": schema.Time(),
"status": schema.String(),
"message": schema.String(),
"results": schema.StringMap(schema.Any()),
"id": schema.String(),
}
// Some values don't have to be there.
defaults := schema.Defaults{
"started": time.Time{},
"completed": time.Time{},
}
checker := schema.FieldMap(fields, defaults)
coerced, err := checker.Coerce(source, nil)
if err != nil {
return nil, errors.Annotatef(err, "action v1 schema check failed")
}
valid := coerced.(map[string]interface{})
action := &action{
Id_: valid["id"].(string),
Receiver_: valid["receiver"].(string),
Name_: valid["name"].(string),
Status_: valid["status"].(string),
Message_: valid["message"].(string),
Parameters_: valid["parameters"].(map[string]interface{}),
Enqueued_: valid["enqueued"].(time.Time).UTC(),
Results_: valid["results"].(map[string]interface{}),
}
started := valid["started"].(time.Time)
if !started.IsZero() {
started = started.UTC()
action.Started_ = &started
}
completed := valid["completed"].(time.Time)
if !started.IsZero() {
completed = completed.UTC()
action.Completed_ = &completed
}
return action, nil
}
func device_2_0(source map[string]interface{}) (*device, error) {
fields := schema.Fields{
"resource_uri": schema.String(),
"system_id": schema.String(),
"hostname": schema.String(),
"fqdn": schema.String(),
"parent": schema.String(),
"owner": schema.String(),
"ip_addresses": schema.List(schema.String()),
"interface_set": schema.List(schema.StringMap(schema.Any())),
"zone": schema.StringMap(schema.Any()),
}
checker := schema.FieldMap(fields, nil) // no defaults
coerced, err := checker.Coerce(source, nil)
if err != nil {
return nil, WrapWithDeserializationError(err, "device 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.
interfaceSet, err := readInterfaceList(valid["interface_set"].([]interface{}), interface_2_0)
if err != nil {
return nil, errors.Trace(err)
}
zone, err := zone_2_0(valid["zone"].(map[string]interface{}))
if err != nil {
return nil, errors.Trace(err)
}
result := &device{
resourceURI: valid["resource_uri"].(string),
systemID: valid["system_id"].(string),
hostname: valid["hostname"].(string),
fqdn: valid["fqdn"].(string),
parent: valid["parent"].(string),
owner: valid["owner"].(string),
ipAddresses: convertToStringSlice(valid["ip_addresses"]),
interfaceSet: interfaceSet,
zone: zone,
}
return result, nil
}
func importBlockDeviceV1(source map[string]interface{}) (*blockdevice, error) {
fields := schema.Fields{
"name": schema.String(),
"links": schema.List(schema.String()),
"label": schema.String(),
"uuid": schema.String(),
"hardware-id": schema.String(),
"bus-address": schema.String(),
"size": schema.ForceUint(),
"fs-type": schema.String(),
"in-use": schema.Bool(),
"mount-point": schema.String(),
}
defaults := schema.Defaults{
"links": schema.Omit,
"label": "",
"uuid": "",
"hardware-id": "",
"bus-address": "",
"fs-type": "",
"mount-point": "",
}
checker := schema.FieldMap(fields, defaults)
coerced, err := checker.Coerce(source, nil)
if err != nil {
return nil, errors.Annotatef(err, "block device v1 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.
result := &blockdevice{
Name_: valid["name"].(string),
Links_: convertToStringSlice(valid["links"]),
Label_: valid["label"].(string),
UUID_: valid["uuid"].(string),
HardwareID_: valid["hardware-id"].(string),
BusAddress_: valid["bus-address"].(string),
Size_: valid["size"].(uint64),
FilesystemType_: valid["fs-type"].(string),
InUse_: valid["in-use"].(bool),
MountPoint_: valid["mount-point"].(string),
}
return result, nil
}
// ValidateUnknownAttrs checks the unknown attributes of the config against
// the supplied fields and defaults, and returns an error if any fails to
// validate. Unknown fields are warned about, but preserved, on the basis
// that they are reasonably likely to have been written by or for a version
// of juju that does recognise the fields, but that their presence is still
// anomalous to some degree and should be flagged (and that there is thereby
// a mechanism for observing fields that really are typos etc).
func (cfg *Config) ValidateUnknownAttrs(fields schema.Fields, defaults schema.Defaults) (map[string]interface{}, error) {
attrs := cfg.UnknownAttrs()
checker := schema.FieldMap(fields, defaults)
coerced, err := checker.Coerce(attrs, nil)
if err != nil {
logger.Debugf("coercion failed attributes: %#v, checker: %#v, %v", attrs, checker, err)
return nil, err
}
result := coerced.(map[string]interface{})
for name, value := range attrs {
if fields[name] == nil {
logger.Warningf("unknown config field %q", name)
result[name] = value
}
}
return result, nil
}
