You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
terraform-provider-decort/internal/service/cloudbroker/rg/flattens.go

502 lines
15 KiB

package rg
import (
log "github.com/sirupsen/logrus"
"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
"repository.basistech.ru/BASIS/decort-golang-sdk/pkg/cloudbroker/rg"
)
func flattenResgroup(d *schema.ResourceData, rgData *rg.RecordRG) {
log.Debugf("flattenResgroup: decoded RG name %q / ID %d, account ID %d",
rgData.Name, rgData.ID, rgData.AccountID)
d.Set("account_id", rgData.AccountID)
d.Set("account_name", rgData.AccountName)
d.Set("acl", flattenRgAcl(rgData.ACL))
d.Set("compute_features", rgData.ComputeFeatures)
d.Set("cpu_allocation_parameter", rgData.CPUAllocationParameter)
d.Set("cpu_allocation_ratio", rgData.CPUAllocationRatio)
d.Set("created_by", rgData.CreatedBy)
d.Set("created_time", rgData.CreatedTime)
d.Set("def_net_id", rgData.DefNetID)
d.Set("def_net_type", rgData.DefNetType)
d.Set("deleted_by", rgData.DeletedBy)
d.Set("deleted_time", rgData.DeletedTime)
d.Set("desc", rgData.Description)
d.Set("dirty", rgData.Dirty)
d.Set("gid", rgData.GID)
d.Set("guid", rgData.GUID)
d.Set("rg_id", rgData.ID)
d.Set("lock_status", rgData.LockStatus)
d.Set("milestones", rgData.Milestones)
d.Set("name", rgData.Name)
d.Set("register_computes", rgData.RegisterComputes)
d.Set("resource_limits", flattenRgResourceLimits(rgData.ResourceLimits))
d.Set("resource_types", rgData.ResTypes)
d.Set("secret", rgData.Secret)
d.Set("status", rgData.Status)
d.Set("uniq_pools", rgData.UniqPools)
d.Set("updated_by", rgData.UpdatedBy)
d.Set("updated_time", rgData.UpdatedTime)
d.Set("vins", rgData.VINS)
d.Set("computes", rgData.VMs)
}
func flattenRgAcl(rgACLs rg.ListACL) []map[string]interface{} {
res := make([]map[string]interface{}, 0, len(rgACLs))
for _, acl := range rgACLs {
temp := map[string]interface{}{
"explicit": acl.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 flattenRgResourceLimits(rl rg.ResourceLimits) []map[string]interface{} {
res := make([]map[string]interface{}, 0)
temp := map[string]interface{}{
"cu_c": rl.CUC,
"cu_d": rl.CuD,
"cu_dm": rl.CUDM,
"cu_i": rl.CUI,
"cu_m": rl.CUM,
"cu_np": rl.CUNP,
"gpu_units": rl.GPUUnits,
}
res = append(res, temp)
return res
}
func flattenRgAudits(rgAudits rg.ListAudits) []map[string]interface{} {
res := make([]map[string]interface{}, 0, len(rgAudits))
for _, rgAudit := range rgAudits {
temp := map[string]interface{}{
"call": rgAudit.Call,
"responsetime": rgAudit.ResponseTime,
"statuscode": rgAudit.StatusCode,
"timestamp": rgAudit.Timestamp,
"user": rgAudit.User,
}
res = append(res, temp)
}
return res
}
func flattenRgListGroups(list *rg.ListAffinityGroup) []map[string]interface{} {
res := make([]map[string]interface{}, 0, len(list.Data))
for _, item := range list.Data {
for key, vals := range item {
for _, v := range vals {
temp := map[string]interface{}{
"label": key,
"id": v.ID,
"node_id": v.NodeID,
}
res = append(res, temp)
}
}
}
return res
}
func flattenRgAffinityGroupComputes(list rg.ListAffinityGroupCompute) []map[string]interface{} {
res := make([]map[string]interface{}, 0, len(list))
for _, item := range list {
temp := map[string]interface{}{
"compute_id": item.ComputeID,
"other_node": item.OtherNode,
"other_node_indirect": item.OtherNodeIndirect,
"other_node_indirect_soft": item.OtherNodeIndirectSoft,
"other_node_soft": item.OtherNodeSoft,
"same_node": item.SameNode,
"same_node_soft": item.SameNodeSoft,
}
res = append(res, temp)
}
return res
}
func flattenRGResourceConsumption(d *schema.ResourceData, rg *rg.ItemResourceConsumption) {
d.Set("consumed", flattenResource(rg.Consumed))
d.Set("reserved", flattenResource(rg.Reserved))
d.Set("resource_limits", flattenRgResourceLimits(rg.ResourceLimits))
d.Set("rg_id", rg.RGID)
}
func flattenRGResourceConsumptionList(rg *rg.ListResourceConsumption) []map[string]interface{} {
res := make([]map[string]interface{}, 0, len(rg.Data))
for _, rc := range rg.Data {
temp := map[string]interface{}{
"consumed": flattenResource(rc.Consumed),
"reserved": flattenResource(rc.Reserved),
"resource_limits": flattenRgResourceLimits(rc.ResourceLimits),
"rg_id": rc.RGID,
}
res = append(res, temp)
}
return res
}
func flattenRgUsageResource(d *schema.ResourceData, usage rg.Reservation) {
d.Set("cpu", usage.CPU)
d.Set("disk_size", usage.DiskSize)
d.Set("disk_size_max", usage.DiskSizeMax)
d.Set("extips", usage.ExtIPs)
d.Set("exttraffic", usage.ExtTraffic)
d.Set("gpu", usage.GPU)
d.Set("ram", usage.RAM)
d.Set("seps", flattenRGSeps(usage.SEPs))
}
func flattenResource(resource rg.Reservation) []map[string]interface{} {
res := make([]map[string]interface{}, 0)
temp := map[string]interface{}{
"cpu": resource.CPU,
"disk_size": resource.DiskSize,
"disk_size_max": resource.DiskSizeMax,
"extips": resource.ExtIPs,
"exttraffic": resource.ExtTraffic,
"gpu": resource.GPU,
"ram": resource.RAM,
"seps": flattenRGSeps(resource.SEPs),
}
res = append(res, temp)
return res
}
func flattenRGSeps(seps map[string]map[string]rg.DiskUsage) []map[string]interface{} {
res := make([]map[string]interface{}, 0)
for sepKey, sepVal := range seps {
for dataKey, dataVal := range sepVal {
temp := map[string]interface{}{
"sep_id": sepKey,
"data_name": dataKey,
"disk_size": dataVal.DiskSize,
"disk_size_max": dataVal.DiskSizeMax,
}
res = append(res, temp)
}
}
return res
}
func flattenRgListComputes(lc *rg.ListComputes) []map[string]interface{} {
res := make([]map[string]interface{}, 0, len(lc.Data))
for _, compute := range lc.Data {
temp := map[string]interface{}{
"account_id": compute.AccountID,
"account_name": compute.AccountName,
"affinity_label": compute.AffinityLabel,
"affinity_rules": flattenRules(compute.AffinityRules),
"affinity_weight": compute.AffinityWeight,
"antiaffinity_rules": flattenRules(compute.AntiAffinityRules),
"cpus": compute.CPUs,
"created_by": compute.CreatedBy,
"created_time": compute.CreatedTime,
"deleted_by": compute.DeletedBy,
"deleted_time": compute.DeletedTime,
"id": compute.ID,
"name": compute.Name,
"ram": compute.RAM,
"registered": compute.Registered,
"rg_id": compute.RGID,
"rg_name": compute.RGName,
"status": compute.Status,
"tech_status": compute.TechStatus,
"total_disks_size": compute.TotalDisksSize,
"updated_by": compute.UpdatedBy,
"updated_time": compute.UpdatedTime,
"user_managed": compute.UserManaged,
"vins_connected": compute.VINSConnected,
}
res = append(res, temp)
}
return res
}
func flattenRules(list rg.ListRules) []map[string]interface{} {
res := make([]map[string]interface{}, 0, len(list))
for _, rule := range list {
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 flattenRgListLb(listLb *rg.ListLB) []map[string]interface{} {
res := make([]map[string]interface{}, 0, len(listLb.Data))
for _, lb := range listLb.Data {
temp := map[string]interface{}{
"ha_mode": lb.HAMode,
"acl": lb.ACL,
"backends": flattenBackends(lb.Backends),
"created_by": lb.CreatedBy,
"created_time": lb.CreatedTime,
"deleted_by": lb.DeletedBy,
"deleted_time": lb.DeletedTime,
"desc": lb.Description,
"dp_api_user": lb.DPAPIUser,
"extnet_id": lb.ExtNetID,
"frontends": flattenFrontends(lb.Frontends),
"gid": lb.GID,
"guid": lb.GUID,
"id": lb.ID,
"image_id": lb.ImageID,
"milestones": lb.Milestones,
"name": lb.Name,
"primary_node": flattenNode(lb.PrimaryNode),
"rg_name": lb.RGName,
"secondary_node": flattenNode(lb.SecondaryNode),
"status": lb.Status,
"tech_status": lb.TechStatus,
"updated_by": lb.UpdatedBy,
"updated_time": lb.UpdatedTime,
"vins_id": lb.VINSID,
}
res = append(res, temp)
}
return res
}
func flattenNode(node rg.RecordNode) []map[string]interface{} {
res := make([]map[string]interface{}, 0)
temp := map[string]interface{}{
"backend_ip": node.BackendIP,
"compute_id": node.ComputeID,
"frontend_ip": node.FrontendIP,
"guid": node.GUID,
"mgmt_ip": node.MGMTIP,
"network_id": node.NetworkID,
}
res = append(res, temp)
return res
}
func flattenFrontends(list rg.ListFrontends) []map[string]interface{} {
res := make([]map[string]interface{}, 0, len(list))
for _, front := range list {
temp := map[string]interface{}{
"backend": front.Backend,
"bindings": flattenBindings(front.Bindings),
"guid": front.GUID,
"name": front.Name,
}
res = append(res, temp)
}
return res
}
func flattenBindings(list rg.ListBindings) []map[string]interface{} {
res := make([]map[string]interface{}, 0, len(list))
for _, bind := range list {
temp := map[string]interface{}{
"address": bind.Address,
"guid": bind.GUID,
"name": bind.Name,
"port": bind.Port,
}
res = append(res, temp)
}
return res
}
func flattenBackends(b rg.ListBackends) []map[string]interface{} {
res := make([]map[string]interface{}, 0, len(b))
for _, item := range b {
temp := map[string]interface{}{
"algorithm": item.Algorithm,
"guid": item.GUID,
"name": item.Name,
"server_default_settings": flattenServerSettings(item.ServerDefaultSettings),
"servers": flattenListServers(item.Servers),
}
res = append(res, temp)
}
return res
}
func flattenListServers(list rg.ListServers) []map[string]interface{} {
res := make([]map[string]interface{}, 0, len(list))
for _, serv := range list {
temp := map[string]interface{}{
"address": serv.Address,
"check": serv.Check,
"guid": serv.GUID,
"name": serv.Name,
"port": serv.Port,
"server_settings": flattenServerSettings(serv.ServerSettings),
}
res = append(res, temp)
}
return res
}
func flattenServerSettings(settings rg.ServerSettings) []map[string]interface{} {
res := make([]map[string]interface{}, 0)
temp := map[string]interface{}{
"inter": settings.Inter,
"guid": settings.GUID,
"down_inter": settings.DownInter,
"rise": settings.Rise,
"fall": settings.Fall,
"slow_start": settings.SlowStart,
"max_conn": settings.MaxConn,
"max_queue": settings.MaxQueue,
"weight": settings.Weight,
}
res = append(res, temp)
return res
}
func flattenRgList(rgl *rg.ListRG) []map[string]interface{} {
res := make([]map[string]interface{}, 0, len(rgl.Data))
for _, rg := range rgl.Data {
temp := map[string]interface{}{
"account_id": rg.AccountID,
"account_name": rg.AccountName,
"acl": flattenRgAcl(rg.ACL),
"compute_features": rg.ComputeFeatures,
"cpu_allocation_parameter": rg.CPUAllocationParameter,
"cpu_allocation_ratio": rg.CPUAllocationRatio,
"created_by": rg.CreatedBy,
"created_time": rg.CreatedTime,
"def_net_id": rg.DefNetID,
"def_net_type": rg.DefNetType,
"deleted_by": rg.DeletedBy,
"deleted_time": rg.DeletedTime,
"desc": rg.Description,
"dirty": rg.Dirty,
"gid": rg.GID,
"guid": rg.GUID,
"rg_id": rg.ID,
"lock_status": rg.LockStatus,
"milestones": rg.Milestones,
"name": rg.Name,
"register_computes": rg.RegisterComputes,
"resource_limits": flattenRgResourceLimits(rg.ResourceLimits),
"secret": rg.Secret,
"status": rg.Status,
"updated_by": rg.UpdatedBy,
"updated_time": rg.UpdatedTime,
"vins": rg.VINS,
"vms": rg.VMs,
}
res = append(res, temp)
}
return res
}
func flattenRgListVins(lv *rg.ListVINS) []map[string]interface{} {
res := make([]map[string]interface{}, 0, len(lv.Data))
for _, vins := range lv.Data {
temp := map[string]interface{}{
"account_id": vins.AccountID,
"account_name": vins.AccountName,
"computes": vins.Computes,
"created_by": vins.CreatedBy,
"created_time": vins.CreatedTime,
"deleted_by": vins.DeletedBy,
"deleted_time": vins.DeletedTime,
"external_ip": vins.ExternalIP,
"extnet_id": vins.ExtnetId,
"free_ips": vins.FreeIPs,
"id": vins.ID,
"name": vins.Name,
"network": vins.Network,
"pri_vnf_dev_id": vins.PriVNFDevID,
"rg_id": vins.RGID,
"rg_name": vins.RGName,
"status": vins.Status,
"updated_by": vins.UpdatedBy,
"updated_time": vins.UpdatedTime,
}
res = append(res, temp)
}
return res
}
func flattenRgListPfw(listPfw *rg.ListPFW) []map[string]interface{} {
res := make([]map[string]interface{}, 0, len(listPfw.Data))
for _, pfw := range listPfw.Data {
temp := map[string]interface{}{
"public_port_end": pfw.PublicPortEnd,
"public_port_start": pfw.PublicPortStart,
"vm_id": pfw.VMID,
"vm_ip": pfw.VMIP,
"vm_name": pfw.VMName,
"vm_port": pfw.VMPort,
"vins_id": pfw.VINSID,
"vins_name": pfw.VINSName,
}
res = append(res, temp)
}
return res
}
func flattenResourceRG(d *schema.ResourceData, rgData *rg.RecordRG) {
d.Set("account_id", rgData.AccountID)
d.Set("gid", rgData.GID)
d.Set("rg_name", rgData.Name)
d.Set("resource_limits", flattenRgResourceLimits(rgData.ResourceLimits))
d.Set("description", rgData.Description)
d.Set("register_computes", rgData.RegisterComputes)
d.Set("uniq_pools", rgData.UniqPools)
d.Set("cpu_allocation_parameter", rgData.CPUAllocationParameter)
d.Set("cpu_allocation_ratio", rgData.CPUAllocationRatio)
d.Set("acl", flattenRgAcl(rgData.ACL))
d.Set("account_name", rgData.AccountName)
d.Set("created_by", rgData.CreatedBy)
d.Set("created_time", rgData.CreatedTime)
d.Set("def_net_id", rgData.DefNetID)
d.Set("deleted_by", rgData.DeletedBy)
d.Set("deleted_time", rgData.DeletedTime)
d.Set("guid", rgData.GUID)
d.Set("rg_id", rgData.ID)
d.Set("lock_status", rgData.LockStatus)
d.Set("milestones", rgData.Milestones)
d.Set("resource_types", rgData.ResTypes)
d.Set("secret", rgData.Secret)
d.Set("status", rgData.Status)
d.Set("updated_by", rgData.UpdatedBy)
d.Set("updated_time", rgData.UpdatedTime)
d.Set("vins", rgData.VINS)
d.Set("vms", rgData.VMs)
}