582 lines
20 KiB
Go
582 lines
20 KiB
Go
/*
|
|
Copyright (c) 2019-2022 Digital Energy Cloud Solutions LLC. All Rights Reserved.
|
|
Authors:
|
|
Petr Krutov, <petr.krutov@digitalenergy.online>
|
|
Stanislav Solovev, <spsolovev@digitalenergy.online>
|
|
Kasim Baybikov, <kmbaybikov@basistech.ru>
|
|
|
|
Licensed under the Apache License, Version 2.0 (the "License");
|
|
you may not use this file except in compliance with the License.
|
|
You may obtain a copy of the License at
|
|
|
|
http://www.apache.org/licenses/LICENSE-2.0
|
|
|
|
Unless required by applicable law or agreed to in writing, software
|
|
distributed under the License is distributed on an "AS IS" BASIS,
|
|
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
See the License for the specific language governing permissions and
|
|
limitations under the License.
|
|
*/
|
|
|
|
/*
|
|
Terraform DECORT provider - manage resources provided by DECORT (Digital Energy Cloud
|
|
Orchestration Technology) with Terraform by Hashicorp.
|
|
|
|
Source code: https://repository.basistech.ru/BASIS/terraform-provider-decort
|
|
|
|
Please see README.md to learn where to place source code so that it
|
|
builds seamlessly.
|
|
|
|
Documentation: https://repository.basistech.ru/BASIS/terraform-provider-decort/wiki
|
|
*/
|
|
|
|
package netobjgroups
|
|
|
|
import (
|
|
"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
|
|
"repository.basistech.ru/BASIS/decort-golang-sdk/pkg/sdn/netobjgroups"
|
|
)
|
|
|
|
func flattenNetworkObjectGroupResource(d *schema.ResourceData, rec *netobjgroups.RecordNetObjGroup) {
|
|
d.Set("name", rec.Name)
|
|
d.Set("access_group_id", rec.AccessGroupID)
|
|
d.Set("access_group_name", rec.AccessGroupName)
|
|
d.Set("description", rec.Description)
|
|
d.Set("type", rec.Type)
|
|
d.Set("purpose", rec.Purpose)
|
|
d.Set("version_id", int(rec.VersionID))
|
|
d.Set("addresses", flattenAddresses(rec.Addresses))
|
|
d.Set("counters", flattenCounters(rec.Counters))
|
|
d.Set("l2_connection_ports", flattenL2ConnectionPorts(rec.L2ConnectionPorts))
|
|
d.Set("logical_ports", flattenLogicalPorts(rec.LogicalPorts))
|
|
d.Set("external_network_ports", flattenExternalNetworkPorts(rec.ExternalNetworkPorts))
|
|
d.Set("security_policies", flattenSecurityPolicies(rec.SecurityPolicies))
|
|
}
|
|
|
|
func flattenNetworkObjectGroupDataSource(d *schema.ResourceData, rec *netobjgroups.RecordNetObjGroup) {
|
|
d.Set("name", rec.Name)
|
|
d.Set("access_group_id", rec.AccessGroupID)
|
|
d.Set("access_group_name", rec.AccessGroupName)
|
|
d.Set("description", rec.Description)
|
|
d.Set("type", rec.Type)
|
|
d.Set("purpose", rec.Purpose)
|
|
d.Set("version_id", int(rec.VersionID))
|
|
d.Set("created_at", rec.CreatedAt)
|
|
d.Set("updated_at", rec.UpdatedAt)
|
|
d.Set("addresses", flattenAddresses(rec.Addresses))
|
|
d.Set("counters", flattenCounters(rec.Counters))
|
|
d.Set("l2_connection_ports", flattenL2ConnectionPorts(rec.L2ConnectionPorts))
|
|
d.Set("logical_ports", flattenLogicalPorts(rec.LogicalPorts))
|
|
d.Set("external_network_ports", flattenExternalNetworkPorts(rec.ExternalNetworkPorts))
|
|
d.Set("security_policies", flattenSecurityPolicies(rec.SecurityPolicies))
|
|
}
|
|
|
|
func flattenAddresses(addrs netobjgroups.NetAddresses) []map[string]interface{} {
|
|
res := make([]map[string]interface{}, 0, len(addrs))
|
|
for _, a := range addrs {
|
|
res = append(res, map[string]interface{}{
|
|
"id": a.ID,
|
|
"net_address_type": a.NetAddressType,
|
|
"ip_addr": a.IPAddr,
|
|
"ip_addr_range_end": a.IPAddrRangeEnd,
|
|
"ip_prefix": a.IPPrefix,
|
|
"mac_addr": a.MACAddr,
|
|
})
|
|
}
|
|
return res
|
|
}
|
|
|
|
func flattenCounters(c netobjgroups.Counter) []map[string]interface{} {
|
|
return []map[string]interface{}{
|
|
{
|
|
"addresses_count": int(c.AddressesCount),
|
|
"l2_connection_ports_count": int(c.L2ConnectionPortsCount),
|
|
"logical_ports_count": int(c.LogicalPortsCount),
|
|
"security_policies_count": int(c.SecurityPoliciesCount),
|
|
"security_rules_count": int(c.SecurityRulesCount),
|
|
},
|
|
}
|
|
}
|
|
|
|
func flattenStatus(s netobjgroups.Status) []map[string]interface{} {
|
|
return []map[string]interface{}{
|
|
{
|
|
"operation_status": s.OperationStatus,
|
|
"hypervisor_status": s.HypervisorStatus,
|
|
"hypervisors": flattenHypervisorsInfo(s.Hypervisors),
|
|
},
|
|
}
|
|
}
|
|
|
|
func flattenHypervisorsInfo(hvs netobjgroups.HypervisorsInfo) []map[string]interface{} {
|
|
res := make([]map[string]interface{}, 0, len(hvs))
|
|
for _, hv := range hvs {
|
|
res = append(res, map[string]interface{}{
|
|
"operation_status": hv.OperationStatus,
|
|
"name": hv.Name,
|
|
"display_name": hv.DisplayName,
|
|
"hypervisor_status": hv.HypervisorStatus,
|
|
"synced_at": hv.SyncedAt,
|
|
})
|
|
}
|
|
return res
|
|
}
|
|
|
|
func flattenLogicalPortAddresses(addrs netobjgroups.LogicalPortAddresses) []map[string]interface{} {
|
|
res := make([]map[string]interface{}, 0, len(addrs))
|
|
for _, a := range addrs {
|
|
res = append(res, map[string]interface{}{
|
|
"ip": a.IP,
|
|
"ip_type": a.IPType,
|
|
"is_discovered": a.IsDiscovered,
|
|
"is_primary": a.IsPrimary,
|
|
"mac": a.MAC,
|
|
"id": a.ID,
|
|
"logical_port_id": a.LogicalPortID,
|
|
"assigned_at": a.AssignedAt,
|
|
})
|
|
}
|
|
return res
|
|
}
|
|
|
|
func flattenBindings(b netobjgroups.Bindings) []map[string]interface{} {
|
|
return []map[string]interface{}{
|
|
{
|
|
"id": b.ID,
|
|
"segment_display_name": b.SegmentDisplayName,
|
|
"segment_id": b.SegmentID,
|
|
"port_security": b.PortSecurity,
|
|
"address_detection": b.AddressDetection,
|
|
"version_id": int(b.VersionID),
|
|
"created_at": b.CreatedAt,
|
|
"updated_at": b.UpdatedAt,
|
|
"logical_port_addresses": flattenLogicalPortAddresses(b.LogicalPortAddresses),
|
|
},
|
|
}
|
|
}
|
|
|
|
func flattenExcludeFirewall(e netobjgroups.ExcludeFirewall) []map[string]interface{} {
|
|
return []map[string]interface{}{
|
|
{
|
|
"exclusion_reason": e.ExclusionReason,
|
|
"logical_port_addresses_excluded": e.LogicalPortAddressesExcluded,
|
|
"logical_port_excluded": e.LogicalPortExcluded,
|
|
},
|
|
}
|
|
}
|
|
|
|
func flattenLabels(l netobjgroups.Labels) []map[string]interface{} {
|
|
return []map[string]interface{}{
|
|
{
|
|
"vm_id": l.VMID,
|
|
"vm_name": l.VMName,
|
|
},
|
|
}
|
|
}
|
|
|
|
func flattenLogicalPort(lp netobjgroups.LogicalPort) map[string]interface{} {
|
|
return map[string]interface{}{
|
|
"id": lp.ID,
|
|
"access_group_id": lp.AccessGroupID,
|
|
"access_group_name": lp.AccessGroupName,
|
|
"adapter_mac": lp.AdapterMAC,
|
|
"address_detection": lp.AddressDetection,
|
|
"description": lp.Description,
|
|
"created_at": lp.CreatedAt,
|
|
"display_name": lp.DisplayName,
|
|
"enabled": lp.Enabled,
|
|
"exclude_firewall": flattenExcludeFirewall(lp.ExcludeFirewall),
|
|
"external_network_id": lp.ExternalNetworkID,
|
|
"hypervisor": lp.Hypervisor,
|
|
"hypervisor_display_name": lp.HypervisorDisplayName,
|
|
"labels": flattenLabels(lp.Labels),
|
|
"live_migration_target_hv": lp.LiveMigrationTargetHV,
|
|
"status": flattenStatus(lp.Status),
|
|
"bindings": flattenBindings(lp.Bindings),
|
|
"unique_identifier": lp.UniqueIdentifier,
|
|
"updated_at": lp.UpdatedAt,
|
|
"version_id": int(lp.VersionID),
|
|
}
|
|
}
|
|
|
|
func flattenLogicalPorts(ports netobjgroups.LogicalPorts) []map[string]interface{} {
|
|
res := make([]map[string]interface{}, 0, len(ports))
|
|
for _, lp := range ports {
|
|
res = append(res, flattenLogicalPort(lp))
|
|
}
|
|
return res
|
|
}
|
|
|
|
func flattenL2ExternalNetwork(n netobjgroups.L2ExternalNetwork) []map[string]interface{} {
|
|
hypervisors := make([]interface{}, 0, len(n.Hypervisors))
|
|
for _, h := range n.Hypervisors {
|
|
hypervisors = append(hypervisors, h)
|
|
}
|
|
vlanTag := 0
|
|
if n.VLANTag != nil {
|
|
vlanTag = *n.VLANTag
|
|
}
|
|
return []map[string]interface{}{
|
|
{
|
|
"bridge_network_name": n.BridgeNetworkName,
|
|
"created_at": n.CreatedAt,
|
|
"description": n.Description,
|
|
"display_name": n.DisplayName,
|
|
"hypervisors": hypervisors,
|
|
"id": n.ID,
|
|
"updated_at": n.UpdatedAt,
|
|
"version_id": int(n.VersionID),
|
|
"vlan_tag": vlanTag,
|
|
},
|
|
}
|
|
}
|
|
|
|
func flattenL2ConnectionPorts(ports netobjgroups.L2ConnectionPorts) []map[string]interface{} {
|
|
res := make([]map[string]interface{}, 0, len(ports))
|
|
for _, p := range ports {
|
|
res = append(res, map[string]interface{}{
|
|
"id": p.ID,
|
|
"access_group_id": p.AccessGroupID,
|
|
"created_at": p.CreatedAt,
|
|
"updated_at": p.UpdatedAt,
|
|
"version_id": int(p.VersionID),
|
|
"l2_external_network": flattenL2ExternalNetwork(p.L2ExternalNetwork),
|
|
})
|
|
}
|
|
return res
|
|
}
|
|
|
|
func flattenIPv6Config(c netobjgroups.IPv6Config) []map[string]interface{} {
|
|
return []map[string]interface{}{
|
|
{
|
|
"address_mode": c.AddressMode,
|
|
"enable_periodic_ra": c.EnablePeriodicRA,
|
|
"interval_ra": int(c.IntervalRA),
|
|
"router_preference": c.RouterPreference,
|
|
},
|
|
}
|
|
}
|
|
|
|
func flattenRouterGatewayPort(r netobjgroups.RouterGateawayPort) []map[string]interface{} {
|
|
return []map[string]interface{}{
|
|
{
|
|
"created_at": r.CreatedAt,
|
|
"description": r.Description,
|
|
"id": r.ID,
|
|
"router_display_name": r.RouterDisplayName,
|
|
"router_id": r.RouterID,
|
|
"snat_enabled": r.SNATEnabled,
|
|
"updated_at": r.UpdatedAt,
|
|
},
|
|
}
|
|
}
|
|
|
|
func flattenSegment(s netobjgroups.Segment) []map[string]interface{} {
|
|
return []map[string]interface{}{
|
|
{
|
|
"access_group_id": s.AccessGroupID,
|
|
"access_group_name": s.AccessGroupName,
|
|
"created_at": s.CreatedAt,
|
|
"description": s.Description,
|
|
"display_name": s.DisplayName,
|
|
"enabled": s.Enabled,
|
|
"id": s.ID,
|
|
"subnet_v4": s.SubnetV4,
|
|
"subnet_v6": s.SubnetV6,
|
|
"updated_at": s.UpdatedAt,
|
|
"version_id": int(s.VersionID),
|
|
},
|
|
}
|
|
}
|
|
|
|
func flattenRouter(r netobjgroups.Router) []map[string]interface{} {
|
|
gateawayPorts := make([]map[string]interface{}, 0, len(r.GateawayPorts))
|
|
for _, gp := range r.GateawayPorts {
|
|
gateawayPorts = append(gateawayPorts, map[string]interface{}{
|
|
"created_at": gp.CreatedAt,
|
|
"description": gp.Description,
|
|
"external_l4_port_max": int(gp.ExternalL4PortMax),
|
|
"external_l4_port_min": int(gp.ExternalL4PortMin),
|
|
"id": gp.ID,
|
|
"snat_enabled": gp.SNATEnabled,
|
|
"status": flattenStatus(gp.Status),
|
|
"updated_at": gp.UpdatedAt,
|
|
"version_id": int(gp.VersionID),
|
|
})
|
|
}
|
|
|
|
policies := make([]map[string]interface{}, 0, len(r.Policies))
|
|
for _, pol := range r.Policies {
|
|
nextIPv4 := make([]interface{}, 0, len(pol.NextIPv4Address))
|
|
for _, ip := range pol.NextIPv4Address {
|
|
nextIPv4 = append(nextIPv4, ip)
|
|
}
|
|
nextIPv6 := make([]interface{}, 0, len(pol.NextIPv6Address))
|
|
for _, ip := range pol.NextIPv6Address {
|
|
nextIPv6 = append(nextIPv6, ip)
|
|
}
|
|
policies = append(policies, map[string]interface{}{
|
|
"action": pol.Action,
|
|
"created_at": pol.CreatedAt,
|
|
"display_name": pol.DisplayName,
|
|
"enabled": pol.Enabled,
|
|
"id": pol.ID,
|
|
"match": pol.Match,
|
|
"next_ipv4_address": nextIPv4,
|
|
"next_ipv6_address": nextIPv6,
|
|
"priority": pol.Priority,
|
|
"updated_at": pol.UpdatedAt,
|
|
"version_id": int(pol.VersionID),
|
|
})
|
|
}
|
|
|
|
ports := make([]map[string]interface{}, 0, len(r.Port))
|
|
for _, port := range r.Port {
|
|
ports = append(ports, map[string]interface{}{
|
|
"created_at": port.CreatedAt,
|
|
"description": port.Description,
|
|
"enabled": port.Enabled,
|
|
"id": port.ID,
|
|
"ipv4_address": port.IPv4Address,
|
|
"ipv6_address": port.IPv6Address,
|
|
"ipv6_config": flattenIPv6Config(port.IPv6Config),
|
|
"mac": port.MAC,
|
|
"segment_id": port.SegmentID,
|
|
"segment": flattenSegment(port.Segment),
|
|
"status": flattenStatus(port.Status),
|
|
"updated_at": port.UpdatedAt,
|
|
"version_id": int(port.VersionID),
|
|
})
|
|
}
|
|
|
|
return []map[string]interface{}{
|
|
{
|
|
"access_group_id": r.AccessGroupID,
|
|
"access_group_name": r.AccessGroupName,
|
|
"created_at": r.CreatedAt,
|
|
"description": r.Description,
|
|
"display_name": r.DisplayName,
|
|
"enabled": r.Enabled,
|
|
"gateaway_ports": gateawayPorts,
|
|
"id": r.ID,
|
|
"policies": policies,
|
|
"ports": ports,
|
|
"status": flattenStatus(r.Status),
|
|
"updated_at": r.UpdatedAt,
|
|
"version_id": int(r.VersionID),
|
|
},
|
|
}
|
|
}
|
|
|
|
func flattenFloatingIP(f netobjgroups.FloatingIP) []map[string]interface{} {
|
|
return []map[string]interface{}{
|
|
{
|
|
"access_group_id": f.AccessGroupID,
|
|
"access_group_name": f.AccessGroupName,
|
|
"created_at": f.CreatedAt,
|
|
"updated_at": f.UpdatedAt,
|
|
"version_id": int(f.VersionID),
|
|
"logical_port": []map[string]interface{}{flattenLogicalPort(f.LogicalPort)},
|
|
"router": flattenRouter(f.Router),
|
|
},
|
|
}
|
|
}
|
|
|
|
func flattenExternalNetworkPortFields(ports netobjgroups.ExternalNetworkPortsField) []map[string]interface{} {
|
|
res := make([]map[string]interface{}, 0, len(ports))
|
|
for _, p := range ports {
|
|
res = append(res, map[string]interface{}{
|
|
"access_group_id": p.AccessGroupID,
|
|
"access_group_name": p.AccessGroupName,
|
|
"comment": p.Comment,
|
|
"display_name": p.DisplayName,
|
|
"enabled": p.Enabled,
|
|
"ipv4": p.IPv4,
|
|
"ipv6": p.IPv6,
|
|
"ipv6_config": flattenIPv6Config(p.IPv6Config),
|
|
"mac": p.MAC,
|
|
"router_gateaway_port": flattenRouterGatewayPort(p.RouterGateawayPort),
|
|
"floating_ip": flattenFloatingIP(p.FloatingIP),
|
|
})
|
|
}
|
|
return res
|
|
}
|
|
|
|
func flattenExternalNetworkPorts(ports netobjgroups.ExternalNetworkPorts) []map[string]interface{} {
|
|
res := make([]map[string]interface{}, 0, len(ports))
|
|
for _, p := range ports {
|
|
hypervisors := make([]interface{}, 0, len(p.Hypervisors))
|
|
for _, h := range p.Hypervisors {
|
|
hypervisors = append(hypervisors, h)
|
|
}
|
|
res = append(res, map[string]interface{}{
|
|
"id": p.ID,
|
|
"access_group_id": p.AccessGroupID,
|
|
"access_group_name": p.AccessGroupName,
|
|
"bridge_network_name": p.BridgeNetworkName,
|
|
"comment": p.Comment,
|
|
"default_gateway_ipv4": p.DefaultGatewayIPv4,
|
|
"default_gateway_ipv6": p.DefaultGatewayIPv6,
|
|
"description": p.Description,
|
|
"enabled": p.Enabled,
|
|
"external_network_ports": flattenExternalNetworkPortFields(p.ExternalNetworkPorts),
|
|
"hypervisors": hypervisors,
|
|
"ipv4": p.IPv4,
|
|
"status": flattenStatus(p.Status),
|
|
"version_id": int(p.VersionID),
|
|
"subnet_v4": p.SubnetV4,
|
|
"subnet_v6": p.SubnetV6,
|
|
"created_at": p.CreatedAt,
|
|
"updated_at": p.UpdatedAt,
|
|
"vlan_tag": p.VLANTag,
|
|
"mac": p.MAC,
|
|
})
|
|
}
|
|
return res
|
|
}
|
|
|
|
func flattenAppliedNetObjectGroups(groups netobjgroups.AppliedNetObjectGroups) []map[string]interface{} {
|
|
res := make([]map[string]interface{}, 0, len(groups))
|
|
for _, g := range groups {
|
|
res = append(res, map[string]interface{}{
|
|
"id": g.ID,
|
|
"name": g.Name,
|
|
"version_id": int(g.VersionID),
|
|
})
|
|
}
|
|
return res
|
|
}
|
|
|
|
func flattenSecurityRules(rules netobjgroups.SecurityRules) []map[string]interface{} {
|
|
res := make([]map[string]interface{}, 0, len(rules))
|
|
for _, r := range rules {
|
|
srcNetObj := []map[string]interface{}{}
|
|
if r.SourceNetObject != nil {
|
|
srcNetObj = []map[string]interface{}{
|
|
{
|
|
"display_name": r.SourceNetObject.DisplayName,
|
|
"net_address_pool_id": r.SourceNetObject.NetAddressPoolID,
|
|
"net_object_group_id": r.SourceNetObject.NetObjectGroupID,
|
|
},
|
|
}
|
|
}
|
|
dstNetObj := []map[string]interface{}{}
|
|
if r.DestinationNetObject != nil {
|
|
dstNetObj = []map[string]interface{}{
|
|
{
|
|
"display_name": r.DestinationNetObject.DisplayName,
|
|
"net_address_pool_id": r.DestinationNetObject.NetAddressPoolID,
|
|
"net_object_group_id": r.DestinationNetObject.NetObjectGroupID,
|
|
},
|
|
}
|
|
}
|
|
filter := []map[string]interface{}{}
|
|
if r.Filter != nil {
|
|
tcpDstPorts := make([]interface{}, 0, len(r.Filter.Filters.TCPDstPorts))
|
|
for _, p := range r.Filter.Filters.TCPDstPorts {
|
|
tcpDstPorts = append(tcpDstPorts, p)
|
|
}
|
|
udpDstPorts := make([]interface{}, 0, len(r.Filter.Filters.UDPDstPorts))
|
|
for _, p := range r.Filter.Filters.UDPDstPorts {
|
|
udpDstPorts = append(udpDstPorts, p)
|
|
}
|
|
filter = []map[string]interface{}{
|
|
{
|
|
"name": r.Filter.Name,
|
|
"filters": []map[string]interface{}{
|
|
{
|
|
"all": r.Filter.Filters.All,
|
|
"arp": r.Filter.Filters.ARP,
|
|
"dhcp": r.Filter.Filters.DHCP,
|
|
"expression": r.Filter.Filters.Expression,
|
|
"icmp": r.Filter.Filters.ICMP,
|
|
"ip": r.Filter.Filters.IP,
|
|
"ip_v4": r.Filter.Filters.IPv4,
|
|
"ip_v6": r.Filter.Filters.IPv6,
|
|
"keep_opened_sessions": r.Filter.Filters.KeepOpenedSessions,
|
|
"nd": r.Filter.Filters.ND,
|
|
"tcp": r.Filter.Filters.TCP,
|
|
"tcp_dst_ports": tcpDstPorts,
|
|
"udp": r.Filter.Filters.UDP,
|
|
"udp_dst_ports": udpDstPorts,
|
|
},
|
|
},
|
|
},
|
|
}
|
|
}
|
|
res = append(res, map[string]interface{}{
|
|
"access_group_id": r.AccessGroupID,
|
|
"action": r.Action,
|
|
"description": r.Description,
|
|
"destination_net_object": dstNetObj,
|
|
"direction": r.Direction,
|
|
"display_name": r.DisplayName,
|
|
"enabled": r.Enabled,
|
|
"filter": filter,
|
|
"id": r.ID,
|
|
"log_enabled": r.LogEnabled,
|
|
"log_name": r.LogName,
|
|
"log_severity": r.LogSeverity,
|
|
"priority": r.Priority,
|
|
"security_policy_id": r.SecurityPolicyID,
|
|
"source_net_object": srcNetObj,
|
|
"statistics_enabled": r.StatisticsEnabled,
|
|
"type": r.Type,
|
|
"version_id": int(r.VersionID),
|
|
})
|
|
}
|
|
return res
|
|
}
|
|
|
|
func flattenSecurityPolicies(policies netobjgroups.SecurityPolicies) []map[string]interface{} {
|
|
res := make([]map[string]interface{}, 0, len(policies))
|
|
for _, p := range policies {
|
|
res = append(res, map[string]interface{}{
|
|
"access_group_id": p.AccessGroupID,
|
|
"access_group_name": p.AccessGroupName,
|
|
"applied_net_object_groups": flattenAppliedNetObjectGroups(p.AppliedNetObjectGroups),
|
|
"created_at": p.CreatedAt,
|
|
"description": p.Description,
|
|
"display_name": p.DisplayName,
|
|
"enabled": p.Enabled,
|
|
"end_priority": int(p.EndPriority),
|
|
"id": p.ID,
|
|
"security_rules": flattenSecurityRules(p.SecurityRules),
|
|
"start_priority": int(p.StartPriority),
|
|
"status": flattenStatus(p.Status),
|
|
"type": p.Type,
|
|
"version_id": int(p.VersionID),
|
|
"updated_at": p.UpdatedAt,
|
|
})
|
|
}
|
|
return res
|
|
}
|
|
|
|
func flattenNetworkObjectGroupList(list *netobjgroups.NetObjGroupList) []map[string]interface{} {
|
|
if list == nil {
|
|
return []map[string]interface{}{}
|
|
}
|
|
res := make([]map[string]interface{}, 0, len(list.Objects))
|
|
for _, v := range list.Objects {
|
|
res = append(res, map[string]interface{}{
|
|
"id": v.ID,
|
|
"name": v.Name,
|
|
"access_group_id": v.AccessGroupID,
|
|
"access_group_name": v.AccessGroupName,
|
|
"description": v.Description,
|
|
"type": v.Type,
|
|
"purpose": v.Purpose,
|
|
"version_id": int(v.VersionID),
|
|
"created_at": v.CreatedAt,
|
|
"updated_at": v.UpdatedAt,
|
|
"addresses": flattenAddresses(v.Addresses),
|
|
"counters": flattenCounters(v.Counters),
|
|
"l2_connection_ports": flattenL2ConnectionPorts(v.L2ConnectionPorts),
|
|
"logical_ports": flattenLogicalPorts(v.LogicalPorts),
|
|
"external_network_ports": flattenExternalNetworkPorts(v.ExternalNetworkPorts),
|
|
"security_policies": flattenSecurityPolicies(v.SecurityPolicies),
|
|
})
|
|
}
|
|
return res
|
|
}
|