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 }