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.
503 lines
15 KiB
503 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("def_net_type", rgData.DefNetType)
|
|
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)
|
|
}
|