git test

internal/service/cloudbroker/node/data_source_node.go

@@ -0,0 +1,70 @@
+/*
+Copyright (c) 2019-2023 Digital Energy Cloud Solutions LLC. All Rights Reserved.
+Authors:
+Petr Krutov, <petr.krutov@digitalenergy.online>
+Stanislav Solovev, <spsolovev@digitalenergy.online>
+Sergey Kisil, <svkisil@digitalenergy.online>
+
+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 node
+
+import (
+	"context"
+	"strconv"
+
+	"github.com/hashicorp/terraform-plugin-sdk/v2/diag"
+	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
+	"repository.basistech.ru/BASIS/terraform-provider-decort/internal/constants"
+)
+
+func dataSourceNodeRead(ctx context.Context, d *schema.ResourceData, m interface{}) diag.Diagnostics {
+	nodeRec, err := utilityNodeCheckPresence(ctx, d, m)
+	if err != nil {
+		d.SetId("") // ensure ID is empty in this case
+		return diag.FromErr(err)
+	}
+
+	flattenNode(d, nodeRec)
+	d.SetId(strconv.Itoa(d.Get("node_id").(int)))
+
+	return nil
+}
+
+func DataSourceNode() *schema.Resource {
+	return &schema.Resource{
+		SchemaVersion: 1,
+
+		ReadContext: dataSourceNodeRead,
+
+		Timeouts: &schema.ResourceTimeout{
+			Read:    &constants.Timeout30s,
+			Default: &constants.Timeout60s,
+		},
+
+		Schema: dataSourceNodeSchemaMake(),
+	}
+}

internal/service/cloudbroker/node/data_source_node_list.go

@@ -0,0 +1,72 @@
+/*
+Copyright (c) 2019-2023 Digital Energy Cloud Solutions LLC. All Rights Reserved.
+Authors:
+Petr Krutov, <petr.krutov@digitalenergy.online>
+Stanislav Solovev, <spsolovev@digitalenergy.online>
+Sergey Kisil, <svkisil@digitalenergy.online>
+
+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 node
+
+import (
+	"context"
+
+	"github.com/google/uuid"
+	"github.com/hashicorp/terraform-plugin-sdk/v2/diag"
+	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
+	"repository.basistech.ru/BASIS/terraform-provider-decort/internal/constants"
+)
+
+func dataSourceNodeListRead(ctx context.Context, d *schema.ResourceData, m interface{}) diag.Diagnostics {
+	nodeList, err := utilityNodeListCheckPresence(ctx, d, m)
+	if err != nil {
+		d.SetId("")
+		return diag.FromErr(err)
+	}
+
+	id := uuid.New()
+	d.SetId(id.String())
+	d.Set("items", flattenNodeList(nodeList))
+	d.Set("entry_count", nodeList.EntryCount)
+
+	return nil
+}
+
+func DataSourceNodeList() *schema.Resource {
+	return &schema.Resource{
+		SchemaVersion: 1,
+
+		ReadContext: dataSourceNodeListRead,
+
+		Timeouts: &schema.ResourceTimeout{
+			Read:    &constants.Timeout30s,
+			Default: &constants.Timeout60s,
+		},
+
+		Schema: dataSourceNodeListSchemaMake(),
+	}
+}

internal/service/cloudbroker/node/data_source_node_network_info.go

@@ -0,0 +1,355 @@
+/*
+Copyright (c) 2019-2023 Digital Energy Cloud Solutions LLC. All Rights Reserved.
+Authors:
+Petr Krutov, <petr.krutov@digitalenergy.online>
+Stanislav Solovev, <spsolovev@digitalenergy.online>
+Sergey Kisil, <svkisil@digitalenergy.online>
+
+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 node
+
+import (
+	"context"
+
+	"github.com/google/uuid"
+	"github.com/hashicorp/terraform-plugin-sdk/v2/diag"
+	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
+	"repository.basistech.ru/BASIS/decort-golang-sdk/pkg/cloudbroker/node"
+	"repository.basistech.ru/BASIS/terraform-provider-decort/internal/constants"
+	"repository.basistech.ru/BASIS/terraform-provider-decort/internal/controller"
+)
+
+func dataSourceNodeNetworkInfoRead(ctx context.Context, d *schema.ResourceData, m interface{}) diag.Diagnostics {
+	c := m.(*controller.ControllerCfg)
+	req := node.GetNetworkInfoRequest{
+		NodeID: uint64(d.Get("node_id").(int)),
+	}
+
+	info, err := c.CloudBroker().Node().GetNetworkInfo(ctx, req)
+	if err != nil {
+		d.SetId("")
+		return diag.FromErr(err)
+	}
+
+	id := uuid.New()
+	d.SetId(id.String())
+	d.Set("system_networks_info", flattenSystemNetworksInfo(info.SystemNetworksInfo))
+	d.Set("ovs_networks_info", flattenOVSNetworksInfo(info.OVSNetworksInfo))
+	d.Set("libvirt_networks_info", flattenLibvirtNetworksInfo(info.LibvirtNetworksInfo))
+	d.Set("topology", flattenNetworkTopology(info.Topology))
+
+	return nil
+}
+
+func dataSourceNodeNetworkInfoSchemaMake() map[string]*schema.Schema {
+	return map[string]*schema.Schema{
+		"node_id": {
+			Type:        schema.TypeInt,
+			Required:    true,
+			Description: "Node ID",
+		},
+		"system_networks_info": {
+			Type:        schema.TypeList,
+			Computed:    true,
+			Description: "System-level information about all network interfaces on the node",
+			Elem: &schema.Resource{
+				Schema: map[string]*schema.Schema{
+					"name": {
+						Type:        schema.TypeString,
+						Computed:    true,
+						Description: "Interface name",
+					},
+					"mtu": {
+						Type:        schema.TypeInt,
+						Computed:    true,
+						Description: "MTU value",
+					},
+					"speed": {
+						Type:        schema.TypeInt,
+						Computed:    true,
+						Description: "Interface link speed",
+					},
+					"bridge_id": {
+						Type:        schema.TypeString,
+						Computed:    true,
+						Description: "Linux bridge ID",
+					},
+					"bport_id": {
+						Type:        schema.TypeString,
+						Computed:    true,
+						Description: "Bridge port ID",
+					},
+					"mac": {
+						Type:        schema.TypeString,
+						Computed:    true,
+						Description: "MAC address",
+					},
+				},
+			},
+		},
+		"ovs_networks_info": {
+			Type:        schema.TypeList,
+			Computed:    true,
+			Description: "Raw OVS ports data",
+			Elem: &schema.Resource{
+				Schema: map[string]*schema.Schema{
+					"bridge_name": {
+						Type:        schema.TypeString,
+						Computed:    true,
+						Description: "Bridge name",
+					},
+					"bridge_tag": {
+						Type:        schema.TypeString,
+						Computed:    true,
+						Description: "Bridge tag",
+					},
+					"interface_uuid": {
+						Type:        schema.TypeString,
+						Computed:    true,
+						Description: "Interface UUID",
+					},
+					"interface_type": {
+						Type:        schema.TypeString,
+						Computed:    true,
+						Description: "Interface type",
+					},
+					"interface_name": {
+						Type:        schema.TypeString,
+						Computed:    true,
+						Description: "Interface name",
+					},
+					"interface_mtu": {
+						Type:        schema.TypeInt,
+						Computed:    true,
+						Description: "Interface MTU value",
+					},
+					"interface_ip": {
+						Type:        schema.TypeString,
+						Computed:    true,
+						Description: "Interface IP address",
+					},
+					"interface_mac": {
+						Type:        schema.TypeString,
+						Computed:    true,
+						Description: "Interface MAC address",
+					},
+					"interface_peer": {
+						Type:        schema.TypeString,
+						Computed:    true,
+						Description: "Interface peer name",
+					},
+				},
+			},
+		},
+		"libvirt_networks_info": {
+			Type:        schema.TypeList,
+			Computed:    true,
+			Description: "VM network interface connections",
+			Elem: &schema.Resource{
+				Schema: map[string]*schema.Schema{
+					"vm_name": {
+						Type:        schema.TypeString,
+						Computed:    true,
+						Description: "VM name",
+					},
+					"interface": {
+						Type:        schema.TypeString,
+						Computed:    true,
+						Description: "Host-side interface name used by the VM",
+					},
+					"interface_type": {
+						Type:        schema.TypeString,
+						Computed:    true,
+						Description: "Interface type",
+					},
+					"interface_source": {
+						Type:        schema.TypeString,
+						Computed:    true,
+						Description: "Name of the bridge the VM interface is attached to",
+					},
+				},
+			},
+		},
+		"topology": {
+			Type:        schema.TypeList,
+			Computed:    true,
+			Description: "Assembled network topology of the node",
+			Elem: &schema.Resource{
+				Schema: map[string]*schema.Schema{
+					"interfaces": {
+						Type:        schema.TypeList,
+						Computed:    true,
+						Description: "Network interfaces and their topology details",
+						Elem: &schema.Resource{
+							Schema: map[string]*schema.Schema{
+								"name": {
+									Type:        schema.TypeString,
+									Computed:    true,
+									Description: "Interface name",
+								},
+								"type": {
+									Type:        schema.TypeString,
+									Computed:    true,
+									Description: "Interface type",
+								},
+								"mtu": {
+									Type:        schema.TypeInt,
+									Computed:    true,
+									Description: "Interface MTU value",
+								},
+								"speed": {
+									Type:        schema.TypeInt,
+									Computed:    true,
+									Description: "Interface link speed",
+								},
+								"vlans": {
+									Type:        schema.TypeList,
+									Computed:    true,
+									Elem:        &schema.Schema{Type: schema.TypeString},
+									Description: "VLANs associated with the interface",
+								},
+								"bridge_id": {
+									Type:        schema.TypeString,
+									Computed:    true,
+									Description: "Linux bridge ID",
+								},
+								"peer": {
+									Type:        schema.TypeString,
+									Computed:    true,
+									Description: "Peer interface name",
+								},
+								"uuid": {
+									Type:        schema.TypeString,
+									Computed:    true,
+									Description: "OVS UUID",
+								},
+								"connected_interfaces": {
+									Type:     schema.TypeList,
+									Computed: true, Elem: &schema.Schema{Type: schema.TypeString},
+									Description: "Names of interfaces attached to this bridge as ports",
+								},
+								"connections": {
+									Type:     schema.TypeList,
+									Computed: true,
+									Elem: &schema.Resource{
+										Schema: map[string]*schema.Schema{
+											"vms": {
+												Type:     schema.TypeList,
+												Computed: true,
+												Elem: &schema.Resource{
+													Schema: map[string]*schema.Schema{
+														"name":              {Type: schema.TypeString, Computed: true},
+														"vm_interface":      {Type: schema.TypeString, Computed: true},
+														"vm_interface_type": {Type: schema.TypeString, Computed: true},
+														"connection_type":   {Type: schema.TypeString, Computed: true},
+														"via_bridge":        {Type: schema.TypeString, Computed: true},
+													},
+												},
+											},
+											"bridges": {
+												Type:     schema.TypeList,
+												Computed: true,
+												Elem: &schema.Resource{
+													Schema: map[string]*schema.Schema{
+														"name":     {Type: schema.TypeString, Computed: true},
+														"type":     {Type: schema.TypeString, Computed: true},
+														"via":      {Type: schema.TypeString, Computed: true},
+														"bport_id": {Type: schema.TypeString, Computed: true},
+														"port_info": {
+															Type:     schema.TypeList,
+															Computed: true,
+															Elem: &schema.Resource{
+																Schema: map[string]*schema.Schema{
+																	"name": {Type: schema.TypeString, Computed: true},
+																	"type": {Type: schema.TypeString, Computed: true},
+																	"mtu":  {Type: schema.TypeInt, Computed: true},
+																	"vlan": {Type: schema.TypeString, Computed: true},
+																	"uuid": {Type: schema.TypeString, Computed: true},
+																},
+															},
+														},
+													},
+												},
+											},
+										},
+									},
+								},
+								"bridge_info": {
+									Type:     schema.TypeList,
+									Computed: true,
+									Elem: &schema.Resource{
+										Schema: map[string]*schema.Schema{
+											"type": {Type: schema.TypeString, Computed: true},
+											"ports": {
+												Type:     schema.TypeList,
+												Computed: true,
+												Elem: &schema.Resource{
+													Schema: map[string]*schema.Schema{
+														"name": {Type: schema.TypeString, Computed: true},
+														"type": {Type: schema.TypeString, Computed: true},
+														"mtu":  {Type: schema.TypeInt, Computed: true},
+														"vlan": {Type: schema.TypeString, Computed: true},
+														"uuid": {Type: schema.TypeString, Computed: true},
+														"ip":   {Type: schema.TypeString, Computed: true},
+														"mac":  {Type: schema.TypeString, Computed: true},
+													},
+												},
+											},
+										},
+									},
+								},
+								"bridge_connections": {
+									Type:     schema.TypeList,
+									Computed: true,
+									Elem: &schema.Resource{
+										Schema: map[string]*schema.Schema{
+											"name": {Type: schema.TypeString, Computed: true},
+											"via":  {Type: schema.TypeString, Computed: true},
+											"vlan": {Type: schema.TypeString, Computed: true},
+										},
+									},
+								},
+							},
+						},
+					},
+				},
+			},
+		},
+	}
+}
+
+func DataSourceNodeNetworkInfo() *schema.Resource {
+	return &schema.Resource{
+		SchemaVersion: 1,
+		ReadContext:   dataSourceNodeNetworkInfoRead,
+		Timeouts: &schema.ResourceTimeout{
+			Read:    &constants.Timeout30s,
+			Default: &constants.Timeout60s,
+		},
+		Schema: dataSourceNodeNetworkInfoSchemaMake(),
+	}
+}

internal/service/cloudbroker/node/data_source_node_pci_devices.go

@@ -0,0 +1,172 @@
+/*
+Copyright (c) 2019-2023 Digital Energy Cloud Solutions LLC. All Rights Reserved.
+Authors:
+Petr Krutov, <petr.krutov@digitalenergy.online>
+Stanislav Solovev, <spsolovev@digitalenergy.online>
+Sergey Kisil, <svkisil@digitalenergy.online>
+
+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 node
+
+import (
+	"context"
+
+	"github.com/google/uuid"
+	"github.com/hashicorp/terraform-plugin-sdk/v2/diag"
+	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
+	sdknode "repository.basistech.ru/BASIS/decort-golang-sdk/pkg/cloudbroker/node"
+	"repository.basistech.ru/BASIS/terraform-provider-decort/internal/constants"
+	"repository.basistech.ru/BASIS/terraform-provider-decort/internal/controller"
+)
+
+func dataSourceNodePCIDevicesRead(ctx context.Context, d *schema.ResourceData, m interface{}) diag.Diagnostics {
+	c := m.(*controller.ControllerCfg)
+	req := sdknode.GetPCIDevicesRequest{
+		NodeID: uint64(d.Get("node_id").(int)),
+	}
+	if v, ok := d.GetOk("search"); ok {
+		req.Search = v.(string)
+	}
+	if v, ok := d.GetOk("sort_by"); ok {
+		req.SortBy = v.(string)
+	}
+	if v, ok := d.GetOk("page"); ok {
+		req.Page = uint64(v.(int))
+	}
+	if v, ok := d.GetOk("size"); ok {
+		req.Size = uint64(v.(int))
+	}
+
+	list, err := c.CloudBroker().Node().GetPCIDevices(ctx, req)
+	if err != nil {
+		d.SetId("")
+		return diag.FromErr(err)
+	}
+
+	id := uuid.New()
+	d.SetId(id.String())
+	d.Set("items", flattenNodePCIDevices(list.Data))
+	d.Set("entry_count", list.EntryCount)
+
+	return nil
+}
+
+func dataSourceNodePCIDevicesSchemaMake() map[string]*schema.Schema {
+	return map[string]*schema.Schema{
+		"node_id": {
+			Type:        schema.TypeInt,
+			Required:    true,
+			Description: "Node ID",
+		},
+		"search": {
+			Type:        schema.TypeString,
+			Optional:    true,
+			Description: "Search string",
+		},
+		"sort_by": {
+			Type:        schema.TypeString,
+			Optional:    true,
+			Description: "Sort by one of supported fields, format +|-(field)",
+		},
+		"page": {
+			Type:        schema.TypeInt,
+			Optional:    true,
+			Description: "Page number",
+		},
+		"size": {
+			Type:        schema.TypeInt,
+			Optional:    true,
+			Description: "Page size",
+		},
+		"entry_count": {
+			Type:        schema.TypeInt,
+			Computed:    true,
+			Description: "Total number of PCI devices",
+		},
+		"items": {
+			Type:        schema.TypeList,
+			Computed:    true,
+			Description: "List of PCI devices",
+			Elem: &schema.Resource{
+				Schema: map[string]*schema.Schema{
+					"hw_path": {
+						Type:        schema.TypeString,
+						Computed:    true,
+						Description: "Hardware path",
+					},
+					"current_driver": {
+						Type:        schema.TypeString,
+						Computed:    true,
+						Description: "Current driver",
+					},
+					"numa_node": {
+						Type:        schema.TypeInt,
+						Computed:    true,
+						Description: "NUMA node",
+					},
+					"product_id": {
+						Type:        schema.TypeString,
+						Computed:    true,
+						Description: "Product ID",
+					},
+					"product_name": {
+						Type:        schema.TypeString,
+						Computed:    true,
+						Description: "Product name",
+					},
+					"vendor_id": {
+						Type:        schema.TypeString,
+						Computed:    true,
+						Description: "Vendor ID",
+					},
+					"vendor_name": {
+						Type:        schema.TypeString,
+						Computed:    true,
+						Description: "Vendor name",
+					},
+					"iommu_group": {
+						Type:        schema.TypeInt,
+						Computed:    true,
+						Description: "IOMMU group",
+					},
+				},
+			},
+		},
+	}
+}
+
+func DataSourceNodePCIDevices() *schema.Resource {
+	return &schema.Resource{
+		SchemaVersion: 1,
+		ReadContext:   dataSourceNodePCIDevicesRead,
+		Timeouts: &schema.ResourceTimeout{
+			Read:    &constants.Timeout30s,
+			Default: &constants.Timeout60s,
+		},
+		Schema: dataSourceNodePCIDevicesSchemaMake(),
+	}
+}

internal/service/cloudbroker/node/flattens.go

@@ -0,0 +1,526 @@
+/*
+Copyright (c) 2019-2023 Digital Energy Cloud Solutions LLC. All Rights Reserved.
+Authors:
+Petr Krutov, <petr.krutov@digitalenergy.online>
+Stanislav Solovev, <spsolovev@digitalenergy.online>
+Sergey Kisil, <svkisil@digitalenergy.online>
+
+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 node
+
+import (
+	"strconv"
+
+	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
+	log "github.com/sirupsen/logrus"
+	"repository.basistech.ru/BASIS/decort-golang-sdk/pkg/cloudbroker/node"
+)
+
+func flattenNode(d *schema.ResourceData, item *node.RecordNode) {
+	log.Debugf("flattenNode: decoded node id %d", d.Get("node_id").(int))
+
+	d.Set("auto_start", item.AutoStart)
+	d.Set("auto_start_count", item.AutoStartCount)
+	d.Set("consumption", flattenConsumption(item.Consumption))
+	d.Set("cpu_info", flattenCpuInfo(item.CpuInfo))
+	d.Set("cpu_allocation_ratio", item.CPUAllocationRatio)
+	d.Set("mem_allocation_ratio", item.MemAllocationRatio)
+	d.Set("description", item.Description)
+	d.Set("dpdk", flattenDPDKItem(item.DPDK))
+	d.Set("gid", item.GID)
+	d.Set("ipaddr", item.IPAddr)
+	d.Set("isolated_cpus", flattenNodeItem(item.IsolatedCpus))
+	d.Set("name", item.Name)
+	d.Set("need_reboot", item.NeedReboot)
+	d.Set("net_addr", flattenGetNetAddr(item.NetAddr))
+	d.Set("network_mode", item.NetworkMode)
+	d.Set("openvswitch_bridges", item.OpenvSwitchBridges)
+	d.Set("nic_info", flattenNicInfo(item.NicInfo))
+	d.Set("numa_topology", flattenNumaTopology(item.NumaTopology))
+	d.Set("reserved_cpus", flattenNodeItem(item.ReservedCPUs))
+	d.Set("roles", item.Roles)
+	d.Set("sdn_hypervisor_name", item.SDNHypervisorName)
+	d.Set("sriov_enabled", item.SriovEnabled)
+	d.Set("node_id", item.ID)
+	d.Set("status", item.Status)
+	d.Set("to_active", flattenRole(item.ToActive))
+	d.Set("to_installing", flattenRole(item.ToInstalling))
+	d.Set("to_maintenance", flattenRole(item.ToMaintenance))
+	d.Set("to_restricted", flattenRole(item.ToRestricted))
+	d.Set("version", item.Version)
+	d.Set("zone_id", item.ZoneID)
+	d.Set("usable_cpus", item.UsableCPUs)
+}
+
+func flattenConsumption(info node.ConsumptionInfo) []map[string]interface{} {
+	res := make([]map[string]interface{}, 1)
+	tempRes := map[string]interface{}{
+		"hostname": info.Hostname,
+	}
+
+	tempConsumed := map[string]interface{}{
+		"ram":      info.Consumed.RAM,
+		"computes": info.Consumed.Computes,
+		"routers":  info.Consumed.Routers,
+		"vcpu":     info.Consumed.VCPU,
+	}
+	tempRes["consumed"] = []map[string]interface{}{
+		tempConsumed,
+	}
+
+	tempFree := map[string]interface{}{
+		"ram":  info.Free.RAM,
+		"vcpu": info.Free.VCPU,
+	}
+	tempRes["free"] = []map[string]interface{}{
+		tempFree,
+	}
+
+	tempReserved := map[string]interface{}{
+		"ram": info.Reserved.RAM,
+	}
+	tempRes["reserved"] = []map[string]interface{}{
+		tempReserved,
+	}
+
+	tempTotal := map[string]interface{}{
+		"ram": info.Total.RAM,
+	}
+	tempRes["total"] = []map[string]interface{}{
+		tempTotal,
+	}
+
+	res[0] = tempRes
+	return res
+}
+
+func flattenNodeList(nodes *node.ListNodes) []map[string]interface{} {
+	res := make([]map[string]interface{}, 0, len(nodes.Data))
+	for _, item := range nodes.Data {
+		temp := map[string]interface{}{
+			"additional_pkgs":      flattenNodeItem(item.AdditionalPkgs),
+			"auto_start":           item.AutoStart,
+			"auto_start_count":     item.AutoStartCount,
+			"cpu_info":             flattenCpuInfo(item.CpuInfo),
+			"description":          item.Description,
+			"dpdk":                 flattenDPDKItem(item.DPDK),
+			"gid":                  item.GID,
+			"guid":                 item.GUID,
+			"hostkey":              item.HostKey,
+			"node_id":              item.ID,
+			"ipaddr":               item.IPAddr,
+			"isolated_cpus":        flattenNodeItem(item.IsolatedCpus),
+			"lastcheck":            item.LastCheck,
+			"machine_guid":         item.MachineGUID,
+			"mainboard_sn":         item.MainboardSN,
+			"memory":               item.Memory,
+			"milestones":           item.Milestones,
+			"model":                item.Model,
+			"name":                 item.Name,
+			"need_reboot":          item.NeedReboot,
+			"net_addr":             flattenNetAddr(item.NetAddr),
+			"network_mode":         item.NetworkMode,
+			"nic_info":             flattenNicInfo(item.NicInfo),
+			"node_uuid":            item.NodeUUID,
+			"numa_topology":        flattenNumaTopology(item.NumaTopology),
+			"peer_backup":          item.PeerBackup,
+			"peer_log":             item.PeerLog,
+			"peer_stats":           item.PeerStats,
+			"pgpus":                item.Pgpus,
+			"public_keys":          item.PublicKeys,
+			"release":              item.Release,
+			"reserved_cpus":        flattenNodeItem(item.ReservedCPUs),
+			"roles":                item.Roles,
+			"sdn_hypervisor_name":  item.SDNHypervisorName,
+			"seps":                 item.Seps,
+			"serial_num":           item.SerialNum,
+			"sriov_enabled":        item.SriovEnabled,
+			"status":               item.Status,
+			"tags":                 item.Tags,
+			"type":                 item.Type,
+			"uefi_firmware_file":   item.UEFIFirmwareFile,
+			"usable_cpus":          item.UsableCPUs,
+			"version":              item.Version,
+			"zone_id":              item.ZoneID,
+			"openvswitch_bridges":  item.OpenvSwitchBridges,
+			"api_url":              item.APIUrl,
+			"drivers":              item.Drivers,
+			"old_compat_lvm_id":    item.OldCompatLVMID,
+			"cpu_allocation_ratio": item.CPUAllocationRatio,
+			"mem_allocation_ratio": item.MemAllocationRatio,
+			"packages":             flattenPackages(item.Packages),
+			"pci_devices":          flattenNodePCIDevices(item.PCIDevices),
+		}
+		res = append(res, temp)
+	}
+	return res
+}
+
+func flattenNumaTopology(info node.NumaTopologyInfo) []map[string]interface{} {
+	res := make([]map[string]interface{}, 1)
+	tempRes := map[string]interface{}{
+		"node_num": info.NodeNum,
+	}
+	resNodes := make([]map[string]interface{}, 0, len(info.Nodes))
+	for _, item := range info.Nodes {
+		memoryTemp := []map[string]interface{}{
+			{
+				"one_g":               item.Memory.OneG,
+				"one_g_free":          item.Memory.OneGFree,
+				"one_g_reserved":      item.Memory.OneGReserved,
+				"one_g_available":     item.Memory.OneGAvailable,
+				"one_g_used":          item.Memory.OneGUsed,
+				"one_g_dpdk_reserved": item.Memory.OneGDPDKReserved,
+				"two_m":               item.Memory.TwoM,
+				"two_m_free":          item.Memory.TwoMFree,
+				"two_m_reserved":      item.Memory.TwoMReserved,
+				"two_m_available":     item.Memory.TwoMAvailable,
+				"two_m_used":          item.Memory.TwoMUsed,
+				"total":               item.Memory.Total,
+			},
+		}
+		temp := map[string]interface{}{
+			"cpu_list": item.CPUList,
+			"memory":   memoryTemp,
+		}
+		resNodes = append(resNodes, temp)
+	}
+	tempRes["nodes"] = resNodes
+	res[0] = tempRes
+	return res
+}
+
+func flattenNicInfo(infos node.ListNicInfo) []map[string]interface{} {
+	res := make([]map[string]interface{}, 0, len(infos))
+	for _, item := range infos {
+		temp := map[string]interface{}{
+			"driver":    item.Driver,
+			"max_vfs":   item.MaxVFS,
+			"numa_node": item.NumaNode,
+			"num_vfs":   item.NumVFS,
+			"os_name":   item.OSName,
+			"pci_slot":  item.PCISlot,
+			"vf_list":   flattenVFList(item.VFList),
+		}
+		res = append(res, temp)
+	}
+	return res
+}
+
+func flattenVFList(vfList []interface{}) []map[string]interface{} {
+	res := make([]map[string]interface{}, 0, len(vfList))
+	for _, v := range vfList {
+		vConv := v.(map[string]interface{})
+		temp := map[string]interface{}{
+			"fn_id":    vConv["fnId"],
+			"pci_slot": vConv["pciSlot"],
+		}
+		res = append(res, temp)
+	}
+	return res
+}
+
+func flattenNetAddr(addresses node.ListNetAddr) []map[string]interface{} {
+	res := make([]map[string]interface{}, 0, len(addresses))
+	for _, item := range addresses {
+		temp := map[string]interface{}{
+			"cidr":  item.CIDR,
+			"index": item.Index,
+			"ip":    item.IP,
+			"mac":   item.Mac,
+			"mtu":   item.MTU,
+			"name":  item.Name,
+		}
+		res = append(res, temp)
+	}
+	return res
+}
+
+func flattenGetNetAddr(address node.NetAddr) []map[string]interface{} {
+	res := make([]map[string]interface{}, 1)
+	temp := map[string]interface{}{
+		"ip":   address.IP,
+		"name": address.Name,
+	}
+	res[0] = temp
+	return res
+}
+
+func flattenCpuInfo(info node.CpuInfo) []map[string]interface{} {
+	res := make([]map[string]interface{}, 1)
+	temp := map[string]interface{}{
+		"clock_speed":  info.ClockSpeed,
+		"core_count":   info.CoreCount,
+		"phys_count":   info.PhysCount,
+		"flags":        info.Flags,
+		"model_name":   info.ModelName,
+		"thread_count": info.ThreadCount,
+	}
+	res[0] = temp
+	return res
+}
+
+func flattenNodeItem(m []interface{}) []string {
+	output := []string{}
+	for _, item := range m {
+		switch d := item.(type) {
+		case string:
+			output = append(output, d)
+		case int:
+			output = append(output, strconv.Itoa(d))
+		case int64:
+			output = append(output, strconv.FormatInt(d, 10))
+		case float64:
+			output = append(output, strconv.FormatInt(int64(d), 10))
+		default:
+			output = append(output, "")
+		}
+	}
+	return output
+}
+
+func flattenPackages(pkgs map[string]node.PackageInfo) []map[string]interface{} {
+	res := make([]map[string]interface{}, 0, len(pkgs))
+
+	for _, p := range pkgs {
+		temp := map[string]interface{}{
+			"ver":  p.Ver,
+			"size": p.InstalledSize,
+		}
+		res = append(res, temp)
+	}
+
+	return res
+}
+
+func flattenDPDKItem(dpdk node.DPDK) []map[string]interface{} {
+	res := make([]map[string]interface{}, 1)
+	bridges := make([]map[string]interface{}, 1)
+	backplane := make([]map[string]interface{}, 1)
+	backplane[0] = map[string]interface{}{
+		"interfaces": dpdk.Bridges.Backplane1.Interfaces,
+		"numa_node":  dpdk.Bridges.Backplane1.NumaNode,
+	}
+
+	bridges[0] = map[string]interface{}{
+		"backplane1": backplane,
+	}
+
+	res[0] = map[string]interface{}{
+		"bridges":   bridges,
+		"hp_memory": dpdk.HPMemory,
+		"pmd_cpu":   dpdk.PMDCPU,
+	}
+
+	return res
+}
+
+func flattenRole(role node.Role) []map[string]interface{} {
+	res := make([]map[string]interface{}, 1)
+	temp := map[string]interface{}{
+		"actor":  role.Actor,
+		"reason": role.Reason,
+		"time":   role.Time,
+	}
+	res[0] = temp
+	return res
+}
+
+func flattenSystemNetworksInfo(m map[string]node.SystemNetworkInfo) []map[string]interface{} {
+	res := make([]map[string]interface{}, 0, len(m))
+	for name, info := range m {
+		res = append(res, map[string]interface{}{
+			"name":      name,
+			"mtu":       info.MTU,
+			"speed":     info.Speed,
+			"bridge_id": info.BridgeID,
+			"bport_id":  info.BPortID,
+			"mac":       info.MAC,
+		})
+	}
+	return res
+}
+
+func flattenOVSNetworksInfo(items []node.OVSNetworkInfo) []map[string]interface{} {
+	res := make([]map[string]interface{}, 0, len(items))
+	for _, item := range items {
+		res = append(res, map[string]interface{}{
+			"bridge_name":    item.BridgeName,
+			"bridge_tag":     item.BridgeTag,
+			"interface_uuid": item.InterfaceUUID,
+			"interface_type": item.InterfaceType,
+			"interface_name": item.InterfaceName,
+			"interface_mtu":  item.InterfaceMTU,
+			"interface_ip":   item.InterfaceIP,
+			"interface_mac":  item.InterfaceMAC,
+			"interface_peer": item.InterfacePeer,
+		})
+	}
+	return res
+}
+
+func flattenLibvirtNetworksInfo(items []node.LibvirtNetworkInfo) []map[string]interface{} {
+	res := make([]map[string]interface{}, 0, len(items))
+	for _, item := range items {
+		res = append(res, map[string]interface{}{
+			"vm_name":          item.VMName,
+			"interface":        item.Interface,
+			"interface_type":   item.InterfaceType,
+			"interface_source": item.InterfaceSource,
+		})
+	}
+	return res
+}
+
+func flattenNetworkTopology(t node.NetworkTopology) []map[string]interface{} {
+	return []map[string]interface{}{
+		{
+			"interfaces": flattenTopologyInterfaces(t.Interfaces),
+		},
+	}
+}
+
+func flattenTopologyInterfaces(m map[string]node.TopologyInterface) []map[string]interface{} {
+	res := make([]map[string]interface{}, 0, len(m))
+	for name, iface := range m {
+		res = append(res, map[string]interface{}{
+			"name":                 name,
+			"type":                 iface.Type,
+			"mtu":                  iface.MTU,
+			"speed":                iface.Speed,
+			"vlans":                iface.VLANs,
+			"bridge_id":            iface.BridgeID,
+			"peer":                 iface.Peer,
+			"uuid":                 iface.UUID,
+			"connected_interfaces": iface.ConnectedInterfaces,
+			"connections":          flattenTopologyConnections(iface.Connections),
+			"bridge_info":          flattenTopologyBridgeInfo(iface.BridgeInfo),
+			"bridge_connections":   flattenTopologyBridgeRefs(iface.BridgeConnections),
+		})
+	}
+	return res
+}
+
+func flattenTopologyConnections(c node.TopologyInterfaceConnections) []map[string]interface{} {
+	vms := make([]map[string]interface{}, 0, len(c.VMs))
+	for _, vm := range c.VMs {
+		vms = append(vms, map[string]interface{}{
+			"name":              vm.Name,
+			"vm_interface":      vm.VMInterface,
+			"vm_interface_type": vm.VMInterfaceType,
+			"connection_type":   vm.ConnectionType,
+			"via_bridge":        vm.ViaBridge,
+		})
+	}
+
+	bridges := make([]map[string]interface{}, 0, len(c.Bridges))
+	for _, b := range c.Bridges {
+		portInfo := flattenTopologyPortInfo(b.PortInfo)
+		bridges = append(bridges, map[string]interface{}{
+			"name":      b.Name,
+			"type":      b.Type,
+			"via":       b.Via,
+			"bport_id":  b.BPortID,
+			"port_info": portInfo,
+		})
+	}
+
+	return []map[string]interface{}{
+		{
+			"vms":     vms,
+			"bridges": bridges,
+		},
+	}
+}
+
+func flattenTopologyPortInfo(p *node.TopologyPortInfo) []map[string]interface{} {
+	if p == nil {
+		return nil
+	}
+	return []map[string]interface{}{
+		{
+			"name": p.Name,
+			"type": p.Type,
+			"mtu":  p.MTU,
+			"vlan": p.VLAN,
+			"uuid": p.UUID,
+		},
+	}
+}
+
+func flattenTopologyBridgeInfo(b *node.TopologyBridgeInfo) []map[string]interface{} {
+	if b == nil {
+		return nil
+	}
+	ports := make([]map[string]interface{}, 0, len(b.Ports))
+	for _, p := range b.Ports {
+		ports = append(ports, map[string]interface{}{
+			"name": p.Name,
+			"type": p.Type,
+			"mtu":  p.MTU,
+			"vlan": p.VLAN,
+			"uuid": p.UUID,
+			"ip":   p.IP,
+			"mac":  p.MAC,
+		})
+	}
+	return []map[string]interface{}{
+		{
+			"type":  b.Type,
+			"ports": ports,
+		},
+	}
+}
+
+func flattenTopologyBridgeRefs(refs []node.TopologyBridgeRef) []map[string]interface{} {
+	res := make([]map[string]interface{}, 0, len(refs))
+	for _, r := range refs {
+		res = append(res, map[string]interface{}{
+			"name": r.Name,
+			"via":  r.Via,
+			"vlan": r.VLAN,
+		})
+	}
+	return res
+}
+
+func flattenNodePCIDevices(items []node.ItemPCIDevice) []map[string]interface{} {
+	res := make([]map[string]interface{}, 0, len(items))
+	for _, item := range items {
+		res = append(res, map[string]interface{}{
+			"hw_path":        item.HWPath,
+			"current_driver": item.CurrentDriver,
+			"numa_node":      item.NUMANode,
+			"product_id":     item.ProductID,
+			"product_name":   item.ProductName,
+			"vendor_id":      item.VendorID,
+			"vendor_name":    item.VendorName,
+			"iommu_group":    item.IOMMUGroup,
+		})
+	}
+	return res
+}

internal/service/cloudbroker/node/utility_node.go

@@ -0,0 +1,56 @@
+/*
+Copyright (c) 2019-2023 Digital Energy Cloud Solutions LLC. All Rights Reserved.
+Authors:
+Petr Krutov, <petr.krutov@digitalenergy.online>
+Stanislav Solovev, <spsolovev@digitalenergy.online>
+Sergey Kisil, <svkisil@digitalenergy.online>
+
+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 node
+
+import (
+	"context"
+
+	log "github.com/sirupsen/logrus"
+	"repository.basistech.ru/BASIS/decort-golang-sdk/pkg/cloudbroker/node"
+	"repository.basistech.ru/BASIS/terraform-provider-decort/internal/controller"
+
+	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
+)
+
+func utilityNodeCheckPresence(ctx context.Context, d *schema.ResourceData, m interface{}) (*node.RecordNode, error) {
+	c := m.(*controller.ControllerCfg)
+	req := node.GetRequest{NID: uint64(d.Get("node_id").(int))}
+
+	log.Debugf("utilityNodeCheckPresence: load node")
+	nodeInfo, err := c.CloudBroker().Node().Get(ctx, req)
+	if err != nil {
+		return nil, err
+	}
+
+	return nodeInfo, nil
+}

internal/service/cloudbroker/node/utility_node_list.go

@@ -0,0 +1,90 @@
+/*
+Copyright (c) 2019-2023 Digital Energy Cloud Solutions LLC. All Rights Reserved.
+Authors:
+Petr Krutov, <petr.krutov@digitalenergy.online>
+Stanislav Solovev, <spsolovev@digitalenergy.online>
+Sergey Kisil, <svkisil@digitalenergy.online>
+
+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 node
+
+import (
+	"context"
+
+	log "github.com/sirupsen/logrus"
+	"repository.basistech.ru/BASIS/decort-golang-sdk/pkg/cloudbroker/node"
+	"repository.basistech.ru/BASIS/terraform-provider-decort/internal/controller"
+
+	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
+)
+
+func utilityNodeListCheckPresence(ctx context.Context, d *schema.ResourceData, m interface{}) (*node.ListNodes, error) {
+	c := m.(*controller.ControllerCfg)
+	req := node.ListRequest{}
+
+	if byId, ok := d.GetOk("by_id"); ok {
+		req.ByID = uint64(byId.(int))
+	}
+	if name, ok := d.GetOk("name"); ok {
+		req.Name = name.(string)
+	}
+	if version, ok := d.GetOk("version"); ok {
+		req.Version = version.(string)
+	}
+	if release, ok := d.GetOk("release"); ok {
+		req.Release = release.(string)
+	}
+	if sepId, ok := d.GetOk("sep_id"); ok {
+		req.SepID = uint64(sepId.(int))
+	}
+	if role, ok := d.GetOk("role"); ok {
+		req.Role = role.(string)
+	}
+	if status, ok := d.GetOk("status"); ok {
+		req.Status = status.(string)
+	}
+	if sortBy, ok := d.GetOk("sort_by"); ok {
+		req.SortBy = sortBy.(string)
+	}
+	if Page, ok := d.GetOk("page"); ok {
+		req.Page = uint64(Page.(int))
+	}
+	if Size, ok := d.GetOk("size"); ok {
+		req.Size = uint64(Size.(int))
+	}
+	if zoneId, ok := d.GetOk("zone_id"); ok {
+		req.ZoneID = uint64(zoneId.(int))
+	}
+
+	log.Debugf("utilityNodeListCheckPresence: load node list")
+	nodeList, err := c.CloudBroker().Node().List(ctx, req)
+	if err != nil {
+		return nil, err
+	}
+
+	return nodeList, nil
+}