git test

internal/service/cloudapi/kvmvm/data_source_compute_audits.go

@@ -0,0 +1,148 @@
+/*
+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 kvmvm
+
+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 dataSourceComputeAuditsRead(ctx context.Context, d *schema.ResourceData, m interface{}) diag.Diagnostics {
+	computeAudits, err := utilityComputeAuditsCheckPresence(ctx, d, m)
+	if err != nil {
+		d.SetId("")
+		return diag.FromErr(err)
+	}
+	id := uuid.New()
+	d.SetId(id.String())
+	d.Set("items", flattenComputeAudits(computeAudits))
+	d.Set("entry_count", computeAudits.EntryCount)
+	return nil
+}
+
+func dataSourceComputeAuditsSchemaMake() map[string]*schema.Schema {
+	return map[string]*schema.Schema{
+		"compute_id": {
+			Type:     schema.TypeInt,
+			Required: true,
+		},
+		"timestamp_at": {
+			Type:     schema.TypeInt,
+			Optional: true,
+		},
+		"timestamp_to": {
+			Type:     schema.TypeInt,
+			Optional: true,
+		},
+		"user": {
+			Type:     schema.TypeString,
+			Optional: true,
+		},
+		"call": {
+			Type:     schema.TypeString,
+			Optional: true,
+		},
+		"sort_by": {
+			Type:     schema.TypeString,
+			Optional: true,
+		},
+		"page": {
+			Type:     schema.TypeInt,
+			Optional: true,
+		},
+		"size": {
+			Type:     schema.TypeInt,
+			Optional: true,
+		},
+		"min_status_code": {
+			Type:     schema.TypeInt,
+			Optional: true,
+		},
+		"max_status_code": {
+			Type:     schema.TypeInt,
+			Optional: true,
+		},
+
+		"items": {
+			Type:     schema.TypeList,
+			Computed: true,
+			Elem: &schema.Resource{
+				Schema: map[string]*schema.Schema{
+					"call": {
+						Type:     schema.TypeString,
+						Computed: true,
+					},
+					"responsetime": {
+						Type:     schema.TypeFloat,
+						Computed: true,
+					},
+					"statuscode": {
+						Type:     schema.TypeInt,
+						Computed: true,
+					},
+					"timestamp": {
+						Type:     schema.TypeFloat,
+						Computed: true,
+					},
+					"user": {
+						Type:     schema.TypeString,
+						Computed: true,
+					},
+				},
+			},
+		},
+		"entry_count": {
+			Type:     schema.TypeInt,
+			Computed: true,
+		},
+	}
+}
+
+func DataSourceComputeAudits() *schema.Resource {
+	return &schema.Resource{
+		SchemaVersion: 1,
+
+		ReadContext: dataSourceComputeAuditsRead,
+
+		Timeouts: &schema.ResourceTimeout{
+			Read:    &constants.Timeout30s,
+			Default: &constants.Timeout60s,
+		},
+
+		Schema: dataSourceComputeAuditsSchemaMake(),
+	}
+}

internal/service/cloudapi/kvmvm/data_source_compute_cpu_alignment_profile.go

@@ -0,0 +1,98 @@
+/*
+Copyright (c) 2019-2023 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 kvmvm
+
+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 dataSourceComputeCPUAlignmentProfileRead(ctx context.Context, d *schema.ResourceData, m interface{}) diag.Diagnostics {
+	profile, err := utilityComputeGetCPUAlignmentProfile(ctx, d, m)
+	if err != nil {
+		d.SetId("")
+		return diag.FromErr(err)
+	}
+
+	id := uuid.New()
+	d.SetId(id.String())
+	d.Set("model", profile.Model)
+	d.Set("name", profile.Name)
+	d.Set("vendor", profile.Vendor)
+
+	return nil
+}
+
+func dataSourceComputeCPUAlignmentProfileSchemaMake() map[string]*schema.Schema {
+	return map[string]*schema.Schema{
+		"compute_id": {
+			Type:        schema.TypeInt,
+			Required:    true,
+			Description: "ID of the compute instance",
+		},
+		"model": {
+			Type:        schema.TypeString,
+			Computed:    true,
+			Description: "CPU model of the alignment profile",
+		},
+		"name": {
+			Type:        schema.TypeString,
+			Computed:    true,
+			Description: "Name of the CPU alignment profile",
+		},
+		"vendor": {
+			Type:        schema.TypeString,
+			Computed:    true,
+			Description: "CPU vendor of the alignment profile",
+		},
+	}
+}
+
+func DataSourceComputeCPUAlignmentProfile() *schema.Resource {
+	return &schema.Resource{
+		SchemaVersion: 1,
+
+		ReadContext: dataSourceComputeCPUAlignmentProfileRead,
+
+		Timeouts: &schema.ResourceTimeout{
+			Read:    &constants.Timeout30s,
+			Default: &constants.Timeout60s,
+		},
+
+		Schema: dataSourceComputeCPUAlignmentProfileSchemaMake(),
+	}
+}

internal/service/cloudapi/kvmvm/data_source_compute_get_audits.go

@@ -0,0 +1,95 @@
+/*
+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 kvmvm
+
+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 dataSourceComputeGetAuditsRead(ctx context.Context, d *schema.ResourceData, m interface{}) diag.Diagnostics {
+	computeAudits, err := utilityComputeGetAuditsCheckPresence(ctx, d, m)
+	if err != nil {
+		d.SetId("")
+		return diag.FromErr(err)
+	}
+	id := uuid.New()
+	d.SetId(id.String())
+	d.Set("items", flattenComputeGetAudits(computeAudits))
+	return nil
+}
+
+func dataSourceComputeGetAuditsSchemaMake() map[string]*schema.Schema {
+	return map[string]*schema.Schema{
+		"compute_id": {
+			Type:     schema.TypeInt,
+			Required: true,
+		},
+
+		"items": {
+			Type:     schema.TypeList,
+			Computed: true,
+			Elem: &schema.Resource{
+				Schema: map[string]*schema.Schema{
+					"epoch": {
+						Type:     schema.TypeFloat,
+						Computed: true,
+					},
+					"message": {
+						Type:     schema.TypeString,
+						Computed: true,
+					},
+				},
+			},
+		},
+	}
+}
+
+func DataSourceComputeGetAudits() *schema.Resource {
+	return &schema.Resource{
+		SchemaVersion: 1,
+
+		ReadContext: dataSourceComputeGetAuditsRead,
+
+		Timeouts: &schema.ResourceTimeout{
+			Read:    &constants.Timeout30s,
+			Default: &constants.Timeout60s,
+		},
+
+		Schema: dataSourceComputeGetAuditsSchemaMake(),
+	}
+}

internal/service/cloudapi/kvmvm/data_source_compute_get_console_url.go

@@ -0,0 +1,85 @@
+/*
+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 kvmvm
+
+import (
+	"context"
+	"strings"
+
+	"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 dataSourceComputeGetConsoleUrlRead(ctx context.Context, d *schema.ResourceData, m interface{}) diag.Diagnostics {
+	computeConsoleUrl, err := utilityComputeGetConsoleUrlCheckPresence(ctx, d, m)
+	if err != nil {
+		d.SetId("")
+		return diag.FromErr(err)
+	}
+	id := uuid.New()
+	d.SetId(id.String())
+	result := strings.ReplaceAll(computeConsoleUrl, "\"", "")
+	result = strings.ReplaceAll(result, "\\", "")
+	d.Set("console_url", result)
+	return nil
+}
+
+func dataSourceComputeGetConsoleUrlSchemaMake() map[string]*schema.Schema {
+	return map[string]*schema.Schema{
+		"compute_id": {
+			Type:     schema.TypeInt,
+			Required: true,
+		},
+		"console_url": {
+			Type:     schema.TypeString,
+			Computed: true,
+		},
+	}
+}
+
+func DataSourceComputeGetConsoleUrl() *schema.Resource {
+	return &schema.Resource{
+		SchemaVersion: 1,
+
+		ReadContext: dataSourceComputeGetConsoleUrlRead,
+
+		Timeouts: &schema.ResourceTimeout{
+			Read:    &constants.Timeout30s,
+			Default: &constants.Timeout60s,
+		},
+
+		Schema: dataSourceComputeGetConsoleUrlSchemaMake(),
+	}
+}

internal/service/cloudapi/kvmvm/data_source_compute_get_log.go

@@ -0,0 +1,86 @@
+/*
+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 kvmvm
+
+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 dataSourceComputeGetLogRead(ctx context.Context, d *schema.ResourceData, m interface{}) diag.Diagnostics {
+	computeGetLog, err := utilityComputeGetLogCheckPresence(ctx, d, m)
+	if err != nil {
+		d.SetId("")
+		return diag.FromErr(err)
+	}
+	id := uuid.New()
+	d.SetId(id.String())
+	d.Set("log", computeGetLog)
+	return nil
+}
+
+func dataSourceComputeGetLogSchemaMake() map[string]*schema.Schema {
+	return map[string]*schema.Schema{
+		"compute_id": {
+			Type:     schema.TypeInt,
+			Required: true,
+		},
+		"path": {
+			Type:     schema.TypeString,
+			Required: true,
+		},
+		"log": {
+			Type:     schema.TypeString,
+			Computed: true,
+		},
+	}
+}
+
+func DataSourceComputeGetLog() *schema.Resource {
+	return &schema.Resource{
+		SchemaVersion: 1,
+
+		ReadContext: dataSourceComputeGetLogRead,
+
+		Timeouts: &schema.ResourceTimeout{
+			Read:    &constants.Timeout30s,
+			Default: &constants.Timeout60s,
+		},
+
+		Schema: dataSourceComputeGetLogSchemaMake(),
+	}
+}

internal/service/cloudapi/kvmvm/data_source_compute_list.go

@@ -0,0 +1,587 @@
+/*
+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 kvmvm
+
+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 dataSourceComputeListRead(ctx context.Context, d *schema.ResourceData, m interface{}) diag.Diagnostics {
+	computeList, err := utilityDataComputeListCheckPresence(ctx, d, m)
+	if err != nil {
+		d.SetId("")
+		return diag.FromErr(err)
+	}
+
+	result := computeList
+	if d.Get("ignore_k8s").(bool) {
+		// matches automatically generated names like "s234-g2134-c1" etc
+		result = matchComputes(computeList)
+	}
+
+	id := uuid.New()
+	d.SetId(id.String())
+	d.Set("items", flattenComputeList(result))
+	d.Set("entry_count", computeList.EntryCount)
+
+	return nil
+}
+
+func computeDisksSchemaMake() map[string]*schema.Schema {
+	return map[string]*schema.Schema{
+		"bus_number": {
+			Type:     schema.TypeInt,
+			Computed: true,
+		},
+		"disk_id": {
+			Type:     schema.TypeInt,
+			Computed: true,
+		},
+		"pci_slot": {
+			Type:     schema.TypeInt,
+			Computed: true,
+		},
+		"sep_id": {
+			Type:     schema.TypeInt,
+			Computed: true,
+		},
+	}
+}
+func itemComputeSchemaMake() map[string]*schema.Schema {
+	return map[string]*schema.Schema{
+		"acl": {
+			Type:     schema.TypeList,
+			Computed: true,
+			Elem: &schema.Resource{
+				Schema: computeListACLSchemaMake(),
+			},
+		},
+		"account_id": {
+			Type:     schema.TypeInt,
+			Computed: true,
+		},
+		"account_name": {
+			Type:     schema.TypeString,
+			Computed: true,
+		},
+		"affinity_label": {
+			Type:     schema.TypeString,
+			Computed: true,
+		},
+		"affinity_rules": {
+			Type:     schema.TypeList,
+			Computed: true,
+			Elem: &schema.Resource{
+				Schema: computeListRulesSchemaMake(),
+			},
+		},
+		"affinity_weight": {
+			Type:     schema.TypeInt,
+			Computed: true,
+		},
+		"anti_affinity_rules": {
+			Type:     schema.TypeList,
+			Computed: true,
+			Elem: &schema.Resource{
+				Schema: computeListRulesSchemaMake(),
+			},
+		},
+		"arch": {
+			Type:     schema.TypeString,
+			Computed: true,
+		},
+		"auto_start_w_node": {
+			Type:     schema.TypeBool,
+			Computed: true,
+		},
+		"boot_order": {
+			Type:     schema.TypeList,
+			Computed: true,
+			Elem: &schema.Schema{
+				Type: schema.TypeString,
+			},
+		},
+		"bootdisk_size": {
+			Type:     schema.TypeInt,
+			Computed: true,
+		},
+		"boot_image_id": {
+			Type:     schema.TypeInt,
+			Computed: true,
+		},
+		"cd_image_id": {
+			Type:     schema.TypeInt,
+			Computed: true,
+		},
+		"clone_reference": {
+			Type:     schema.TypeInt,
+			Computed: true,
+		},
+		"chipset": {
+			Type:     schema.TypeString,
+			Computed: true,
+		},
+		"clock": {
+			Type:     schema.TypeString,
+			Computed: true,
+		},
+		"clones": {
+			Type:     schema.TypeList,
+			Computed: true,
+			Elem: &schema.Schema{
+				Type: schema.TypeInt,
+			},
+		},
+		"computeci_id": {
+			Type:     schema.TypeInt,
+			Computed: true,
+		},
+		"cpu_alignment_profiles": {
+			Type:     schema.TypeList,
+			Computed: true,
+			Elem: &schema.Resource{
+				Schema: map[string]*schema.Schema{
+					"name": {
+						Type:     schema.TypeString,
+						Computed: true,
+					},
+					"model": {
+						Type:     schema.TypeString,
+						Computed: true,
+					},
+					"vendor": {
+						Type:     schema.TypeString,
+						Computed: true,
+					},
+				},
+			},
+		},
+		"cpu_pin": {
+			Type:     schema.TypeBool,
+			Computed: true,
+		},
+		"cpus": {
+			Type:     schema.TypeInt,
+			Computed: true,
+		},
+		"created_by": {
+			Type:     schema.TypeString,
+			Computed: true,
+		},
+		"created_time": {
+			Type:     schema.TypeInt,
+			Computed: true,
+		},
+		"custom_fields": { //NEED
+			Type:     schema.TypeString,
+			Computed: true,
+		},
+		"deleted_by": {
+			Type:     schema.TypeString,
+			Computed: true,
+		},
+		"deleted_time": {
+			Type:     schema.TypeInt,
+			Computed: true,
+		},
+		"desc": {
+			Type:     schema.TypeString,
+			Computed: true,
+		},
+		"devices": { //NEED
+			Type:     schema.TypeString,
+			Computed: true,
+		},
+		"disks": {
+			Type:     schema.TypeList,
+			Computed: true,
+			Elem: &schema.Resource{
+				Schema: computeDisksSchemaMake(),
+			},
+		},
+		"driver": {
+			Type:     schema.TypeString,
+			Computed: true,
+		},
+		"gid": {
+			Type:     schema.TypeInt,
+			Computed: true,
+		},
+		"guid": {
+			Type:     schema.TypeInt,
+			Computed: true,
+		},
+		"hp_backed": {
+			Type:     schema.TypeBool,
+			Computed: true,
+		},
+		"compute_id": {
+			Type:     schema.TypeInt,
+			Computed: true,
+		},
+		"interfaces": {
+			Type:     schema.TypeList,
+			Computed: true,
+			Elem: &schema.Resource{
+				Schema: computeInterfacesSchemaMake(),
+			},
+		},
+		"lock_status": {
+			Type:     schema.TypeString,
+			Computed: true,
+		},
+		"live_migration_job_id": {
+			Type:     schema.TypeInt,
+			Computed: true,
+		},
+		"manager_id": {
+			Type:     schema.TypeInt,
+			Computed: true,
+		},
+		"manager_type": {
+			Type:     schema.TypeString,
+			Computed: true,
+		},
+		"migrationjob": {
+			Type:     schema.TypeInt,
+			Computed: true,
+		},
+		"milestones": {
+			Type:     schema.TypeInt,
+			Computed: true,
+		},
+		"name": {
+			Type:     schema.TypeString,
+			Computed: true,
+		},
+		"need_reboot": {
+			Type:     schema.TypeBool,
+			Computed: true,
+		},
+		"numa_affinity": {
+			Type:     schema.TypeString,
+			Computed: true,
+		},
+		"numa_node_id": {
+			Type:     schema.TypeInt,
+			Computed: true,
+		},
+		"os_version": {
+			Type:     schema.TypeString,
+			Computed: true,
+		},
+		"pinned": {
+			Type:     schema.TypeBool,
+			Computed: true,
+		},
+		"preferred_cpu": {
+			Type:     schema.TypeList,
+			Computed: true,
+			Elem: &schema.Schema{
+				Type: schema.TypeInt,
+			},
+		},
+		"qemu_guest": {
+			Type: schema.TypeList,
+			Elem: &schema.Resource{
+				Schema: map[string]*schema.Schema{
+					"enabled": {
+						Type:     schema.TypeBool,
+						Computed: true,
+					},
+					"enabled_agent_features": {
+						Type: schema.TypeList,
+						Elem: &schema.Schema{
+							Type: schema.TypeString,
+						},
+						Computed: true,
+					},
+					"guid": {
+						Type:     schema.TypeString,
+						Computed: true,
+					},
+					"last_update": {
+						Type:     schema.TypeInt,
+						Computed: true,
+					},
+					"user": {
+						Type:     schema.TypeString,
+						Computed: true,
+					},
+				},
+			},
+			Computed: true,
+		},
+		"ram": {
+			Type:     schema.TypeInt,
+			Computed: true,
+		},
+		"reference_id": {
+			Type:     schema.TypeString,
+			Computed: true,
+		},
+		"registered": {
+			Type:     schema.TypeBool,
+			Computed: true,
+		},
+		"res_name": {
+			Type:     schema.TypeString,
+			Computed: true,
+		},
+		"reserved_node_cpus": {
+			Type:     schema.TypeList,
+			Computed: true,
+			Elem: &schema.Schema{
+				Type: schema.TypeInt,
+			},
+		},
+		"rg_id": {
+			Type:     schema.TypeInt,
+			Computed: true,
+		},
+		"rg_name": {
+			Type:     schema.TypeString,
+			Computed: true,
+		},
+		"snap_sets": {
+			Type:     schema.TypeList,
+			Computed: true,
+			Elem: &schema.Resource{
+				Schema: computeSnapSetsSchemaMake(),
+			},
+		},
+		"stateless_sep_id": {
+			Type:     schema.TypeInt,
+			Computed: true,
+		},
+		"stateless_sep_type": {
+			Type:     schema.TypeString,
+			Computed: true,
+		},
+		"status": {
+			Type:     schema.TypeString,
+			Computed: true,
+		},
+		"tags": {
+			Type:     schema.TypeList,
+			Computed: true,
+			Elem: &schema.Resource{
+				Schema: map[string]*schema.Schema{
+					"key": {
+						Type:     schema.TypeString,
+						Computed: true,
+					},
+					"val": {
+						Type:     schema.TypeString,
+						Computed: true,
+					},
+				},
+			},
+		},
+		"tech_status": {
+			Type:     schema.TypeString,
+			Computed: true,
+		},
+		"total_disk_size": {
+			Type:     schema.TypeInt,
+			Computed: true,
+		},
+		"updated_by": {
+			Type:     schema.TypeString,
+			Computed: true,
+		},
+		"updated_time": {
+			Type:     schema.TypeInt,
+			Computed: true,
+		},
+		"user_managed": {
+			Type:     schema.TypeBool,
+			Computed: true,
+		},
+		"read_only": {
+			Type:        schema.TypeBool,
+			Computed:    true,
+			Description: "Shows if compute is in read-only mode.",
+		},
+		"vgpus": {
+			Type:     schema.TypeList,
+			Computed: true,
+			Elem: &schema.Schema{
+				Type: schema.TypeInt,
+			},
+		},
+		"vins_connected": {
+			Type:     schema.TypeInt,
+			Computed: true,
+		},
+		"loader_type": {
+			Type:     schema.TypeString,
+			Computed: true,
+		},
+		"boot_type": {
+			Type:     schema.TypeString,
+			Computed: true,
+		},
+		"hot_resize": {
+			Type:     schema.TypeBool,
+			Computed: true,
+		},
+		"network_interface_naming": {
+			Type:     schema.TypeString,
+			Computed: true,
+		},
+		"zone_id": {
+			Type:     schema.TypeInt,
+			Computed: true,
+		},
+		"weight": {
+			Type:     schema.TypeInt,
+			Computed: true,
+		},
+	}
+}
+
+func dataSourceComputeListSchemaMake() map[string]*schema.Schema {
+	res := map[string]*schema.Schema{
+		"by_id": {
+			Type:        schema.TypeInt,
+			Optional:    true,
+			Description: "Find by ID",
+		},
+		"name": {
+			Type:        schema.TypeString,
+			Optional:    true,
+			Description: "Find by name",
+		},
+		"account_id": {
+			Type:        schema.TypeInt,
+			Optional:    true,
+			Description: "Find by AccountID",
+		},
+		"rg_name": {
+			Type:        schema.TypeString,
+			Optional:    true,
+			Description: "Find by resgroup name",
+		},
+		"rg_id": {
+			Type:        schema.TypeInt,
+			Optional:    true,
+			Description: "Find by RGID",
+		},
+		"tech_status": {
+			Type:        schema.TypeString,
+			Optional:    true,
+			Description: "Find by tech status",
+		},
+		"status": {
+			Type:        schema.TypeString,
+			Optional:    true,
+			Description: "Find by status",
+		},
+		"ip_address": {
+			Type:        schema.TypeString,
+			Optional:    true,
+			Description: "Find by IP address",
+		},
+		"extnet_name": {
+			Type:        schema.TypeString,
+			Optional:    true,
+			Description: "Find by Extnet name",
+		},
+		"extnet_id": {
+			Type:        schema.TypeInt,
+			Optional:    true,
+			Description: "Find by Extnet ID",
+		},
+		"includedeleted": {
+			Type:     schema.TypeBool,
+			Optional: true,
+		},
+		"sort_by": {
+			Type:        schema.TypeString,
+			Optional:    true,
+			Description: "sort by one of supported fields, format +|-(field)",
+		},
+		"page": {
+			Type:     schema.TypeInt,
+			Optional: true,
+		},
+		"size": {
+			Type:     schema.TypeInt,
+			Optional: true,
+		},
+		"ignore_k8s": {
+			Type:        schema.TypeBool,
+			Optional:    true,
+			Default:     false,
+			Description: "If set to true, ignores any VMs associated with any k8s cluster",
+		},
+		"zone_id": {
+			Type:        schema.TypeInt,
+			Optional:    true,
+			Description: "Zone ID",
+		},
+		"items": {
+			Type:     schema.TypeList,
+			Computed: true,
+			Elem: &schema.Resource{
+				Schema: itemComputeSchemaMake(),
+			},
+		},
+		"entry_count": {
+			Type:     schema.TypeInt,
+			Computed: true,
+		},
+	}
+	return res
+}
+
+func DataSourceComputeList() *schema.Resource {
+	return &schema.Resource{
+		SchemaVersion: 1,
+
+		ReadContext: dataSourceComputeListRead,
+
+		Timeouts: &schema.ResourceTimeout{
+			Read:    &constants.Timeout30s,
+			Default: &constants.Timeout60s,
+		},
+
+		Schema: dataSourceComputeListSchemaMake(),
+	}
+}

internal/service/cloudapi/kvmvm/data_source_compute_list_deleted.go

@@ -0,0 +1,159 @@
+/*
+Copyright (c) 2019-2023 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 kvmvm
+
+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 dataSourceComputeListDeletedRead(ctx context.Context, d *schema.ResourceData, m interface{}) diag.Diagnostics {
+	computeList, err := utilityDataComputeListDeletedCheckPresence(ctx, d, m)
+	if err != nil {
+		d.SetId("")
+		return diag.FromErr(err)
+	}
+
+	result := computeList
+	if d.Get("ignore_k8s").(bool) {
+		// matches automatically generated names like "s234-g2134-c1" etc
+		result = matchComputes(computeList)
+	}
+
+	id := uuid.New()
+	d.SetId(id.String())
+	d.Set("items", flattenComputeList(result))
+	d.Set("entry_count", computeList.EntryCount)
+
+	return nil
+}
+
+func dataSourceComputeListDeletedSchemaMake() map[string]*schema.Schema {
+	res := map[string]*schema.Schema{
+		"by_id": {
+			Type:        schema.TypeInt,
+			Optional:    true,
+			Description: "Find by ID",
+		},
+		"name": {
+			Type:        schema.TypeString,
+			Optional:    true,
+			Description: "Find by name",
+		},
+		"account_id": {
+			Type:        schema.TypeInt,
+			Optional:    true,
+			Description: "Find by AccountID",
+		},
+		"rg_name": {
+			Type:        schema.TypeString,
+			Optional:    true,
+			Description: "Find by resgroup name",
+		},
+		"rg_id": {
+			Type:        schema.TypeInt,
+			Optional:    true,
+			Description: "Find by RGID",
+		},
+		"tech_status": {
+			Type:        schema.TypeString,
+			Optional:    true,
+			Description: "Find by tech status",
+		},
+		"ip_address": {
+			Type:        schema.TypeString,
+			Optional:    true,
+			Description: "Find by IP address",
+		},
+		"extnet_name": {
+			Type:        schema.TypeString,
+			Optional:    true,
+			Description: "Find by Extnet name",
+		},
+		"extnet_id": {
+			Type:        schema.TypeInt,
+			Optional:    true,
+			Description: "Find by Extnet ID",
+		},
+		"sort_by": {
+			Type:        schema.TypeString,
+			Optional:    true,
+			Description: "sort by one of supported fields, format +|-(field)",
+		},
+		"page": {
+			Type:     schema.TypeInt,
+			Optional: true,
+		},
+		"size": {
+			Type:     schema.TypeInt,
+			Optional: true,
+		},
+		"ignore_k8s": {
+			Type:        schema.TypeBool,
+			Optional:    true,
+			Default:     false,
+			Description: "If set to true, ignores any VMs associated with any k8s cluster",
+		},
+		"items": {
+			Type:     schema.TypeList,
+			Computed: true,
+			Elem: &schema.Resource{
+				Schema: itemComputeSchemaMake(),
+			},
+		},
+		"entry_count": {
+			Type:     schema.TypeInt,
+			Computed: true,
+		},
+	}
+	return res
+}
+
+func DataSourceComputeListDeleted() *schema.Resource {
+	return &schema.Resource{
+		SchemaVersion: 1,
+
+		ReadContext: dataSourceComputeListDeletedRead,
+
+		Timeouts: &schema.ResourceTimeout{
+			Read:    &constants.Timeout30s,
+			Default: &constants.Timeout60s,
+		},
+
+		Schema: dataSourceComputeListDeletedSchemaMake(),
+	}
+}

internal/service/cloudapi/kvmvm/data_source_compute_pci_device_list.go

@@ -0,0 +1,166 @@
+/*
+Copyright (c) 2019-2023 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 kvmvm
+
+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 dataSourceComputePCIDeviceListRead(ctx context.Context, d *schema.ResourceData, m interface{}) diag.Diagnostics {
+	computePCIDeviceList, err := utilityComputePCIDeviceListCheckPresence(ctx, d, m)
+	if err != nil {
+		d.SetId("")
+		return diag.FromErr(err)
+	}
+	id := uuid.New()
+	d.SetId(id.String())
+	d.Set("items", flattenPCIDevice(computePCIDeviceList.Data))
+	d.Set("entry_count", computePCIDeviceList.EntryCount)
+	return nil
+}
+
+func dataSourceComputePCIDeviceListSchemaMake() map[string]*schema.Schema {
+	return map[string]*schema.Schema{
+		"compute_id": {
+			Type:     schema.TypeInt,
+			Required: true,
+		},
+		"rg_id": {
+			Type:        schema.TypeInt,
+			Optional:    true,
+			Description: "Find by RG id",
+		},
+		"device_id": {
+			Type:        schema.TypeInt,
+			Optional:    true,
+			Description: "Find by device id",
+		},
+		"name": {
+			Type:        schema.TypeString,
+			Computed:    true,
+			Description: "Find by name",
+		},
+		"status": {
+			Type:        schema.TypeString,
+			Computed:    true,
+			Description: "Find by status",
+		},
+		"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",
+		},
+		"items": {
+			Type:     schema.TypeList,
+			Computed: true,
+			Elem: &schema.Resource{
+				Schema: map[string]*schema.Schema{
+					"compute_id": {
+						Type:     schema.TypeInt,
+						Computed: true,
+					},
+					"description": {
+						Type:     schema.TypeString,
+						Computed: true,
+					},
+					"guid": {
+						Type:     schema.TypeInt,
+						Computed: true,
+					},
+					"hwpath": {
+						Type:     schema.TypeString,
+						Computed: true,
+					},
+					"device_id": {
+						Type:     schema.TypeInt,
+						Computed: true,
+					},
+					"name": {
+						Type:     schema.TypeString,
+						Computed: true,
+					},
+					"rg_id": {
+						Type:     schema.TypeInt,
+						Computed: true,
+					},
+					"node_id": {
+						Type:     schema.TypeInt,
+						Computed: true,
+					},
+					"status": {
+						Type:     schema.TypeString,
+						Computed: true,
+					},
+					"system_name": {
+						Type:     schema.TypeString,
+						Computed: true,
+					},
+				},
+			},
+		},
+		"entry_count": {
+			Type:     schema.TypeInt,
+			Computed: true,
+		},
+	}
+}
+
+func DataSourceComputePCIDeviceList() *schema.Resource {
+	return &schema.Resource{
+		SchemaVersion: 1,
+
+		ReadContext: dataSourceComputePCIDeviceListRead,
+
+		Timeouts: &schema.ResourceTimeout{
+			Read:    &constants.Timeout30s,
+			Default: &constants.Timeout60s,
+		},
+
+		Schema: dataSourceComputePCIDeviceListSchemaMake(),
+	}
+}

internal/service/cloudapi/kvmvm/data_source_compute_pfw_list.go

@@ -0,0 +1,119 @@
+/*
+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 kvmvm
+
+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 dataSourceComputePfwListRead(ctx context.Context, d *schema.ResourceData, m interface{}) diag.Diagnostics {
+	computePfwList, err := utilityComputePfwListCheckPresence(ctx, d, m)
+	if err != nil {
+		d.SetId("")
+		return diag.FromErr(err)
+	}
+	id := uuid.New()
+	d.SetId(id.String())
+	d.Set("items", flattenPfwList(computePfwList))
+	d.Set("entry_count", computePfwList.EntryCount)
+	return nil
+}
+
+func dataSourceComputePfwListSchemaMake() map[string]*schema.Schema {
+	return map[string]*schema.Schema{
+		"compute_id": {
+			Type:     schema.TypeInt,
+			Required: true,
+		},
+		"items": {
+			Type:     schema.TypeList,
+			Computed: true,
+			Elem: &schema.Resource{
+				Schema: map[string]*schema.Schema{
+					"pfw_id": {
+						Type:     schema.TypeInt,
+						Computed: true,
+					},
+					"local_ip": {
+						Type:     schema.TypeString,
+						Computed: true,
+					},
+					"local_port": {
+						Type:     schema.TypeInt,
+						Computed: true,
+					},
+					"protocol": {
+						Type:     schema.TypeString,
+						Computed: true,
+					},
+					"public_port_end": {
+						Type:     schema.TypeInt,
+						Computed: true,
+					},
+					"public_port_start": {
+						Type:     schema.TypeInt,
+						Computed: true,
+					},
+					"vm_id": {
+						Type:     schema.TypeInt,
+						Computed: true,
+					},
+				},
+			},
+		},
+		"entry_count": {
+			Type:     schema.TypeInt,
+			Computed: true,
+		},
+	}
+}
+
+func DataSourceComputePfwList() *schema.Resource {
+	return &schema.Resource{
+		SchemaVersion: 1,
+
+		ReadContext: dataSourceComputePfwListRead,
+
+		Timeouts: &schema.ResourceTimeout{
+			Read:    &constants.Timeout30s,
+			Default: &constants.Timeout60s,
+		},
+
+		Schema: dataSourceComputePfwListSchemaMake(),
+	}
+}

internal/service/cloudapi/kvmvm/data_source_compute_snapshot_usage.go

@@ -0,0 +1,74 @@
+package kvmvm
+
+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 dataSourceComputeSnapshotUsageRead(ctx context.Context, d *schema.ResourceData, m interface{}) diag.Diagnostics {
+	computeSnapshotUsage, err := utilityComputeSnapshotUsageCheckPresence(ctx, d, m)
+	if err != nil {
+		d.SetId("")
+		return diag.FromErr(err)
+	}
+	id := uuid.New()
+	d.SetId(id.String())
+	d.Set("items", flattenSnapshotUsage(computeSnapshotUsage))
+	return nil
+}
+
+func dataSourceComputeSnapshotUsagSchemaMake() map[string]*schema.Schema {
+	return map[string]*schema.Schema{
+		"compute_id": {
+			Type:     schema.TypeInt,
+			Required: true,
+		},
+		"label": {
+			Type:     schema.TypeString,
+			Optional: true,
+		},
+		"items": {
+			Type:     schema.TypeList,
+			Computed: true,
+			Elem: &schema.Resource{
+				Schema: map[string]*schema.Schema{
+					"count": {
+						Type:     schema.TypeInt,
+						Computed: true,
+					},
+					"stored": {
+						Type:     schema.TypeFloat,
+						Computed: true,
+					},
+					"label": {
+						Type:     schema.TypeString,
+						Computed: true,
+					},
+					"timestamp": {
+						Type:     schema.TypeInt,
+						Computed: true,
+					},
+				},
+			},
+		},
+	}
+}
+
+func DataSourceComputeSnapshotUsage() *schema.Resource {
+	return &schema.Resource{
+		SchemaVersion: 1,
+
+		ReadContext: dataSourceComputeSnapshotUsageRead,
+
+		Timeouts: &schema.ResourceTimeout{
+			Read:    &constants.Timeout30s,
+			Default: &constants.Timeout60s,
+		},
+
+		Schema: dataSourceComputeSnapshotUsagSchemaMake(),
+	}
+}

internal/service/cloudapi/kvmvm/data_source_compute_user_list.go

@@ -0,0 +1,78 @@
+/*
+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 kvmvm
+
+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 dataSourceComputeUserListRead(ctx context.Context, d *schema.ResourceData, m interface{}) diag.Diagnostics {
+	computeUserList, err := utilityComputeUserListCheckPresence(ctx, d, m)
+	if err != nil {
+		d.SetId("")
+		return diag.FromErr(err)
+	}
+	id := uuid.New()
+	d.SetId(id.String())
+	flattenUserList(d, computeUserList)
+	return nil
+}
+
+func dataSourceComputeUserListSchemaMake() map[string]*schema.Schema {
+	res := computeACLSchemaMake()
+	res["compute_id"] = &schema.Schema{
+		Type:     schema.TypeInt,
+		Required: true,
+	}
+	return res
+}
+
+func DataSourceComputeUserList() *schema.Resource {
+	return &schema.Resource{
+		SchemaVersion: 1,
+
+		ReadContext: dataSourceComputeUserListRead,
+
+		Timeouts: &schema.ResourceTimeout{
+			Read:    &constants.Timeout30s,
+			Default: &constants.Timeout60s,
+		},
+
+		Schema: dataSourceComputeUserListSchemaMake(),
+	}
+}

internal/service/cloudapi/kvmvm/data_source_compute_vgpu_list.go

@@ -0,0 +1,198 @@
+/*
+Copyright (c) 2019-2023 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 kvmvm
+
+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 dataSourceComputeVGPUListRead(ctx context.Context, d *schema.ResourceData, m interface{}) diag.Diagnostics {
+	computeVGPUList, err := utilityComputeVGPUListCheckPresence(ctx, d, m)
+	if err != nil {
+		d.SetId("")
+		return diag.FromErr(err)
+	}
+	id := uuid.New()
+	d.SetId(id.String())
+	d.Set("items", flattenVGPU(computeVGPUList.Data))
+	d.Set("entry_count", computeVGPUList.EntryCount)
+	return nil
+}
+
+func dataSourceComputeVGPUListSchemaMake() map[string]*schema.Schema {
+	return map[string]*schema.Schema{
+		"compute_id": {
+			Type:     schema.TypeInt,
+			Required: true,
+		},
+		"gpu_id": {
+			Type:        schema.TypeInt,
+			Optional:    true,
+			Description: "Find by GPU id",
+		},
+		"type": {
+			Type:        schema.TypeString,
+			Computed:    true,
+			Description: "Find by type",
+		},
+		"status": {
+			Type:        schema.TypeString,
+			Computed:    true,
+			Description: "Find by status",
+		},
+		"includedeleted": {
+			Type:        schema.TypeBool,
+			Optional:    true,
+			Description: "Include deleted computes. If using field 'status', then includedeleted will be ignored",
+		},
+		"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",
+		},
+		"items": {
+			Type:     schema.TypeList,
+			Computed: true,
+			Elem: &schema.Resource{
+				Schema: map[string]*schema.Schema{
+					"account_id": {
+						Type:     schema.TypeInt,
+						Computed: true,
+					},
+					"created_time": {
+						Type:     schema.TypeInt,
+						Computed: true,
+					},
+					"deleted_time": {
+						Type:     schema.TypeInt,
+						Computed: true,
+					},
+					"gid": {
+						Type:     schema.TypeInt,
+						Computed: true,
+					},
+					"guid": {
+						Type:     schema.TypeInt,
+						Computed: true,
+					},
+					"vgpu_id": {
+						Type:     schema.TypeInt,
+						Computed: true,
+					},
+					"last_claimed_by": {
+						Type:     schema.TypeInt,
+						Computed: true,
+					},
+					"last_update_time": {
+						Type:     schema.TypeInt,
+						Computed: true,
+					},
+					"mode": {
+						Type:     schema.TypeString,
+						Computed: true,
+					},
+					"pci_slot": {
+						Type:     schema.TypeInt,
+						Computed: true,
+					},
+					"pgpuid": {
+						Type:     schema.TypeInt,
+						Computed: true,
+					},
+					"profile_id": {
+						Type:     schema.TypeInt,
+						Computed: true,
+					},
+					"ram": {
+						Type:     schema.TypeInt,
+						Computed: true,
+					},
+					"reference_id": {
+						Type:     schema.TypeString,
+						Computed: true,
+					},
+					"rg_id": {
+						Type:     schema.TypeInt,
+						Computed: true,
+					},
+					"status": {
+						Type:     schema.TypeString,
+						Computed: true,
+					},
+					"type": {
+						Type:     schema.TypeString,
+						Computed: true,
+					},
+					"vm_id": {
+						Type:     schema.TypeInt,
+						Computed: true,
+					},
+				},
+			},
+		},
+		"entry_count": {
+			Type:     schema.TypeInt,
+			Computed: true,
+		},
+	}
+}
+
+func DataSourceComputeVGPUList() *schema.Resource {
+	return &schema.Resource{
+		SchemaVersion: 1,
+
+		ReadContext: dataSourceComputeVGPUListRead,
+
+		Timeouts: &schema.ResourceTimeout{
+			Read:    &constants.Timeout30s,
+			Default: &constants.Timeout60s,
+		},
+
+		Schema: dataSourceComputeVGPUListSchemaMake(),
+	}
+}

internal/service/cloudapi/kvmvm/flattens.go

@@ -0,0 +1,991 @@
+/*
+Copyright (c) 2019-2023 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 kvmvm
+
+import (
+	"encoding/json"
+	"sort"
+	"strconv"
+
+	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
+	log "github.com/sirupsen/logrus"
+	"repository.basistech.ru/BASIS/decort-golang-sdk/pkg/cloudapi/compute"
+	"repository.basistech.ru/BASIS/terraform-provider-decort/internal/status"
+)
+
+func flattenDisks(disks []compute.InfoDisk) []map[string]interface{} {
+	res := make([]map[string]interface{}, 0)
+	for _, disk := range disks {
+		temp := map[string]interface{}{
+			// "bus_number": disk.BusNumber,
+			"disk_id": disk.ID,
+			// "pci_slot":   disk.PCISlot,
+			"sep_id": disk.SepID,
+		}
+		res = append(res, temp)
+	}
+	return res
+}
+func flattenQOS(qos compute.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 compute.ListInterfaces) []map[string]interface{} {
+	res := make([]map[string]interface{}, 0, len(interfaces))
+	for _, interfaceItem := range interfaces {
+		temp := map[string]interface{}{
+			"bus_number":       interfaceItem.BusNumber,
+			"conn_id":          interfaceItem.ConnID,
+			"conn_type":        interfaceItem.ConnType,
+			"def_gw":           interfaceItem.DefGW,
+			"enabled":          interfaceItem.Enabled,
+			"enable_secgroups": interfaceItem.EnableSecGroups,
+			"flip_group_id":    interfaceItem.FLIPGroupID,
+			"guid":             interfaceItem.GUID,
+			"ip_address":       interfaceItem.IPAddress,
+			"listen_ssh":       interfaceItem.ListenSSH,
+			"mac":              interfaceItem.MAC,
+			"mtu":              interfaceItem.MTU,
+			"name":             interfaceItem.Name,
+			"net_id":           interfaceItem.NetID,
+			"netmask":          interfaceItem.NetMask,
+			"net_type":         interfaceItem.NetType,
+			"node_id":          interfaceItem.NodeID,
+			"pci_slot":         interfaceItem.PCISlot,
+			"qos":              flattenQOS(interfaceItem.QOS),
+			"security_groups":  interfaceItem.SecGroups,
+			"sdn_interface_id": interfaceItem.SDNInterfaceID,
+			"target":           interfaceItem.Target,
+			"type":             interfaceItem.Type,
+			"trunk_tags":       interfaceItem.TrunkTags,
+			"vnfs":             interfaceItem.VNFs,
+			"libvirt_settings": flattenLibvirtSettings(interfaceItem.LibvirtSettings),
+		}
+		res = append(res, temp)
+	}
+	return res
+}
+
+func flattenLibvirtSettings(libvirtSettings compute.LibvirtSettings) []map[string]interface{} {
+	res := make([]map[string]interface{}, 0)
+	temp := map[string]interface{}{
+		"guid":          libvirtSettings.GUID,
+		"txmode":        libvirtSettings.TXMode,
+		"ioeventfd":     libvirtSettings.IOEventFD,
+		"event_idx":     libvirtSettings.EventIDx,
+		"queues":        libvirtSettings.Queues,
+		"rx_queue_size": libvirtSettings.RXQueueSize,
+		"tx_queue_size": libvirtSettings.TXQueueSize,
+	}
+	res = append(res, temp)
+	return res
+}
+
+func flattenSnapSets(snapSets compute.ListSnapSets) []map[string]interface{} {
+	res := make([]map[string]interface{}, 0, len(snapSets))
+	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, len(tags))
+	for key, val := range tags {
+		temp := map[string]interface{}{
+			"key": key,
+			"val": val,
+		}
+		res = append(res, temp)
+	}
+	return res
+}
+
+func flattenListRules(listRules compute.ListRules) []map[string]interface{} {
+	res := make([]map[string]interface{}, 0, len(listRules))
+	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 compute.ListACL) []map[string]interface{} {
+	res := make([]map[string]interface{}, 0, len(listAcl))
+	for _, acl := range listAcl {
+		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 flattenComputeList(computes *compute.ListComputes) []map[string]interface{} {
+	res := make([]map[string]interface{}, 0, len(computes.Data))
+	for _, compute := range computes.Data {
+		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,
+			"auto_start_w_node":        compute.AutoStart,
+			"boot_order":               compute.BootOrder,
+			"bootdisk_size":            compute.BootDiskSize,
+			"boot_image_id":            compute.BootImageID,
+			"chipset":                  compute.Chipset,
+			"clock":                    compute.Clock,
+			"cd_image_id":              compute.CdImageId,
+			"clone_reference":          compute.CloneReference,
+			"clones":                   compute.Clones,
+			"computeci_id":             compute.ComputeCIID,
+			"cpu_alignment_profiles":   flattenCPUAlignmentProfile(compute.CPUAlignmentProfile),
+			"cpu_pin":                  compute.CPUPin,
+			"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,
+			"hp_backed":                compute.HPBacked,
+			"compute_id":               compute.ID,
+			"interfaces":               flattenInterfaces(compute.Interfaces),
+			"live_migration_job_id":    compute.LiveMigrationJobID,
+			"lock_status":              compute.LockStatus,
+			"manager_id":               compute.ManagerID,
+			"manager_type":             compute.ManagerType,
+			"migrationjob":             compute.MigrationJob,
+			"milestones":               compute.Milestones,
+			"name":                     compute.Name,
+			"need_reboot":              compute.NeedReboot,
+			"numa_affinity":            compute.NumaAffinity,
+			"numa_node_id":             compute.NumaNodeId,
+			"os_version":               compute.OSVersion,
+			"pinned":                   compute.PinnedToNode,
+			"preferred_cpu":            compute.PreferredCPU,
+			"qemu_guest":               flattenQemuQuest(compute.QemuQuest),
+			"ram":                      compute.RAM,
+			"reference_id":             compute.ReferenceID,
+			"registered":               compute.Registered,
+			"res_name":                 compute.ResName,
+			"reserved_node_cpus":       compute.ReservedNodeCpus,
+			"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,
+			"read_only":                compute.ReadOnly,
+			"vgpus":                    compute.VGPUs,
+			"vins_connected":           compute.VINSConnected,
+			"loader_type":              compute.LoaderType,
+			"boot_type":                compute.BootType,
+			"hot_resize":               compute.HotResize,
+			"network_interface_naming": compute.NetworkInterfaceNaming,
+			"zone_id":                  compute.ZoneID,
+			"weight":                   compute.Weight,
+		}
+		res = append(res, temp)
+	}
+
+	return res
+}
+
+func flattenBootDisk(bootDisk *compute.ItemComputeDisk) []map[string]interface{} {
+	res := make([]map[string]interface{}, 0)
+
+	temp := map[string]interface{}{
+		"disk_name":         bootDisk.Name,
+		"disk_id":           bootDisk.ID,
+		"sep_id":            bootDisk.SepID,
+		"shareable":         bootDisk.Shareable,
+		"size_max":          bootDisk.SizeMax,
+		"size_used":         bootDisk.SizeUsed,
+		"pool":              bootDisk.Pool,
+		"desc":              bootDisk.Description,
+		"image_id":          bootDisk.ImageID,
+		"size":              bootDisk.SizeMax,
+		"present_to":        bootDisk.PresentTo,
+		"storage_policy_id": bootDisk.StoragePolicyID,
+		"to_clean":          bootDisk.ToClean,
+		"cache":             bootDisk.Cache,
+		"discard":           bootDisk.Discard,
+		"block_size":        bootDisk.BlockSize,
+		"bus_number":        bootDisk.BusNumber,
+		"provision":         bootDisk.Provision,
+		"pci_slot":          bootDisk.PCISlot,
+		"created_time":      bootDisk.CreatedTime,
+		"created_by":        bootDisk.CreatedBy,
+		"deleted_by":        bootDisk.DeletedBy,
+		"deleted_time":      bootDisk.DeletedTime,
+		"updated_time":      bootDisk.UpdatedTime,
+		"devicename":        bootDisk.DeviceName,
+	}
+
+	res = append(res, temp)
+
+	return res
+}
+
+func flattenComputeDisksDemo(disksList compute.ListComputeDisks, disksBlocks, extraDisks []interface{}, bootDiskId uint64) []map[string]interface{} {
+	res := make([]map[string]interface{}, 0, len(disksList))
+
+	sort.Slice(disksList, func(i, j int) bool {
+		return disksList[i].ID < disksList[j].ID
+	})
+
+	indexDataDisks := 0
+
+	for _, disk := range disksList {
+		if disk.ID == bootDiskId || findInExtraDisks(uint(disk.ID), extraDisks) { //skip main bootdisk and extraDisks
+			continue
+		}
+
+		var pernamentlyValue bool
+		if indexDataDisks < len(disksBlocks) {
+			if diskBlock, ok := disksBlocks[indexDataDisks].(map[string]interface{}); ok {
+				if perm, exists := diskBlock["permanently"]; exists {
+					if permBool, ok := perm.(bool); ok {
+						pernamentlyValue = permBool
+					}
+				}
+			}
+		}
+
+		temp := map[string]interface{}{
+			"devicename":        disk.DeviceName,
+			"disk_name":         disk.Name,
+			"disk_id":           disk.ID,
+			"independent":       disk.Independent,
+			"pci_slot":          disk.PCISlot,
+			"bus_number":        disk.BusNumber,
+			"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,
+			"present_to":        disk.PresentTo,
+			"storage_policy_id": disk.StoragePolicyID,
+			"to_clean":          disk.ToClean,
+			"created_by":        disk.CreatedBy,
+			"created_time":      disk.CreatedTime,
+			"deleted_by":        disk.DeletedBy,
+			"deleted_time":      disk.DeletedTime,
+			"updated_time":      disk.UpdatedTime,
+			"permanently":       pernamentlyValue,
+			"cache":             disk.Cache,
+			"discard":           disk.Discard,
+			"block_size":        disk.BlockSize,
+			"provision":         disk.Provision,
+			"iotune":            flattenIotune(disk.IOTune),
+		}
+		res = append(res, temp)
+		indexDataDisks++
+	}
+
+	return res
+}
+
+func flattenNetwork(networks []interface{}, interfaces compute.ListInterfaces) []map[string]interface{} {
+	res := make([]map[string]interface{}, 0, len(interfaces))
+
+	for _, network := range interfaces {
+		temp := map[string]interface{}{
+			"net_id":           network.NetID,
+			"net_type":         network.NetType,
+			"ip_address":       network.IPAddress,
+			"mac":              network.MAC,
+			"mtu":              network.MTU,
+			"net_mask":         network.NetMask,
+			"sdn_interface_id": network.SDNInterfaceID,
+			"weight":           flattenNetworkWeight(networks, network.NetID, network.NetType),
+			"enabled":          network.Enabled,
+		}
+		res = append(res, temp)
+	}
+	return res
+}
+
+func flattenNetworkWeight(networks []interface{}, netID uint64, netType string) int {
+	for _, network := range networks {
+		ns := network.(map[string]interface{})
+		if ns["net_id"].(int) == int(netID) && ns["net_type"].(string) == netType {
+			weight := ns["weight"].(int)
+			return weight
+		}
+	}
+	return 0
+}
+
+func isBootDisk(diskConv map[string]interface{}, chipset string) bool {
+	if chipset == "i440fx" {
+		return diskConv["pci_slot"].(int) == 6
+	}
+	return diskConv["bus_number"].(int) == 6
+}
+
+func findBootDisk(disks compute.ListComputeDisks, chipset string) *compute.ItemComputeDisk {
+	for _, disk := range disks {
+		if chipset == "i440fx" {
+			if disk.PCISlot == 6 {
+				return &disk
+			}
+		} else {
+			if disk.BusNumber == 6 {
+				return &disk
+			}
+		}
+	}
+	return &compute.ItemComputeDisk{}
+}
+
+func flattenCompute(d *schema.ResourceData, computeRec compute.RecordCompute, pciList *compute.ListPCIDevices) 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
+	log.Debugf("flattenCompute: ID %d, RG ID %d", computeRec.ID, computeRec.RGID)
+
+	devices, _ := json.Marshal(computeRec.Devices)
+	bootDisk := findBootDisk(computeRec.Disks, computeRec.Chipset)
+
+	//check extraDisks, ipa_type, is,
+	d.SetId(strconv.FormatUint(computeRec.ID, 10))
+	// d.Set("acl", flattenACL(computeRec.ACL))
+	d.Set("account_id", computeRec.AccountID)
+	d.Set("account_name", computeRec.AccountName)
+	d.Set("affinity_weight", computeRec.AffinityWeight)
+	d.Set("arch", computeRec.Architecture)
+	d.Set("auto_start_w_node", computeRec.AutoStart)
+	d.Set("boot_order", computeRec.BootOrder)
+	// we intentionally use the SizeMax field, do not change it until the BootDiskSize field is fixed on the platform
+	d.Set("boot_disk_size", bootDisk.SizeMax)
+	d.Set("boot_disk", flattenBootDisk(bootDisk))
+	d.Set("boot_disk_id", bootDisk.ID)
+	d.Set("boot_image_id", computeRec.BootImageID)
+	d.Set("cd_image_id", computeRec.CdImageId)
+	d.Set("sep_id", bootDisk.SepID)
+	d.Set("pool", bootDisk.Pool)
+	d.Set("chipset", computeRec.Chipset)
+	d.Set("clock", computeRec.Clock)
+	d.Set("clone_reference", computeRec.CloneReference)
+	d.Set("clones", computeRec.Clones)
+	d.Set("computeci_id", computeRec.ComputeCIID)
+	d.Set("created_by", computeRec.CreatedBy)
+	d.Set("created_time", computeRec.CreatedTime)
+	// d.Set("custom_fields", flattenCustomFields(computeRec.CustomFields))
+	d.Set("deleted_by", computeRec.DeletedBy)
+	d.Set("deleted_time", computeRec.DeletedTime)
+	d.Set("description", computeRec.Description)
+	d.Set("devices", string(devices))
+	err := d.Set("disks", flattenComputeDisksDemo(computeRec.Disks, d.Get("disks").([]interface{}), d.Get("extra_disks").(*schema.Set).List(), bootDisk.ID))
+	if err != nil {
+		return err
+	}
+	d.Set("driver", computeRec.Driver)
+	d.Set("cpu", computeRec.CPU)
+	d.Set("gid", computeRec.GID)
+	d.Set("guid", computeRec.GUID)
+	d.Set("compute_id", computeRec.ID)
+	d.Set("image_id", computeRec.ImageID)
+	d.Set("interfaces", flattenInterfaces(computeRec.Interfaces))
+	d.Set("lock_status", computeRec.LockStatus)
+	d.Set("manager_id", computeRec.ManagerID)
+	d.Set("manager_type", computeRec.ManagerType)
+	d.Set("migrationjob", computeRec.MigrationJob)
+	d.Set("milestones", computeRec.Milestones)
+	d.Set("name", computeRec.Name)
+	d.Set("need_reboot", computeRec.NeedReboot)
+	d.Set("numa_node_id", computeRec.NumaNodeId)
+	d.Set("natable_vins_id", computeRec.NatableVINSID)
+	d.Set("natable_vins_ip", computeRec.NatableVINSIP)
+	d.Set("natable_vins_name", computeRec.NatableVINSName)
+	d.Set("natable_vins_network", computeRec.NatableVINSNetwork)
+	d.Set("natable_vins_network_name", computeRec.NatableVINSNetworkName)
+	if err := d.Set("os_users", parseOsUsers(computeRec.OSUsers)); err != nil {
+		return err
+	}
+	d.Set("pinned", computeRec.PinnedToNode)
+	d.Set("preferred_cpu", computeRec.PreferredCPU)
+	d.Set("ram", computeRec.RAM)
+	d.Set("reference_id", computeRec.ReferenceID)
+	d.Set("registered", computeRec.Registered)
+	d.Set("res_name", computeRec.ResName)
+	d.Set("reserved_node_cpus", computeRec.ReservedNodeCpus)
+	d.Set("rg_id", computeRec.RGID)
+	d.Set("rg_name", computeRec.RGName)
+	d.Set("snap_sets", flattenSnapSets(computeRec.SnapSets))
+	d.Set("stateless_sep_id", computeRec.StatelessSepID)
+	d.Set("stateless_sep_type", computeRec.StatelessSepType)
+	d.Set("status", computeRec.Status)
+	// d.Set("tags", flattenTags(computeRec.Tags))
+	d.Set("tech_status", computeRec.TechStatus)
+	d.Set("updated_by", computeRec.UpdatedBy)
+	d.Set("updated_time", computeRec.UpdatedTime)
+	d.Set("user_managed", computeRec.UserManaged)
+	d.Set("read_only", computeRec.ReadOnly)
+	d.Set("vnc_password", computeRec.VNCPassword)
+	d.Set("vgpus", flattenVGPUs(computeRec.VGPUs))
+	d.Set("loader_type", computeRec.LoaderType)
+	d.Set("boot_type", computeRec.BootType)
+	d.Set("hot_resize", computeRec.HotResize)
+	d.Set("network_interface_naming", computeRec.NetworkInterfaceNaming)
+	d.Set("zone_id", computeRec.ZoneID)
+	d.Set("loader_meta_iso", flattenLoaderMetaIso(computeRec.LoaderMetaIso))
+	d.Set("cpu_pin", computeRec.CPUPin)
+	d.Set("cpu_alignment_profile", computeRec.CPUAlignmentProfile.Name)
+	d.Set("numa_affinity", computeRec.NumaAffinity)
+	d.Set("hp_backed", computeRec.HPBacked)
+	d.Set("weight", computeRec.Weight)
+
+	d.Set("enabled", false)
+	if computeRec.Status == status.Enabled {
+		d.Set("enabled", true)
+	}
+
+	d.Set("started", false)
+	if computeRec.TechStatus == "STARTED" {
+		d.Set("started", true)
+	}
+
+	d.Set("network", flattenNetwork(d.Get("network").(*schema.Set).List(), computeRec.Interfaces))
+	d.Set("pci_devices", flattenPCI(*pciList))
+
+	d.Set("os_version", computeRec.OSVersion)
+
+	return nil
+}
+
+func flattenLoaderMetaIso(loaderMetaIso compute.LoaderMetaIso) []map[string]interface{} {
+	res := make([]map[string]interface{}, 0)
+	temp := map[string]interface{}{
+		"device_name": loaderMetaIso.DeviceName,
+		"path":        loaderMetaIso.Path,
+	}
+	res = append(res, temp)
+	return res
+}
+
+func flattenACL(acl compute.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 compute.ListRules) []map[string]interface{} {
+	res := make([]map[string]interface{}, 0, len(affinityRules))
+	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 compute.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 compute.SnapshotExtendList) []map[string]interface{} {
+	res := make([]map[string]interface{}, 0, len(snapshots))
+	for _, snapshot := range snapshots {
+		temp := map[string]interface{}{
+			"guid":          snapshot.GUID,
+			"label":         snapshot.Label,
+			"res_id":        snapshot.ResID,
+			"reference_id":  snapshot.ReferenceID,
+			"snap_set_guid": snapshot.SnapSetGUID,
+			"snap_set_time": snapshot.SnapSetTime,
+			"timestamp":     snapshot.TimeStamp,
+		}
+		res = append(res, temp)
+	}
+
+	return res
+}
+
+func flattenListComputeDisks(disks compute.ListComputeDisks) []map[string]interface{} {
+	res := make([]map[string]interface{}, 0, len(disks))
+	for _, disk := range disks {
+		acl, _ := json.Marshal(disk.ACL)
+		temp := map[string]interface{}{
+			"_ckey":                 disk.CKey,
+			"acl":                   string(acl),
+			"account_id":            disk.AccountID,
+			"discard":               disk.Discard,
+			"block_size":            disk.BlockSize,
+			"boot_partition":        disk.BootPartition,
+			"bus_number":            disk.BusNumber,
+			"created_time":          disk.CreatedTime,
+			"cache":                 disk.Cache,
+			"created_by":            disk.CreatedBy,
+			"deleted_time":          disk.DeletedTime,
+			"deleted_by":            disk.DeletedBy,
+			"devicename":            disk.DeviceName,
+			"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),
+			"independent":           disk.Independent,
+			"iqn":                   disk.IQN,
+			"login":                 disk.Login,
+			"milestones":            disk.Milestones,
+			"name":                  disk.Name,
+			"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,
+			"replication":           flattenDiskReplication(disk.Replication),
+			"reality_device_number": disk.RealityDeviceNumber,
+			"res_id":                disk.ResID,
+			"role":                  disk.Role,
+			"sep_id":                disk.SepID,
+			"shareable":             disk.Shareable,
+			"size_available":        disk.SizeAvailable,
+			"size_max":              disk.SizeMax,
+			"size_used":             disk.SizeUsed,
+			"snapshots":             flattenSnapshots(disk.Snapshots),
+			"status":                disk.Status,
+			"storage_policy_id":     disk.StoragePolicyID,
+			"tech_status":           disk.TechStatus,
+			"to_clean":              disk.ToClean,
+			"provision":             disk.Provision,
+			"updated_time":          disk.UpdatedTime,
+		}
+		res = append(res, temp)
+	}
+
+	return res
+}
+
+func flattenDiskReplication(rep compute.ItemReplication) []map[string]interface{} {
+	res := []map[string]interface{}{
+		{
+			"disk_id":        rep.DiskID,
+			"pool_id":        rep.PoolID,
+			"role":           rep.Role,
+			"self_volume_id": rep.SelfVolumeID,
+			"storage_id":     rep.StorageID,
+			"volume_id":      rep.VolumeID,
+		},
+	}
+	return res
+}
+
+func flattenCustomFields(customFields map[string]interface{}) string {
+	encoded, _ := json.Marshal(customFields)
+	return string(encoded)
+}
+
+func flattenOsUsers(osUsers compute.ListOSUser) []map[string]interface{} {
+	res := make([]map[string]interface{}, 0, len(osUsers))
+	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, computeRec compute.RecordCompute, pciList *compute.ListPCIDevices) {
+	devices, _ := json.Marshal(computeRec.Devices)
+	userdata, _ := json.Marshal(computeRec.Userdata)
+	d.Set("acl", flattenACL(computeRec.ACL))
+	d.Set("account_id", computeRec.AccountID)
+	d.Set("account_name", computeRec.AccountName)
+	d.Set("affinity_label", computeRec.AffinityLabel)
+	d.Set("affinity_rules", flattenAffinityRules(computeRec.AffinityRules))
+	d.Set("affinity_weight", computeRec.AffinityWeight)
+	d.Set("anti_affinity_rules", flattenListRules(computeRec.AntiAffinityRules))
+	d.Set("auto_start_w_node", computeRec.AutoStart)
+	d.Set("arch", computeRec.Architecture)
+	d.Set("chipset", computeRec.Chipset)
+	d.Set("clock", computeRec.Clock)
+	d.Set("boot_order", computeRec.BootOrder)
+	d.Set("bootdisk_size", computeRec.BootDiskSize)
+	d.Set("boot_image_id", computeRec.BootImageID)
+	d.Set("cd_image_id", computeRec.CdImageId)
+	d.Set("clone_reference", computeRec.CloneReference)
+	d.Set("clones", computeRec.Clones)
+	d.Set("computeci_id", computeRec.ComputeCIID)
+	d.Set("cpu_pin", computeRec.CPUPin)
+	d.Set("cpus", computeRec.CPU)
+	d.Set("created_by", computeRec.CreatedBy)
+	d.Set("created_time", computeRec.CreatedTime)
+	d.Set("custom_fields", flattenCustomFields(computeRec.CustomFields))
+	d.Set("deleted_by", computeRec.DeletedBy)
+	d.Set("deleted_time", computeRec.DeletedTime)
+	d.Set("desc", computeRec.Description)
+	d.Set("devices", string(devices))
+	d.Set("disks", flattenListComputeDisks(computeRec.Disks))
+	d.Set("driver", computeRec.Driver)
+	d.Set("gid", computeRec.GID)
+	d.Set("guid", computeRec.GUID)
+	d.Set("hp_backed", computeRec.HPBacked)
+	d.Set("compute_id", computeRec.ID)
+	d.Set("image_id", computeRec.ImageID)
+	d.Set("image_name", computeRec.ImageName)
+	d.Set("interfaces", flattenInterfaces(computeRec.Interfaces))
+	d.Set("live_migration_job_id", computeRec.LiveMigrationJobID)
+	d.Set("lock_status", computeRec.LockStatus)
+	d.Set("manager_id", computeRec.ManagerID)
+	d.Set("manager_type", computeRec.ManagerType)
+	d.Set("migrationjob", computeRec.MigrationJob)
+	d.Set("milestones", computeRec.Milestones)
+	d.Set("name", computeRec.Name)
+	d.Set("need_reboot", computeRec.NeedReboot)
+	d.Set("numa_affinity", computeRec.NumaAffinity)
+	d.Set("numa_node_id", computeRec.NumaNodeId)
+	d.Set("natable_vins_id", computeRec.NatableVINSID)
+	d.Set("natable_vins_ip", computeRec.NatableVINSIP)
+	d.Set("natable_vins_name", computeRec.NatableVINSName)
+	d.Set("natable_vins_network", computeRec.NatableVINSNetwork)
+	d.Set("natable_vins_network_name", computeRec.NatableVINSNetworkName)
+	d.Set("os_users", flattenOsUsers(computeRec.OSUsers))
+	d.Set("pinned", computeRec.PinnedToNode)
+	d.Set("preferred_CPU", computeRec.PreferredCPU)
+	d.Set("qemu_guest", flattenQemuQuest(computeRec.QemuQuest))
+	d.Set("ram", computeRec.RAM)
+	d.Set("reference_id", computeRec.ReferenceID)
+	d.Set("registered", computeRec.Registered)
+	d.Set("res_name", computeRec.ResName)
+	d.Set("reserved_node_cpus", computeRec.ReservedNodeCpus)
+	d.Set("rg_id", computeRec.RGID)
+	d.Set("rg_name", computeRec.RGName)
+	d.Set("snap_sets", flattenSnapSets(computeRec.SnapSets))
+	d.Set("stateless_sep_id", computeRec.StatelessSepID)
+	d.Set("stateless_sep_type", computeRec.StatelessSepType)
+	d.Set("status", computeRec.Status)
+	d.Set("tags", computeRec.Tags)
+	d.Set("tech_status", computeRec.TechStatus)
+	d.Set("updated_by", computeRec.UpdatedBy)
+	d.Set("updated_time", computeRec.UpdatedTime)
+	d.Set("user_managed", computeRec.UserManaged)
+	d.Set("read_only", computeRec.ReadOnly)
+	d.Set("userdata", string(userdata))
+	d.Set("vnc_password", computeRec.VNCPassword)
+	d.Set("vgpus", flattenVGPUs(computeRec.VGPUs))
+	d.Set("pci_devices", flattenPCI(*pciList))
+	d.Set("loader_type", computeRec.LoaderType)
+	d.Set("boot_type", computeRec.BootType)
+	d.Set("hot_resize", computeRec.HotResize)
+	d.Set("network_interface_naming", computeRec.NetworkInterfaceNaming)
+	d.Set("zone_id", computeRec.ZoneID)
+	d.Set("loader_meta_iso", flattenLoaderMetaIso(computeRec.LoaderMetaIso))
+	d.Set("os_version", computeRec.OSVersion)
+	d.Set("cpu_alignment_profiles", flattenCPUAlignmentProfile(computeRec.CPUAlignmentProfile))
+	d.Set("weight", computeRec.Weight)
+}
+
+func flattenCPUAlignmentProfile(profile compute.CPUAlignmentProfile) []map[string]interface{} {
+	if profile.Name == "" && profile.Model == "" && profile.Vendor == "" {
+		return nil
+	}
+	return []map[string]interface{}{
+		{
+			"name":   profile.Name,
+			"model":  profile.Model,
+			"vendor": profile.Vendor,
+		},
+	}
+}
+
+func flattenPCI(pciList compute.ListPCIDevices) []uint64 {
+	res := make([]uint64, 0, len(pciList.Data))
+
+	for _, v := range pciList.Data {
+		res = append(res, v.ID)
+	}
+
+	return res
+}
+
+func flattenComputeAudits(computeAudits compute.ListAudits) []map[string]interface{} {
+	res := make([]map[string]interface{}, 0, len(computeAudits.Data))
+	for _, computeAudit := range computeAudits.Data {
+		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 *compute.ListPFWs) []map[string]interface{} {
+	res := make([]map[string]interface{}, 0, len(computePfws.Data))
+	for _, computePfw := range computePfws.Data {
+		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 *compute.ListUsers) {
+	d.Set("account_acl", flattenListACL(userList.Data.AccountACL))
+	d.Set("compute_acl", flattenListACL(userList.Data.ComputeACL))
+	d.Set("rg_acl", flattenListACL(userList.Data.RGACL))
+}
+
+func flattenComputeGetAudits(computeAudits compute.ListShortAudits) []map[string]interface{} {
+	res := make([]map[string]interface{}, 0, len(computeAudits))
+	for _, computeAudit := range computeAudits {
+		temp := map[string]interface{}{
+			"epoch":   computeAudit.Epoch,
+			"message": computeAudit.Message,
+		}
+		res = append(res, temp)
+	}
+	return res
+}
+
+func flattenSnapshotUsage(computeSnapshotUsages compute.ListUsageSnapshots) []map[string]interface{} {
+	res := make([]map[string]interface{}, 0, len(computeSnapshotUsages))
+	for _, computeUsage := range computeSnapshotUsages {
+		temp := map[string]interface{}{
+			"count":     computeUsage.Count,
+			"stored":    computeUsage.Stored,
+			"label":     computeUsage.Label,
+			"timestamp": computeUsage.Timestamp,
+		}
+		res = append(res, temp)
+	}
+	return res
+}
+
+// func flattenSnapshotList(computeSnapshotUsages *compute.ListSnapShots) []map[string]interface{} {
+// 	res := make([]map[string]interface{}, 0, len(computeSnapshotUsages.Data))
+// 	for _, computeUsage := range computeSnapshotUsages.Data {
+// 		temp := map[string]interface{}{
+// 			"disks":     computeUsage.Disks,
+// 			"guid":      computeUsage.GUID,
+// 			"label":     computeUsage.Label,
+// 			"timestamp": computeUsage.Timestamp,
+// 		}
+// 		res = append(res, temp)
+// 	}
+// 	return res
+// }
+
+func flattenVGPU(vgpuList []compute.ItemVGPU) []map[string]interface{} {
+	res := make([]map[string]interface{}, 0, len(vgpuList))
+	for _, dev := range vgpuList {
+		temp := map[string]interface{}{
+			"account_id":       dev.AccountID,
+			"created_time":     dev.CreatedTime,
+			"deleted_time":     dev.DeletedTime,
+			"gid":              dev.GID,
+			"guid":             dev.GUID,
+			"vgpu_id":          dev.ID,
+			"last_claimed_by":  dev.LastClaimedBy,
+			"last_update_time": dev.LastUpdateTime,
+			"mode":             dev.Mode,
+			"pci_slot":         dev.PCISlot,
+			"pgpuid":           dev.PGPUID,
+			"profile_id":       dev.ProfileID,
+			"ram":              dev.RAM,
+			"reference_id":     dev.ReferenceID,
+			"rg_id":            dev.RGID,
+			"status":           dev.Status,
+			"type":             dev.Type,
+			"vm_id":            dev.VMID,
+		}
+		res = append(res, temp)
+	}
+	return res
+}
+
+func flattenPCIDevice(deviceList []compute.ItemPCIDevice) []map[string]interface{} {
+	res := make([]map[string]interface{}, 0, len(deviceList))
+	for _, dev := range deviceList {
+		temp := map[string]interface{}{
+			"compute_id":  dev.ComputeID,
+			"description": dev.Description,
+			"guid":        dev.GUID,
+			"hwpath":      dev.HwPath,
+			"device_id":   dev.ID,
+			"name":        dev.Name,
+			"rg_id":       dev.RGID,
+			"node_id":     dev.NodeID,
+			"status":      dev.Status,
+			"system_name": dev.SystemName,
+		}
+		res = append(res, temp)
+	}
+	return res
+}
+
+func flattenVGPUs(vgpus []compute.VGPUItem) []map[string]interface{} {
+	res := make([]map[string]interface{}, len(vgpus))
+
+	for i, vgpu := range vgpus {
+
+		res[i] = map[string]interface{}{
+			"id":               int(vgpu.ID),
+			"gid":              int(vgpu.GID),
+			"type":             vgpu.Type,
+			"mode":             vgpu.Mode,
+			"status":           vgpu.Status,
+			"profile_id":       vgpu.ProfileID,
+			"ram":              int(vgpu.RAM),
+			"last_update_time": int(vgpu.LastUpdateTime),
+			"created_time":     int(vgpu.CreatedTime),
+			"deleted_time":     int(vgpu.DeletedTime),
+			"vmid":             int(vgpu.VMID),
+			"pgpuid":           int(vgpu.PGPuid),
+			"reference_id":     vgpu.ReferenceID,
+			"account_id":       int(vgpu.AccountID),
+			"rg_id":            int(vgpu.RgID),
+			"last_claimed_by":  int(vgpu.LastClaimedBy),
+			"pci_slot":         int(vgpu.PCISlot),
+			"bus_number":       int(vgpu.BusNumber),
+			"guid":             int(vgpu.GUID),
+		}
+	}
+
+	return res
+}
+
+func flattenQemuQuest(qemuQuest compute.QemuQuest) []map[string]interface{} {
+	res := make([]map[string]interface{}, 0)
+
+	temp := map[string]interface{}{
+		"enabled":                qemuQuest.Enabled,
+		"enabled_agent_features": qemuQuest.EnabledAgentFeatures,
+		"guid":                   qemuQuest.GUID,
+		"last_update":            uint64(qemuQuest.LastUpdate),
+		"user":                   qemuQuest.User,
+	}
+
+	res = append(res, temp)
+
+	return res
+}

internal/service/cloudapi/kvmvm/models.go

@@ -0,0 +1,10 @@
+package kvmvm
+
+type updatedNetwork struct {
+	DetachMap    []map[string]interface{}
+	ChangeIPMap  []map[string]interface{}
+	ChangeMacMap []map[string]interface{}
+	ChangeMTUMap []map[string]interface{}
+	AttachMap    []map[string]interface{}
+	EnableMap    []map[string]interface{}
+}

internal/service/cloudapi/kvmvm/network_subresource.go

@@ -0,0 +1,196 @@
+/*
+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>
+Tim Tkachev, <tvtkachev@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 kvmvm
+
+import (
+	"bytes"
+	"hash/fnv"
+
+	log "github.com/sirupsen/logrus"
+	"repository.basistech.ru/BASIS/terraform-provider-decort/internal/statefuncs"
+
+	"sort"
+
+	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
+	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/validation"
+)
+
+// This is subresource of compute resource used when creating/managing compute network connections
+
+func networkSubresIPAddreDiffSupperss(key, oldVal, newVal string, d *schema.ResourceData) bool {
+	if newVal != "" && newVal != oldVal {
+		log.Debugf("networkSubresIPAddreDiffSupperss: key=%s, oldVal=%q, newVal=%q -> suppress=FALSE", key, oldVal, newVal)
+		return false
+	}
+	log.Debugf("networkSubresIPAddreDiffSupperss: key=%s, oldVal=%q, newVal=%q -> suppress=TRUE", key, oldVal, newVal)
+	return true // suppress difference
+}
+
+// This function is based on the original Terraform SerializeResourceForHash found
+// in helper/schema/serialize.go
+// It skips network subresource attributes, which are irrelevant for identification
+// of unique network blocks
+func networkSubresourceSerialize(output *bytes.Buffer, val interface{}, resource *schema.Resource) {
+	if val == nil {
+		return
+	}
+
+	rs := resource.Schema
+	m := val.(map[string]interface{})
+
+	keys := make([]string, 0, len(rs))
+	allComputed := true
+
+	for k, val := range rs {
+		if val.Optional || val.Required {
+			allComputed = false
+		}
+
+		keys = append(keys, k)
+	}
+
+	sort.Strings(keys)
+	for _, k := range keys {
+		// explicitly ignore "ip_address" when hashing
+		if k == "ip_address" {
+			continue
+		}
+
+		subSchema := rs[k]
+		// Skip attributes that are not user-provided. Computed attributes
+		// do not contribute to the hash since their ultimate value cannot
+		// be known at plan/diff time.
+		if !allComputed && !(subSchema.Required || subSchema.Optional) {
+			continue
+		}
+
+		output.WriteString(k)
+		output.WriteRune(':')
+		value := m[k]
+		schema.SerializeValueForHash(output, value, subSchema)
+	}
+}
+
+// HashNetworkSubresource hashes network subresource of compute resource. It uses
+// specially designed networkSubresourceSerialize (see above) to make sure hashing
+// does not involve attributes that we deem irrelevant to the uniqueness of network
+// subresource definitions.
+// It is this function that should be specified as SchemaSetFunc when creating Set
+// from network subresource (e.g. in flattenCompute)
+//
+// This function is based on the original Terraform function HashResource from
+// helper/schema/set.go
+func HashNetworkSubresource(resource *schema.Resource) schema.SchemaSetFunc {
+	return func(v interface{}) int {
+		var serialized bytes.Buffer
+		networkSubresourceSerialize(&serialized, v, resource)
+
+		hs := fnv.New32a()
+		hs.Write(serialized.Bytes())
+		return int(hs.Sum32())
+	}
+}
+
+func networkSubresourceSchemaMake() map[string]*schema.Schema {
+	rets := map[string]*schema.Schema{
+		"net_type": {
+			Type:         schema.TypeString,
+			Required:     true,
+			StateFunc:    statefuncs.StateFuncToUpper,
+			ValidateFunc: validation.StringInSlice([]string{"EXTNET", "VINS", "VFNIC", "DPDK", "SDN", "TRUNK"}, false), // observe case while validating
+			Description:  "Type of the network for this connection",
+		},
+
+		"net_id": {
+			Type:        schema.TypeInt,
+			Required:    true,
+			Description: "ID of the network for this connection.",
+		},
+
+		"ip_address": {
+			Type:             schema.TypeString,
+			Optional:         true,
+			Computed:         true,
+			DiffSuppressFunc: networkSubresIPAddreDiffSupperss,
+			Description:      "Optional IP address to assign to this connection. This IP should belong to the selected network and free for use.",
+		},
+
+		"mac": {
+			Type:             schema.TypeString,
+			Optional:         true,
+			Computed:         true,
+			DiffSuppressFunc: networkSubresIPAddreDiffSupperss,
+			Description:      "MAC address associated with this connection. MAC address is assigned automatically.",
+		},
+
+		"weight": {
+			Type:        schema.TypeInt,
+			Optional:    true,
+			Computed:    true,
+			Description: "weight the network if you need to sort network list, the smallest attach first. zero or null weight attach last",
+		},
+
+		"mtu": {
+			Type:     schema.TypeInt,
+			Optional: true,
+			Computed: true,
+			//Default:      1500,
+			ValidateFunc: validation.IntBetween(1500, 9216),
+			Description:  "Maximum transmission unit, used only for DPDK type, must be 1500-9216",
+		},
+
+		"sdn_interface_id": {
+			Type:             schema.TypeString,
+			Optional:         true,
+			Computed:         true,
+			DiffSuppressFunc: networkSubresIPAddreDiffSupperss,
+			Description:      "unique_identifier of LogicalPort on SDN side",
+		},
+
+		"enabled": {
+			Type:        schema.TypeBool,
+			Optional:    true,
+			Computed:    true,
+			Description: "network enable flag",
+		},
+
+		"net_mask": {
+			Type:        schema.TypeInt,
+			Optional:    true,
+			Computed:    true,
+			Description: "Subnet mask, used only for DPDK and VFNIC network types",
+		},
+	}
+	return rets
+}

internal/service/cloudapi/kvmvm/osusers_subresource.go

@@ -0,0 +1,88 @@
+/*
+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 kvmvm
+
+import (
+	log "github.com/sirupsen/logrus"
+	"repository.basistech.ru/BASIS/decort-golang-sdk/pkg/cloudapi/compute"
+
+	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
+)
+
+func parseOsUsers(logins compute.ListOSUser) []interface{} {
+	var result = make([]interface{}, len(logins))
+
+	for index, value := range logins {
+		elem := make(map[string]interface{})
+
+		elem["guid"] = value.GUID
+		elem["login"] = value.Login
+		elem["password"] = value.Password
+		elem["public_key"] = value.PubKey
+		result[index] = elem
+		log.Debugf("parseOsUsers: parsed element %d - login %q", index, value.Login)
+	}
+
+	return result
+}
+
+func osUsersSubresourceSchemaMake() map[string]*schema.Schema {
+	rets := map[string]*schema.Schema{
+		"guid": {
+			Type:        schema.TypeString,
+			Computed:    true,
+			Description: "GUID of this guest OS user.",
+		},
+
+		"login": {
+			Type:        schema.TypeString,
+			Computed:    true,
+			Description: "Login name of this guest OS user.",
+		},
+
+		"password": {
+			Type:     schema.TypeString,
+			Computed: true,
+			//Sensitive:   true,
+			Description: "Password of this guest OS user.",
+		},
+
+		"public_key": {
+			Type:        schema.TypeString,
+			Computed:    true,
+			Description: "SSH public key of this guest OS user.",
+		},
+	}
+
+	return rets
+}

internal/service/cloudapi/kvmvm/resource_check_input_values.go

@@ -0,0 +1,184 @@
+/*
+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>
+Tim Tkachev, <tvtkachev@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 kvmvm
+
+import (
+	"context"
+
+	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
+	log "github.com/sirupsen/logrus"
+	"repository.basistech.ru/BASIS/decort-golang-sdk/pkg/cloudapi/dpdknet"
+	"repository.basistech.ru/BASIS/decort-golang-sdk/pkg/cloudapi/extnet"
+	"repository.basistech.ru/BASIS/decort-golang-sdk/pkg/cloudapi/image"
+	"repository.basistech.ru/BASIS/decort-golang-sdk/pkg/cloudapi/rg"
+	"repository.basistech.ru/BASIS/decort-golang-sdk/pkg/cloudapi/trunk"
+	"repository.basistech.ru/BASIS/decort-golang-sdk/pkg/cloudapi/vfpool"
+	"repository.basistech.ru/BASIS/decort-golang-sdk/pkg/cloudapi/vins"
+	"repository.basistech.ru/BASIS/terraform-provider-decort/internal/controller"
+)
+
+func existRgID(ctx context.Context, d *schema.ResourceData, m interface{}) (bool, error) {
+	c := m.(*controller.ControllerCfg)
+	rgId := uint64(d.Get("rg_id").(int))
+	req := rg.ListRequest{
+		IncludeDeleted: false,
+	}
+
+	rgList, err := c.CloudAPI().RG().List(ctx, req)
+	if err != nil {
+		return false, err
+	}
+
+	return len(rgList.FilterByID(rgId).Data) != 0, nil
+}
+
+func existImageId(ctx context.Context, d *schema.ResourceData, m interface{}) (bool, error) {
+	c := m.(*controller.ControllerCfg)
+	imageId := uint64(d.Get("image_id").(int))
+	req := image.ListRequest{
+		ByID: imageId,
+	}
+
+	imageList, err := c.CloudAPI().Image().List(ctx, req)
+	if err != nil {
+		return false, err
+	}
+
+	return len(imageList.Data) != 0, nil
+}
+
+func existVinsIdInList(vinsId uint64, vinsList *vins.ListVINS) bool {
+	for _, vins := range vinsList.Data {
+		if vinsId == vins.ID {
+			return true
+		}
+	}
+
+	return false
+}
+
+func existExtNetIdInList(extId uint64, extList *extnet.ListExtNets) bool {
+	for _, ext := range extList.Data {
+		if extId == ext.ID {
+			return true
+		}
+	}
+
+	return false
+}
+
+func existVinsId(ctx context.Context, m interface{}, id int) (int, bool) {
+	c := m.(*controller.ControllerCfg)
+	req := vins.ListRequest{IncludeDeleted: false}
+
+	vinsList, err := c.CloudAPI().VINS().List(ctx, req)
+	if err != nil {
+		log.Debugf("Unable to retrieve ViNS list, %s", err)
+		return 0, false
+	}
+
+	if !existVinsIdInList(uint64(id), vinsList) {
+		return id, false
+	}
+
+	return 0, true
+}
+
+func existExtNetId(ctx context.Context, m interface{}, id int) (int, bool) {
+	c := m.(*controller.ControllerCfg)
+	req := extnet.ListRequest{}
+
+	extNetList, err := c.CloudAPI().ExtNet().List(ctx, req)
+	if err != nil {
+		log.Debugf("Unable to retrieve extnet list, %s", err)
+		return 0, false
+	}
+
+	if !existExtNetIdInList(uint64(id), extNetList) {
+		return id, false
+	}
+
+	return 0, true
+}
+
+func existVFPoolId(ctx context.Context, m interface{}, id int) (int, bool) {
+	c := m.(*controller.ControllerCfg)
+	req := vfpool.ListRequest{ByID: uint64(id)}
+
+	vfpoolList, err := c.CloudAPI().VFPool().List(ctx, req)
+	if err != nil {
+		log.Debugf("Unable to retrieve vfpool list, %s", err)
+		return id, false
+	}
+
+	if len(vfpoolList.Data) == 1 {
+		return 0, true
+	}
+
+	return id, false
+}
+
+func existDPDKNetId(ctx context.Context, m interface{}, id int) (int, bool) {
+	c := m.(*controller.ControllerCfg)
+	req := dpdknet.ListRequest{ByID: uint64(id)}
+
+	dpdkList, err := c.CloudAPI().DPDKNet().List(ctx, req)
+	if err != nil {
+		log.Debugf("Unable to retrieve dpdk list, %s", err)
+		return id, false
+	}
+
+	if len(dpdkList.Data) == 1 {
+		return 0, true
+	}
+
+	return id, false
+}
+
+func existTRUNKId(ctx context.Context, m interface{}, id int) (int, bool) {
+	c := m.(*controller.ControllerCfg)
+	req := trunk.ListRequest{IDs: []uint64{uint64(id)}}
+
+	trunkList, err := c.CloudAPI().Trunk().List(ctx, req)
+	if err != nil {
+		log.Debugf("Unable to retrieve trunk list, %s", err)
+		return id, false
+	}
+
+	if len(trunkList.Data) == 1 {
+		return 0, true
+	}
+
+	return id, false
+}

internal/service/cloudapi/kvmvm/state_upgraders.go

@@ -0,0 +1,64 @@
+package kvmvm
+
+import (
+	"context"
+	"fmt"
+	"strings"
+
+	log "github.com/sirupsen/logrus"
+)
+
+func resourceCompueteStateUpgradeV1(ctx context.Context, rawState map[string]interface{}, meta any) (map[string]interface{}, error) {
+	log.Debug("resourceCompueteStateUpgradeV1: upgrading state")
+	customFields, ok := rawState["custom_fields"]
+	if !ok || customFields == nil {
+		rawState["custom_fields"] = "{}"
+		return rawState, nil
+	}
+
+	b := &strings.Builder{}
+	b.WriteString("{")
+	oldCustomFieldsSlice := customFields.([]interface{})
+	for i := range oldCustomFieldsSlice {
+		oldCustomFields := oldCustomFieldsSlice[i].(map[string]interface{})
+		b.WriteString(fmt.Sprintf(`"%s":"%s"`, oldCustomFields["key"], oldCustomFields["val"]))
+		if i < len(oldCustomFieldsSlice)-1 {
+			b.WriteString(",")
+		}
+	}
+	b.WriteString("}")
+	rawState["custom_fields"] = b.String()
+
+	return rawState, nil
+}
+
+func resourceComputeStateUpgradeV2(ctx context.Context, rawState map[string]interface{}, meta any) (map[string]interface{}, error) {
+	log.Debug("resourceComputeStateUpgradeV2: upgrading state")
+
+	delete(rawState, "with_default_vins")
+
+	return rawState, nil
+}
+
+func resourceComputeStateUpgradeV3(ctx context.Context, rawState map[string]interface{}, meta any) (map[string]interface{}, error) {
+	log.Debug("resourceComputeStateUpgradeV3: upgrading state")
+
+	for _, blockKey := range []string{"disks", "boot_disk"} {
+		if items, ok := rawState[blockKey].([]interface{}); ok {
+			for _, item := range items {
+				if disk, ok := item.(map[string]interface{}); ok {
+					if v, ok := disk["blk_discard"].(bool); ok {
+						if v {
+							disk["discard"] = "unmap"
+						} else {
+							disk["discard"] = "ignore"
+						}
+					}
+					delete(disk, "blk_discard")
+				}
+			}
+		}
+	}
+
+	return rawState, nil
+}

internal/service/cloudapi/kvmvm/utility_compute.go

@@ -0,0 +1,722 @@
+/*
+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 kvmvm
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"regexp"
+	"sort"
+	"strconv"
+
+	"github.com/hashicorp/go-cty/cty"
+	log "github.com/sirupsen/logrus"
+	"repository.basistech.ru/BASIS/decort-golang-sdk/pkg/cloudapi/compute"
+	"repository.basistech.ru/BASIS/decort-golang-sdk/pkg/cloudapi/disks"
+	"repository.basistech.ru/BASIS/terraform-provider-decort/internal/controller"
+
+	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
+)
+
+func matchComputes(computeList *compute.ListComputes) *compute.ListComputes {
+	matched, _ := regexp.Compile(`[a-zA-Z]+\\d+-[a-zA-Z]+\\d+-[a-zA-Z]+\\d+`)
+	result := computeList.FilterFunc(func(ic compute.ItemCompute) bool {
+		res := matched.Match([]byte(ic.Name))
+		return !res
+	})
+
+	return &result
+}
+
+func utilityComputeExtraDisksConfigure(ctx context.Context, d *schema.ResourceData, m interface{}, do_delta bool, disks compute.ListComputeDisks) error {
+	c := m.(*controller.ControllerCfg)
+
+	log.Debugf("utilityComputeExtraDisksConfigure: called for Compute ID %s with do_delta = %t", d.Id(), do_delta)
+
+	old_set, new_set := d.GetChange("extra_disks")
+
+	apiErrCount := 0
+	var lastSavedError error
+
+	if !do_delta {
+		if new_set.(*schema.Set).Len() < 1 {
+			return nil
+		}
+
+		for _, disk := range new_set.(*schema.Set).List() {
+			computeId, _ := strconv.ParseUint(d.Id(), 10, 64)
+			req := compute.DiskAttachRequest{
+				ComputeID: computeId,
+				DiskID:    uint64(disk.(int)),
+			}
+
+			_, err := c.CloudAPI().Compute().DiskAttach(ctx, req)
+			if err != nil {
+				apiErrCount++
+				lastSavedError = err
+			}
+		}
+
+		if apiErrCount > 0 {
+			log.Errorf("utilityComputeExtraDisksConfigure: there were %d error(s) when attaching disks to Compute ID %s. Last error was: %s",
+				apiErrCount, d.Id(), lastSavedError)
+			return lastSavedError
+		}
+
+		return nil
+	}
+
+	detach_set := old_set.(*schema.Set).Difference(new_set.(*schema.Set))
+	log.Debugf("utilityComputeExtraDisksConfigure: detach set has %d items for Compute ID %s", detach_set.Len(), d.Id())
+
+	if detach_set.Len() > 0 {
+		computeId, _ := strconv.ParseUint(d.Id(), 10, 64)
+
+		for _, diskId := range detach_set.List() {
+			req := compute.DiskDetachRequest{
+				ComputeID: computeId,
+				DiskID:    uint64(diskId.(int)),
+			}
+			_, err := c.CloudAPI().Compute().DiskDetach(ctx, req)
+			if err != nil {
+				log.Errorf("utilityComputeExtraDisksConfigure: failed to detach disk ID %d from Compute ID %s: %s", diskId.(int), d.Id(), err)
+				apiErrCount++
+				lastSavedError = err
+			}
+		}
+
+	}
+
+	attach_set := new_set.(*schema.Set).Difference(old_set.(*schema.Set))
+	log.Debugf("utilityComputeExtraDisksConfigure: attach set has %d items for Compute ID %s", attach_set.Len(), d.Id())
+	for _, diskId := range attach_set.List() {
+		computeId, _ := strconv.ParseUint(d.Id(), 10, 64)
+		req := compute.DiskAttachRequest{
+			ComputeID: computeId,
+			DiskID:    uint64(diskId.(int)),
+		}
+
+		log.Debug("before attach HERE0")
+
+		flag := false
+
+		// check if there is an extra disk in the disks from the platform, so as not to attach it if it is already attached
+		for _, elem := range disks {
+			if elem.ID == uint64(diskId.(int)) {
+				flag = true
+				break
+			}
+		}
+
+		if flag {
+			continue
+		}
+
+		_, err := c.CloudAPI().Compute().DiskAttach(ctx, req)
+		if err != nil {
+			log.Errorf("utilityComputeExtraDisksConfigure: failed to attach disk ID %d to Compute ID %s: %s", diskId.(int), d.Id(), err)
+			apiErrCount++
+			lastSavedError = err
+		}
+	}
+
+	if apiErrCount > 0 {
+		log.Errorf("utilityComputeExtraDisksConfigure: there were %d error(s) when managing disks of Compute ID %s. Last error was: %s",
+			apiErrCount, d.Id(), lastSavedError)
+		return lastSavedError
+	}
+
+	return nil
+}
+
+func utilityComputeNetworksConfigure(ctx context.Context, d *schema.ResourceData, m interface{}) error {
+	c := m.(*controller.ControllerCfg)
+
+	oldSet, newSet := d.GetChange("network")
+
+	oldList := oldSet.(*schema.Set).List()
+	newList := newSet.(*schema.Set).List()
+
+	updateNetwork := differenceNetwork(oldList, newList)
+
+	apiErrCount := 0
+	var lastSavedError error
+
+	log.Debugf("utilityComputeNetworksConfigure: detach set has %d items for Compute ID %s", len(updateNetwork.DetachMap), d.Id())
+	for _, netData := range updateNetwork.DetachMap {
+		computeId, _ := strconv.ParseUint(d.Id(), 10, 64)
+		req := compute.NetDetachRequest{
+			ComputeID: computeId,
+			IPAddr:    netData["ip_address"].(string),
+			MAC:       netData["mac"].(string),
+		}
+
+		_, err := c.CloudAPI().Compute().NetDetach(ctx, req)
+		if err != nil {
+			log.Errorf("utilityComputeNetworksConfigure: failed to detach net ID %d of type %s from Compute ID %s: %s",
+				netData["net_id"].(int), netData["net_type"].(string), d.Id(), err)
+			apiErrCount++
+			lastSavedError = err
+		}
+	}
+
+	log.Debugf("utilityComputeNetworksConfigure: changeIp set has %d items for Compute ID %s", len(updateNetwork.ChangeIPMap), d.Id())
+	for _, netData := range updateNetwork.ChangeIPMap {
+		computeId, _ := strconv.ParseUint(d.Id(), 10, 64)
+		req := compute.ChangeIPRequest{
+			ComputeID: computeId,
+			NetType:   netData["net_type"].(string),
+			NetID:     uint64(netData["net_id"].(int)),
+			IPAddr:    netData["ip_address"].(string),
+		}
+
+		_, err := c.CloudAPI().Compute().ChangeIP(ctx, req)
+		if err != nil {
+			log.Errorf("utilityComputeNetworksConfigure: failed to change net ID %d of type %s from Compute ID %s: %s",
+				netData["net_id"].(int), netData["net_type"].(string), d.Id(), err)
+			apiErrCount++
+			lastSavedError = err
+		}
+	}
+
+	needStart := false
+
+	if oldSet.(*schema.Set).Len() == len(updateNetwork.DetachMap) || oldSet.(*schema.Set).Len() == 0 || hasDPDKnetwork(updateNetwork.AttachMap) || len(updateNetwork.ChangeMacMap) != 0 {
+		computeId, _ := strconv.ParseUint(d.Id(), 10, 64)
+		if err := utilityComputeStop(ctx, computeId, m); err != nil {
+			apiErrCount++
+			lastSavedError = err
+		}
+		if start := d.Get("started"); start.(bool) {
+			needStart = true
+		}
+	}
+
+	log.Debugf("utilityComputeNetworksConfigure: changeMac set has %d items for Compute ID %s", len(updateNetwork.ChangeMacMap), d.Id())
+	for _, netData := range updateNetwork.ChangeMacMap {
+		computeId, _ := strconv.ParseUint(d.Id(), 10, 64)
+		req := compute.ChangeMACRequest{
+			ComputeID:  computeId,
+			NewMAC:     netData["mac"].(string),
+			СurrentMAC: netData["old_mac"].(string),
+		}
+
+		_, err := c.CloudAPI().Compute().ChangeMAC(ctx, req)
+		if err != nil {
+			log.Errorf("utilityComputeNetworksConfigure: failed to change mac %s to  %s from Compute ID %s: %s",
+				req.СurrentMAC, req.NewMAC, d.Id(), err)
+			apiErrCount++
+			lastSavedError = err
+		}
+	}
+
+	sort.Slice(updateNetwork.AttachMap, func(i, j int) bool {
+		weightI := updateNetwork.AttachMap[i]["weight"].(int)
+		weightJ := updateNetwork.AttachMap[j]["weight"].(int)
+		if weightI == 0 {
+			return false
+		}
+		if weightJ == 0 {
+			return true
+		}
+		return weightI < weightJ
+	})
+
+	log.Debugf("utilityComputeNetworksConfigure: attach set has %d items for Compute ID %s", len(updateNetwork.AttachMap), d.Id())
+	for _, netData := range updateNetwork.AttachMap {
+		computeId, _ := strconv.ParseUint(d.Id(), 10, 64)
+		req := compute.NetAttachRequest{
+			ComputeID: computeId,
+			NetType:   netData["net_type"].(string),
+			NetID:     uint64(netData["net_id"].(int)),
+		}
+
+		if netData["ip_address"].(string) != "" {
+			req.IPAddr = netData["ip_address"].(string)
+		}
+
+		if netData["mac"].(string) != "" {
+			req.MACAddr = netData["mac"].(string)
+		}
+
+		if netData["sdn_interface_id"].(string) != "" {
+			req.SDNInterfaceID = netData["sdn_interface_id"].(string)
+		}
+
+		if enabledNetwork(d.GetRawConfig().GetAttr("network"), req.NetID, req.NetType) {
+			req.Enabled = netData["enabled"].(bool)
+		}
+
+		if req.NetType == "DPDK" || req.NetType == "EXTNET" {
+			req.MTU = uint64(netData["mtu"].(int))
+		}
+
+		if req.NetType == "DPDK" || req.NetType == "VFNIC" {
+			if netMask, ok := netData["net_mask"].(int); ok && netMask > 0 {
+				req.NetMask = uint64(netMask)
+			}
+		}
+
+		_, err := c.CloudAPI().Compute().NetAttach(ctx, req)
+		if err != nil {
+			log.Errorf("utilityComputeNetworksConfigure: failed to attach net ID %d of type %s to Compute ID %s: %s",
+				netData["net_id"].(int), netData["net_type"].(string), d.Id(), err)
+			apiErrCount++
+			lastSavedError = err
+		}
+	}
+
+	if needStart {
+		computeId, _ := strconv.ParseUint(d.Id(), 10, 64)
+		var altBootID uint64
+		if altBootIDRaw, ok := d.Get("alt_boot_id").(int); ok {
+			altBootID = uint64(altBootIDRaw)
+		} else {
+			altBootID = 0
+		}
+		if numErr, err := utilityComputeStart(ctx, computeId, altBootID, m); err != nil {
+			apiErrCount += numErr
+			lastSavedError = err
+		}
+	}
+
+	log.Debugf("utilityComputeNetworksConfigure: changeMTU set has %d items for Compute ID %s", len(updateNetwork.ChangeMTUMap), d.Id())
+	for _, netData := range updateNetwork.ChangeMTUMap {
+		computeId, _ := strconv.ParseUint(d.Id(), 10, 64)
+		req := compute.ChangeMTURequest{
+			ComputeID: computeId,
+			Interface: netData["mac"].(string),
+			MTU:       uint64(netData["mtu"].(int)),
+		}
+
+		_, err := c.CloudAPI().Compute().ChangeMTU(ctx, req)
+		if err != nil {
+			log.Errorf("utilityComputeNetworksConfigure: failed to change MTU ID %d of type %s from Compute ID %s: %s",
+				netData["net_id"].(int), netData["net_type"].(string), d.Id(), err)
+			apiErrCount++
+			lastSavedError = err
+		}
+	}
+
+	log.Debugf("utilityComputeNetworksConfigure: enableMap set has %d items for Compute ID %s", len(updateNetwork.EnableMap), d.Id())
+	for _, netData := range updateNetwork.EnableMap {
+		computeId, _ := strconv.ParseUint(d.Id(), 10, 64)
+		req := compute.ChangeLinkStateRequest{
+			ComputeID: computeId,
+			Interface: netData["mac"].(string),
+			State:     "off",
+		}
+
+		if netData["enabled"].(bool) {
+			req.State = "on"
+		}
+
+		_, err := c.CloudAPI().Compute().ChangeLinkState(ctx, req)
+		if err != nil {
+			log.Errorf("utilityComputeNetworksConfigure: failed to change link state network ID %d of type %s from Compute ID %s: %s",
+				netData["net_id"].(int), netData["net_type"].(string), d.Id(), err)
+			apiErrCount++
+			lastSavedError = err
+		}
+	}
+
+	if apiErrCount > 0 {
+		log.Errorf("utilityComputeNetworksConfigure: there were %d error(s) when managing networks of Compute ID %s. Last error was: %s",
+			apiErrCount, d.Id(), lastSavedError)
+		return lastSavedError
+	}
+
+	return nil
+}
+
+func utilityComputeSecGroupsConfigure(ctx context.Context, d *schema.ResourceData, m interface{}) error {
+	c := m.(*controller.ControllerCfg)
+
+	computeId, _ := strconv.ParseUint(d.Id(), 10, 64)
+	simpleCompRec, err := utilityComputeCheckPresence(ctx, d, m)
+	if err != nil {
+		return err
+	}
+
+	apiErrCount := 0
+	var lastSavedError error
+
+	oldSecGroups, newSecGroups := d.GetChange("security_groups")
+	updateSecGroups := (newSecGroups.(*schema.Set).Difference(oldSecGroups.(*schema.Set))).List()
+
+	log.Debugf("utilityComputeSecGroupsConfigure: update security groups has %d items for Compute ID %s", len(updateSecGroups), d.Id())
+	if len(updateSecGroups) > 0 {
+		for _, elem := range updateSecGroups {
+			secGroupsMap := elem.(map[string]interface{})
+
+			netType := secGroupsMap["net_type"].(string)
+			netId := uint64(secGroupsMap["net_id"].(int))
+			var mac string
+			for _, iface := range simpleCompRec.Interfaces {
+				if iface.NetID == netId && iface.NetType == netType {
+					mac = iface.MAC
+					break
+				}
+			}
+			if mac == "" {
+				log.Errorf("utilityComputeSecGroupsConfigure: Network with type %s and id %d is not connected to the compute %s",
+					netType, netId, d.Id())
+				apiErrCount++
+				lastSavedError = errors.New(fmt.Sprintf("utilityComputeSecGroupsConfigure: Network with type %s and id %d is not connected to the compute %s",
+					netType, netId, d.Id()))
+				continue
+			}
+			secGroupsIDs := make([]uint64, 0)
+			for _, id := range secGroupsMap["security_groups"].(*schema.Set).List() {
+				secGroupsIDs = append(secGroupsIDs, uint64(id.(int)))
+			}
+			log.Debugf("utilityComputeSecGroupsConfigure: Configure security groups interface parameters on Network with type %s and id %d", netType, netId)
+			req := compute.ChangeSecGroupsRequest{
+				ComputeID: computeId,
+				Interface: mac,
+				SecGroups: secGroupsIDs,
+			}
+
+			if secGroupsMap["enable_secgroups"] != nil {
+				req.EnableSecGroups = secGroupsMap["enable_secgroups"].(bool)
+			}
+
+			_, err := c.CloudAPI().Compute().ChangeSecGroups(ctx, req)
+			if err != nil {
+				apiErrCount++
+				lastSavedError = err
+			}
+		}
+	}
+
+	if apiErrCount > 0 {
+		log.Errorf("utilityComputeSecGroupsConfigure: there were %d error(s) when managing security groups of Compute ID %s. Last error was: %s",
+			apiErrCount, d.Id(), lastSavedError)
+		return lastSavedError
+	}
+
+	return nil
+}
+
+func hasDPDKnetwork(networkAttachMap []map[string]interface{}) bool {
+	for _, elem := range networkAttachMap {
+		if elem["net_type"].(string) == "DPDK" {
+			return true
+		}
+	}
+	return false
+}
+
+func utilityComputeCheckPresence(ctx context.Context, d *schema.ResourceData, m interface{}) (compute.RecordCompute, error) {
+	c := m.(*controller.ControllerCfg)
+	computeId, _ := strconv.ParseUint(d.Id(), 10, 64)
+	req := compute.GetRequest{
+		ComputeID: computeId,
+	}
+
+	computeRecord, err := c.CloudAPI().Compute().Get(ctx, req)
+	if err != nil {
+		return compute.RecordCompute{}, err
+	}
+
+	return *computeRecord, nil
+}
+
+func utilityComputeStop(ctx context.Context, computeID uint64, m interface{}) error {
+	c := m.(*controller.ControllerCfg)
+	req := compute.StopRequest{
+		ComputeID: computeID,
+		Force:     true,
+	}
+
+	log.Debugf("utilityComputeNetworksConfigure: stopping compute %d", computeID)
+	_, err := c.CloudAPI().Compute().Stop(ctx, req)
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+func utilityComputeStart(ctx context.Context, computeID uint64, altBootID uint64, m interface{}) (int, error) {
+	c := m.(*controller.ControllerCfg)
+	startReq := compute.StartRequest{ComputeID: computeID}
+
+	if altBootID > 0 {
+		startReq.AltBootID = altBootID
+	}
+
+	log.Debugf("utilityComputeNetworksConfigure: starting compute %d", computeID)
+	_, err := c.CloudAPI().Compute().Start(ctx, startReq)
+	if err != nil {
+		return 1, err
+	}
+	return 0, nil
+}
+
+func utilityComputeUpdatePciDevices(ctx context.Context, d *schema.ResourceData, m interface{}) error {
+	c := m.(*controller.ControllerCfg)
+	computeId, _ := strconv.ParseUint(d.Id(), 10, 64)
+	oldSet, newSet := d.GetChange("pci_devices")
+	deletedDevices := (oldSet.(*schema.Set).Difference(newSet.(*schema.Set))).List()
+	if len(deletedDevices) > 0 {
+		for _, ar := range deletedDevices {
+			arConv := ar.(int)
+			req := compute.DetachPCIDeviceRequest{
+				ComputeID: computeId,
+				DeviceID:  uint64(arConv),
+			}
+			_, err := c.CloudAPI().Compute().DetachPCIDevice(ctx, req)
+			if err != nil {
+				return err
+			}
+		}
+	}
+
+	added := (newSet.(*schema.Set).Difference(oldSet.(*schema.Set))).List()
+	if len(added) > 0 {
+		for _, ar := range added {
+			arConv := ar.(int)
+			req := compute.AttachPCIDeviceRequest{
+				ComputeID: computeId,
+				DeviceID:  uint64(arConv),
+			}
+
+			_, err := c.CloudAPI().Compute().AttachPCIDevice(ctx, req)
+			if err != nil {
+				return err
+			}
+		}
+	}
+
+	return nil
+}
+
+func differenceNetwork(oldList, newList []interface{}) *updatedNetwork {
+	attachMap := make([]map[string]interface{}, 0)
+	changeIpMap := make([]map[string]interface{}, 0)
+	changeMacMap := make([]map[string]interface{}, 0)
+	changeMTUMap := make([]map[string]interface{}, 0)
+	detachMap := make([]map[string]interface{}, 0)
+	enableMap := make([]map[string]interface{}, 0)
+	for _, oldNetwork := range oldList {
+		oldMap := oldNetwork.(map[string]interface{})
+		found := false
+		for _, newNetwork := range newList {
+			newMap := newNetwork.(map[string]interface{})
+			if compareNetwork(newMap, oldMap) {
+				found = true
+				if (newMap["net_type"].(string) == "EXTNET" || newMap["net_type"].(string) == "VINS") && (newMap["ip_address"] != oldMap["ip_address"] && newMap["ip_address"].(string) != "") {
+					changeIpMap = append(changeIpMap, newMap)
+				}
+				if newMap["mac"] != oldMap["mac"] && newMap["mac"].(string) != "" {
+					newMap["old_mac"] = oldMap["mac"]
+					changeMacMap = append(changeMacMap, newMap)
+				}
+				if (newMap["net_type"].(string) == "EXTNET" || newMap["net_type"].(string) == "DPDK") && (newMap["mtu"] != oldMap["mtu"] && newMap["mtu"].(int) != 0) {
+					changeMTUMap = append(changeMTUMap, newMap)
+				}
+				if newMap["enabled"].(bool) != oldMap["enabled"].(bool) {
+					mac, _ := newMap["mac"].(string)
+					if mac == "" {
+						newMap["mac"] = oldMap["mac"]
+					}
+					enableMap = append(enableMap, newMap)
+				}
+			}
+			if found {
+				break
+			}
+		}
+		if found {
+			continue
+		}
+		detachMap = append(detachMap, oldMap)
+	}
+
+	for _, newNetwork := range newList {
+		newMap := newNetwork.(map[string]interface{})
+		found := false
+		for _, oldNetwork := range oldList {
+			oldMap := oldNetwork.(map[string]interface{})
+			if compareNetwork(newMap, oldMap) {
+				found = true
+				break
+			}
+		}
+		if found {
+			continue
+		}
+		attachMap = append(attachMap, newMap)
+	}
+
+	res := updatedNetwork{
+		DetachMap:    detachMap,
+		ChangeIPMap:  changeIpMap,
+		ChangeMacMap: changeMacMap,
+		ChangeMTUMap: changeMTUMap,
+		AttachMap:    attachMap,
+		EnableMap:    enableMap,
+	}
+
+	return &res
+}
+
+func compareNetwork(newMap, oldMap map[string]interface{}) bool {
+	return newMap["net_type"] == oldMap["net_type"] && newMap["net_id"] == oldMap["net_id"] && newMap["sdn_interface_id"] == oldMap["sdn_interface_id"] && newMap["weight"] == oldMap["weight"]
+}
+
+func utilityComputeUpdateZoneID(ctx context.Context, d *schema.ResourceData, m interface{}) error {
+	c := m.(*controller.ControllerCfg)
+
+	computeId, _ := strconv.ParseUint(d.Id(), 10, 64)
+
+	req := compute.MigrateToZoneRequest{
+		ComputeID: computeId,
+	}
+
+	zoneID, ok := d.GetOk("zone_id")
+	if ok {
+		req.ZoneID = uint64(zoneID.(int))
+	}
+
+	_, err := c.CloudAPI().Compute().MigrateToZone(ctx, req)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func enabledNetwork(rawNetworkConfig cty.Value, netID uint64, netType string) bool {
+	for _, netConfigVal := range rawNetworkConfig.AsValueSlice() {
+		if netConfigVal.IsNull() {
+			continue
+		}
+
+		netConfig := netConfigVal.AsValueMap()
+
+		tempID, _ := netConfig["net_id"].AsBigFloat().Int64()
+		configNetID := uint64(tempID)
+
+		configNetType := netConfig["net_type"].AsString()
+
+		if configNetID == netID && configNetType == netType {
+			enabledVal := netConfig["enabled"]
+			return !enabledVal.IsNull()
+		}
+	}
+
+	return false
+}
+
+func getComputeDiskIDsAPI(disksList compute.ListComputeDisks, disksBlocks, extraDisks []interface{}, bootDiskId uint64) []interface{} {
+	res := make([]interface{}, 0)
+
+	if len(disksBlocks) == 0 {
+		return res
+	}
+
+	sort.Slice(disksList, func(i, j int) bool {
+		return disksList[i].ID < disksList[j].ID
+	})
+
+	for _, disk := range disksList {
+		if disk.ID == bootDiskId || findInExtraDisks(uint(disk.ID), extraDisks) {
+			continue
+		}
+		res = append(res, disk.ID)
+	}
+
+	return res
+}
+
+func utilityComputeCreateIOTune(ctx context.Context, d *schema.ResourceData, m interface{}) error {
+	c := m.(*controller.ControllerCfg)
+	diskList := d.Get("disks").([]interface{})
+
+	iotuneArr := make([]interface{}, 0, len(diskList))
+	hasAny := false
+	for _, elem := range diskList {
+		diskVal := elem.(map[string]interface{})
+		iotune := diskVal["iotune"].([]interface{})
+		iotuneArr = append(iotuneArr, iotune)
+		if len(iotune) > 0 {
+			hasAny = true
+		}
+	}
+
+	if !hasAny {
+		return nil
+	}
+
+	computeRec, err := utilityComputeCheckPresence(ctx, d, m)
+	if err != nil {
+		return err
+	}
+	bootDisk := findBootDisk(computeRec.Disks, computeRec.Chipset)
+	computeDisksIDs := getComputeDiskIDsAPI(computeRec.Disks, diskList, d.Get("extra_disks").(*schema.Set).List(), bootDisk.ID)
+
+	for i, diskID := range computeDisksIDs {
+		if i >= len(iotuneArr) {
+			continue
+		}
+		iotune, ok := iotuneArr[i].([]interface{})
+		if !ok || len(iotune) == 0 {
+			continue
+		}
+		iotuneMap := iotune[0].(map[string]interface{})
+		req := disks.LimitIORequest{
+			DiskID:           diskID.(uint64),
+			ReadBytesSec:     uint64(iotuneMap["read_bytes_sec"].(int)),
+			ReadBytesSecMax:  uint64(iotuneMap["read_bytes_sec_max"].(int)),
+			ReadIOPSSec:      uint64(iotuneMap["read_iops_sec"].(int)),
+			ReadIOPSSecMax:   uint64(iotuneMap["read_iops_sec_max"].(int)),
+			SizeIOPSSec:      uint64(iotuneMap["size_iops_sec"].(int)),
+			TotalBytesSec:    uint64(iotuneMap["total_bytes_sec"].(int)),
+			TotalBytesSecMax: uint64(iotuneMap["total_bytes_sec_max"].(int)),
+			TotalIOPSSec:     uint64(iotuneMap["total_iops_sec"].(int)),
+			TotalIOPSSecMax:  uint64(iotuneMap["total_iops_sec_max"].(int)),
+			WriteBytesSec:    uint64(iotuneMap["write_bytes_sec"].(int)),
+			WriteBytesSecMax: uint64(iotuneMap["write_bytes_sec_max"].(int)),
+			WriteIOPSSec:     uint64(iotuneMap["write_iops_sec"].(int)),
+			WriteIOPSSecMax:  uint64(iotuneMap["write_iops_sec_max"].(int)),
+		}
+		_, err := c.CloudAPI().Disks().LimitIO(ctx, req)
+		if err != nil {
+			return err
+		}
+	}
+
+	return nil
+}

internal/service/cloudapi/kvmvm/utility_compute_audits.go

@@ -0,0 +1,81 @@
+/*
+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 kvmvm
+
+import (
+	"context"
+
+	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
+	"repository.basistech.ru/BASIS/decort-golang-sdk/pkg/cloudapi/compute"
+	"repository.basistech.ru/BASIS/terraform-provider-decort/internal/controller"
+)
+
+func utilityComputeAuditsCheckPresence(ctx context.Context, d *schema.ResourceData, m interface{}) (compute.ListAudits, error) {
+	c := m.(*controller.ControllerCfg)
+	req := compute.AuditsRequest{
+		ComputeID: uint64(d.Get("compute_id").(int)),
+	}
+	if timestampAt, ok := d.GetOk("timestamp_at"); ok {
+		req.TimestampAT = uint64(timestampAt.(int))
+	}
+	if timestampTo, ok := d.GetOk("timestamp_to"); ok {
+		req.TimestampTO = uint64(timestampTo.(int))
+	}
+	if user, ok := d.GetOk("user"); ok {
+		req.User = user.(string)
+	}
+	if call, ok := d.GetOk("call"); ok {
+		req.Call = call.(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 minStatusCode, ok := d.GetOk("min_status_code"); ok {
+		req.MinStatusCode = uint64(minStatusCode.(int))
+	}
+	if maxStatusCode, ok := d.GetOk("max_status_code"); ok {
+		req.MaxStatusCode = uint64(maxStatusCode.(int))
+	}
+
+	computeAudits, err := c.CloudAPI().Compute().Audits(ctx, req)
+	if err != nil {
+		return compute.ListAudits{}, err
+	}
+	return *computeAudits, nil
+}

internal/service/cloudapi/kvmvm/utility_compute_boot_disk.go

@@ -0,0 +1,56 @@
+/*
+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 kvmvm
+
+import (
+	"context"
+
+	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
+	"repository.basistech.ru/BASIS/decort-golang-sdk/pkg/cloudapi/compute"
+)
+
+func utilityComputeBootDiskCheckPresence(ctx context.Context, d *schema.ResourceData, m interface{}) (*compute.ItemComputeDisk, error) {
+	computeRecord, err := utilityComputeCheckPresence(ctx, d, m)
+	if err != nil {
+		return nil, err
+	}
+
+	bootDisk := &compute.ItemComputeDisk{}
+	for _, disk := range computeRecord.Disks {
+		if disk.Name == "bootdisk" {
+			*bootDisk = disk
+			break
+		}
+	}
+	return bootDisk, nil
+}

internal/service/cloudapi/kvmvm/utility_compute_cpu_alignment_profile.go

@@ -0,0 +1,71 @@
+/*
+Copyright (c) 2019-2023 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 kvmvm
+
+import (
+	"context"
+	"strconv"
+
+	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
+	"repository.basistech.ru/BASIS/decort-golang-sdk/pkg/cloudapi/compute"
+	"repository.basistech.ru/BASIS/terraform-provider-decort/internal/controller"
+)
+
+func utilityComputeUpdateCPUAlignmentProfile(ctx context.Context, d *schema.ResourceData, m interface{}) error {
+	c := m.(*controller.ControllerCfg)
+	computeId, _ := strconv.ParseUint(d.Id(), 10, 64)
+
+	profileName := d.Get("cpu_alignment_profile").(string)
+	if profileName == "" {
+		req := compute.DeleteCPUAlignmentProfileRequest{
+			ComputeIDs: []uint64{computeId},
+		}
+		_, err := c.CloudAPI().Compute().DeleteCPUAlignmentProfile(ctx, req)
+		return err
+	}
+
+	req := compute.SetCPUAlignmentProfileRequest{
+		ComputeIDs:          []int64{int64(computeId)},
+		CPUAlignmentProfile: profileName,
+	}
+	_, err := c.CloudAPI().Compute().SetCPUAlignmentProfile(ctx, req)
+	return err
+}
+
+func utilityComputeGetCPUAlignmentProfile(ctx context.Context, d *schema.ResourceData, m interface{}) (*compute.CPUAlignmentProfile, error) {
+	c := m.(*controller.ControllerCfg)
+	req := compute.GetCPUAlignmentProfileRequest{
+		ComputeID: uint64(d.Get("compute_id").(int)),
+	}
+	return c.CloudAPI().Compute().GetCPUAlignmentProfile(ctx, req)
+}

internal/service/cloudapi/kvmvm/utility_compute_get_audits.go

@@ -0,0 +1,55 @@
+/*
+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 kvmvm
+
+import (
+	"context"
+
+	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
+	"repository.basistech.ru/BASIS/decort-golang-sdk/pkg/cloudapi/compute"
+	"repository.basistech.ru/BASIS/terraform-provider-decort/internal/controller"
+)
+
+func utilityComputeGetAuditsCheckPresence(ctx context.Context, d *schema.ResourceData, m interface{}) (compute.ListShortAudits, error) {
+	c := m.(*controller.ControllerCfg)
+	req := compute.GetAuditsRequest{
+		ComputeID: uint64(d.Get("compute_id").(int)),
+	}
+
+	computeAudits, err := c.CloudAPI().Compute().GetAudits(ctx, req)
+	if err != nil {
+		return nil, err
+	}
+
+	return computeAudits, nil
+}

internal/service/cloudapi/kvmvm/utility_compute_get_console_url.go

@@ -0,0 +1,55 @@
+/*
+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 kvmvm
+
+import (
+	"context"
+
+	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
+	"repository.basistech.ru/BASIS/decort-golang-sdk/pkg/cloudapi/compute"
+	"repository.basistech.ru/BASIS/terraform-provider-decort/internal/controller"
+)
+
+func utilityComputeGetConsoleUrlCheckPresence(ctx context.Context, d *schema.ResourceData, m interface{}) (string, error) {
+	c := m.(*controller.ControllerCfg)
+
+	req := compute.GetConsoleURLRequest{
+		ComputeID: uint64(d.Get("compute_id").(int)),
+	}
+	computeConsoleUrl, err := c.CloudAPI().Compute().GetConsoleURL(ctx, req)
+	if err != nil {
+		return "", err
+	}
+
+	return computeConsoleUrl, nil
+}

internal/service/cloudapi/kvmvm/utility_compute_get_log.go

@@ -0,0 +1,56 @@
+/*
+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 kvmvm
+
+import (
+	"context"
+
+	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
+	"repository.basistech.ru/BASIS/decort-golang-sdk/pkg/cloudapi/compute"
+	"repository.basistech.ru/BASIS/terraform-provider-decort/internal/controller"
+)
+
+func utilityComputeGetLogCheckPresence(ctx context.Context, d *schema.ResourceData, m interface{}) (string, error) {
+	c := m.(*controller.ControllerCfg)
+	req := compute.GetLogRequest{
+		ComputeID: uint64(d.Get("compute_id").(int)),
+		Path:      d.Get("path").(string),
+	}
+
+	computeGetLog, err := c.CloudAPI().Compute().GetLog(ctx, req)
+	if err != nil {
+		return "", err
+	}
+
+	return computeGetLog, nil
+}

internal/service/cloudapi/kvmvm/utility_compute_list.go

@@ -0,0 +1,99 @@
+/*
+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 kvmvm
+
+import (
+	"context"
+
+	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
+	"repository.basistech.ru/BASIS/decort-golang-sdk/pkg/cloudapi/compute"
+	"repository.basistech.ru/BASIS/terraform-provider-decort/internal/controller"
+)
+
+func utilityDataComputeListCheckPresence(ctx context.Context, d *schema.ResourceData, m interface{}) (*compute.ListComputes, error) {
+	c := m.(*controller.ControllerCfg)
+	req := compute.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 accountId, ok := d.GetOk("account_id"); ok {
+		req.AccountID = uint64(accountId.(int))
+	}
+	if rgName, ok := d.GetOk("rg_name"); ok {
+		req.RGName = rgName.(string)
+	}
+	if rgId, ok := d.GetOk("rg_id"); ok {
+		req.RGID = uint64(rgId.(int))
+	}
+	if techStatus, ok := d.GetOk("tech_status"); ok {
+		req.TechStatus = techStatus.(string)
+	}
+	if status, ok := d.GetOk("status"); ok {
+		req.Status = status.(string)
+	}
+	if ipAddress, ok := d.GetOk("ip_address"); ok {
+		req.IPAddress = ipAddress.(string)
+	}
+	if extNetName, ok := d.GetOk("extnet_name"); ok {
+		req.ExtNetName = extNetName.(string)
+	}
+	if extnetId, ok := d.GetOk("extnet_id"); ok {
+		req.ExtNetID = uint64(extnetId.(int))
+	}
+	if includeDeleted, ok := d.GetOk("includedeleted"); ok {
+		req.IncludeDeleted = includeDeleted.(bool)
+	}
+	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))
+	}
+
+	listComputes, err := c.CloudAPI().Compute().List(ctx, req)
+	if err != nil {
+		return nil, err
+	}
+
+	return listComputes, nil
+}

internal/service/cloudapi/kvmvm/utility_compute_list_deleted.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>
+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 kvmvm
+
+import (
+	"context"
+
+	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
+	"repository.basistech.ru/BASIS/decort-golang-sdk/pkg/cloudapi/compute"
+	"repository.basistech.ru/BASIS/terraform-provider-decort/internal/controller"
+)
+
+func utilityDataComputeListDeletedCheckPresence(ctx context.Context, d *schema.ResourceData, m interface{}) (*compute.ListComputes, error) {
+	c := m.(*controller.ControllerCfg)
+	req := compute.ListDeletedRequest{}
+
+	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 accountId, ok := d.GetOk("account_id"); ok {
+		req.AccountID = uint64(accountId.(int))
+	}
+	if rgName, ok := d.GetOk("rg_name"); ok {
+		req.RGName = rgName.(string)
+	}
+	if rgId, ok := d.GetOk("rg_id"); ok {
+		req.RGID = uint64(rgId.(int))
+	}
+	if techStatus, ok := d.GetOk("tech_status"); ok {
+		req.TechStatus = techStatus.(string)
+	}
+	if ipAddress, ok := d.GetOk("ip_address"); ok {
+		req.IPAddress = ipAddress.(string)
+	}
+	if extNetName, ok := d.GetOk("extnet_name"); ok {
+		req.ExtNetName = extNetName.(string)
+	}
+	if extnetId, ok := d.GetOk("extnet_id"); ok {
+		req.ExtNetID = uint64(extnetId.(int))
+	}
+	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))
+	}
+
+	listComputes, err := c.CloudAPI().Compute().ListDeleted(ctx, req)
+	if err != nil {
+		return nil, err
+	}
+
+	return listComputes, nil
+}

internal/service/cloudapi/kvmvm/utility_compute_pci_device_list.go

@@ -0,0 +1,77 @@
+/*
+Copyright (c) 2019-2023 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 kvmvm
+
+import (
+	"context"
+
+	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
+	"repository.basistech.ru/BASIS/decort-golang-sdk/pkg/cloudapi/compute"
+	"repository.basistech.ru/BASIS/terraform-provider-decort/internal/controller"
+)
+
+func utilityComputePCIDeviceListCheckPresence(ctx context.Context, d *schema.ResourceData, m interface{}) (*compute.ListPCIDevices, error) {
+	c := m.(*controller.ControllerCfg)
+	req := compute.ListPCIDeviceRequest{
+		ComputeID: uint64(d.Get("compute_id").(int)),
+	}
+	if rgId, ok := d.GetOk("rg_id"); ok {
+		req.RGID = uint64(rgId.(int))
+	}
+	if devId, ok := d.GetOk("device_id"); ok {
+		req.DevID = uint64(devId.(int))
+	}
+	if name, ok := d.GetOk("name"); ok {
+		req.Name = name.(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))
+	}
+
+	listPCIDevice, err := c.CloudAPI().Compute().ListPCIDevice(ctx, req)
+	if err != nil {
+		return nil, err
+	}
+
+	return listPCIDevice, err
+
+}

internal/service/cloudapi/kvmvm/utility_compute_pfw_list.go

@@ -0,0 +1,56 @@
+/*
+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 kvmvm
+
+import (
+	"context"
+
+	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
+	"repository.basistech.ru/BASIS/decort-golang-sdk/pkg/cloudapi/compute"
+	"repository.basistech.ru/BASIS/terraform-provider-decort/internal/controller"
+)
+
+func utilityComputePfwListCheckPresence(ctx context.Context, d *schema.ResourceData, m interface{}) (*compute.ListPFWs, error) {
+	c := m.(*controller.ControllerCfg)
+	req := compute.PFWListRequest{
+		ComputeID: uint64(d.Get("compute_id").(int)),
+	}
+
+	listPFWs, err := c.CloudAPI().Compute().PFWList(ctx, req)
+	if err != nil {
+		return nil, err
+	}
+
+	return listPFWs, err
+
+}

internal/service/cloudapi/kvmvm/utility_compute_snapshot_usage.go

@@ -0,0 +1,28 @@
+package kvmvm
+
+import (
+	"context"
+
+	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
+	"repository.basistech.ru/BASIS/decort-golang-sdk/pkg/cloudapi/compute"
+	"repository.basistech.ru/BASIS/terraform-provider-decort/internal/controller"
+)
+
+func utilityComputeSnapshotUsageCheckPresence(ctx context.Context, d *schema.ResourceData, m interface{}) (compute.ListUsageSnapshots, error) {
+	c := m.(*controller.ControllerCfg)
+	req := compute.SnapshotUsageRequest{
+		ComputeID: uint64(d.Get("compute_id").(int)),
+	}
+
+	if label, ok := d.GetOk("label"); ok {
+		req.Label = label.(string)
+	}
+
+	computeSnapshotUsage, err := c.CloudAPI().Compute().SnapshotUsage(ctx, req)
+	if err != nil {
+		return nil, err
+	}
+
+	return computeSnapshotUsage, err
+
+}

internal/service/cloudapi/kvmvm/utility_compute_user_list.go

@@ -0,0 +1,55 @@
+/*
+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 kvmvm
+
+import (
+	"context"
+
+	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
+	"repository.basistech.ru/BASIS/decort-golang-sdk/pkg/cloudapi/compute"
+	"repository.basistech.ru/BASIS/terraform-provider-decort/internal/controller"
+)
+
+func utilityComputeUserListCheckPresence(ctx context.Context, d *schema.ResourceData, m interface{}) (*compute.ListUsers, error) {
+	c := m.(*controller.ControllerCfg)
+	req := compute.UserListRequest{
+		ComputeID: uint64(d.Get("compute_id").(int)),
+	}
+
+	computeUserList, err := c.CloudAPI().Compute().UserList(ctx, req)
+	if err != nil {
+		return computeUserList, err
+	}
+
+	return computeUserList, err
+}

internal/service/cloudapi/kvmvm/utility_compute_vgpu_list.go

@@ -0,0 +1,77 @@
+/*
+Copyright (c) 2019-2023 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 kvmvm
+
+import (
+	"context"
+
+	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
+	"repository.basistech.ru/BASIS/decort-golang-sdk/pkg/cloudapi/compute"
+	"repository.basistech.ru/BASIS/terraform-provider-decort/internal/controller"
+)
+
+func utilityComputeVGPUListCheckPresence(ctx context.Context, d *schema.ResourceData, m interface{}) (*compute.ListVGPUs, error) {
+	c := m.(*controller.ControllerCfg)
+	req := compute.ListVGPURequest{
+		ComputeID: uint64(d.Get("compute_id").(int)),
+	}
+	if GPUID, ok := d.GetOk("gpu_id"); ok {
+		req.GPUID = uint64(GPUID.(int))
+	}
+	if typeVGPU, ok := d.GetOk("type"); ok {
+		req.Type = typeVGPU.(string)
+	}
+	if status, ok := d.GetOk("status"); ok {
+		req.Status = status.(string)
+	}
+	if includeDeleted, ok := d.GetOk("includedeleted"); ok {
+		req.IncludeDeleted = includeDeleted.(bool)
+	}
+	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))
+	}
+
+	listVGPU, err := c.CloudAPI().Compute().ListVGPU(ctx, req)
+	if err != nil {
+		return nil, err
+	}
+
+	return listVGPU, err
+
+}

internal/service/cloudapi/kvmvm/utility_data_source_compute.go

@@ -0,0 +1,79 @@
+/*
+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 kvmvm
+
+import (
+	"context"
+	"strconv"
+
+	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
+	"repository.basistech.ru/BASIS/decort-golang-sdk/pkg/cloudapi/compute"
+	"repository.basistech.ru/BASIS/terraform-provider-decort/internal/controller"
+)
+
+func utilityDataComputeCheckPresence(ctx context.Context, d *schema.ResourceData, m interface{}) (compute.RecordCompute, error) {
+	c := m.(*controller.ControllerCfg)
+	req := compute.GetRequest{}
+	if d.Id() != "" {
+		computeId, _ := strconv.ParseUint(d.Id(), 10, 64)
+		req.ComputeID = computeId
+	} else {
+		req.ComputeID = uint64(d.Get("compute_id").(int))
+	}
+
+	computeRecord, err := c.CloudAPI().Compute().Get(ctx, req)
+	if err != nil {
+		return compute.RecordCompute{}, err
+	}
+
+	return *computeRecord, nil
+}
+
+func utilityComputePCIDevicesList(ctx context.Context, d *schema.ResourceData, m interface{}) (*compute.ListPCIDevices, error) {
+	c := m.(*controller.ControllerCfg)
+	req := compute.ListPCIDeviceRequest{}
+
+	if d.Id() != "" {
+		computeId, _ := strconv.ParseUint(d.Id(), 10, 64)
+		req.ComputeID = computeId
+	} else {
+		req.ComputeID = uint64(d.Get("compute_id").(int))
+	}
+
+	res, err := c.CloudAPI().Compute().ListPCIDevice(ctx, req)
+	if err != nil {
+		return nil, err
+	}
+
+	return res, nil
+}