BASIS/terraform-provider-decort
8
0
Fork 0
Code Issues Pull Requests Packages Projects Releases 68 Wiki Activity

3.5.0

Browse Source
This commit is contained in:
KasimBaybikov
2023-03-10 12:42:15 +03:00
parent f5e0a53364
commit af82decadd
79 changed files with 9422 additions and 1567 deletions
Download Patch File Download Diff File Expand all files Collapse all files

627
internal/service/cloudapi/kvmvm/flattens.go
View File

@@ -2,17 +2,195 @@ package kvmvm
import (
"encoding/json"
"fmt"
"sort"
"strconv"
"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
"github.com/rudecs/terraform-provider-decort/internal/status"
log "github.com/sirupsen/logrus"
)
func flattenComputeDisksDemo(disksList []DiskRecord, extraDisks []interface{}) []map[string]interface{} {
func flattenDisks(disks []InfoDisk) []map[string]interface{} {
res := make([]map[string]interface{}, 0)
for _, disk := range disks {
temp := map[string]interface{}{
"disk_id": disk.ID,
"pci_slot": disk.PCISlot,
}
res = append(res, temp)
}
return res
}
func flattenQOS(qos QOS) []map[string]interface{} {
res := make([]map[string]interface{}, 0)
temp := map[string]interface{}{
"e_rate": qos.ERate,
"guid": qos.GUID,
"in_brust": qos.InBurst,
"in_rate": qos.InRate,
}
res = append(res, temp)
return res
}
func flattenInterfaces(interfaces ListInterfaces) []map[string]interface{} {
res := make([]map[string]interface{}, 0)
for _, interfaceItem := range interfaces {
temp := map[string]interface{}{
"conn_id": interfaceItem.ConnID,
"conn_type": interfaceItem.ConnType,
"def_gw": interfaceItem.DefGW,
"flip_group_id": interfaceItem.FLIPGroupID,
"guid": interfaceItem.GUID,
"ip_address": interfaceItem.IPAddress,
"listen_ssh": interfaceItem.ListenSSH,
"mac": interfaceItem.MAC,
"name": interfaceItem.Name,
"net_id": interfaceItem.NetID,
"netmask": interfaceItem.NetMask,
"net_type": interfaceItem.NetType,
"pci_slot": interfaceItem.PCISlot,
"qos": flattenQOS(interfaceItem.QOS),
"target": interfaceItem.Target,
"type": interfaceItem.Type,
"vnfs": interfaceItem.VNFs,
}
res = append(res, temp)
}
return res
}
func flattenSnapSets(snapSets ListSnapSets) []map[string]interface{} {
res := make([]map[string]interface{}, 0)
for _, snapSet := range snapSets {
temp := map[string]interface{}{
"disks": snapSet.Disks,
"guid": snapSet.GUID,
"label": snapSet.Label,
"timestamp": snapSet.Timestamp,
}
res = append(res, temp)
}
return res
}
func flattenTags(tags map[string]string) []map[string]interface{} {
res := make([]map[string]interface{}, 0)
for key, val := range tags {
temp := map[string]interface{}{
"key": key,
"val": val,
}
res = append(res, temp)
}
return res
}
func flattenListRules(listRules ListRules) []map[string]interface{} {
res := make([]map[string]interface{}, 0)
for _, rule := range listRules {
temp := map[string]interface{}{
"guid": rule.GUID,
"key": rule.Key,
"mode": rule.Mode,
"policy": rule.Policy,
"topology": rule.Topology,
"value": rule.Value,
}
res = append(res, temp)
}
return res
}
func flattenListACL(listAcl ListACL) []map[string]interface{} {
res := make([]map[string]interface{}, 0)
for _, acl := range listAcl {
var explicit interface{}
switch acl.Explicit.(type) { //Платформенный хак
case bool:
explicit = acl.Explicit.(bool)
case string:
explicit, _ = strconv.ParseBool(acl.Explicit.(string))
}
temp := map[string]interface{}{
"explicit": explicit,
"guid": acl.GUID,
"right": acl.Right,
"status": acl.Status,
"type": acl.Type,
"user_group_id": acl.UserGroupID,
}
res = append(res, temp)
}
return res
}
func flattenComputeList(computes ListComputes) []map[string]interface{} {
res := make([]map[string]interface{}, 0)
for _, compute := range computes {
customFields, _ := json.Marshal(compute.CustomFields)
devices, _ := json.Marshal(compute.Devices)
temp := map[string]interface{}{
"acl": flattenListACL(compute.ACL),
"account_id": compute.AccountID,
"account_name": compute.AccountName,
"affinity_label": compute.AffinityLabel,
"affinity_rules": flattenListRules(compute.AffinityRules),
"affinity_weight": compute.AffinityWeight,
"anti_affinity_rules": flattenListRules(compute.AntiAffinityRules),
"arch": compute.Architecture,
"boot_order": compute.BootOrder,
"bootdisk_size": compute.BootDiskSize,
"clone_reference": compute.CloneReference,
"clones": compute.Clones,
"computeci_id": compute.ComputeCIID,
"cpus": compute.CPU,
"created_by": compute.CreatedBy,
"created_time": compute.CreatedTime,
"custom_fields": string(customFields),
"deleted_by": compute.DeletedBy,
"deleted_time": compute.DeletedTime,
"desc": compute.Description,
"devices": string(devices),
"disks": flattenDisks(compute.Disks),
"driver": compute.Driver,
"gid": compute.GID,
"guid": compute.GUID,
"compute_id": compute.ID,
"image_id": compute.ImageID,
"interfaces": flattenInterfaces(compute.Interfaces),
"lock_status": compute.LockStatus,
"manager_id": compute.ManagerID,
"manager_type": compute.ManagerType,
"migrationjob": compute.MigrationJob,
"milestones": compute.Milestones,
"name": compute.Name,
"pinned": compute.Pinned,
"ram": compute.RAM,
"reference_id": compute.ReferenceID,
"registered": compute.Registered,
"res_name": compute.ResName,
"rg_id": compute.RGID,
"rg_name": compute.RGName,
"snap_sets": flattenSnapSets(compute.SnapSets),
"stateless_sep_id": compute.StatelessSepID,
"stateless_sep_type": compute.StatelessSepType,
"status": compute.Status,
"tags": flattenTags(compute.Tags),
"tech_status": compute.TechStatus,
"total_disk_size": compute.TotalDiskSize,
"updated_by": compute.UpdatedBy,
"updated_time": compute.UpdatedTime,
"user_managed": compute.UserManaged,
"vgpus": compute.VGPUs,
"vins_connected": compute.VINSConnected,
"virtual_image_id": compute.VirtualImageID,
}
res = append(res, temp)
}
return res
}
func flattenComputeDisksDemo(disksList ListComputeDisks, extraDisks []interface{}) []map[string]interface{} {
res := make([]map[string]interface{}, 0, len(disksList))
for _, disk := range disksList {
if disk.Name == "bootdisk" || findInExtraDisks(disk.ID, extraDisks) { //skip main bootdisk and extraDisks
if disk.Name == "bootdisk" || findInExtraDisks(uint(disk.ID), extraDisks) { //skip main bootdisk and extraDisks
continue
}
temp := map[string]interface{}{
@@ -24,66 +202,139 @@ func flattenComputeDisksDemo(disksList []DiskRecord, extraDisks []interface{}) [
"size_max": disk.SizeMax,
"size_used": disk.SizeUsed,
"pool": disk.Pool,
"desc": disk.Desc,
"desc": disk.Description,
"image_id": disk.ImageID,
"size": disk.SizeMax,
}
res = append(res, temp)
}
sort.Slice(res, func(i, j int) bool {
return res[i]["disk_id"].(uint64) < res[j]["disk_id"].(uint64)
})
return res
}
func flattenNetwork(interfaces ListInterfaces) []map[string]interface{} {
res := make([]map[string]interface{}, 0, len(interfaces))
//index := 0
for _, network := range interfaces {
temp := map[string]interface{}{
"net_id": network.NetID,
"net_type": network.NetType,
"ip_address": network.IPAddress,
"mac": network.MAC,
}
res = append(res, temp)
}
return res
}
func flattenCompute(d *schema.ResourceData, compFacts string) error {
func findBootDisk(disks ListComputeDisks) *ItemComputeDisk {
for _, disk := range disks {
if disk.Name == "bootdisk" {
return &disk
}
}
return nil
}
func flattenCompute(d *schema.ResourceData, compute RecordCompute) error {
// This function expects that compFacts string contains response from API compute/get,
// i.e. detailed information about compute instance.
//
// NOTE: this function modifies ResourceData argument - as such it should never be called
// from resourceComputeExists(...) method
model := ComputeGetResp{}
log.Debugf("flattenCompute: ready to unmarshal string %s", compFacts)
err := json.Unmarshal([]byte(compFacts), &model)
log.Debugf("flattenCompute: ID %d, RG ID %d", compute.ID, compute.RGID)
devices, _ := json.Marshal(compute.Devices)
userdata, _ := json.Marshal(compute.Userdata)
//check extraDisks, ipa_type, is,
d.SetId(strconv.FormatUint(compute.ID, 10))
d.Set("acl", flattenACL(compute.ACL))
d.Set("account_id", compute.AccountID)
d.Set("account_name", compute.AccountName)
d.Set("affinity_weight", compute.AffinityWeight)
d.Set("arch", compute.Architecture)
d.Set("boot_order", compute.BootOrder)
d.Set("boot_disk_size", compute.BootDiskSize)
bootDisk := findBootDisk(compute.Disks)
d.Set("boot_disk_id", bootDisk.ID)
d.Set("sep_id", bootDisk.SepID)
d.Set("pool", bootDisk.Pool)
d.Set("clone_reference", compute.CloneReference)
d.Set("clones", compute.Clones)
if string(userdata) != "{}" {
d.Set("cloud_init", string(userdata))
}
d.Set("computeci_id", compute.ComputeCIID)
d.Set("created_by", compute.CreatedBy)
d.Set("created_time", compute.CreatedTime)
d.Set("custom_fields", flattenCustomFields(compute.CustomFields))
d.Set("deleted_by", compute.DeletedBy)
d.Set("deleted_time", compute.DeletedTime)
d.Set("description", compute.Description)
d.Set("devices", string(devices))
err := d.Set("disks", flattenComputeDisksDemo(compute.Disks, d.Get("extra_disks").(*schema.Set).List()))
if err != nil {
return err
}
log.Debugf("flattenCompute: ID %d, RG ID %d", model.ID, model.RgID)
d.SetId(fmt.Sprintf("%d", model.ID))
// d.Set("compute_id", model.ID) - we should NOT set compute_id in the schema here: if it was set - it is already set, if it wasn't - we shouldn't
d.Set("name", model.Name)
d.Set("rg_id", model.RgID)
d.Set("rg_name", model.RgName)
d.Set("account_id", model.AccountID)
d.Set("account_name", model.AccountName)
d.Set("driver", model.Driver)
d.Set("cpu", model.Cpu)
d.Set("ram", model.Ram)
// d.Set("boot_disk_size", model.BootDiskSize) - bootdiskSize key in API compute/get is always zero, so we set boot_disk_size in another way
if model.VirtualImageID != 0 {
d.Set("image_id", model.VirtualImageID)
d.Set("driver", compute.Driver)
d.Set("cpu", compute.CPU)
d.Set("gid", compute.GID)
d.Set("guid", compute.GUID)
d.Set("compute_id", compute.ID)
if compute.VirtualImageID != 0 {
d.Set("image_id", compute.VirtualImageID)
} else {
d.Set("image_id", model.ImageID)
d.Set("image_id", compute.ImageID)
}
d.Set("description", model.Desc)
d.Set("interfaces", flattenInterfaces(compute.Interfaces))
d.Set("lock_status", compute.LockStatus)
d.Set("manager_id", compute.ManagerID)
d.Set("manager_type", compute.ManagerType)
d.Set("migrationjob", compute.MigrationJob)
d.Set("milestones", compute.Milestones)
d.Set("name", compute.Name)
d.Set("natable_vins_id", compute.NatableVINSID)
d.Set("natable_vins_ip", compute.NatableVINSIP)
d.Set("natable_vins_name", compute.NatableVINSName)
d.Set("natable_vins_network", compute.NatableVINSNetwork)
d.Set("natable_vins_network_name", compute.NatableVINSNetworkName)
if err := d.Set("os_users", parseOsUsers(compute.OSUsers)); err != nil {
return err
}
d.Set("pinned", compute.Pinned)
d.Set("ram", compute.RAM)
d.Set("reference_id", compute.ReferenceID)
d.Set("registered", compute.Registered)
d.Set("res_name", compute.ResName)
d.Set("rg_id", compute.RGID)
d.Set("rg_name", compute.RGName)
d.Set("snap_sets", flattenSnapSets(compute.SnapSets))
d.Set("stateless_sep_id", compute.StatelessSepID)
d.Set("stateless_sep_type", compute.StatelessSepType)
d.Set("status", compute.Status)
d.Set("tags", flattenTags(compute.Tags))
d.Set("tech_status", compute.TechStatus)
d.Set("updated_by", compute.UpdatedBy)
d.Set("updated_time", compute.UpdatedTime)
d.Set("user_managed", compute.UserManaged)
d.Set("vgpus", compute.VGPUs)
d.Set("virtual_image_id", compute.VirtualImageID)
d.Set("virtual_image_name", compute.VirtualImageName)
d.Set("enabled", false)
if model.Status == status.Enabled {
if compute.Status == status.Enabled {
d.Set("enabled", true)
}
//d.Set("cloud_init", "applied") // NOTE: for existing compute we hard-code this value as an indicator for DiffSuppress fucntion
//d.Set("status", model.Status)
//d.Set("tech_status", model.TechStatus)
d.Set("started", false)
if model.TechStatus == "STARTED" {
if compute.TechStatus == "STARTED" {
d.Set("started", true)
}
bootDisk := findBootDisk(model.Disks)
d.Set("boot_disk_size", bootDisk.SizeMax)
d.Set("boot_disk_id", bootDisk.ID) // we may need boot disk ID in resize operations
d.Set("sep_id", bootDisk.SepID)
d.Set("pool", bootDisk.Pool)
d.Set("network", flattenNetwork(compute.Interfaces))
//if len(model.Disks) > 0 {
//log.Debugf("flattenCompute: calling parseComputeDisksToExtraDisks for %d disks", len(model.Disks))
@@ -92,24 +343,288 @@ func flattenCompute(d *schema.ResourceData, compFacts string) error {
//}
//}
if len(model.Interfaces) > 0 {
log.Debugf("flattenCompute: calling parseComputeInterfacesToNetworks for %d interfaces", len(model.Interfaces))
if err = d.Set("network", parseComputeInterfacesToNetworks(model.Interfaces)); err != nil {
return err
}
}
if len(model.OsUsers) > 0 {
log.Debugf("flattenCompute: calling parseOsUsers for %d logins", len(model.OsUsers))
if err = d.Set("os_users", parseOsUsers(model.OsUsers)); err != nil {
return err
}
}
err = d.Set("disks", flattenComputeDisksDemo(model.Disks, d.Get("extra_disks").(*schema.Set).List()))
if err != nil {
return err
}
return nil
}
func flattenDataComputeDisksDemo(disksList ListComputeDisks, extraDisks []interface{}) []map[string]interface{} {
res := make([]map[string]interface{}, 0)
for _, disk := range disksList {
if findInExtraDisks(uint(disk.ID), extraDisks) { //skip main bootdisk and extraDisks
continue
}
temp := map[string]interface{}{
"disk_name": disk.Name,
"disk_id": disk.ID,
"disk_type": disk.Type,
"sep_id": disk.SepID,
"shareable": disk.Shareable,
"size_max": disk.SizeMax,
"size_used": disk.SizeUsed,
"pool": disk.Pool,
"desc": disk.Description,
"image_id": disk.ImageID,
"size": disk.SizeMax,
}
res = append(res, temp)
}
return res
}
func flattenACL(acl RecordACL) []map[string]interface{} {
res := make([]map[string]interface{}, 0)
temp := map[string]interface{}{
"account_acl": flattenListACL(acl.AccountACL),
"compute_acl": flattenListACL(acl.ComputeACL),
"rg_acl": flattenListACL(acl.RGACL),
}
res = append(res, temp)
return res
}
func flattenAffinityRules(affinityRules ListRules) []map[string]interface{} {
res := make([]map[string]interface{}, 0)
for _, affinityRule := range affinityRules {
temp := map[string]interface{}{
"guid": affinityRule.GUID,
"key": affinityRule.Key,
"mode": affinityRule.Mode,
"policy": affinityRule.Policy,
"topology": affinityRule.Topology,
"value": affinityRule.Value,
}
res = append(res, temp)
}
return res
}
func flattenIotune(iotune IOTune) []map[string]interface{} {
res := make([]map[string]interface{}, 0)
temp := map[string]interface{}{
"read_bytes_sec": iotune.ReadBytesSec,
"read_bytes_sec_max": iotune.ReadBytesSecMax,
"read_iops_sec": iotune.ReadIOPSSec,
"read_iops_sec_max": iotune.ReadIOPSSecMax,
"size_iops_sec": iotune.SizeIOPSSec,
"total_bytes_sec": iotune.TotalBytesSec,
"total_bytes_sec_max": iotune.TotalBytesSecMax,
"total_iops_sec": iotune.TotalIOPSSec,
"total_iops_sec_max": iotune.TotalIOPSSecMax,
"write_bytes_sec": iotune.WriteBytesSec,
"write_bytes_sec_max": iotune.WriteBytesSecMax,
"write_iops_sec": iotune.WriteIOPSSec,
"write_iops_sec_max": iotune.WriteIOPSSecMax,
}
res = append(res, temp)
return res
}
func flattenSnapshots(snapshots SnapshotExtendList) []map[string]interface{} {
res := make([]map[string]interface{}, 0)
for _, snapshot := range snapshots {
temp := map[string]interface{}{
"guid": snapshot.GUID,
"label": snapshot.Label,
"res_id": snapshot.ResID,
"snap_set_guid": snapshot.SnapSetGUID,
"snap_set_time": snapshot.SnapSetTime,
"timestamp": snapshot.TimeStamp,
}
res = append(res, temp)
}
return res
}
func flattenListComputeDisks(disks ListComputeDisks) []map[string]interface{} {
res := make([]map[string]interface{}, 0)
for _, disk := range disks {
acl, _ := json.Marshal(disk.ACL)
temp := map[string]interface{}{
"_ckey": disk.CKey,
"acl": string(acl),
"account_id": disk.AccountID,
"boot_partition": disk.BootPartition,
"created_time": disk.CreatedTime,
"deleted_time": disk.DeletedTime,
"description": disk.Description,
"destruction_time": disk.DestructionTime,
"disk_path": disk.DiskPath,
"gid": disk.GID,
"guid": disk.GUID,
"disk_id": disk.ID,
"image_id": disk.ImageID,
"images": disk.Images,
"iotune": flattenIotune(disk.IOTune),
"iqn": disk.IQN,
"login": disk.Login,
"milestones": disk.Milestones,
"name": disk.Name,
"order": disk.Order,
"params": disk.Params,
"parent_id": disk.ParentID,
"passwd": disk.Passwd,
"pci_slot": disk.PCISlot,
"pool": disk.Pool,
"present_to": disk.PresentTo,
"purge_time": disk.PurgeTime,
"reality_device_number": disk.RealityDeviceNumber,
"res_id": disk.ResID,
"role": disk.Role,
"sep_id": disk.SepID,
"shareable": disk.Shareable,
"size_max": disk.SizeMax,
"size_used": disk.SizeUsed,
"snapshots": flattenSnapshots(disk.Snapshots),
"status": disk.Status,
"tech_status": disk.TechStatus,
"type": disk.Type,
"vmid": disk.VMID,
}
res = append(res, temp)
}
return res
}
func flattenCustomFields(customFileds map[string]interface{}) []map[string]interface{} {
res := make([]map[string]interface{}, 0)
for key, val := range customFileds {
value, _ := json.Marshal(val)
temp := map[string]interface{}{
"key": key,
"val": string(value),
}
res = append(res, temp)
}
return res
}
func flattenOsUsers(osUsers ListOSUser) []map[string]interface{} {
res := make([]map[string]interface{}, 0)
for _, user := range osUsers {
temp := map[string]interface{}{
"guid": user.GUID,
"login": user.Login,
"password": user.Password,
"public_key": user.PubKey,
}
res = append(res, temp)
}
return res
}
func flattenDataCompute(d *schema.ResourceData, compute RecordCompute) {
devices, _ := json.Marshal(compute.Devices)
userdata, _ := json.Marshal(compute.Userdata)
d.Set("acl", flattenACL(compute.ACL))
d.Set("account_id", compute.AccountID)
d.Set("account_name", compute.AccountName)
d.Set("affinity_label", compute.AffinityLabel)
d.Set("affinity_rules", flattenAffinityRules(compute.AffinityRules))
d.Set("affinity_weight", compute.AffinityWeight)
d.Set("anti_affinity_rules", flattenListRules(compute.AntiAffinityRules))
d.Set("arch", compute.Architecture)
d.Set("boot_order", compute.BootOrder)
d.Set("bootdisk_size", compute.BootDiskSize)
d.Set("clone_reference", compute.CloneReference)
d.Set("clones", compute.Clones)
d.Set("computeci_id", compute.ComputeCIID)
d.Set("cpus", compute.CPU)
d.Set("created_by", compute.CreatedBy)
d.Set("created_time", compute.CreatedTime)
d.Set("custom_fields", flattenCustomFields(compute.CustomFields))
d.Set("deleted_by", compute.DeletedBy)
d.Set("deleted_time", compute.DeletedTime)
d.Set("desc", compute.Description)
d.Set("devices", string(devices))
d.Set("disks", flattenListComputeDisks(compute.Disks))
d.Set("driver", compute.Driver)
d.Set("gid", compute.GID)
d.Set("guid", compute.GUID)
d.Set("compute_id", compute.ID)
d.Set("image_id", compute.ImageID)
d.Set("interfaces", flattenInterfaces(compute.Interfaces))
d.Set("lock_status", compute.LockStatus)
d.Set("manager_id", compute.ManagerID)
d.Set("manager_type", compute.ManagerType)
d.Set("migrationjob", compute.MigrationJob)
d.Set("milestones", compute.Milestones)
d.Set("name", compute.Name)
d.Set("natable_vins_id", compute.NatableVINSID)
d.Set("natable_vins_ip", compute.NatableVINSIP)
d.Set("natable_vins_name", compute.NatableVINSName)
d.Set("natable_vins_network", compute.NatableVINSNetwork)
d.Set("natable_vins_network_name", compute.NatableVINSNetworkName)
d.Set("os_users", flattenOsUsers(compute.OSUsers))
d.Set("pinned", compute.Pinned)
d.Set("ram", compute.RAM)
d.Set("reference_id", compute.ReferenceID)
d.Set("registered", compute.Registered)
d.Set("res_name", compute.ResName)
d.Set("rg_id", compute.RGID)
d.Set("rg_name", compute.RGName)
d.Set("snap_sets", flattenSnapSets(compute.SnapSets))
d.Set("stateless_sep_id", compute.StatelessSepID)
d.Set("stateless_sep_type", compute.StatelessSepType)
d.Set("status", compute.Status)
d.Set("tags", compute.Tags)
d.Set("tech_status", compute.TechStatus)
d.Set("updated_by", compute.UpdatedBy)
d.Set("updated_time", compute.UpdatedTime)
d.Set("user_managed", compute.UserManaged)
d.Set("userdata", string(userdata))
d.Set("vgpus", compute.VGPUs)
d.Set("virtual_image_id", compute.VirtualImageID)
d.Set("virtual_image_name", compute.VirtualImageName)
}
func flattenComputeAudits(computeAudits ListAudits) []map[string]interface{} {
res := make([]map[string]interface{}, 0)
for _, computeAudit := range computeAudits {
temp := map[string]interface{}{
"call": computeAudit.Call,
"responsetime": computeAudit.ResponseTime,
"statuscode": computeAudit.StatusCode,
"timestamp": computeAudit.Timestamp,
"user": computeAudit.User,
}
res = append(res, temp)
}
return res
}
func flattenPfwList(computePfws ListPFWs) []map[string]interface{} {
res := make([]map[string]interface{}, 0)
for _, computePfw := range computePfws {
temp := map[string]interface{}{
"pfw_id": computePfw.ID,
"local_ip": computePfw.LocalIP,
"local_port": computePfw.LocalPort,
"protocol": computePfw.Protocol,
"public_port_end": computePfw.PublicPortEnd,
"public_port_start": computePfw.PublicPortStart,
"vm_id": computePfw.VMID,
}
res = append(res, temp)
}
return res
}
func flattenUserList(d *schema.ResourceData, userList RecordACL) {
d.Set("account_acl", flattenListACL(userList.AccountACL))
d.Set("compute_acl", flattenListACL(userList.ComputeACL))
d.Set("rg_acl", flattenListACL(userList.RGACL))
}
func flattenComputeGetAudits(computeAudits ListShortAudits) []map[string]interface{} {
res := make([]map[string]interface{}, 0)
for _, computeAudit := range computeAudits {
temp := map[string]interface{}{
"epoch": computeAudit.Epoch,
"message": computeAudit.Message,
}
res = append(res, temp)
}
return res
}