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 importCloudInstanceV1(source map[string]interface{}) (*cloudInstance, error) {
fields := schema.Fields{
"instance-id": schema.String(),
"status": schema.String(),
"architecture": schema.String(),
"memory": schema.ForceUint(),
"root-disk": schema.ForceUint(),
"cores": schema.ForceUint(),
"cpu-power": schema.ForceUint(),
"tags": schema.List(schema.String()),
"availability-zone": schema.String(),
}
// Some values don't have to be there.
defaults := schema.Defaults{
"architecture": "",
"memory": uint64(0),
"root-disk": uint64(0),
"cores": uint64(0),
"cpu-power": uint64(0),
"tags": schema.Omit,
"availability-zone": "",
}
checker := schema.FieldMap(fields, defaults)
coerced, err := checker.Coerce(source, nil)
if err != nil {
return nil, errors.Annotatef(err, "cloudInstance 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 &cloudInstance{
Version: 1,
InstanceId_: valid["instance-id"].(string),
Status_: valid["status"].(string),
Architecture_: valid["architecture"].(string),
Memory_: valid["memory"].(uint64),
RootDisk_: valid["root-disk"].(uint64),
CpuCores_: valid["cores"].(uint64),
CpuPower_: valid["cpu-power"].(uint64),
Tags_: convertToStringSlice(valid["tags"]),
AvailabilityZone_: valid["availability-zone"].(string),
}, 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
}
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 importVolumeV1(source map[string]interface{}) (*volume, error) {
fields := schema.Fields{
"id": schema.String(),
"storage-id": schema.String(),
"binding": schema.String(),
"provisioned": schema.Bool(),
"size": schema.ForceUint(),
"pool": schema.String(),
"hardware-id": schema.String(),
"volume-id": schema.String(),
"persistent": schema.Bool(),
"status": schema.StringMap(schema.Any()),
"attachments": schema.StringMap(schema.Any()),
}
defaults := schema.Defaults{
"storage-id": "",
"binding": "",
"pool": "",
"hardware-id": "",
"volume-id": "",
"attachments": schema.Omit,
}
addStatusHistorySchema(fields)
checker := schema.FieldMap(fields, defaults)
coerced, err := checker.Coerce(source, nil)
if err != nil {
return nil, errors.Annotatef(err, "volume 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 := &volume{
ID_: valid["id"].(string),
StorageID_: valid["storage-id"].(string),
Binding_: valid["binding"].(string),
Provisioned_: valid["provisioned"].(bool),
Size_: valid["size"].(uint64),
Pool_: valid["pool"].(string),
HardwareID_: valid["hardware-id"].(string),
VolumeID_: valid["volume-id"].(string),
Persistent_: valid["persistent"].(bool),
StatusHistory_: newStatusHistory(),
}
if err := result.importStatusHistory(valid); err != nil {
return nil, errors.Trace(err)
}
status, err := importStatus(valid["status"].(map[string]interface{}))
if err != nil {
return nil, errors.Trace(err)
}
result.Status_ = status
attachments, err := importVolumeAttachments(valid["attachments"].(map[string]interface{}))
if err != nil {
return nil, errors.Trace(err)
}
result.setAttachments(attachments)
return result, nil
}
func importConstraintsV1(source map[string]interface{}) (*constraints, error) {
fields := schema.Fields{
"architecture": schema.String(),
"container": schema.String(),
"cpu-cores": schema.ForceUint(),
"cores": schema.ForceUint(),
"cpu-power": schema.ForceUint(),
"instance-type": schema.String(),
"memory": schema.ForceUint(),
"root-disk": schema.ForceUint(),
"spaces": schema.List(schema.String()),
"tags": schema.List(schema.String()),
"virt-type": schema.String(),
}
// Some values don't have to be there.
defaults := schema.Defaults{
"architecture": "",
"container": "",
"cpu-cores": schema.Omit,
"cores": schema.Omit,
"cpu-power": uint64(0),
"instance-type": "",
"memory": uint64(0),
"root-disk": uint64(0),
"spaces": schema.Omit,
"tags": schema.Omit,
"virt-type": "",
}
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{})
_, hasCPU := valid["cpu-cores"]
_, hasCores := valid["cores"]
if hasCPU && hasCores {
return nil, errors.Errorf("can not specify both cores and cores constraints")
}
var cores uint64
if hasCPU {
cores = valid["cpu-cores"].(uint64)
}
if hasCores {
cores = valid["cores"].(uint64)
}
// 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_: cores,
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"]),
VirtType_: valid["virt-type"].(string),
}, nil
}