git test

internal/service/cloudapi/disks/data_source_disk.go

@@ -0,0 +1,507 @@
+/*
+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 disks
+
+import (
+	"context"
+
+	// "net/url"
+
+	"github.com/google/uuid"
+	"repository.basistech.ru/BASIS/terraform-provider-decort/internal/constants"
+
+	"github.com/hashicorp/terraform-plugin-sdk/v2/diag"
+	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
+)
+
+func dataSourceDiskRead(ctx context.Context, d *schema.ResourceData, m interface{}) diag.Diagnostics {
+	disk, err := utilityDiskCheckPresence(ctx, d, m)
+	if err != nil {
+		d.SetId("")
+		return diag.FromErr(err)
+	}
+
+	id := uuid.New()
+	d.SetId(id.String())
+
+	flattenDisk(d, disk)
+
+	return nil
+}
+
+func dataSourceDiskSchemaMake() map[string]*schema.Schema {
+	rets := map[string]*schema.Schema{
+		"disk_id": {
+			Type:        schema.TypeInt,
+			Required:    true,
+			Description: "The unique ID of the subscriber-owner of the disk",
+		},
+		"account_id": {
+			Type:        schema.TypeInt,
+			Computed:    true,
+			Description: "The unique ID of the subscriber-owner of the disk",
+		},
+		"account_name": {
+			Type:        schema.TypeString,
+			Computed:    true,
+			Description: "The name of the subscriber '(account') to whom this disk belongs",
+		},
+		"acl": {
+			Type:     schema.TypeString,
+			Computed: true,
+		},
+		"discard": {
+			Type:     schema.TypeString,
+			Computed: true,
+		},
+		"block_size": {
+			Type:     schema.TypeString,
+			Computed: true,
+		},
+		// "boot_partition": {
+		// 	Type:        schema.TypeInt,
+		// 	Computed:    true,
+		// 	Description: "Number of disk partitions",
+		// },
+		"computes": {
+			Type:     schema.TypeList,
+			Computed: true,
+			Elem: &schema.Resource{
+				Schema: map[string]*schema.Schema{
+					"compute_id": {
+						Type:     schema.TypeString,
+						Computed: true,
+					},
+					"compute_name": {
+						Type:     schema.TypeString,
+						Computed: true,
+					},
+				},
+			},
+		},
+		"created_by": {
+			Type:     schema.TypeString,
+			Computed: true,
+		},
+		"created_time": {
+			Type:        schema.TypeInt,
+			Computed:    true,
+			Description: "Created time",
+		},
+		"deleted_by": {
+			Type:     schema.TypeString,
+			Computed: true,
+		},
+		"deleted_time": {
+			Type:        schema.TypeInt,
+			Computed:    true,
+			Description: "Deleted time",
+		},
+		"desc": {
+			Type:        schema.TypeString,
+			Computed:    true,
+			Description: "Description of disk",
+		},
+		"destruction_time": {
+			Type:        schema.TypeInt,
+			Computed:    true,
+			Description: "Time of final deletion",
+		},
+		"devicename": {
+			Type:        schema.TypeString,
+			Computed:    true,
+			Description: "Name of the device",
+		},
+		// "disk_path": {
+		// 	Type:        schema.TypeString,
+		// 	Computed:    true,
+		// 	Description: "Disk path",
+		// },
+		"gid": {
+			Type:        schema.TypeInt,
+			Computed:    true,
+			Description: "ID of the grid (platform)",
+		},
+		// "guid": {
+		// 	Type:        schema.TypeInt,
+		// 	Computed:    true,
+		// 	Description: "Disk ID on the storage side",
+		// },
+		"image_id": {
+			Type:        schema.TypeInt,
+			Computed:    true,
+			Description: "Image ID",
+		},
+		"images": {
+			Type:     schema.TypeList,
+			Computed: true,
+			Elem: &schema.Schema{
+				Type: schema.TypeInt,
+			},
+			Description: "IDs of images using the disk",
+		},
+		"independent": {
+			Type:     schema.TypeBool,
+			Computed: true,
+		},
+		"iotune": {
+			Type:     schema.TypeList,
+			Computed: true,
+			Elem: &schema.Resource{
+				Schema: map[string]*schema.Schema{
+					"read_bytes_sec": {
+						Type:        schema.TypeInt,
+						Computed:    true,
+						Description: "Number of bytes to read per second",
+					},
+					"read_bytes_sec_max": {
+						Type:        schema.TypeInt,
+						Computed:    true,
+						Description: "Maximum number of bytes to read",
+					},
+					"read_iops_sec": {
+						Type:        schema.TypeInt,
+						Computed:    true,
+						Description: "Number of io read operations per second",
+					},
+					"read_iops_sec_max": {
+						Type:        schema.TypeInt,
+						Computed:    true,
+						Description: "Maximum number of io read operations",
+					},
+					"size_iops_sec": {
+						Type:        schema.TypeInt,
+						Computed:    true,
+						Description: "Size of io operations",
+					},
+					"total_bytes_sec": {
+						Type:        schema.TypeInt,
+						Computed:    true,
+						Description: "Total size bytes per second",
+					},
+					"total_bytes_sec_max": {
+						Type:        schema.TypeInt,
+						Computed:    true,
+						Description: "Maximum total size of bytes per second",
+					},
+					"total_iops_sec": {
+						Type:        schema.TypeInt,
+						Computed:    true,
+						Description: "Total number of io operations per second",
+					},
+					"total_iops_sec_max": {
+						Type:        schema.TypeInt,
+						Computed:    true,
+						Description: "Maximum total number of io operations per second",
+					},
+					"write_bytes_sec": {
+						Type:        schema.TypeInt,
+						Computed:    true,
+						Description: "Number of bytes to write per second",
+					},
+					"write_bytes_sec_max": {
+						Type:        schema.TypeInt,
+						Computed:    true,
+						Description: "Maximum number of bytes to write per second",
+					},
+					"write_iops_sec": {
+						Type:        schema.TypeInt,
+						Computed:    true,
+						Description: "Number of write operations per second",
+					},
+					"write_iops_sec_max": {
+						Type:        schema.TypeInt,
+						Computed:    true,
+						Description: "Maximum number of write operations per second",
+					},
+				},
+			},
+		},
+		// "iqn": {
+		// 	Type:        schema.TypeString,
+		// 	Computed:    true,
+		// 	Description: "Disk IQN",
+		// },
+		// "login": {
+		// 	Type:        schema.TypeString,
+		// 	Computed:    true,
+		// 	Description: "Login to access the disk",
+		// },
+		"milestones": {
+			Type:        schema.TypeInt,
+			Computed:    true,
+			Description: "Milestones",
+		},
+		"disk_name": {
+			Type:        schema.TypeString,
+			Computed:    true,
+			Description: "Name of disk",
+		},
+		"machine_id": {
+			Type:     schema.TypeInt,
+			Computed: true,
+		},
+		"machine_name": {
+			Type:     schema.TypeString,
+			Computed: true,
+		},
+		"order": {
+			Type:        schema.TypeInt,
+			Computed:    true,
+			Description: "Disk order",
+		},
+		"params": {
+			Type:        schema.TypeString,
+			Computed:    true,
+			Description: "Disk params",
+		},
+		"parent_id": {
+			Type:        schema.TypeInt,
+			Computed:    true,
+			Description: "ID of the parent disk",
+		},
+		// "passwd": {
+		// 	Type:        schema.TypeString,
+		// 	Computed:    true,
+		// 	Description: "Password to access the disk",
+		// },
+		"pci_slot": {
+			Type:        schema.TypeInt,
+			Computed:    true,
+			Description: "ID of the pci slot to which the disk is connected",
+		},
+		"pool": {
+			Type:        schema.TypeString,
+			Computed:    true,
+			Description: "Pool for disk location",
+		},
+		"present_to": {
+			Type:     schema.TypeMap,
+			Computed: true,
+			Elem: &schema.Schema{
+				Type: schema.TypeInt,
+			},
+		},
+		"provision": {
+			Type:     schema.TypeString,
+			Computed: true,
+		},
+		// "purge_attempts": {
+		// 	Type:        schema.TypeInt,
+		// 	Computed:    true,
+		// 	Description: "Number of deletion attempts",
+		// },
+		"purge_time": {
+			Type:        schema.TypeInt,
+			Computed:    true,
+			Description: "Time of the last deletion attempt",
+		},
+		"replication": {
+			Type:     schema.TypeList,
+			Computed: true,
+			Elem: &schema.Resource{
+				Schema: map[string]*schema.Schema{
+					"disk_id": {
+						Type:     schema.TypeInt,
+						Computed: true,
+					},
+					"pool_id": {
+						Type:     schema.TypeString,
+						Computed: true,
+					},
+					"role": {
+						Type:     schema.TypeString,
+						Computed: true,
+					},
+					"self_volume_id": {
+						Type:     schema.TypeString,
+						Computed: true,
+					},
+					"storage_id": {
+						Type:     schema.TypeString,
+						Computed: true,
+					},
+					"volume_id": {
+						Type:     schema.TypeString,
+						Computed: true,
+					},
+				},
+			},
+			Description: "Replication status",
+		},
+		// "reality_device_number": {
+		// 	Type:        schema.TypeInt,
+		// 	Computed:    true,
+		// 	Description: "Reality device number",
+		// },
+		// "reference_id": {
+		// 	Type:        schema.TypeString,
+		// 	Computed:    true,
+		// 	Description: "ID of the reference to the disk",
+		// },
+		"res_id": {
+			Type:        schema.TypeString,
+			Computed:    true,
+			Description: "Resource ID",
+		},
+		"res_name": {
+			Type:        schema.TypeString,
+			Computed:    true,
+			Description: "Name of the resource",
+		},
+		"role": {
+			Type:        schema.TypeString,
+			Computed:    true,
+			Description: "Disk role",
+		},
+		"sep_id": {
+			Type:        schema.TypeInt,
+			Computed:    true,
+			Description: "Storage endpoint provider ID to create disk",
+		},
+		"sep_type": {
+			Type:        schema.TypeString,
+			Computed:    true,
+			Description: "Type SEP. Defines the type of storage system and contains one of the values set in the cloud platform",
+		},
+		"shareable": {
+			Type:     schema.TypeBool,
+			Computed: true,
+		},
+		"cache": {
+			Type:     schema.TypeString,
+			Computed: true,
+		},
+		"size_available": {
+			Type:     schema.TypeFloat,
+			Computed: true,
+		},
+		"size_max": {
+			Type:        schema.TypeInt,
+			Computed:    true,
+			Description: "Size in GB",
+		},
+		"size_used": {
+			Type:        schema.TypeFloat,
+			Computed:    true,
+			Description: "Number of used space, in GB",
+		},
+		"snapshots": {
+			Type:     schema.TypeList,
+			Computed: true,
+			Elem: &schema.Resource{
+				Schema: map[string]*schema.Schema{
+					"guid": {
+						Type:        schema.TypeString,
+						Computed:    true,
+						Description: "ID of the snapshot",
+					},
+					"label": {
+						Type:        schema.TypeString,
+						Computed:    true,
+						Description: "Name of the snapshot",
+					},
+					"res_id": {
+						Type:        schema.TypeString,
+						Computed:    true,
+						Description: "Reference to the snapshot",
+					},
+					"snap_set_guid": {
+						Type:        schema.TypeString,
+						Computed:    true,
+						Description: "The set snapshot ID",
+					},
+					"snap_set_time": {
+						Type:        schema.TypeInt,
+						Computed:    true,
+						Description: "The set time of the snapshot",
+					},
+					"timestamp": {
+						Type:        schema.TypeInt,
+						Computed:    true,
+						Description: "Snapshot time",
+					},
+				},
+			},
+		},
+		"status": {
+			Type:        schema.TypeString,
+			Computed:    true,
+			Description: "Disk status",
+		},
+		"storage_policy_id": {
+			Type:        schema.TypeFloat,
+			Computed:    true,
+			Description: "Storage policy ID",
+		},
+		"tech_status": {
+			Type:        schema.TypeString,
+			Computed:    true,
+			Description: "Technical status of the disk",
+		},
+		"vmid": {
+			Type:        schema.TypeInt,
+			Computed:    true,
+			Description: "Virtual Machine ID (Deprecated)",
+		},
+		"updated_by": {
+			Type:     schema.TypeString,
+			Computed: true,
+		},
+		"updated_time": {
+			Type:     schema.TypeInt,
+			Computed: true,
+		},
+		"to_clean": {
+			Type:     schema.TypeBool,
+			Computed: true,
+		},
+	}
+
+	return rets
+}
+
+func DataSourceDisk() *schema.Resource {
+	return &schema.Resource{
+		SchemaVersion: 1,
+
+		ReadContext: dataSourceDiskRead,
+
+		Timeouts: &schema.ResourceTimeout{
+			Read:    &constants.Timeout30s,
+			Default: &constants.Timeout60s,
+		},
+
+		Schema: dataSourceDiskSchemaMake(),
+	}
+}

internal/service/cloudapi/disks/data_source_disk_list.go

@@ -0,0 +1,592 @@
+/*
+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 disks
+
+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 dataSourceDiskListRead(ctx context.Context, d *schema.ResourceData, m interface{}) diag.Diagnostics {
+	diskList, err := utilityDiskListCheckPresence(ctx, d, m)
+	if err != nil {
+		d.SetId("")
+		return diag.FromErr(err)
+	}
+
+	id := uuid.New()
+	d.SetId(id.String())
+	d.Set("items", flattenDiskList(diskList))
+	d.Set("entry_count", diskList.EntryCount)
+
+	return nil
+}
+
+func dataSourceDiskListSchemaMake() 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_name": {
+			Type:        schema.TypeString,
+			Optional:    true,
+			Description: "Find by account name",
+		},
+		"disk_max_size": {
+			Type:        schema.TypeInt,
+			Optional:    true,
+			Description: "Find by max disk size",
+		},
+		"status": {
+			Type:        schema.TypeString,
+			Optional:    true,
+			Description: "Find by status",
+		},
+		"shared": {
+			Type:        schema.TypeBool,
+			Optional:    true,
+			Description: "Find by shared field",
+		},
+		"account_id": {
+			Type:        schema.TypeInt,
+			Optional:    true,
+			Description: "ID of the account the disks belong to",
+		},
+		"sep_id": {
+			Type:        schema.TypeInt,
+			Optional:    true,
+			Description: "find by sep ID",
+		},
+		"pool_name": {
+			Type:        schema.TypeString,
+			Optional:    true,
+			Description: "find by pool name",
+		},
+		"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",
+		},
+		"storage_policy_id": {
+			Type:        schema.TypeInt,
+			Optional:    true,
+			Description: "storage policy ID ",
+		},
+		"compute_id": {
+			Type:        schema.TypeInt,
+			Optional:    true,
+			Description: "Find by compute ID",
+		},
+		"rg_id": {
+			Type:        schema.TypeInt,
+			Optional:    true,
+			Description: "Find by rg ID",
+		},
+		"items": {
+			Type:     schema.TypeList,
+			Computed: true,
+			Elem: &schema.Resource{
+				Schema: map[string]*schema.Schema{
+					"account_id": {
+						Type:        schema.TypeInt,
+						Computed:    true,
+						Description: "The unique ID of the subscriber-owner of the disk",
+					},
+					"account_name": {
+						Type:        schema.TypeString,
+						Computed:    true,
+						Description: "The name of the subscriber '(account') to whom this disk belongs",
+					},
+					"acl": {
+						Type:     schema.TypeString,
+						Computed: true,
+					},
+					"discard": {
+						Type:     schema.TypeString,
+						Computed: true,
+					},
+					"block_size": {
+						Type:     schema.TypeString,
+						Computed: true,
+					},
+					// "boot_partition": {
+					// 	Type:        schema.TypeInt,
+					// 	Computed:    true,
+					// 	Description: "Number of disk partitions",
+					// },
+					"computes": {
+						Type:     schema.TypeList,
+						Computed: true,
+						Elem: &schema.Resource{
+							Schema: map[string]*schema.Schema{
+								"compute_id": {
+									Type:     schema.TypeString,
+									Computed: true,
+								},
+								"compute_name": {
+									Type:     schema.TypeString,
+									Computed: true,
+								},
+							},
+						},
+					},
+					"created_by": {
+						Type:     schema.TypeString,
+						Computed: true,
+					},
+					"created_time": {
+						Type:        schema.TypeInt,
+						Computed:    true,
+						Description: "Created time",
+					},
+					"deleted_time": {
+						Type:        schema.TypeInt,
+						Computed:    true,
+						Description: "Deleted time",
+					},
+					"desc": {
+						Type:        schema.TypeString,
+						Computed:    true,
+						Description: "Description of disk",
+					},
+					"destruction_time": {
+						Type:        schema.TypeInt,
+						Computed:    true,
+						Description: "Time of final deletion",
+					},
+					"devicename": {
+						Type:        schema.TypeString,
+						Computed:    true,
+						Description: "Name of the device",
+					},
+					// "disk_path": {
+					// 	Type:        schema.TypeString,
+					// 	Computed:    true,
+					// 	Description: "Disk path",
+					// },
+					"gid": {
+						Type:        schema.TypeInt,
+						Computed:    true,
+						Description: "ID of the grid (platform)",
+					},
+					// "guid": {
+					// 	Type:        schema.TypeInt,
+					// 	Computed:    true,
+					// 	Description: "Disk ID on the storage side",
+					// },
+					"disk_id": {
+						Type:        schema.TypeInt,
+						Computed:    true,
+						Description: "The unique ID of the subscriber-owner of the disk",
+					},
+					"image_id": {
+						Type:        schema.TypeInt,
+						Computed:    true,
+						Description: "Image ID",
+					},
+					"images": {
+						Type:     schema.TypeList,
+						Computed: true,
+						Elem: &schema.Schema{
+							Type: schema.TypeInt,
+						},
+						Description: "IDs of images using the disk",
+					},
+					"independent": {
+						Type:     schema.TypeBool,
+						Computed: true,
+					},
+					"iotune": {
+						Type:     schema.TypeList,
+						Computed: true,
+						Elem: &schema.Resource{
+							Schema: map[string]*schema.Schema{
+								"read_bytes_sec": {
+									Type:        schema.TypeInt,
+									Computed:    true,
+									Description: "Number of bytes to read per second",
+								},
+								"read_bytes_sec_max": {
+									Type:        schema.TypeInt,
+									Computed:    true,
+									Description: "Maximum number of bytes to read",
+								},
+								"read_iops_sec": {
+									Type:        schema.TypeInt,
+									Computed:    true,
+									Description: "Number of io read operations per second",
+								},
+								"read_iops_sec_max": {
+									Type:        schema.TypeInt,
+									Computed:    true,
+									Description: "Maximum number of io read operations",
+								},
+								"size_iops_sec": {
+									Type:        schema.TypeInt,
+									Computed:    true,
+									Description: "Size of io operations",
+								},
+								"total_bytes_sec": {
+									Type:        schema.TypeInt,
+									Computed:    true,
+									Description: "Total size bytes per second",
+								},
+								"total_bytes_sec_max": {
+									Type:        schema.TypeInt,
+									Computed:    true,
+									Description: "Maximum total size of bytes per second",
+								},
+								"total_iops_sec": {
+									Type:        schema.TypeInt,
+									Computed:    true,
+									Description: "Total number of io operations per second",
+								},
+								"total_iops_sec_max": {
+									Type:        schema.TypeInt,
+									Computed:    true,
+									Description: "Maximum total number of io operations per second",
+								},
+								"write_bytes_sec": {
+									Type:        schema.TypeInt,
+									Computed:    true,
+									Description: "Number of bytes to write per second",
+								},
+								"write_bytes_sec_max": {
+									Type:        schema.TypeInt,
+									Computed:    true,
+									Description: "Maximum number of bytes to write per second",
+								},
+								"write_iops_sec": {
+									Type:        schema.TypeInt,
+									Computed:    true,
+									Description: "Number of write operations per second",
+								},
+								"write_iops_sec_max": {
+									Type:        schema.TypeInt,
+									Computed:    true,
+									Description: "Maximum number of write operations per second",
+								},
+							},
+						},
+					},
+					// "iqn": {
+					// 	Type:        schema.TypeString,
+					// 	Computed:    true,
+					// 	Description: "Disk IQN",
+					// },
+					// "login": {
+					// 	Type:        schema.TypeString,
+					// 	Computed:    true,
+					// 	Description: "Login to access the disk",
+					// },
+					"machine_id": {
+						Type:        schema.TypeInt,
+						Computed:    true,
+						Description: "Machine ID",
+					},
+					"machine_name": {
+						Type:        schema.TypeString,
+						Computed:    true,
+						Description: "Machine name",
+					},
+					"deleted_by": {
+						Type:     schema.TypeString,
+						Computed: true,
+					},
+					"milestones": {
+						Type:        schema.TypeInt,
+						Computed:    true,
+						Description: "Milestones",
+					},
+					"disk_name": {
+						Type:        schema.TypeString,
+						Computed:    true,
+						Description: "Name of disk",
+					},
+					"order": {
+						Type:        schema.TypeInt,
+						Computed:    true,
+						Description: "Disk order",
+					},
+					"params": {
+						Type:        schema.TypeString,
+						Computed:    true,
+						Description: "Disk params",
+					},
+					"parent_id": {
+						Type:        schema.TypeInt,
+						Computed:    true,
+						Description: "ID of the parent disk",
+					},
+					// "passwd": {
+					// 	Type:        schema.TypeString,
+					// 	Computed:    true,
+					// 	Description: "Password to access the disk",
+					// },
+					"pci_slot": {
+						Type:        schema.TypeInt,
+						Computed:    true,
+						Description: "ID of the pci slot to which the disk is connected",
+					},
+					"pool": {
+						Type:        schema.TypeString,
+						Computed:    true,
+						Description: "Pool for disk location",
+					},
+					"present_to": {
+						Type:     schema.TypeMap,
+						Computed: true,
+						Elem: &schema.Schema{
+							Type: schema.TypeInt,
+						},
+					},
+					"provision": {
+						Type:     schema.TypeString,
+						Computed: true,
+					},
+					// "purge_attempts": {
+					// 	Type:        schema.TypeInt,
+					// 	Computed:    true,
+					// 	Description: "Number of deletion attempts",
+					// },
+					"purge_time": {
+						Type:        schema.TypeInt,
+						Computed:    true,
+						Description: "Time of the last deletion attempt",
+					},
+					// "reality_device_number": {
+					// 	Type:        schema.TypeInt,
+					// 	Computed:    true,
+					// 	Description: "Reality device number",
+					// },
+					// "reference_id": {
+					// 	Type:        schema.TypeString,
+					// 	Computed:    true,
+					// 	Description: "ID of the reference to the disk",
+					// },
+					"replication": {
+						Type:     schema.TypeList,
+						Computed: true,
+						Elem: &schema.Resource{
+							Schema: map[string]*schema.Schema{
+								"disk_id": {
+									Type:     schema.TypeInt,
+									Computed: true,
+								},
+								"pool_id": {
+									Type:     schema.TypeString,
+									Computed: true,
+								},
+								"role": {
+									Type:     schema.TypeString,
+									Computed: true,
+								},
+								"self_volume_id": {
+									Type:     schema.TypeString,
+									Computed: true,
+								},
+								"storage_id": {
+									Type:     schema.TypeString,
+									Computed: true,
+								},
+								"volume_id": {
+									Type:     schema.TypeString,
+									Computed: true,
+								},
+							},
+						},
+						Description: "Replication status",
+					},
+					"res_id": {
+						Type:        schema.TypeString,
+						Computed:    true,
+						Description: "Resource ID",
+					},
+					"res_name": {
+						Type:        schema.TypeString,
+						Computed:    true,
+						Description: "Name of the resource",
+					},
+					"role": {
+						Type:        schema.TypeString,
+						Computed:    true,
+						Description: "Disk role",
+					},
+					"sep_id": {
+						Type:        schema.TypeInt,
+						Computed:    true,
+						Description: "Storage endpoint provider ID to create disk",
+					},
+					"sep_type": {
+						Type:        schema.TypeString,
+						Computed:    true,
+						Description: "Type SEP. Defines the type of storage system and contains one of the values set in the cloud platform",
+					},
+					"shareable": {
+						Type:     schema.TypeBool,
+						Computed: true,
+					},
+					"cache": {
+						Type:     schema.TypeString,
+						Computed: true,
+					},
+					"size_available": {
+						Type:     schema.TypeFloat,
+						Computed: true,
+					},
+					"size_max": {
+						Type:        schema.TypeInt,
+						Computed:    true,
+						Description: "Size in GB",
+					},
+					"size_used": {
+						Type:        schema.TypeFloat,
+						Computed:    true,
+						Description: "Number of used space, in GB",
+					},
+					"snapshots": {
+						Type:     schema.TypeList,
+						Computed: true,
+						Elem: &schema.Resource{
+							Schema: map[string]*schema.Schema{
+								"guid": {
+									Type:        schema.TypeString,
+									Computed:    true,
+									Description: "ID of the snapshot",
+								},
+								"label": {
+									Type:        schema.TypeString,
+									Computed:    true,
+									Description: "Name of the snapshot",
+								},
+								"res_id": {
+									Type:        schema.TypeString,
+									Computed:    true,
+									Description: "Reference to the snapshot",
+								},
+								"snap_set_guid": {
+									Type:        schema.TypeString,
+									Computed:    true,
+									Description: "The set snapshot ID",
+								},
+								"snap_set_time": {
+									Type:        schema.TypeInt,
+									Computed:    true,
+									Description: "The set time of the snapshot",
+								},
+								"timestamp": {
+									Type:        schema.TypeInt,
+									Computed:    true,
+									Description: "Snapshot time",
+								},
+							},
+						},
+					},
+					"status": {
+						Type:        schema.TypeString,
+						Computed:    true,
+						Description: "Disk status",
+					},
+					"storage_policy_id": {
+						Type:        schema.TypeFloat,
+						Computed:    true,
+						Description: "Storage policy ID",
+					},
+					"tech_status": {
+						Type:        schema.TypeString,
+						Computed:    true,
+						Description: "Technical status of the disk",
+					},
+					"vmid": {
+						Type:        schema.TypeInt,
+						Computed:    true,
+						Description: "Virtual Machine ID (Deprecated)",
+					},
+					"updated_by": {
+						Type:     schema.TypeString,
+						Computed: true,
+					},
+					"updated_time": {
+						Type:     schema.TypeInt,
+						Computed: true,
+					},
+					"to_clean": {
+						Type:     schema.TypeBool,
+						Computed: true,
+					},
+				},
+			},
+		},
+		"entry_count": {
+			Type:     schema.TypeInt,
+			Computed: true,
+		},
+	}
+	return res
+}
+
+func DataSourceDiskList() *schema.Resource {
+	return &schema.Resource{
+		SchemaVersion: 1,
+
+		ReadContext: dataSourceDiskListRead,
+
+		Timeouts: &schema.ResourceTimeout{
+			Read:    &constants.Timeout30s,
+			Default: &constants.Timeout60s,
+		},
+
+		Schema: dataSourceDiskListSchemaMake(),
+	}
+}

internal/service/cloudapi/disks/data_source_disk_list_unattached.go

@@ -0,0 +1,484 @@
+/*
+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 disks
+
+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 dataSourceDiskListUnattachedRead(ctx context.Context, d *schema.ResourceData, m interface{}) diag.Diagnostics {
+	diskListUnattached, err := utilityDiskListUnattachedCheckPresence(ctx, d, m)
+	if err != nil {
+		d.SetId("")
+		return diag.FromErr(err)
+	}
+
+	id := uuid.New()
+	d.SetId(id.String())
+	d.Set("items", flattenDiskListUnattached(diskListUnattached))
+	d.Set("entry_count", diskListUnattached.EntryCount)
+
+	return nil
+}
+
+func DataSourceDiskListUnattached() *schema.Resource {
+	return &schema.Resource{
+		SchemaVersion: 1,
+
+		ReadContext: dataSourceDiskListUnattachedRead,
+
+		Timeouts: &schema.ResourceTimeout{
+			Read:    &constants.Timeout30s,
+			Default: &constants.Timeout60s,
+		},
+
+		Schema: dataSourceDiskListUnattachedSchemaMake(),
+	}
+}
+
+func dataSourceDiskListUnattachedSchemaMake() map[string]*schema.Schema {
+	res := map[string]*schema.Schema{
+		"by_id": {
+			Type:        schema.TypeInt,
+			Optional:    true,
+			Description: "Find by ID",
+		},
+		"account_name": {
+			Type:        schema.TypeString,
+			Optional:    true,
+			Description: "Find by account name",
+		},
+		"disk_max_size": {
+			Type:        schema.TypeInt,
+			Optional:    true,
+			Description: "Find by max disk size",
+		},
+		"status": {
+			Type:        schema.TypeString,
+			Optional:    true,
+			Description: "Find by status",
+		},
+		"account_id": {
+			Type:        schema.TypeInt,
+			Optional:    true,
+			Description: "ID of the account the disks belong to",
+		},
+		"sep_id": {
+			Type:        schema.TypeInt,
+			Optional:    true,
+			Description: "find by sep ID",
+		},
+		"pool_name": {
+			Type:        schema.TypeString,
+			Optional:    true,
+			Description: "find by pool name",
+		},
+		"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",
+		},
+		"storage_policy_id": {
+			Type:        schema.TypeInt,
+			Optional:    true,
+			Description: "storage policy ID ",
+		},
+		"items": {
+			Type:     schema.TypeList,
+			Computed: true,
+			Elem: &schema.Resource{
+				Schema: map[string]*schema.Schema{
+					"_meta": {
+						Type:     schema.TypeList,
+						Computed: true,
+						Elem: &schema.Schema{
+							Type: schema.TypeString,
+						},
+						Description: "Meta parameters",
+					},
+					"account_id": {
+						Type:        schema.TypeInt,
+						Computed:    true,
+						Description: "ID of the account the disks belong to",
+					},
+					"account_name": {
+						Type:        schema.TypeString,
+						Computed:    true,
+						Description: "The name of the subscriber '(account') to whom this disk belongs",
+					},
+					"acl": {
+						Type:     schema.TypeString,
+						Computed: true,
+					},
+					"discard": {
+						Type:     schema.TypeString,
+						Computed: true,
+					},
+					"block_size": {
+						Type:     schema.TypeString,
+						Computed: true,
+					},
+					"boot_partition": {
+						Type:        schema.TypeInt,
+						Computed:    true,
+						Description: "Number of disk partitions",
+					},
+					"created_time": {
+						Type:        schema.TypeInt,
+						Computed:    true,
+						Description: "Created time",
+					},
+					"deleted_time": {
+						Type:        schema.TypeInt,
+						Computed:    true,
+						Description: "Deleted time",
+					},
+					"desc": {
+						Type:        schema.TypeString,
+						Computed:    true,
+						Description: "Description of disk",
+					},
+					"destruction_time": {
+						Type:        schema.TypeInt,
+						Computed:    true,
+						Description: "Time of final deletion",
+					},
+					"disk_path": {
+						Type:        schema.TypeString,
+						Computed:    true,
+						Description: "Disk path",
+					},
+					"gid": {
+						Type:        schema.TypeInt,
+						Computed:    true,
+						Description: "ID of the grid (platform)",
+					},
+					"guid": {
+						Type:        schema.TypeInt,
+						Computed:    true,
+						Description: "Disk ID on the storage side",
+					},
+					"disk_id": {
+						Type:        schema.TypeInt,
+						Computed:    true,
+						Description: "The unique ID of the subscriber-owner of the disk",
+					},
+					"image_id": {
+						Type:        schema.TypeInt,
+						Computed:    true,
+						Description: "Image ID",
+					},
+					"images": {
+						Type:     schema.TypeList,
+						Computed: true,
+						Elem: &schema.Schema{
+							Type: schema.TypeInt,
+						},
+						Description: "IDs of images using the disk",
+					},
+					"iotune": {
+						Type:     schema.TypeList,
+						Computed: true,
+						Elem: &schema.Resource{
+							Schema: map[string]*schema.Schema{
+								"read_bytes_sec": {
+									Type:        schema.TypeInt,
+									Computed:    true,
+									Description: "Number of bytes to read per second",
+								},
+								"read_bytes_sec_max": {
+									Type:        schema.TypeInt,
+									Computed:    true,
+									Description: "Maximum number of bytes to read",
+								},
+								"read_iops_sec": {
+									Type:        schema.TypeInt,
+									Computed:    true,
+									Description: "Number of io read operations per second",
+								},
+								"read_iops_sec_max": {
+									Type:        schema.TypeInt,
+									Computed:    true,
+									Description: "Maximum number of io read operations",
+								},
+								"size_iops_sec": {
+									Type:        schema.TypeInt,
+									Computed:    true,
+									Description: "Size of io operations",
+								},
+								"total_bytes_sec": {
+									Type:        schema.TypeInt,
+									Computed:    true,
+									Description: "Total size bytes per second",
+								},
+								"total_bytes_sec_max": {
+									Type:        schema.TypeInt,
+									Computed:    true,
+									Description: "Maximum total size of bytes per second",
+								},
+								"total_iops_sec": {
+									Type:        schema.TypeInt,
+									Computed:    true,
+									Description: "Total number of io operations per second",
+								},
+								"total_iops_sec_max": {
+									Type:        schema.TypeInt,
+									Computed:    true,
+									Description: "Maximum total number of io operations per second",
+								},
+								"write_bytes_sec": {
+									Type:        schema.TypeInt,
+									Computed:    true,
+									Description: "Number of bytes to write per second",
+								},
+								"write_bytes_sec_max": {
+									Type:        schema.TypeInt,
+									Computed:    true,
+									Description: "Maximum number of bytes to write per second",
+								},
+								"write_iops_sec": {
+									Type:        schema.TypeInt,
+									Computed:    true,
+									Description: "Number of write operations per second",
+								},
+								"write_iops_sec_max": {
+									Type:        schema.TypeInt,
+									Computed:    true,
+									Description: "Maximum number of write operations per second",
+								},
+							},
+						},
+					},
+					"iqn": {
+						Type:        schema.TypeString,
+						Computed:    true,
+						Description: "Disk IQN",
+					},
+					"login": {
+						Type:        schema.TypeString,
+						Computed:    true,
+						Description: "Login to access the disk",
+					},
+					"milestones": {
+						Type:        schema.TypeInt,
+						Computed:    true,
+						Description: "Milestones",
+					},
+					"disk_name": {
+						Type:        schema.TypeString,
+						Computed:    true,
+						Description: "Name of disk",
+					},
+					"order": {
+						Type:        schema.TypeInt,
+						Computed:    true,
+						Description: "Disk order",
+					},
+					"params": {
+						Type:        schema.TypeString,
+						Computed:    true,
+						Description: "Disk params",
+					},
+					"parent_id": {
+						Type:        schema.TypeInt,
+						Computed:    true,
+						Description: "ID of the parent disk",
+					},
+					"present_to": {
+						Type:     schema.TypeMap,
+						Computed: true,
+						Elem: &schema.Schema{
+							Type: schema.TypeInt,
+						},
+					},
+					"provision": {
+						Type:     schema.TypeString,
+						Computed: true,
+					},
+					"passwd": {
+						Type:        schema.TypeString,
+						Computed:    true,
+						Description: "Password to access the disk",
+					},
+					"pci_slot": {
+						Type:        schema.TypeInt,
+						Computed:    true,
+						Description: "ID of the pci slot to which the disk is connected",
+					},
+					"pool": {
+						Type:        schema.TypeString,
+						Computed:    true,
+						Description: "Pool for disk location",
+					},
+					"purge_attempts": {
+						Type:        schema.TypeInt,
+						Computed:    true,
+						Description: "Number of deletion attempts",
+					},
+					"purge_time": {
+						Type:        schema.TypeInt,
+						Computed:    true,
+						Description: "Time of the last deletion attempt",
+					},
+					"reality_device_number": {
+						Type:        schema.TypeInt,
+						Computed:    true,
+						Description: "Reality device number",
+					},
+					"reference_id": {
+						Type:        schema.TypeString,
+						Computed:    true,
+						Description: "ID of the reference to the disk",
+					},
+					"res_id": {
+						Type:        schema.TypeString,
+						Computed:    true,
+						Description: "Resource ID",
+					},
+					"res_name": {
+						Type:        schema.TypeString,
+						Computed:    true,
+						Description: "Name of the resource",
+					},
+					"role": {
+						Type:        schema.TypeString,
+						Computed:    true,
+						Description: "Disk role",
+					},
+					"sep_id": {
+						Type:        schema.TypeInt,
+						Computed:    true,
+						Description: "Storage endpoint provider ID to create disk",
+					},
+					"shareable": {
+						Type:        schema.TypeBool,
+						Computed:    true,
+						Description: "shareable",
+					},
+					"cache": {
+						Type:        schema.TypeString,
+						Computed:    true,
+						Description: "Cache mode for the disk",
+					},
+					"size_max": {
+						Type:        schema.TypeInt,
+						Computed:    true,
+						Description: "Size in GB",
+					},
+					"size_used": {
+						Type:        schema.TypeFloat,
+						Computed:    true,
+						Description: "Number of used space, in GB",
+					},
+					"snapshots": {
+						Type:     schema.TypeList,
+						Computed: true,
+						Elem: &schema.Resource{
+							Schema: map[string]*schema.Schema{
+								"guid": {
+									Type:        schema.TypeString,
+									Computed:    true,
+									Description: "ID of the snapshot",
+								},
+								"label": {
+									Type:        schema.TypeString,
+									Computed:    true,
+									Description: "Name of the snapshot",
+								},
+								"res_id": {
+									Type:        schema.TypeString,
+									Computed:    true,
+									Description: "Reference to the snapshot",
+								},
+								"snap_set_guid": {
+									Type:        schema.TypeString,
+									Computed:    true,
+									Description: "The set snapshot ID",
+								},
+								"snap_set_time": {
+									Type:        schema.TypeInt,
+									Computed:    true,
+									Description: "The set time of the snapshot",
+								},
+								"timestamp": {
+									Type:        schema.TypeInt,
+									Computed:    true,
+									Description: "Snapshot time",
+								},
+							},
+						},
+					},
+					"status": {
+						Type:        schema.TypeString,
+						Computed:    true,
+						Description: "Disk status",
+					},
+					"tech_status": {
+						Type:        schema.TypeString,
+						Computed:    true,
+						Description: "Technical status of the disk",
+					},
+					"to_clean": {
+						Type:     schema.TypeBool,
+						Computed: true,
+					},
+					"vmid": {
+						Type:        schema.TypeInt,
+						Computed:    true,
+						Description: "Virtual Machine ID (Deprecated)",
+					},
+				},
+			},
+		},
+		"entry_count": {
+			Type:     schema.TypeInt,
+			Computed: true,
+		},
+	}
+	return res
+}

internal/service/cloudapi/disks/data_source_disk_replication.go

@@ -0,0 +1,475 @@
+/*
+Copyright (c) 2019-2024 Digital Energy Cloud Solutions LLC. All Rights Reserved.
+Authors:
+Petr Krutov, <petr.krutov@digitalenergy.online>
+Stanislav Solovev, <spsolovev@digitalenergy.online>
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+/*
+Terraform DECORT provider - manage resources provided by DECORT (Digital Energy Cloud
+Orchestration Technology) with Terraform by Hashicorp.
+
+Source code: https://repository.basistech.ru/BASIS/terraform-provider-decort
+
+Please see README.md to learn where to place source code so that it
+builds seamlessly.
+
+Documentation: https://repository.basistech.ru/BASIS/terraform-provider-decort/wiki
+*/
+
+package disks
+
+import (
+	"context"
+
+	"github.com/google/uuid"
+	log "github.com/sirupsen/logrus"
+	"repository.basistech.ru/BASIS/decort-golang-sdk/pkg/cloudapi/disks"
+	"repository.basistech.ru/BASIS/terraform-provider-decort/internal/constants"
+	"repository.basistech.ru/BASIS/terraform-provider-decort/internal/controller"
+
+	"github.com/hashicorp/terraform-plugin-sdk/v2/diag"
+	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
+)
+
+func dataSourceDiskReplicationRead(ctx context.Context, d *schema.ResourceData, m interface{}) diag.Diagnostics {
+	log.Debugf("dataSourceDiskReplicationRead: called for disk with ID: %s", d.Id())
+	c := m.(*controller.ControllerCfg)
+
+	req := disks.ReplicationStatusRequest{
+		DiskID: uint64(d.Get("disk_id").(int)),
+	}
+
+	status, err := c.CloudAPI().Disks().ReplicationStatus(ctx, req)
+	if err != nil {
+		d.SetId("")
+		return diag.FromErr(err)
+	}
+
+	id := uuid.New()
+	d.SetId(id.String())
+
+	disk, err := utilityDiskReplicaCheckPresence(ctx, d, m)
+	if err != nil {
+		d.SetId("")
+		return diag.FromErr(err)
+	}
+
+	flattenDiskReplica(d, disk, status)
+
+	log.Debugf("dataSourceDiskReplicationRead: read complete for disk with ID: %s", d.Id())
+
+	return nil
+}
+
+func dataSourceDiskReplicationSchemaMake() map[string]*schema.Schema {
+	rets := map[string]*schema.Schema{
+		"disk_id": {
+			Type:        schema.TypeInt,
+			Required:    true,
+			Description: "Id of primary disk",
+		},
+		"replica_disk_id": {
+			Type:        schema.TypeInt,
+			Required:    true,
+			Description: "Id of secondary disk",
+		},
+		"status_replication": {
+			Type:        schema.TypeString,
+			Computed:    true,
+			Description: "Status of replication",
+		},
+		"account_id": {
+			Type:        schema.TypeInt,
+			Computed:    true,
+			Description: "The unique ID of the subscriber-owner of the disk",
+		},
+		"account_name": {
+			Type:        schema.TypeString,
+			Computed:    true,
+			Description: "The name of the subscriber '(account') to whom this disk belongs",
+		},
+		"acl": {
+			Type:     schema.TypeString,
+			Computed: true,
+		},
+		// "boot_partition": {
+		// 	Type:        schema.TypeInt,
+		// 	Computed:    true,
+		// 	Description: "Number of disk partitions",
+		// },
+		"computes": {
+			Type:     schema.TypeList,
+			Computed: true,
+			Elem: &schema.Resource{
+				Schema: map[string]*schema.Schema{
+					"compute_id": {
+						Type:     schema.TypeString,
+						Computed: true,
+					},
+					"compute_name": {
+						Type:     schema.TypeString,
+						Computed: true,
+					},
+				},
+			},
+		},
+		"created_time": {
+			Type:        schema.TypeInt,
+			Computed:    true,
+			Description: "Created time",
+		},
+		"deleted_time": {
+			Type:        schema.TypeInt,
+			Computed:    true,
+			Description: "Deleted time",
+		},
+		"desc": {
+			Type:        schema.TypeString,
+			Computed:    true,
+			Description: "Description of disk",
+		},
+		"destruction_time": {
+			Type:        schema.TypeInt,
+			Computed:    true,
+			Description: "Time of final deletion",
+		},
+		"devicename": {
+			Type:        schema.TypeString,
+			Computed:    true,
+			Description: "Name of the device",
+		},
+		// "disk_path": {
+		// 	Type:        schema.TypeString,
+		// 	Computed:    true,
+		// 	Description: "Disk path",
+		// },
+		"gid": {
+			Type:        schema.TypeInt,
+			Computed:    true,
+			Description: "ID of the grid (platform)",
+		},
+		// "guid": {
+		// 	Type:        schema.TypeInt,
+		// 	Computed:    true,
+		// 	Description: "Disk ID on the storage side",
+		// },
+		"image_id": {
+			Type:        schema.TypeInt,
+			Computed:    true,
+			Description: "Image ID",
+		},
+		"images": {
+			Type:     schema.TypeList,
+			Computed: true,
+			Elem: &schema.Schema{
+				Type: schema.TypeInt,
+			},
+			Description: "IDs of images using the disk",
+		},
+		"iotune": {
+			Type:     schema.TypeList,
+			Computed: true,
+			Elem: &schema.Resource{
+				Schema: map[string]*schema.Schema{
+					"read_bytes_sec": {
+						Type:        schema.TypeInt,
+						Computed:    true,
+						Description: "Number of bytes to read per second",
+					},
+					"read_bytes_sec_max": {
+						Type:        schema.TypeInt,
+						Computed:    true,
+						Description: "Maximum number of bytes to read",
+					},
+					"read_iops_sec": {
+						Type:        schema.TypeInt,
+						Computed:    true,
+						Description: "Number of io read operations per second",
+					},
+					"read_iops_sec_max": {
+						Type:        schema.TypeInt,
+						Computed:    true,
+						Description: "Maximum number of io read operations",
+					},
+					"size_iops_sec": {
+						Type:        schema.TypeInt,
+						Computed:    true,
+						Description: "Size of io operations",
+					},
+					"total_bytes_sec": {
+						Type:        schema.TypeInt,
+						Computed:    true,
+						Description: "Total size bytes per second",
+					},
+					"total_bytes_sec_max": {
+						Type:        schema.TypeInt,
+						Computed:    true,
+						Description: "Maximum total size of bytes per second",
+					},
+					"total_iops_sec": {
+						Type:        schema.TypeInt,
+						Computed:    true,
+						Description: "Total number of io operations per second",
+					},
+					"total_iops_sec_max": {
+						Type:        schema.TypeInt,
+						Computed:    true,
+						Description: "Maximum total number of io operations per second",
+					},
+					"write_bytes_sec": {
+						Type:        schema.TypeInt,
+						Computed:    true,
+						Description: "Number of bytes to write per second",
+					},
+					"write_bytes_sec_max": {
+						Type:        schema.TypeInt,
+						Computed:    true,
+						Description: "Maximum number of bytes to write per second",
+					},
+					"write_iops_sec": {
+						Type:        schema.TypeInt,
+						Computed:    true,
+						Description: "Number of write operations per second",
+					},
+					"write_iops_sec_max": {
+						Type:        schema.TypeInt,
+						Computed:    true,
+						Description: "Maximum number of write operations per second",
+					},
+				},
+			},
+		},
+		// "iqn": {
+		// 	Type:        schema.TypeString,
+		// 	Computed:    true,
+		// 	Description: "Disk IQN",
+		// },
+		// "login": {
+		// 	Type:        schema.TypeString,
+		// 	Computed:    true,
+		// 	Description: "Login to access the disk",
+		// },
+		// "milestones": {
+		// 	Type:        schema.TypeInt,
+		// 	Computed:    true,
+		// 	Description: "Milestones",
+		// },
+		"disk_name": {
+			Type:        schema.TypeString,
+			Computed:    true,
+			Description: "Name of disk",
+		},
+		"order": {
+			Type:        schema.TypeInt,
+			Computed:    true,
+			Description: "Disk order",
+		},
+		"params": {
+			Type:        schema.TypeString,
+			Computed:    true,
+			Description: "Disk params",
+		},
+		"parent_id": {
+			Type:        schema.TypeInt,
+			Computed:    true,
+			Description: "ID of the parent disk",
+		},
+		// "passwd": {
+		// 	Type:        schema.TypeString,
+		// 	Computed:    true,
+		// 	Description: "Password to access the disk",
+		// },
+		"pci_slot": {
+			Type:        schema.TypeInt,
+			Computed:    true,
+			Description: "ID of the pci slot to which the disk is connected",
+		},
+		"pool": {
+			Type:        schema.TypeString,
+			Computed:    true,
+			Description: "Pool for disk location",
+		},
+		"present_to": {
+			Type:     schema.TypeMap,
+			Computed: true,
+			Elem: &schema.Schema{
+				Type: schema.TypeInt,
+			},
+		},
+		// "purge_attempts": {
+		// 	Type:        schema.TypeInt,
+		// 	Computed:    true,
+		// 	Description: "Number of deletion attempts",
+		// },
+		"purge_time": {
+			Type:        schema.TypeInt,
+			Computed:    true,
+			Description: "Time of the last deletion attempt",
+		},
+		"replication": {
+			Type:     schema.TypeList,
+			Computed: true,
+			Elem: &schema.Resource{
+				Schema: map[string]*schema.Schema{
+					"disk_id": {
+						Type:     schema.TypeInt,
+						Computed: true,
+					},
+					"pool_id": {
+						Type:     schema.TypeString,
+						Computed: true,
+					},
+					"role": {
+						Type:     schema.TypeString,
+						Computed: true,
+					},
+					"self_volume_id": {
+						Type:     schema.TypeString,
+						Computed: true,
+					},
+					"storage_id": {
+						Type:     schema.TypeString,
+						Computed: true,
+					},
+					"volume_id": {
+						Type:     schema.TypeString,
+						Computed: true,
+					},
+				},
+			},
+			Description: "Replication status",
+		},
+		// "reality_device_number": {
+		// 	Type:        schema.TypeInt,
+		// 	Computed:    true,
+		// 	Description: "Reality device number",
+		// },
+		// "reference_id": {
+		// 	Type:        schema.TypeString,
+		// 	Computed:    true,
+		// 	Description: "ID of the reference to the disk",
+		// },
+		"res_id": {
+			Type:        schema.TypeString,
+			Computed:    true,
+			Description: "Resource ID",
+		},
+		"res_name": {
+			Type:        schema.TypeString,
+			Computed:    true,
+			Description: "Name of the resource",
+		},
+		"role": {
+			Type:        schema.TypeString,
+			Computed:    true,
+			Description: "Disk role",
+		},
+		"sep_id": {
+			Type:        schema.TypeInt,
+			Computed:    true,
+			Description: "Storage endpoint provider ID to create disk",
+		},
+		"sep_type": {
+			Type:        schema.TypeString,
+			Computed:    true,
+			Description: "Type SEP. Defines the type of storage system and contains one of the values set in the cloud platform",
+		},
+		"shareable": {
+			Type:     schema.TypeBool,
+			Computed: true,
+		},
+		"size_max": {
+			Type:        schema.TypeInt,
+			Computed:    true,
+			Description: "Size in GB",
+		},
+		"size_used": {
+			Type:        schema.TypeFloat,
+			Computed:    true,
+			Description: "Number of used space, in GB",
+		},
+		"snapshots": {
+			Type:     schema.TypeList,
+			Computed: true,
+			Elem: &schema.Resource{
+				Schema: map[string]*schema.Schema{
+					"guid": {
+						Type:        schema.TypeString,
+						Computed:    true,
+						Description: "ID of the snapshot",
+					},
+					"label": {
+						Type:        schema.TypeString,
+						Computed:    true,
+						Description: "Name of the snapshot",
+					},
+					"res_id": {
+						Type:        schema.TypeString,
+						Computed:    true,
+						Description: "Reference to the snapshot",
+					},
+					"snap_set_guid": {
+						Type:        schema.TypeString,
+						Computed:    true,
+						Description: "The set snapshot ID",
+					},
+					"snap_set_time": {
+						Type:        schema.TypeInt,
+						Computed:    true,
+						Description: "The set time of the snapshot",
+					},
+					"timestamp": {
+						Type:        schema.TypeInt,
+						Computed:    true,
+						Description: "Snapshot time",
+					},
+				},
+			},
+		},
+		"status": {
+			Type:        schema.TypeString,
+			Computed:    true,
+			Description: "Disk status",
+		},
+		"tech_status": {
+			Type:        schema.TypeString,
+			Computed:    true,
+			Description: "Technical status of the disk",
+		},
+		"vmid": {
+			Type:        schema.TypeInt,
+			Computed:    true,
+			Description: "Virtual Machine ID (Deprecated)",
+		},
+	}
+
+	return rets
+}
+
+func DataSourceDiskReplication() *schema.Resource {
+	return &schema.Resource{
+		SchemaVersion: 1,
+
+		ReadContext: dataSourceDiskReplicationRead,
+
+		Timeouts: &schema.ResourceTimeout{
+			Read:    &constants.Timeout30s,
+			Default: &constants.Timeout60s,
+		},
+
+		Schema: dataSourceDiskReplicationSchemaMake(),
+	}
+}

internal/service/cloudapi/disks/data_source_disk_snapshot.go

@@ -0,0 +1,126 @@
+/*
+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 disks
+
+import (
+	"context"
+
+	"github.com/google/uuid"
+	"github.com/hashicorp/terraform-plugin-sdk/v2/diag"
+	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
+	"repository.basistech.ru/BASIS/decort-golang-sdk/pkg/cloudapi/disks"
+	"repository.basistech.ru/BASIS/terraform-provider-decort/internal/constants"
+)
+
+func dataSourceDiskSnapshotRead(ctx context.Context, d *schema.ResourceData, m interface{}) diag.Diagnostics {
+	disk, err := utilityDiskCheckPresence(ctx, d, m)
+	if err != nil {
+		d.SetId("")
+		return diag.FromErr(err)
+	}
+
+	var snapshot disks.ItemSnapshot
+	label := d.Get("label").(string)
+	for _, sn := range disk.Snapshots {
+		if label == sn.Label {
+			snapshot = sn
+			break
+		}
+	}
+	if label != snapshot.Label {
+		return diag.Errorf("Snapshot with label \"%v\" not found", label)
+	}
+
+	id := uuid.New()
+	d.SetId(id.String())
+
+	flattenDiskSnapshot(d, snapshot)
+
+	return nil
+}
+
+func DataSourceDiskSnapshot() *schema.Resource {
+	return &schema.Resource{
+		SchemaVersion: 1,
+
+		ReadContext: dataSourceDiskSnapshotRead,
+
+		Timeouts: &schema.ResourceTimeout{
+			Read:    &constants.Timeout30s,
+			Default: &constants.Timeout60s,
+		},
+
+		Schema: dataSourceDiskSnapshotSchemaMake(),
+	}
+}
+
+func dataSourceDiskSnapshotSchemaMake() map[string]*schema.Schema {
+	rets := map[string]*schema.Schema{
+		"disk_id": {
+			Type:        schema.TypeInt,
+			Required:    true,
+			Description: "The unique ID of the subscriber-owner of the disk",
+		},
+		"label": {
+			Type:        schema.TypeString,
+			Required:    true,
+			Description: "Name of the snapshot",
+		},
+		"guid": {
+			Type:        schema.TypeString,
+			Computed:    true,
+			Description: "ID of the snapshot",
+		},
+		"timestamp": {
+			Type:        schema.TypeInt,
+			Computed:    true,
+			Description: "Snapshot time",
+		},
+		"res_id": {
+			Type:        schema.TypeString,
+			Computed:    true,
+			Description: "Reference to the snapshot",
+		},
+		"snap_set_guid": {
+			Type:        schema.TypeString,
+			Computed:    true,
+			Description: "The set snapshot ID",
+		},
+		"snap_set_time": {
+			Type:        schema.TypeInt,
+			Computed:    true,
+			Description: "The set time of the snapshot",
+		},
+	}
+	return rets
+}

internal/service/cloudapi/disks/data_source_disk_snapshot_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 disks
+
+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 dataSourceDiskSnapshotListRead(ctx context.Context, d *schema.ResourceData, m interface{}) diag.Diagnostics {
+	disk, err := utilityDiskCheckPresence(ctx, d, m)
+	if err != nil {
+		d.SetId("")
+		return diag.FromErr(err)
+	}
+
+	id := uuid.New()
+	d.SetId(id.String())
+	d.Set("items", flattenDiskSnapshotList(disk.Snapshots))
+	return nil
+}
+
+func DataSourceDiskSnapshotList() *schema.Resource {
+	return &schema.Resource{
+		SchemaVersion: 1,
+
+		ReadContext: dataSourceDiskSnapshotListRead,
+
+		Timeouts: &schema.ResourceTimeout{
+			Read:    &constants.Timeout30s,
+			Default: &constants.Timeout60s,
+		},
+
+		Schema: dataSourceDiskSnapshotListSchemaMake(),
+	}
+}
+
+func dataSourceDiskSnapshotListSchemaMake() map[string]*schema.Schema {
+	rets := map[string]*schema.Schema{
+		"disk_id": {
+			Type:        schema.TypeInt,
+			Required:    true,
+			Description: "The unique ID of the subscriber-owner of the disk",
+		},
+		"items": {
+			Type:     schema.TypeList,
+			Computed: true,
+			Elem: &schema.Resource{
+				Schema: map[string]*schema.Schema{
+					"label": {
+						Type:        schema.TypeString,
+						Computed:    true,
+						Description: "Name of the snapshot",
+					},
+					"guid": {
+						Type:        schema.TypeString,
+						Computed:    true,
+						Description: "ID of the snapshot",
+					},
+					"timestamp": {
+						Type:        schema.TypeInt,
+						Computed:    true,
+						Description: "Snapshot time",
+					},
+					"res_id": {
+						Type:        schema.TypeString,
+						Computed:    true,
+						Description: "Reference to the snapshot",
+					},
+					"snap_set_guid": {
+						Type:        schema.TypeString,
+						Computed:    true,
+						Description: "The set snapshot ID",
+					},
+					"snap_set_time": {
+						Type:        schema.TypeInt,
+						Computed:    true,
+						Description: "The set time of the snapshot",
+					},
+				},
+			},
+		},
+	}
+	return rets
+}

internal/service/cloudapi/disks/data_source_list_deleted.go

@@ -0,0 +1,562 @@
+/*
+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 disks
+
+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 dataSourceDiskListDeletedRead(ctx context.Context, d *schema.ResourceData, m interface{}) diag.Diagnostics {
+	diskList, err := utilityDiskListDeletedCheckPresence(ctx, d, m)
+	if err != nil {
+		d.SetId("")
+		return diag.FromErr(err)
+	}
+
+	id := uuid.New()
+	d.SetId(id.String())
+	d.Set("items", flattenDiskList(diskList))
+	d.Set("entry_count", diskList.EntryCount)
+
+	return nil
+}
+
+func dataSourceDiskDeletedListSchemaMake() map[string]*schema.Schema {
+	res := map[string]*schema.Schema{
+		"by_id": {
+			Type:        schema.TypeInt,
+			Optional:    true,
+			Description: "Filter by disk ID",
+		},
+		"name": {
+			Type:        schema.TypeString,
+			Optional:    true,
+			Description: "Filter by disk name",
+		},
+		"account_name": {
+			Type:        schema.TypeString,
+			Optional:    true,
+			Description: "Filter by account name",
+		},
+		"disk_max_size": {
+			Type:        schema.TypeInt,
+			Optional:    true,
+			Description: "Filter by max disk size",
+		},
+		"shared": {
+			Type:        schema.TypeBool,
+			Optional:    true,
+			Description: "Find shared disks",
+		},
+		"account_id": {
+			Type:        schema.TypeInt,
+			Optional:    true,
+			Description: "ID of the account the disks belong to",
+		},
+		"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,
+						Description: "The unique ID of the subscriber-owner of the disk",
+					},
+					"account_name": {
+						Type:        schema.TypeString,
+						Computed:    true,
+						Description: "The name of the subscriber '(account') to whom this disk belongs",
+					},
+					"acl": {
+						Type:     schema.TypeString,
+						Computed: true,
+					},
+					"discard": {
+						Type:     schema.TypeString,
+						Computed: true,
+					},
+					"block_size": {
+						Type:     schema.TypeString,
+						Computed: true,
+					},
+					// "boot_partition": {
+					// 	Type:        schema.TypeInt,
+					// 	Computed:    true,
+					// 	Description: "Number of disk partitions",
+					// },
+					"computes": {
+						Type:     schema.TypeList,
+						Computed: true,
+						Elem: &schema.Resource{
+							Schema: map[string]*schema.Schema{
+								"compute_id": {
+									Type:     schema.TypeString,
+									Computed: true,
+								},
+								"compute_name": {
+									Type:     schema.TypeString,
+									Computed: true,
+								},
+							},
+						},
+					},
+					"created_by": {
+						Type:     schema.TypeString,
+						Computed: true,
+					},
+					"created_time": {
+						Type:        schema.TypeInt,
+						Computed:    true,
+						Description: "Created time",
+					},
+					"deleted_by": {
+						Type:     schema.TypeString,
+						Computed: true,
+					},
+					"deleted_time": {
+						Type:        schema.TypeInt,
+						Computed:    true,
+						Description: "Deleted time",
+					},
+					"desc": {
+						Type:        schema.TypeString,
+						Computed:    true,
+						Description: "Description of disk",
+					},
+					"destruction_time": {
+						Type:        schema.TypeInt,
+						Computed:    true,
+						Description: "Time of final deletion",
+					},
+					"devicename": {
+						Type:        schema.TypeString,
+						Computed:    true,
+						Description: "Name of the device",
+					},
+					// "disk_path": {
+					// 	Type:        schema.TypeString,
+					// 	Computed:    true,
+					// 	Description: "Disk path",
+					// },
+					"gid": {
+						Type:        schema.TypeInt,
+						Computed:    true,
+						Description: "ID of the grid (platform)",
+					},
+					// "guid": {
+					// 	Type:        schema.TypeInt,
+					// 	Computed:    true,
+					// 	Description: "Disk ID on the storage side",
+					// },
+					"disk_id": {
+						Type:        schema.TypeInt,
+						Computed:    true,
+						Description: "The unique ID of the subscriber-owner of the disk",
+					},
+					"image_id": {
+						Type:        schema.TypeInt,
+						Computed:    true,
+						Description: "Image ID",
+					},
+					"images": {
+						Type:     schema.TypeList,
+						Computed: true,
+						Elem: &schema.Schema{
+							Type: schema.TypeInt,
+						},
+						Description: "IDs of images using the disk",
+					},
+					"independent": {
+						Type:     schema.TypeBool,
+						Computed: true,
+					},
+					"iotune": {
+						Type:     schema.TypeList,
+						Computed: true,
+						Elem: &schema.Resource{
+							Schema: map[string]*schema.Schema{
+								"read_bytes_sec": {
+									Type:        schema.TypeInt,
+									Computed:    true,
+									Description: "Number of bytes to read per second",
+								},
+								"read_bytes_sec_max": {
+									Type:        schema.TypeInt,
+									Computed:    true,
+									Description: "Maximum number of bytes to read",
+								},
+								"read_iops_sec": {
+									Type:        schema.TypeInt,
+									Computed:    true,
+									Description: "Number of io read operations per second",
+								},
+								"read_iops_sec_max": {
+									Type:        schema.TypeInt,
+									Computed:    true,
+									Description: "Maximum number of io read operations",
+								},
+								"size_iops_sec": {
+									Type:        schema.TypeInt,
+									Computed:    true,
+									Description: "Size of io operations",
+								},
+								"total_bytes_sec": {
+									Type:        schema.TypeInt,
+									Computed:    true,
+									Description: "Total size bytes per second",
+								},
+								"total_bytes_sec_max": {
+									Type:        schema.TypeInt,
+									Computed:    true,
+									Description: "Maximum total size of bytes per second",
+								},
+								"total_iops_sec": {
+									Type:        schema.TypeInt,
+									Computed:    true,
+									Description: "Total number of io operations per second",
+								},
+								"total_iops_sec_max": {
+									Type:        schema.TypeInt,
+									Computed:    true,
+									Description: "Maximum total number of io operations per second",
+								},
+								"write_bytes_sec": {
+									Type:        schema.TypeInt,
+									Computed:    true,
+									Description: "Number of bytes to write per second",
+								},
+								"write_bytes_sec_max": {
+									Type:        schema.TypeInt,
+									Computed:    true,
+									Description: "Maximum number of bytes to write per second",
+								},
+								"write_iops_sec": {
+									Type:        schema.TypeInt,
+									Computed:    true,
+									Description: "Number of write operations per second",
+								},
+								"write_iops_sec_max": {
+									Type:        schema.TypeInt,
+									Computed:    true,
+									Description: "Maximum number of write operations per second",
+								},
+							},
+						},
+					},
+					// "iqn": {
+					// 	Type:        schema.TypeString,
+					// 	Computed:    true,
+					// 	Description: "Disk IQN",
+					// },
+					// "login": {
+					// 	Type:        schema.TypeString,
+					// 	Computed:    true,
+					// 	Description: "Login to access the disk",
+					// },
+					"machine_id": {
+						Type:        schema.TypeInt,
+						Computed:    true,
+						Description: "Machine ID",
+					},
+					"machine_name": {
+						Type:        schema.TypeString,
+						Computed:    true,
+						Description: "Machine name",
+					},
+					"milestones": {
+						Type:        schema.TypeInt,
+						Computed:    true,
+						Description: "Milestones",
+					},
+					"disk_name": {
+						Type:        schema.TypeString,
+						Computed:    true,
+						Description: "Name of disk",
+					},
+					"order": {
+						Type:        schema.TypeInt,
+						Computed:    true,
+						Description: "Disk order",
+					},
+					"params": {
+						Type:        schema.TypeString,
+						Computed:    true,
+						Description: "Disk params",
+					},
+					"parent_id": {
+						Type:        schema.TypeInt,
+						Computed:    true,
+						Description: "ID of the parent disk",
+					},
+					// "passwd": {
+					// 	Type:        schema.TypeString,
+					// 	Computed:    true,
+					// 	Description: "Password to access the disk",
+					// },
+					"pci_slot": {
+						Type:        schema.TypeInt,
+						Computed:    true,
+						Description: "ID of the pci slot to which the disk is connected",
+					},
+					"pool": {
+						Type:        schema.TypeString,
+						Computed:    true,
+						Description: "Pool for disk location",
+					},
+					"present_to": {
+						Type:     schema.TypeMap,
+						Computed: true,
+						Elem: &schema.Schema{
+							Type: schema.TypeInt,
+						},
+					},
+					"provision": {
+						Type:     schema.TypeString,
+						Computed: true,
+					},
+					// "purge_attempts": {
+					// 	Type:        schema.TypeInt,
+					// 	Computed:    true,
+					// 	Description: "Number of deletion attempts",
+					// },
+					"purge_time": {
+						Type:        schema.TypeInt,
+						Computed:    true,
+						Description: "Time of the last deletion attempt",
+					},
+					"replication": {
+						Type:     schema.TypeList,
+						Computed: true,
+						Elem: &schema.Resource{
+							Schema: map[string]*schema.Schema{
+								"disk_id": {
+									Type:     schema.TypeInt,
+									Computed: true,
+								},
+								"pool_id": {
+									Type:     schema.TypeString,
+									Computed: true,
+								},
+								"role": {
+									Type:     schema.TypeString,
+									Computed: true,
+								},
+								"self_volume_id": {
+									Type:     schema.TypeString,
+									Computed: true,
+								},
+								"storage_id": {
+									Type:     schema.TypeString,
+									Computed: true,
+								},
+								"volume_id": {
+									Type:     schema.TypeString,
+									Computed: true,
+								},
+							},
+						},
+						Description: "Replication status",
+					},
+					// "reality_device_number": {
+					// 	Type:        schema.TypeInt,
+					// 	Computed:    true,
+					// 	Description: "Reality device number",
+					// },
+					// "reference_id": {
+					// 	Type:        schema.TypeString,
+					// 	Computed:    true,
+					// 	Description: "ID of the reference to the disk",
+					// },
+					"res_id": {
+						Type:        schema.TypeString,
+						Computed:    true,
+						Description: "Resource ID",
+					},
+					"res_name": {
+						Type:        schema.TypeString,
+						Computed:    true,
+						Description: "Name of the resource",
+					},
+					"role": {
+						Type:        schema.TypeString,
+						Computed:    true,
+						Description: "Disk role",
+					},
+					"sep_id": {
+						Type:        schema.TypeInt,
+						Computed:    true,
+						Description: "Storage endpoint provider ID to create disk",
+					},
+					"sep_type": {
+						Type:        schema.TypeString,
+						Computed:    true,
+						Description: "Type SEP. Defines the type of storage system and contains one of the values set in the cloud platform",
+					},
+					"shareable": {
+						Type:     schema.TypeBool,
+						Computed: true,
+					},
+					"cache": {
+						Type:     schema.TypeString,
+						Computed: true,
+					},
+					"size_available": {
+						Type:     schema.TypeFloat,
+						Computed: true,
+					},
+					"size_max": {
+						Type:        schema.TypeInt,
+						Computed:    true,
+						Description: "Size in GB",
+					},
+					"size_used": {
+						Type:        schema.TypeFloat,
+						Computed:    true,
+						Description: "Number of used space, in GB",
+					},
+					"snapshots": {
+						Type:     schema.TypeList,
+						Computed: true,
+						Elem: &schema.Resource{
+							Schema: map[string]*schema.Schema{
+								"guid": {
+									Type:        schema.TypeString,
+									Computed:    true,
+									Description: "ID of the snapshot",
+								},
+								"label": {
+									Type:        schema.TypeString,
+									Computed:    true,
+									Description: "Name of the snapshot",
+								},
+								"res_id": {
+									Type:        schema.TypeString,
+									Computed:    true,
+									Description: "Reference to the snapshot",
+								},
+								"snap_set_guid": {
+									Type:        schema.TypeString,
+									Computed:    true,
+									Description: "The set snapshot ID",
+								},
+								"snap_set_time": {
+									Type:        schema.TypeInt,
+									Computed:    true,
+									Description: "The set time of the snapshot",
+								},
+								"timestamp": {
+									Type:        schema.TypeInt,
+									Computed:    true,
+									Description: "Snapshot time",
+								},
+							},
+						},
+					},
+					"status": {
+						Type:        schema.TypeString,
+						Computed:    true,
+						Description: "Disk status",
+					},
+					"storage_policy_id": {
+						Type:        schema.TypeFloat,
+						Computed:    true,
+						Description: "Storage policy ID",
+					},
+					"tech_status": {
+						Type:        schema.TypeString,
+						Computed:    true,
+						Description: "Technical status of the disk",
+					},
+					"vmid": {
+						Type:        schema.TypeInt,
+						Computed:    true,
+						Description: "Virtual Machine ID (Deprecated)",
+					},
+					"updated_by": {
+						Type:     schema.TypeString,
+						Computed: true,
+					},
+					"updated_time": {
+						Type:     schema.TypeInt,
+						Computed: true,
+					},
+					"to_clean": {
+						Type:     schema.TypeBool,
+						Computed: true,
+					},
+				},
+			},
+		},
+		"entry_count": {
+			Type:     schema.TypeInt,
+			Computed: true,
+		},
+	}
+	return res
+}
+
+func DataSourceDiskListDeleted() *schema.Resource {
+	return &schema.Resource{
+		SchemaVersion: 1,
+		ReadContext:   dataSourceDiskListDeletedRead,
+
+		Timeouts: &schema.ResourceTimeout{
+			Read:    &constants.Timeout30s,
+			Default: &constants.Timeout60s,
+		},
+
+		Schema: dataSourceDiskDeletedListSchemaMake(),
+	}
+}

internal/service/cloudapi/disks/flattens.go

@@ -0,0 +1,313 @@
+package disks
+
+import (
+	"encoding/json"
+
+	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
+	"repository.basistech.ru/BASIS/decort-golang-sdk/pkg/cloudapi/disks"
+	"repository.basistech.ru/BASIS/terraform-provider-decort/internal/flattens"
+)
+
+func flattenDiskSnapshot(d *schema.ResourceData, snapshot disks.ItemSnapshot) {
+	d.Set("timestamp", snapshot.TimeStamp)
+	d.Set("guid", snapshot.GUID)
+	d.Set("res_id", snapshot.ResID)
+	d.Set("snap_set_guid", snapshot.SnapSetGUID)
+	d.Set("snap_set_time", snapshot.SnapSetTime)
+}
+
+func flattenDiskListUnattached(ul *disks.ListDisksUnattached) []map[string]interface{} {
+	res := make([]map[string]interface{}, 0, len(ul.Data))
+	for _, unattachedDisk := range ul.Data {
+		unattachedDiskAcl, _ := json.Marshal(unattachedDisk.ACL)
+		tmp := map[string]interface{}{
+			"_meta":                 flattens.FlattenMeta(unattachedDisk.Meta),
+			"account_id":            unattachedDisk.AccountID,
+			"account_name":          unattachedDisk.AccountName,
+			"acl":                   string(unattachedDiskAcl),
+			"discard":               unattachedDisk.Discard,
+			"block_size":            unattachedDisk.BlockSize,
+			"boot_partition":        unattachedDisk.BootPartition,
+			"created_time":          unattachedDisk.CreatedTime,
+			"deleted_time":          unattachedDisk.DeletedTime,
+			"desc":                  unattachedDisk.Description,
+			"destruction_time":      unattachedDisk.DestructionTime,
+			"disk_path":             unattachedDisk.DiskPath,
+			"gid":                   unattachedDisk.GID,
+			"guid":                  unattachedDisk.GUID,
+			"disk_id":               unattachedDisk.ID,
+			"image_id":              unattachedDisk.ImageID,
+			"images":                unattachedDisk.Images,
+			"iotune":                flattenIOTune(unattachedDisk.IOTune),
+			"iqn":                   unattachedDisk.IQN,
+			"login":                 unattachedDisk.Login,
+			"milestones":            unattachedDisk.Milestones,
+			"disk_name":             unattachedDisk.Name,
+			"order":                 unattachedDisk.Order,
+			"params":                unattachedDisk.Params,
+			"parent_id":             unattachedDisk.ParentID,
+			"passwd":                unattachedDisk.Password,
+			"pci_slot":              unattachedDisk.PCISlot,
+			"pool":                  unattachedDisk.Pool,
+			"present_to":            unattachedDisk.PresentTo,
+			"provision":             unattachedDisk.Provision,
+			"purge_attempts":        unattachedDisk.PurgeAttempts,
+			"purge_time":            unattachedDisk.PurgeTime,
+			"reality_device_number": unattachedDisk.RealityDeviceNumber,
+			"reference_id":          unattachedDisk.ReferenceID,
+			"res_id":                unattachedDisk.ResID,
+			"res_name":              unattachedDisk.ResName,
+			"role":                  unattachedDisk.Role,
+			"sep_id":                unattachedDisk.SEPID,
+			"shareable":             unattachedDisk.Shareable,
+			"cache":                 unattachedDisk.Cache,
+			"size_max":              unattachedDisk.SizeMax,
+			"size_used":             unattachedDisk.SizeUsed,
+			"snapshots":             flattenDiskSnapshotList(unattachedDisk.Snapshots),
+			"status":                unattachedDisk.Status,
+			"to_clean":              unattachedDisk.ToClean,
+			"tech_status":           unattachedDisk.TechStatus,
+			"vmid":                  unattachedDisk.VMID,
+		}
+		res = append(res, tmp)
+	}
+	return res
+}
+
+func flattenDisk(d *schema.ResourceData, disk *disks.RecordDisk) {
+	diskAcl, _ := json.Marshal(disk.ACL)
+	d.Set("account_id", disk.AccountID)
+	d.Set("account_name", disk.AccountName)
+	d.Set("acl", string(diskAcl))
+	d.Set("discard", disk.Discard)
+	d.Set("block_size", disk.BlockSize)
+	// d.Set("boot_partition", disk.BootPartition)
+	d.Set("computes", flattenDiskComputes(disk.Computes))
+	d.Set("created_by", disk.CreatedBy)
+	d.Set("created_time", disk.CreatedTime)
+	d.Set("deleted_by", disk.DeletedBy)
+	d.Set("deleted_time", disk.DeletedTime)
+	d.Set("desc", disk.Description)
+	d.Set("destruction_time", disk.DestructionTime)
+	d.Set("devicename", disk.DeviceName)
+	// d.Set("disk_path", disk.DiskPath)
+	d.Set("gid", disk.GID)
+	// d.Set("guid", disk.GUID)
+	d.Set("disk_id", disk.ID)
+	d.Set("image_id", disk.ImageID)
+	d.Set("images", disk.Images)
+	d.Set("iotune", flattenIOTune(disk.IOTune))
+	// d.Set("iqn", disk.IQN)
+	// d.Set("login", disk.Login)
+	d.Set("independent", disk.Independent)
+	d.Set("machine_id", disk.MachineID)
+	d.Set("machine_name", disk.MachineName)
+	d.Set("disk_name", disk.Name)
+	d.Set("order", disk.Order)
+	d.Set("params", disk.Params)
+	d.Set("parent_id", disk.ParentID)
+	// d.Set("passwd", disk.Passwd)
+	d.Set("pci_slot", disk.PCISlot)
+	d.Set("pool", disk.Pool)
+	d.Set("present_to", disk.PresentTo)
+	d.Set("provision", disk.Provision)
+	// d.Set("purge_attempts", disk.PurgeAttempts)
+	d.Set("purge_time", disk.PurgeTime)
+	d.Set("replication", flattenDiskReplication(disk.Replication))
+	// d.Set("reality_device_number", disk.RealityDeviceNumber)
+	// d.Set("reference_id", disk.ReferenceID)
+	d.Set("res_id", disk.ResID)
+	d.Set("res_name", disk.ResName)
+	d.Set("role", disk.Role)
+	d.Set("sep_id", disk.SepID)
+	d.Set("sep_type", disk.SepType)
+	d.Set("size_max", disk.SizeMax)
+	d.Set("size_used", disk.SizeUsed)
+	d.Set("shareable", disk.Shareable)
+	d.Set("cache", disk.Cache)
+	d.Set("snapshots", flattenDiskSnapshotList(disk.Snapshots))
+	d.Set("status", disk.Status)
+	d.Set("storage_policy_id", disk.StoragePolicyID)
+	d.Set("tech_status", disk.TechStatus)
+	d.Set("vmid", disk.VMID)
+	d.Set("updated_by", disk.UpdatedBy)
+	d.Set("updated_time", disk.UpdatedTime)
+	d.Set("to_clean", disk.ToClean)
+}
+
+func flattenDiskReplication(rep disks.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 flattenDiskReplica(d *schema.ResourceData, disk *disks.RecordDisk, statusReplication string) {
+	diskAcl, _ := json.Marshal(disk.ACL)
+	d.Set("account_id", disk.AccountID)
+	d.Set("account_name", disk.AccountName)
+	d.Set("acl", string(diskAcl))
+	// d.Set("boot_partition", disk.BootPartition)
+	d.Set("computes", flattenDiskComputes(disk.Computes))
+	d.Set("created_time", disk.CreatedTime)
+	d.Set("deleted_time", disk.DeletedTime)
+	d.Set("desc", disk.Description)
+	d.Set("destruction_time", disk.DestructionTime)
+	d.Set("devicename", disk.DeviceName)
+	// d.Set("disk_path", disk.DiskPath)
+	d.Set("gid", disk.GID)
+	// d.Set("guid", disk.GUID)
+	d.Set("replica_disk_id", disk.ID)
+	d.Set("image_id", disk.ImageID)
+	d.Set("images", disk.Images)
+	d.Set("iotune", flattenIOTune(disk.IOTune))
+	// d.Set("iqn", disk.IQN)
+	// d.Set("login", disk.Login)
+	// d.Set("milestones", disk.Milestones)
+	d.Set("disk_name", disk.Name)
+	d.Set("order", disk.Order)
+	d.Set("params", disk.Params)
+	d.Set("parent_id", disk.ParentID)
+	// d.Set("passwd", disk.Passwd)
+	d.Set("pci_slot", disk.PCISlot)
+	d.Set("pool", disk.Pool)
+	d.Set("present_to", disk.PresentTo)
+	// d.Set("purge_attempts", disk.PurgeAttempts)
+	d.Set("purge_time", disk.PurgeTime)
+	d.Set("replication", flattenDiskReplication(disk.Replication))
+	// d.Set("reality_device_number", disk.RealityDeviceNumber)
+	// d.Set("reference_id", disk.ReferenceID)
+	d.Set("res_id", disk.ResID)
+	d.Set("res_name", disk.ResName)
+	d.Set("role", disk.Role)
+	d.Set("sep_id", disk.SepID)
+	d.Set("sep_type", disk.SepType)
+	d.Set("size_max", disk.SizeMax)
+	d.Set("size_used", disk.SizeUsed)
+	d.Set("shareable", disk.Shareable)
+	d.Set("cache", disk.Cache)
+	d.Set("snapshots", flattenDiskSnapshotList(disk.Snapshots))
+	d.Set("status", disk.Status)
+	d.Set("status_replication", statusReplication)
+	d.Set("tech_status", disk.TechStatus)
+	d.Set("vmid", disk.VMID)
+}
+
+func flattenDiskSnapshotList(sl disks.ListSnapshots) []interface{} {
+	res := make([]interface{}, 0, len(sl))
+	for _, snapshot := range sl {
+		temp := map[string]interface{}{
+			"guid":          snapshot.GUID,
+			"label":         snapshot.Label,
+			"res_id":        snapshot.ResID,
+			"snap_set_guid": snapshot.SnapSetGUID,
+			"snap_set_time": snapshot.SnapSetTime,
+			"timestamp":     snapshot.TimeStamp,
+		}
+		res = append(res, temp)
+	}
+
+	return res
+}
+
+func flattenDiskList(dl *disks.ListDisks) []map[string]interface{} {
+	res := make([]map[string]interface{}, 0, len(dl.Data))
+	for _, disk := range dl.Data {
+		diskAcl, _ := json.Marshal(disk.ACL)
+		temp := map[string]interface{}{
+			"account_id":        disk.AccountID,
+			"account_name":      disk.AccountName,
+			"acl":               string(diskAcl),
+			"discard":           disk.Discard,
+			"block_size":        disk.BlockSize,
+			"computes":          flattenDiskComputes(disk.Computes),
+			"created_by":        disk.CreatedBy,
+			"created_time":      disk.CreatedTime,
+			"deleted_by":        disk.DeletedBy,
+			"deleted_time":      disk.DeletedTime,
+			"desc":              disk.Description,
+			"destruction_time":  disk.DestructionTime,
+			"devicename":        disk.DeviceName,
+			"gid":               disk.GID,
+			"disk_id":           disk.ID,
+			"image_id":          disk.ImageID,
+			"images":            disk.Images,
+			"independent":       disk.Independent,
+			"iotune":            flattenIOTune(disk.IOTune),
+			"machine_id":        disk.MachineID,
+			"machine_name":      disk.MachineName,
+			"milestones":        disk.Milestones,
+			"disk_name":         disk.Name,
+			"order":             disk.Order,
+			"params":            disk.Params,
+			"parent_id":         disk.ParentID,
+			"pci_slot":          disk.PCISlot,
+			"pool":              disk.Pool,
+			"present_to":        disk.PresentTo,
+			"provision":         disk.Provision,
+			"purge_time":        disk.PurgeTime,
+			"replication":       flattenDiskReplication(disk.Replication),
+			"res_id":            disk.ResID,
+			"res_name":          disk.ResName,
+			"role":              disk.Role,
+			"sep_id":            disk.SepID,
+			"sep_type":          disk.SepType,
+			"shareable":         disk.Shareable,
+			"cache":             disk.Cache,
+			"size_available":    disk.SizeAvailable,
+			"size_max":          disk.SizeMax,
+			"size_used":         disk.SizeUsed,
+			"snapshots":         flattenDiskSnapshotList(disk.Snapshots),
+			"status":            disk.Status,
+			"storage_policy_id": disk.StoragePolicyID,
+			"tech_status":       disk.TechStatus,
+			"vmid":              disk.VMID,
+			"updated_by":        disk.UpdatedBy,
+			"updated_time":      disk.UpdatedTime,
+			"to_clean":          disk.ToClean,
+		}
+		res = append(res, temp)
+	}
+	return res
+}
+
+func flattenIOTune(iot disks.IOTune) []map[string]interface{} {
+	res := make([]map[string]interface{}, 0)
+	temp := map[string]interface{}{
+		"read_bytes_sec":      iot.ReadBytesSec,
+		"read_bytes_sec_max":  iot.ReadBytesSecMax,
+		"read_iops_sec":       iot.ReadIOPSSec,
+		"read_iops_sec_max":   iot.ReadIOPSSecMax,
+		"size_iops_sec":       iot.SizeIOPSSec,
+		"total_bytes_sec":     iot.TotalBytesSec,
+		"total_bytes_sec_max": iot.TotalBytesSecMax,
+		"total_iops_sec":      iot.TotalIOPSSec,
+		"total_iops_sec_max":  iot.TotalIOPSSecMax,
+		"write_bytes_sec":     iot.WriteBytesSec,
+		"write_bytes_sec_max": iot.WriteBytesSecMax,
+		"write_iops_sec":      iot.WriteIOPSSec,
+		"write_iops_sec_max":  iot.WriteIOPSSecMax,
+	}
+
+	res = append(res, temp)
+	return res
+}
+
+func flattenDiskComputes(computes map[string]string) []map[string]interface{} {
+	res := make([]map[string]interface{}, 0)
+	for computeKey, computeVal := range computes {
+		temp := map[string]interface{}{
+			"compute_id":   computeKey,
+			"compute_name": computeVal,
+		}
+		res = append(res, temp)
+	}
+	return res
+}

internal/service/cloudapi/disks/old_schemas.go

@@ -0,0 +1,430 @@
+package disks
+
+import (
+	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
+	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/validation"
+)
+
+func resourceDiskV1() *schema.Resource {
+	return &schema.Resource{
+		Schema: map[string]*schema.Schema{
+			"account_id": {
+				Type:     schema.TypeInt,
+				Required: true,
+				//ForceNew:    true,
+				Description: "The unique ID of the subscriber-owner of the disk",
+			},
+			"disk_name": {
+				Type:        schema.TypeString,
+				Required:    true,
+				Description: "Name of disk",
+			},
+			"size_max": {
+				Type:        schema.TypeInt,
+				Required:    true,
+				Description: "Size in GB",
+			},
+			"gid": {
+				Type:     schema.TypeInt,
+				Required: true,
+				//ForceNew:    true,
+				Description: "ID of the grid (platform)",
+			},
+			"pool": {
+				Type:        schema.TypeString,
+				Optional:    true,
+				Computed:    true,
+				Description: "Pool for disk location",
+			},
+			"sep_id": {
+				Type:        schema.TypeInt,
+				Optional:    true,
+				Computed:    true,
+				Description: "Storage endpoint provider ID to create disk",
+			},
+			"desc": {
+				Type:        schema.TypeString,
+				Optional:    true,
+				Computed:    true,
+				Description: "Description of disk",
+			},
+			"type": {
+				Type:         schema.TypeString,
+				Optional:     true,
+				Computed:     true,
+				ValidateFunc: validation.StringInSlice([]string{"D", "B", "T"}, false),
+				Description:  "The type of disk in terms of its role in compute: 'B=Boot, D=Data, T=Temp'",
+			},
+			"detach": {
+				Type:        schema.TypeBool,
+				Optional:    true,
+				Default:     false,
+				Description: "Detaching the disk from compute",
+			},
+			"permanently": {
+				Type:        schema.TypeBool,
+				Optional:    true,
+				Default:     false,
+				Description: "Whether to completely delete the disk, works only with non attached disks",
+			},
+			"shareable": {
+				Type:     schema.TypeBool,
+				Optional: true,
+				Computed: true,
+			},
+			"iotune": {
+				Type:     schema.TypeList,
+				Optional: true,
+				MaxItems: 1,
+				Computed: true,
+				Elem: &schema.Resource{
+					Schema: map[string]*schema.Schema{
+						"read_bytes_sec": {
+							Type:        schema.TypeInt,
+							Optional:    true,
+							Computed:    true,
+							Description: "Number of bytes to read per second",
+						},
+						"read_bytes_sec_max": {
+							Type:        schema.TypeInt,
+							Optional:    true,
+							Computed:    true,
+							Description: "Maximum number of bytes to read",
+						},
+						"read_iops_sec": {
+							Type:        schema.TypeInt,
+							Optional:    true,
+							Computed:    true,
+							Description: "Number of io read operations per second",
+						},
+						"read_iops_sec_max": {
+							Type:        schema.TypeInt,
+							Optional:    true,
+							Computed:    true,
+							Description: "Maximum number of io read operations",
+						},
+						"size_iops_sec": {
+							Type:        schema.TypeInt,
+							Optional:    true,
+							Computed:    true,
+							Description: "Size of io operations",
+						},
+						"total_bytes_sec": {
+							Type:        schema.TypeInt,
+							Optional:    true,
+							Computed:    true,
+							Description: "Total size bytes per second",
+						},
+						"total_bytes_sec_max": {
+							Type:        schema.TypeInt,
+							Optional:    true,
+							Computed:    true,
+							Description: "Maximum total size of bytes per second",
+						},
+						"total_iops_sec": {
+							Type:        schema.TypeInt,
+							Optional:    true,
+							Computed:    true,
+							Description: "Total number of io operations per second",
+						},
+						"total_iops_sec_max": {
+							Type:        schema.TypeInt,
+							Optional:    true,
+							Computed:    true,
+							Description: "Maximum total number of io operations per second",
+						},
+						"write_bytes_sec": {
+							Type:        schema.TypeInt,
+							Optional:    true,
+							Computed:    true,
+							Description: "Number of bytes to write per second",
+						},
+						"write_bytes_sec_max": {
+							Type:        schema.TypeInt,
+							Optional:    true,
+							Computed:    true,
+							Description: "Maximum number of bytes to write per second",
+						},
+						"write_iops_sec": {
+							Type:        schema.TypeInt,
+							Optional:    true,
+							Computed:    true,
+							Description: "Number of write operations per second",
+						},
+						"write_iops_sec_max": {
+							Type:        schema.TypeInt,
+							Optional:    true,
+							Computed:    true,
+							Description: "Maximum number of write operations per second",
+						},
+					},
+				},
+			},
+			"present_to": {
+				Type:     schema.TypeList,
+				Computed: true,
+				Elem: &schema.Schema{
+					Type: schema.TypeInt,
+				},
+			},
+			"disk_id": {
+				Type:        schema.TypeInt,
+				Computed:    true,
+				Description: "Disk ID. Duplicates the value of the ID parameter",
+			},
+			"account_name": {
+				Type:        schema.TypeString,
+				Computed:    true,
+				Description: "The name of the subscriber '(account') to whom this disk belongs",
+			},
+			"acl": {
+				Type:     schema.TypeString,
+				Computed: true,
+			},
+			// "boot_partition": {
+			// 	Type:        schema.TypeInt,
+			// 	Computed:    true,
+			// 	Description: "Number of disk partitions",
+			// },
+			"computes": {
+				Type:     schema.TypeList,
+				Computed: true,
+				Elem: &schema.Resource{
+					Schema: map[string]*schema.Schema{
+						"compute_id": {
+							Type:     schema.TypeString,
+							Computed: true,
+						},
+						"compute_name": {
+							Type:     schema.TypeString,
+							Computed: true,
+						},
+					},
+				},
+			},
+			"created_time": {
+				Type:        schema.TypeInt,
+				Computed:    true,
+				Description: "Created time",
+			},
+			"deleted_time": {
+				Type:        schema.TypeInt,
+				Computed:    true,
+				Description: "Deleted time",
+			},
+			"destruction_time": {
+				Type:        schema.TypeInt,
+				Computed:    true,
+				Description: "Time of final deletion",
+			},
+			"devicename": {
+				Type:        schema.TypeString,
+				Computed:    true,
+				Description: "Name of the device",
+			},
+			// "disk_path": {
+			// 	Type:        schema.TypeString,
+			// 	Computed:    true,
+			// 	Description: "Disk path",
+			// },
+			// "guid": {
+			// 	Type:        schema.TypeInt,
+			// 	Computed:    true,
+			// 	Description: "Disk ID on the storage side",
+			// },
+			"image_id": {
+				Type:        schema.TypeInt,
+				Computed:    true,
+				Description: "Image ID",
+			},
+			"images": {
+				Type:     schema.TypeList,
+				Computed: true,
+				Elem: &schema.Schema{
+					Type: schema.TypeString,
+				},
+				Description: "IDs of images using the disk",
+			},
+			// "iqn": {
+			// 	Type:        schema.TypeString,
+			// 	Computed:    true,
+			// 	Description: "Disk IQN",
+			// },
+			// "login": {
+			// 	Type:        schema.TypeString,
+			// 	Computed:    true,
+			// 	Description: "Login to access the disk",
+			// },
+			// "milestones": {
+			// 	Type:        schema.TypeInt,
+			// 	Computed:    true,
+			// 	Description: "Milestones",
+			// },
+			"order": {
+				Type:        schema.TypeInt,
+				Computed:    true,
+				Description: "Disk order",
+			},
+			"params": {
+				Type:        schema.TypeString,
+				Computed:    true,
+				Description: "Disk params",
+			},
+			"parent_id": {
+				Type:        schema.TypeInt,
+				Computed:    true,
+				Description: "ID of the parent disk",
+			},
+			// "passwd": {
+			// 	Type:        schema.TypeString,
+			// 	Computed:    true,
+			// 	Description: "Password to access the disk",
+			// },
+			"pci_slot": {
+				Type:        schema.TypeInt,
+				Computed:    true,
+				Description: "ID of the pci slot to which the disk is connected",
+			},
+			// "purge_attempts": {
+			// 	Type:        schema.TypeInt,
+			// 	Computed:    true,
+			// 	Description: "Number of deletion attempts",
+			// },
+			"purge_time": {
+				Type:        schema.TypeInt,
+				Computed:    true,
+				Description: "Time of the last deletion attempt",
+			},
+			"replication": {
+				Type:     schema.TypeList,
+				Computed: true,
+				Elem: &schema.Resource{
+					Schema: map[string]*schema.Schema{
+						"disk_id": {
+							Type:     schema.TypeInt,
+							Computed: true,
+						},
+						"pool_id": {
+							Type:     schema.TypeString,
+							Computed: true,
+						},
+						"role": {
+							Type:     schema.TypeString,
+							Computed: true,
+						},
+						"self_volume_id": {
+							Type:     schema.TypeString,
+							Computed: true,
+						},
+						"storage_id": {
+							Type:     schema.TypeString,
+							Computed: true,
+						},
+						"volume_id": {
+							Type:     schema.TypeString,
+							Computed: true,
+						},
+					},
+				},
+				Description: "Replication status",
+			},
+			// "reality_device_number": {
+			// 	Type:        schema.TypeInt,
+			// 	Computed:    true,
+			// 	Description: "Reality device number",
+			// },
+			// "reference_id": {
+			// 	Type:        schema.TypeString,
+			// 	Computed:    true,
+			// 	Description: "ID of the reference to the disk",
+			// },
+			"res_id": {
+				Type:        schema.TypeString,
+				Computed:    true,
+				Description: "Resource ID",
+			},
+			"res_name": {
+				Type:        schema.TypeString,
+				Computed:    true,
+				Description: "Name of the resource",
+			},
+			"role": {
+				Type:        schema.TypeString,
+				Computed:    true,
+				Description: "Disk role",
+			},
+			"sep_type": {
+				Type:        schema.TypeString,
+				Computed:    true,
+				Description: "Type SEP. Defines the type of storage system and contains one of the values set in the cloud platform",
+			},
+			"size_used": {
+				Type:        schema.TypeFloat,
+				Computed:    true,
+				Description: "Number of used space, in GB",
+			},
+			"snapshots": {
+				Type:     schema.TypeList,
+				Computed: true,
+				Elem: &schema.Resource{
+					Schema: map[string]*schema.Schema{
+						"guid": {
+							Type:        schema.TypeString,
+							Computed:    true,
+							Description: "ID of the snapshot",
+						},
+						"label": {
+							Type:        schema.TypeString,
+							Computed:    true,
+							Description: "Name of the snapshot",
+						},
+						"res_id": {
+							Type:        schema.TypeString,
+							Computed:    true,
+							Description: "Reference to the snapshot",
+						},
+						"snap_set_guid": {
+							Type:        schema.TypeString,
+							Computed:    true,
+							Description: "The set snapshot ID",
+						},
+						"snap_set_time": {
+							Type:        schema.TypeInt,
+							Computed:    true,
+							Description: "The set time of the snapshot",
+						},
+						"timestamp": {
+							Type:        schema.TypeInt,
+							Computed:    true,
+							Description: "Snapshot time",
+						},
+					},
+				},
+			},
+			"status": {
+				Type:        schema.TypeString,
+				Computed:    true,
+				Description: "Disk status",
+			},
+			"tech_status": {
+				Type:        schema.TypeString,
+				Computed:    true,
+				Description: "Technical status of the disk",
+			},
+			"vmid": {
+				Type:        schema.TypeInt,
+				Computed:    true,
+				Description: "Virtual Machine ID (Deprecated)",
+			},
+		},
+	}
+}
+
+func resourceDiskV2() *schema.Resource {
+	s := resourceDiskSchemaMake()
+	s["blk_discard"] = &schema.Schema{
+		Type:     schema.TypeBool,
+		Computed: true,
+	}
+	return &schema.Resource{Schema: s}
+}

internal/service/cloudapi/disks/resource_check_input_values.go

@@ -0,0 +1,61 @@
+package disks
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
+	"repository.basistech.ru/BASIS/decort-golang-sdk/pkg/cloudapi/account"
+	"repository.basistech.ru/BASIS/decort-golang-sdk/pkg/cloudapi/disks"
+	"repository.basistech.ru/BASIS/decort-golang-sdk/pkg/cloudapi/locations"
+	"repository.basistech.ru/BASIS/terraform-provider-decort/internal/controller"
+)
+
+func existAccountID(ctx context.Context, d *schema.ResourceData, m interface{}) (bool, error) {
+	c := m.(*controller.ControllerCfg)
+	accountId := uint64(d.Get("account_id").(int))
+	req := account.ListRequest{}
+
+	accountList, err := c.CloudAPI().Account().List(ctx, req)
+	if err != nil {
+		return false, err
+	}
+
+	return len(accountList.FilterByID(accountId).Data) != 0, nil
+}
+
+func existGID(ctx context.Context, d *schema.ResourceData, m interface{}) (bool, error) {
+	c := m.(*controller.ControllerCfg)
+	gid := uint64(d.Get("gid").(int))
+	req := locations.ListRequest{}
+
+	locationList, err := c.CloudAPI().Locations().List(ctx, req)
+	if err != nil {
+		return false, err
+	}
+
+	return len(locationList.FilterByGID(gid).Data) != 0, nil
+}
+
+func existDiskID(ctx context.Context, diskId uint64, m interface{}) error {
+	c := m.(*controller.ControllerCfg)
+
+	req := disks.ListRequest{
+		ByID: diskId,
+	}
+
+	diskList, err := c.CloudAPI().Disks().List(ctx, req)
+	if err != nil {
+		return err
+	}
+
+	if len(diskList.Data) == 0 {
+		return fmt.Errorf("resourceDiskReplication: can't create or update Disk replication because DiskID %d is not allowed or does not exist", diskId)
+	}
+
+	if diskList.Data[0].SepType != "TATLIN" {
+		return fmt.Errorf("resourceDiskReplication: can't create or update Disk replication because DiskID %d is not TATLIN SEP Type", diskId)
+	}
+
+	return nil
+}

internal/service/cloudapi/disks/resource_disk.go

@@ -0,0 +1,857 @@
+/*
+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 disks
+
+import (
+	"context"
+	"fmt"
+	"strconv"
+
+	log "github.com/sirupsen/logrus"
+	"repository.basistech.ru/BASIS/decort-golang-sdk/pkg/cloudapi/disks"
+	"repository.basistech.ru/BASIS/terraform-provider-decort/internal/constants"
+	"repository.basistech.ru/BASIS/terraform-provider-decort/internal/controller"
+	"repository.basistech.ru/BASIS/terraform-provider-decort/internal/dc"
+	"repository.basistech.ru/BASIS/terraform-provider-decort/internal/status"
+
+	"github.com/hashicorp/terraform-plugin-sdk/v2/diag"
+	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
+)
+
+func resourceDiskCreate(ctx context.Context, d *schema.ResourceData, m interface{}) diag.Diagnostics {
+	c := m.(*controller.ControllerCfg)
+	req := disks.CreateRequest{}
+
+	haveAccount, err := existAccountID(ctx, d, m)
+	if err != nil {
+		return diag.FromErr(err)
+	}
+	if !haveAccount {
+		return diag.Errorf("resourceDiskCreate: can't create Disk because AccountID %d is not allowed or does not exist", d.Get("account_id").(int))
+	}
+
+	req.AccountID = uint64(d.Get("account_id").(int))
+	req.Name = d.Get("disk_name").(string)
+	req.StoragePolicyID = uint64(d.Get("storage_policy_id").(int))
+	req.Size = uint64(d.Get("size_max").(int))
+
+	if sepId, ok := d.GetOk("sep_id"); ok {
+		req.SEPID = uint64(sepId.(int))
+	}
+
+	if poolName, ok := d.GetOk("pool"); ok {
+		req.Pool = poolName.(string)
+	}
+
+	argVal, argSet := d.GetOk("desc")
+	if argSet {
+		req.Description = argVal.(string)
+	}
+
+	diskId, err := c.CloudAPI().Disks().Create(ctx, req)
+	if err != nil {
+		d.SetId("")
+		return diag.FromErr(err)
+	}
+
+	d.SetId(strconv.FormatUint(diskId, 10))
+
+	if iotuneRaw, ok := d.GetOk("iotune"); ok {
+		iot := iotuneRaw.([]interface{})[0]
+		iotune := iot.(map[string]interface{})
+		req := disks.LimitIORequest{
+			DiskID:           diskId,
+			IOPS:             uint64(iotune["total_iops_sec"].(int)),
+			ReadBytesSec:     uint64(iotune["read_bytes_sec"].(int)),
+			ReadBytesSecMax:  uint64(iotune["read_bytes_sec_max"].(int)),
+			ReadIOPSSec:      uint64(iotune["read_iops_sec"].(int)),
+			ReadIOPSSecMax:   uint64(iotune["read_iops_sec_max"].(int)),
+			SizeIOPSSec:      uint64(iotune["size_iops_sec"].(int)),
+			TotalBytesSec:    uint64(iotune["total_bytes_sec"].(int)),
+			TotalBytesSecMax: uint64(iotune["total_bytes_sec_max"].(int)),
+			TotalIOPSSecMax:  uint64(iotune["total_iops_sec_max"].(int)),
+			TotalIOPSSec:     uint64(iotune["total_iops_sec"].(int)),
+			WriteBytesSec:    uint64(iotune["write_bytes_sec"].(int)),
+			WriteBytesSecMax: uint64(iotune["write_bytes_sec_max"].(int)),
+			WriteIOPSSec:     uint64(iotune["write_iops_sec"].(int)),
+			WriteIOPSSecMax:  uint64(iotune["write_iops_sec_max"].(int)),
+		}
+
+		_, err := c.CloudAPI().Disks().LimitIO(ctx, req)
+		if err != nil {
+			return diag.FromErr(err)
+		}
+	}
+
+	if shareable := d.Get("shareable"); shareable.(bool) == true {
+		req := disks.ShareRequest{
+			DiskID: diskId,
+		}
+
+		_, err := c.CloudAPI().Disks().Share(ctx, req)
+		if err != nil {
+			return diag.FromErr(err)
+		}
+	}
+
+	return resourceDiskRead(ctx, d, m)
+}
+
+func resourceDiskRead(ctx context.Context, d *schema.ResourceData, m interface{}) diag.Diagnostics {
+	// c := m.(*controller.ControllerCfg)
+	warnings := dc.Warnings{}
+
+	disk, err := utilityDiskCheckPresence(ctx, d, m)
+	if err != nil {
+		d.SetId("")
+		return diag.FromErr(err)
+	}
+
+	hasChangeState := false
+
+	switch disk.Status {
+	case status.Destroyed, status.Purged:
+		d.Set("disk_id", 0)
+		d.SetId("")
+		return diag.Errorf("The resource cannot be updated because it has been destroyed")
+		// return resourceDiskCreate(ctx, d, m)
+	case status.Deleted:
+		// hasChangeState = true
+		// req := disks.RestoreRequest{
+		// 	DiskID: disk.ID,
+		// }
+
+		// if reason, ok := d.GetOk("reason"); ok {
+		// 	req.Reason = reason.(string)
+		// } else {
+		// 	req.Reason = "Terraform automatic restore"
+		// }
+
+		// _, err := c.CloudAPI().Disks().Restore(ctx, req)
+		// if err != nil {
+		// 	warnings.Add(err)
+		// }
+	case status.Assigned:
+	case status.Modeled:
+		return diag.Errorf("The disk is in status: %s, please, contact support for more information", disk.Status)
+	case status.Creating:
+	case status.Created:
+	case status.Allocated:
+	case status.Unallocated:
+	}
+
+	if hasChangeState {
+		disk, err = utilityDiskCheckPresence(ctx, d, m)
+		if err != nil {
+			d.SetId("")
+			return diag.FromErr(err)
+		}
+	}
+
+	flattenDisk(d, disk)
+
+	return warnings.Get()
+}
+
+func resourceDiskUpdate(ctx context.Context, d *schema.ResourceData, m interface{}) diag.Diagnostics {
+	c := m.(*controller.ControllerCfg)
+	warnings := dc.Warnings{}
+
+	haveAccount, err := existAccountID(ctx, d, m)
+	if err != nil {
+		return diag.FromErr(err)
+	}
+	if !haveAccount {
+		return diag.Errorf("resourceDiskUpdate: can't update Disk because AccountID %d is not allowed or does not exist", d.Get("account_id").(int))
+	}
+
+	disk, err := utilityDiskCheckPresence(ctx, d, m)
+	if err != nil {
+		d.SetId("")
+		return diag.FromErr(err)
+	}
+
+	hasChangeState := false
+
+	switch disk.Status {
+	case status.Destroyed, status.Purged:
+		d.Set("disk_id", 0)
+		d.SetId("")
+		return diag.Errorf("The resource cannot be updated because it has been destroyed")
+		// return resourceDiskCreate(ctx, d, m)
+	case status.Deleted:
+		hasChangeState = true
+		req := disks.RestoreRequest{
+			DiskID: disk.ID,
+		}
+
+		_, err := c.CloudAPI().Disks().Restore(ctx, req)
+		if err != nil {
+			warnings.Add(err)
+		}
+	case status.Assigned:
+	case status.Modeled:
+		return diag.Errorf("The disk is in status: %s, please, contact support for more information", disk.Status)
+	case status.Creating:
+	case status.Created:
+	case status.Allocated:
+	case status.Unallocated:
+	}
+
+	if hasChangeState {
+		disk, err = utilityDiskCheckPresence(ctx, d, m)
+		if err != nil {
+			d.SetId("")
+			return diag.FromErr(err)
+		}
+	}
+
+	if d.HasChange("storage_policy_id") {
+		req := disks.ChangeDiskStoragePolicyRequest{
+			DiskID:          disk.ID,
+			StoragePolicyID: uint64(d.Get("storage_policy_id").(int)),
+		}
+
+		_, err := c.CloudAPI().Disks().ChangeDiskStoragePolicy(ctx, req)
+		if err != nil {
+			return diag.FromErr(err)
+		}
+	}
+
+	if d.HasChange("size_max") {
+		oldSize, newSize := d.GetChange("size_max")
+		if oldSize.(int) < newSize.(int) {
+			log.Debugf("resourceDiskUpdate: resizing disk ID %s - %d GB -> %d GB",
+				d.Id(), oldSize.(int), newSize.(int))
+			req := disks.ResizeRequest{
+				DiskID: disk.ID,
+				Size:   uint64(newSize.(int)),
+			}
+
+			_, err := c.CloudAPI().Disks().Resize2(ctx, req)
+			if err != nil {
+				return diag.FromErr(err)
+			}
+
+			d.Set("size_max", newSize)
+		} else if oldSize.(int) > newSize.(int) {
+			return diag.FromErr(fmt.Errorf("resourceDiskUpdate: Disk ID %s - reducing disk size is not allowed", d.Id()))
+		}
+	}
+
+	if d.HasChange("disk_name") {
+		req := disks.RenameRequest{
+			DiskID: disk.ID,
+			Name:   d.Get("disk_name").(string),
+		}
+
+		_, err := c.CloudAPI().Disks().Rename(ctx, req)
+		if err != nil {
+			return diag.FromErr(err)
+		}
+	}
+
+	if d.HasChange("iotune") {
+		iot := d.Get("iotune").([]interface{})[0]
+		iotune := iot.(map[string]interface{})
+		req := disks.LimitIORequest{
+			DiskID:           disk.ID,
+			IOPS:             uint64(iotune["total_iops_sec"].(int)),
+			ReadBytesSec:     uint64(iotune["read_bytes_sec"].(int)),
+			ReadBytesSecMax:  uint64(iotune["read_bytes_sec_max"].(int)),
+			ReadIOPSSec:      uint64(iotune["read_iops_sec"].(int)),
+			ReadIOPSSecMax:   uint64(iotune["read_iops_sec_max"].(int)),
+			SizeIOPSSec:      uint64(iotune["size_iops_sec"].(int)),
+			TotalBytesSec:    uint64(iotune["total_bytes_sec"].(int)),
+			TotalBytesSecMax: uint64(iotune["total_bytes_sec_max"].(int)),
+			TotalIOPSSecMax:  uint64(iotune["total_iops_sec_max"].(int)),
+			TotalIOPSSec:     uint64(iotune["total_iops_sec"].(int)),
+			WriteBytesSec:    uint64(iotune["write_bytes_sec"].(int)),
+			WriteBytesSecMax: uint64(iotune["write_bytes_sec_max"].(int)),
+			WriteIOPSSec:     uint64(iotune["write_iops_sec"].(int)),
+			WriteIOPSSecMax:  uint64(iotune["write_iops_sec_max"].(int)),
+		}
+
+		_, err := c.CloudAPI().Disks().LimitIO(ctx, req)
+		if err != nil {
+			return diag.FromErr(err)
+		}
+	}
+
+	if d.HasChange("shareable") {
+		oldShare, newShare := d.GetChange("shareable")
+		if oldShare.(bool) == false && newShare.(bool) == true {
+			req := disks.ShareRequest{DiskID: disk.ID}
+
+			_, err := c.CloudAPI().Disks().Share(ctx, req)
+			if err != nil {
+				return diag.FromErr(err)
+			}
+		}
+		if oldShare.(bool) == true && newShare.(bool) == false {
+			req := disks.UnshareRequest{DiskID: disk.ID}
+
+			_, err := c.CloudAPI().Disks().Unshare(ctx, req)
+			if err != nil {
+				return diag.FromErr(err)
+			}
+		}
+	}
+
+	return resourceDiskRead(ctx, d, m)
+}
+
+func resourceDiskDelete(ctx context.Context, d *schema.ResourceData, m interface{}) diag.Diagnostics {
+	disk, err := utilityDiskCheckPresence(ctx, d, m)
+	if err != nil {
+		d.SetId("")
+		return diag.FromErr(err)
+	}
+	if disk.Status == status.Destroyed || disk.Status == status.Purged {
+		return nil
+	}
+
+	req := disks.DeleteRequest{
+		DiskID:      disk.ID,
+		Detach:      d.Get("detach").(bool),
+		Permanently: d.Get("permanently").(bool),
+	}
+
+	c := m.(*controller.ControllerCfg)
+	_, err = c.CloudAPI().Disks().Delete(ctx, req)
+	if err != nil {
+		return diag.FromErr(err)
+	}
+
+	d.SetId("")
+
+	return nil
+}
+
+func resourceDiskSchemaMake() map[string]*schema.Schema {
+	rets := map[string]*schema.Schema{
+		"account_id": {
+			Type:     schema.TypeInt,
+			Required: true,
+			//ForceNew:    true,
+			Description: "The unique ID of the subscriber-owner of the disk",
+		},
+		"storage_policy_id": {
+			Type:        schema.TypeInt,
+			Required:    true,
+			Description: "ID storage policy under which the disk will be created",
+		},
+		"created_by": {
+			Type:     schema.TypeString,
+			Computed: true,
+		},
+		"deleted_by": {
+			Type:     schema.TypeString,
+			Computed: true,
+		},
+		"disk_name": {
+			Type:        schema.TypeString,
+			Required:    true,
+			Description: "Name of disk",
+		},
+		"size_max": {
+			Type:        schema.TypeInt,
+			Required:    true,
+			Description: "Size in GB",
+		},
+		"pool": {
+			Type:        schema.TypeString,
+			Optional:    true,
+			Computed:    true,
+			Description: "Pool for disk location",
+		},
+		"sep_id": {
+			Type:        schema.TypeInt,
+			Optional:    true,
+			Computed:    true,
+			Description: "Storage endpoint provider ID to create disk",
+		},
+		"desc": {
+			Type:        schema.TypeString,
+			Optional:    true,
+			Computed:    true,
+			Description: "Description of disk",
+		},
+		"detach": {
+			Type:        schema.TypeBool,
+			Optional:    true,
+			Default:     false,
+			Description: "Detaching the disk from compute",
+		},
+		"permanently": {
+			Type:        schema.TypeBool,
+			Optional:    true,
+			Default:     false,
+			Description: "Whether to completely delete the disk, works only with non attached disks",
+		},
+		"shareable": {
+			Type:     schema.TypeBool,
+			Optional: true,
+			Computed: true,
+		},
+		"iotune": {
+			Type:     schema.TypeList,
+			Optional: true,
+			MaxItems: 1,
+			Computed: true,
+			Elem: &schema.Resource{
+				Schema: map[string]*schema.Schema{
+					"read_bytes_sec": {
+						Type:        schema.TypeInt,
+						Optional:    true,
+						Computed:    true,
+						Description: "Number of bytes to read per second",
+					},
+					"read_bytes_sec_max": {
+						Type:        schema.TypeInt,
+						Optional:    true,
+						Computed:    true,
+						Description: "Maximum number of bytes to read",
+					},
+					"read_iops_sec": {
+						Type:        schema.TypeInt,
+						Optional:    true,
+						Computed:    true,
+						Description: "Number of io read operations per second",
+					},
+					"read_iops_sec_max": {
+						Type:        schema.TypeInt,
+						Optional:    true,
+						Computed:    true,
+						Description: "Maximum number of io read operations",
+					},
+					"size_iops_sec": {
+						Type:        schema.TypeInt,
+						Optional:    true,
+						Computed:    true,
+						Description: "Size of io operations",
+					},
+					"total_bytes_sec": {
+						Type:        schema.TypeInt,
+						Optional:    true,
+						Computed:    true,
+						Description: "Total size bytes per second",
+					},
+					"total_bytes_sec_max": {
+						Type:        schema.TypeInt,
+						Optional:    true,
+						Computed:    true,
+						Description: "Maximum total size of bytes per second",
+					},
+					"total_iops_sec": {
+						Type:        schema.TypeInt,
+						Optional:    true,
+						Computed:    true,
+						Description: "Total number of io operations per second",
+					},
+					"total_iops_sec_max": {
+						Type:        schema.TypeInt,
+						Optional:    true,
+						Computed:    true,
+						Description: "Maximum total number of io operations per second",
+					},
+					"write_bytes_sec": {
+						Type:        schema.TypeInt,
+						Optional:    true,
+						Computed:    true,
+						Description: "Number of bytes to write per second",
+					},
+					"write_bytes_sec_max": {
+						Type:        schema.TypeInt,
+						Optional:    true,
+						Computed:    true,
+						Description: "Maximum number of bytes to write per second",
+					},
+					"write_iops_sec": {
+						Type:        schema.TypeInt,
+						Optional:    true,
+						Computed:    true,
+						Description: "Number of write operations per second",
+					},
+					"write_iops_sec_max": {
+						Type:        schema.TypeInt,
+						Optional:    true,
+						Computed:    true,
+						Description: "Maximum number of write operations per second",
+					},
+				},
+			},
+		},
+		"present_to": {
+			Type:     schema.TypeMap,
+			Computed: true,
+			Elem: &schema.Schema{
+				Type: schema.TypeInt,
+			},
+		},
+		"disk_id": {
+			Type:        schema.TypeInt,
+			Computed:    true,
+			Description: "Disk ID. Duplicates the value of the ID parameter",
+		},
+		"account_name": {
+			Type:        schema.TypeString,
+			Computed:    true,
+			Description: "The name of the subscriber '(account') to whom this disk belongs",
+		},
+		"acl": {
+			Type:     schema.TypeString,
+			Computed: true,
+		},
+		"cache": {
+			Type:     schema.TypeString,
+			Computed: true,
+		},
+		// "boot_partition": {
+		// 	Type:        schema.TypeInt,
+		// 	Computed:    true,
+		// 	Description: "Number of disk partitions",
+		// },
+		"computes": {
+			Type:     schema.TypeList,
+			Computed: true,
+			Elem: &schema.Resource{
+				Schema: map[string]*schema.Schema{
+					"compute_id": {
+						Type:     schema.TypeString,
+						Computed: true,
+					},
+					"compute_name": {
+						Type:     schema.TypeString,
+						Computed: true,
+					},
+				},
+			},
+		},
+		"created_time": {
+			Type:        schema.TypeInt,
+			Computed:    true,
+			Description: "Created time",
+		},
+		"deleted_time": {
+			Type:        schema.TypeInt,
+			Computed:    true,
+			Description: "Deleted time",
+		},
+		"destruction_time": {
+			Type:        schema.TypeInt,
+			Computed:    true,
+			Description: "Time of final deletion",
+		},
+		"devicename": {
+			Type:        schema.TypeString,
+			Computed:    true,
+			Description: "Name of the device",
+		},
+		"gid": {
+			Type:        schema.TypeInt,
+			Computed:    true,
+			Description: "ID of the grid (platform)",
+		},
+		// "disk_path": {
+		// 	Type:        schema.TypeString,
+		// 	Computed:    true,
+		// 	Description: "Disk path",
+		// },
+		// "guid": {
+		// 	Type:        schema.TypeInt,
+		// 	Computed:    true,
+		// 	Description: "Disk ID on the storage side",
+		// },
+		"image_id": {
+			Type:        schema.TypeInt,
+			Computed:    true,
+			Description: "Image ID",
+		},
+		"images": {
+			Type:     schema.TypeList,
+			Computed: true,
+			Elem: &schema.Schema{
+				Type: schema.TypeInt,
+			},
+			Description: "IDs of images using the disk",
+		},
+		"independent": {
+			Type:     schema.TypeBool,
+			Computed: true,
+		},
+		// "iqn": {
+		// 	Type:        schema.TypeString,
+		// 	Computed:    true,
+		// 	Description: "Disk IQN",
+		// },
+		// "login": {
+		// 	Type:        schema.TypeString,
+		// 	Computed:    true,
+		// 	Description: "Login to access the disk",
+		// },
+		// "milestones": {
+		// 	Type:        schema.TypeInt,
+		// 	Computed:    true,
+		// 	Description: "Milestones",
+		// },
+		"machine_id": {
+			Type:     schema.TypeInt,
+			Computed: true,
+		},
+		"machine_name": {
+			Type:     schema.TypeString,
+			Computed: true,
+		},
+		"order": {
+			Type:        schema.TypeInt,
+			Computed:    true,
+			Description: "Disk order",
+		},
+		"params": {
+			Type:        schema.TypeString,
+			Computed:    true,
+			Description: "Disk params",
+		},
+		"parent_id": {
+			Type:        schema.TypeInt,
+			Computed:    true,
+			Description: "ID of the parent disk",
+		},
+		// "passwd": {
+		// 	Type:        schema.TypeString,
+		// 	Computed:    true,
+		// 	Description: "Password to access the disk",
+		// },
+		"pci_slot": {
+			Type:        schema.TypeInt,
+			Computed:    true,
+			Description: "ID of the pci slot to which the disk is connected",
+		},
+		// "purge_attempts": {
+		// 	Type:        schema.TypeInt,
+		// 	Computed:    true,
+		// 	Description: "Number of deletion attempts",
+		// },
+		"provision": {
+			Type:     schema.TypeString,
+			Computed: true,
+		},
+		"purge_time": {
+			Type:        schema.TypeInt,
+			Computed:    true,
+			Description: "Time of the last deletion attempt",
+		},
+		"replication": {
+			Type:     schema.TypeList,
+			Computed: true,
+			Elem: &schema.Resource{
+				Schema: map[string]*schema.Schema{
+					"disk_id": {
+						Type:     schema.TypeInt,
+						Computed: true,
+					},
+					"pool_id": {
+						Type:     schema.TypeString,
+						Computed: true,
+					},
+					"role": {
+						Type:     schema.TypeString,
+						Computed: true,
+					},
+					"self_volume_id": {
+						Type:     schema.TypeString,
+						Computed: true,
+					},
+					"storage_id": {
+						Type:     schema.TypeString,
+						Computed: true,
+					},
+					"volume_id": {
+						Type:     schema.TypeString,
+						Computed: true,
+					},
+				},
+			},
+			Description: "Replication status",
+		},
+		// "reality_device_number": {
+		// 	Type:        schema.TypeInt,
+		// 	Computed:    true,
+		// 	Description: "Reality device number",
+		// },
+		// "reference_id": {
+		// 	Type:        schema.TypeString,
+		// 	Computed:    true,
+		// 	Description: "ID of the reference to the disk",
+		// },
+		"res_id": {
+			Type:        schema.TypeString,
+			Computed:    true,
+			Description: "Resource ID",
+		},
+		"res_name": {
+			Type:        schema.TypeString,
+			Computed:    true,
+			Description: "Name of the resource",
+		},
+		"role": {
+			Type:        schema.TypeString,
+			Computed:    true,
+			Description: "Disk role",
+		},
+		"sep_type": {
+			Type:        schema.TypeString,
+			Computed:    true,
+			Description: "Type SEP. Defines the type of storage system and contains one of the values set in the cloud platform",
+		},
+		"size_used": {
+			Type:        schema.TypeFloat,
+			Computed:    true,
+			Description: "Number of used space, in GB",
+		},
+		"snapshots": {
+			Type:     schema.TypeList,
+			Computed: true,
+			Elem: &schema.Resource{
+				Schema: map[string]*schema.Schema{
+					"guid": {
+						Type:        schema.TypeString,
+						Computed:    true,
+						Description: "ID of the snapshot",
+					},
+					"label": {
+						Type:        schema.TypeString,
+						Computed:    true,
+						Description: "Name of the snapshot",
+					},
+					"res_id": {
+						Type:        schema.TypeString,
+						Computed:    true,
+						Description: "Reference to the snapshot",
+					},
+					"snap_set_guid": {
+						Type:        schema.TypeString,
+						Computed:    true,
+						Description: "The set snapshot ID",
+					},
+					"snap_set_time": {
+						Type:        schema.TypeInt,
+						Computed:    true,
+						Description: "The set time of the snapshot",
+					},
+					"timestamp": {
+						Type:        schema.TypeInt,
+						Computed:    true,
+						Description: "Snapshot time",
+					},
+				},
+			},
+		},
+		"status": {
+			Type:        schema.TypeString,
+			Computed:    true,
+			Description: "Disk status",
+		},
+		"tech_status": {
+			Type:        schema.TypeString,
+			Computed:    true,
+			Description: "Technical status of the disk",
+		},
+		"vmid": {
+			Type:        schema.TypeInt,
+			Computed:    true,
+			Description: "Virtual Machine ID (Deprecated)",
+		},
+		"updated_by": {
+			Type:     schema.TypeString,
+			Computed: true,
+		},
+		"updated_time": {
+			Type:     schema.TypeInt,
+			Computed: true,
+		},
+		"to_clean": {
+			Type:     schema.TypeBool,
+			Computed: true,
+		},
+		"discard": {
+			Type:        schema.TypeString,
+			Computed:    true,
+			Description: "Discard mode of the disk",
+		},
+		"block_size": {
+			Type:     schema.TypeString,
+			Computed: true,
+		},
+	}
+
+	return rets
+}
+
+func ResourceDisk() *schema.Resource {
+	return &schema.Resource{
+		SchemaVersion: 3,
+
+		CreateContext: resourceDiskCreate,
+		ReadContext:   resourceDiskRead,
+		UpdateContext: resourceDiskUpdate,
+		DeleteContext: resourceDiskDelete,
+
+		Importer: &schema.ResourceImporter{
+			StateContext: schema.ImportStatePassthroughContext,
+		},
+
+		Timeouts: &schema.ResourceTimeout{
+			Create:  &constants.Timeout600s,
+			Read:    &constants.Timeout300s,
+			Update:  &constants.Timeout300s,
+			Delete:  &constants.Timeout300s,
+			Default: &constants.Timeout300s,
+		},
+
+		Schema: resourceDiskSchemaMake(),
+		StateUpgraders: []schema.StateUpgrader{
+			{
+				Type:    resourceDiskV1().CoreConfigSchema().ImpliedType(),
+				Upgrade: resourceDiskUpgradeV1,
+				Version: 1,
+			},
+			{
+				Type:    resourceDiskV2().CoreConfigSchema().ImpliedType(),
+				Upgrade: resourceDiskUpgradeV2,
+				Version: 2,
+			},
+		},
+	}
+}

internal/service/cloudapi/disks/resource_disk_replication.go

@@ -0,0 +1,631 @@
+/*
+Copyright (c) 2019-2024 Digital Energy Cloud Solutions LLC. All Rights Reserved.
+Authors:
+Petr Krutov, <petr.krutov@digitalenergy.online>
+Stanislav Solovev, <spsolovev@digitalenergy.online>
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+/*
+Terraform DECORT provider - manage resources provided by DECORT (Digital Energy Cloud
+Orchestration Technology) with Terraform by Hashicorp.
+
+Source code: https://repository.basistech.ru/BASIS/terraform-provider-decort
+
+Please see README.md to learn where to place source code so that it
+builds seamlessly.
+
+Documentation: https://repository.basistech.ru/BASIS/terraform-provider-decort/wiki
+*/
+
+package disks
+
+import (
+	"context"
+	"strconv"
+
+	log "github.com/sirupsen/logrus"
+	"repository.basistech.ru/BASIS/decort-golang-sdk/pkg/cloudapi/disks"
+	"repository.basistech.ru/BASIS/terraform-provider-decort/internal/constants"
+	"repository.basistech.ru/BASIS/terraform-provider-decort/internal/controller"
+	"repository.basistech.ru/BASIS/terraform-provider-decort/internal/dc"
+
+	"github.com/hashicorp/terraform-plugin-sdk/v2/diag"
+	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
+)
+
+func resourceDiskReplicationCreate(ctx context.Context, d *schema.ResourceData, m interface{}) diag.Diagnostics {
+	diskId := uint64(d.Get("disk_id").(int))
+
+	log.Debugf("resourceDiskReplicationCreate: called for disk with ID: %d", diskId)
+
+	c := m.(*controller.ControllerCfg)
+
+	err := existDiskID(ctx, diskId, m)
+	if err != nil {
+		return diag.FromErr(err)
+	}
+
+	reqCreate := disks.ReplicateRequest{
+		DiskID:   diskId,
+		Name:     d.Get("disk_name").(string),
+		SepID:    uint64(d.Get("sep_id").(int)),
+		PoolName: d.Get("pool_name").(string),
+	}
+
+	diskReplicaId, err := c.CloudAPI().Disks().Replicate(ctx, reqCreate)
+	if err != nil {
+		d.SetId("")
+		return diag.FromErr(err)
+	}
+
+	d.SetId(strconv.FormatUint(diskReplicaId, 10))
+	d.Set("replica_disk_id", diskReplicaId)
+
+	log.Debugf("resourceDiskReplicationCreate: create replica complete for disk with ID: %d", diskId)
+
+	warnings := dc.Warnings{}
+
+	if start, ok := d.GetOk("start"); ok && !start.(bool) {
+		log.Debugf("resourceDiskReplicationCreate: replication between disk with ID: %d and replica with ID: %d, try to stop", diskId, diskReplicaId)
+		reqStop := disks.ReplicationStopRequest{
+			DiskID: diskId,
+		}
+		_, err = c.CloudAPI().Disks().ReplicationStop(ctx, reqStop)
+		if err != nil {
+			warnings.Add(err)
+		}
+		log.Debugf("resourceDiskReplicationCreate: replication between disk with ID: %d and replica with ID: %d, stoped", diskId, diskReplicaId)
+	}
+	return append(resourceDiskReplicationRead(ctx, d, m), warnings.Get()...)
+}
+
+func resourceDiskReplicationRead(ctx context.Context, d *schema.ResourceData, m interface{}) diag.Diagnostics {
+	log.Debugf("resourceDiskReplicationRead: called for disk with ID: %s", d.Id())
+	c := m.(*controller.ControllerCfg)
+
+	req := disks.ReplicationStatusRequest{
+		DiskID: uint64(d.Get("disk_id").(int)),
+	}
+
+	status, err := c.CloudAPI().Disks().ReplicationStatus(ctx, req)
+	if err != nil {
+		d.SetId("")
+		return diag.FromErr(err)
+	}
+
+	diskReplica, err := utilityDiskReplicaCheckPresence(ctx, d, m)
+	if err != nil {
+		d.SetId("")
+		return diag.FromErr(err)
+	}
+
+	flattenDiskReplica(d, diskReplica, status)
+
+	log.Debugf("resourceDiskReplicationRead: read complete for disk with ID: %s", d.Id())
+	return nil
+}
+
+func resourceDiskReplicationUpdate(ctx context.Context, d *schema.ResourceData, m interface{}) diag.Diagnostics {
+	diskId := uint64(d.Get("disk_id").(int))
+	log.Debugf("resourceDiskReplicationUpdate: called for disk with ID: %d", diskId)
+
+	err := existDiskID(ctx, diskId, m)
+	if err != nil {
+		return diag.FromErr(err)
+	}
+
+	if d.HasChange("start") {
+		if err := utilityDiskReplicationUpdateStartStop(ctx, d, m); err != nil {
+			return diag.FromErr(err)
+		}
+	}
+
+	if d.HasChange("pause") {
+		if err := utilityDiskReplicationUpdatePause(ctx, d, m); err != nil {
+			return diag.FromErr(err)
+		}
+	}
+
+	if d.HasChange("reverse") {
+		if err := utilityDiskReplicationUpdateReverse(ctx, d, m); err != nil {
+			return diag.FromErr(err)
+		}
+	}
+
+	log.Debugf("resourceDiskReplicationUpdate: read complete for disk with ID: %d", diskId)
+	return resourceDiskReplicationRead(ctx, d, m)
+}
+
+func resourceDiskReplicationDelete(ctx context.Context, d *schema.ResourceData, m interface{}) diag.Diagnostics {
+	diskId := uint64(d.Get("disk_id").(int))
+	log.Debugf("resourceDiskReplicationDelete: called for disk with ID: %d", diskId)
+
+	disk, err := utilityDiskReplicaCheckPresence(ctx, d, m)
+	if err != nil {
+		d.SetId("")
+		return diag.FromErr(err)
+	}
+
+	c := m.(*controller.ControllerCfg)
+
+	if d.Get("start").(bool) {
+		reqStop := disks.ReplicationStopRequest{
+			DiskID: uint64(d.Get("disk_id").(int)),
+		}
+
+		log.Debugf("resourceDiskReplicationDelete: stop replication for disk with ID: %d", diskId)
+		_, err = c.CloudAPI().Disks().ReplicationStop(ctx, reqStop)
+		if err != nil {
+			return diag.FromErr(err)
+		}
+		log.Debugf("resourceDiskReplicationDelete: stop replication for disk with ID: %d, complete", diskId)
+	}
+
+	reqDelete := disks.DeleteRequest{
+		DiskID:      disk.ID,
+		Detach:      d.Get("detach").(bool),
+		Permanently: d.Get("permanently").(bool),
+	}
+
+	log.Debugf("resourceDiskReplicationDelete: delete disk replica for disk with ID: %d", diskId)
+	_, err = c.CloudAPI().Disks().Delete(ctx, reqDelete)
+	if err != nil {
+		return diag.FromErr(err)
+	}
+	log.Debugf("resourceDiskReplicationDelete: delete disk replica for disk with ID: %d, complete", diskId)
+
+	d.SetId("")
+
+	return nil
+}
+
+func resourceDiskReplicationSchemaMake() map[string]*schema.Schema {
+	rets := map[string]*schema.Schema{
+		"disk_id": {
+			Type:        schema.TypeInt,
+			Required:    true,
+			Description: "Id of primary disk",
+		},
+		"disk_name": {
+			Type:        schema.TypeString,
+			Required:    true,
+			Description: "Name of disk replica",
+		},
+		"sep_id": {
+			Type:        schema.TypeInt,
+			Required:    true,
+			Description: "Storage endpoint provider ID to create disk replica",
+		},
+		"pool_name": {
+			Type:        schema.TypeString,
+			Required:    true,
+			Description: "Pool for disk location",
+		},
+		"pause": {
+			Type:        schema.TypeBool,
+			Optional:    true,
+			Description: "Resume replication",
+		},
+		"reverse": {
+			Type:        schema.TypeBool,
+			Optional:    true,
+			Default:     false,
+			Description: "Reverse replication",
+		},
+		"start": {
+			Type:        schema.TypeBool,
+			Optional:    true,
+			Default:     true,
+			Description: "Start/Stop replication",
+		},
+		"detach": {
+			Type:        schema.TypeBool,
+			Optional:    true,
+			Default:     false,
+			Description: "Detach disk from machine first",
+		},
+		"permanently": {
+			Type:        schema.TypeBool,
+			Optional:    true,
+			Default:     false,
+			Description: "Delete disk permanently",
+		},
+		"replica_disk_id": {
+			Type:        schema.TypeInt,
+			Computed:    true,
+			Description: "Id of replica disk",
+		},
+		"status_replication": {
+			Type:        schema.TypeString,
+			Computed:    true,
+			Description: "Status of replication",
+		},
+		"account_id": {
+			Type:        schema.TypeInt,
+			Computed:    true,
+			Description: "The unique ID of the subscriber-owner of the disk",
+		},
+		"account_name": {
+			Type:        schema.TypeString,
+			Computed:    true,
+			Description: "The name of the subscriber '(account') to whom this disk belongs",
+		},
+		"acl": {
+			Type:     schema.TypeString,
+			Computed: true,
+		},
+		// "boot_partition": {
+		// 	Type:        schema.TypeInt,
+		// 	Computed:    true,
+		// 	Description: "Number of disk partitions",
+		// },
+		"computes": {
+			Type:     schema.TypeList,
+			Computed: true,
+			Elem: &schema.Resource{
+				Schema: map[string]*schema.Schema{
+					"compute_id": {
+						Type:     schema.TypeString,
+						Computed: true,
+					},
+					"compute_name": {
+						Type:     schema.TypeString,
+						Computed: true,
+					},
+				},
+			},
+		},
+		"created_time": {
+			Type:        schema.TypeInt,
+			Computed:    true,
+			Description: "Created time",
+		},
+		"deleted_time": {
+			Type:        schema.TypeInt,
+			Computed:    true,
+			Description: "Deleted time",
+		},
+		"desc": {
+			Type:        schema.TypeString,
+			Computed:    true,
+			Description: "Description of disk",
+		},
+		"destruction_time": {
+			Type:        schema.TypeInt,
+			Computed:    true,
+			Description: "Time of final deletion",
+		},
+		"devicename": {
+			Type:        schema.TypeString,
+			Computed:    true,
+			Description: "Name of the device",
+		},
+		// "disk_path": {
+		// 	Type:        schema.TypeString,
+		// 	Computed:    true,
+		// 	Description: "Disk path",
+		// },
+		"gid": {
+			Type:        schema.TypeInt,
+			Computed:    true,
+			Description: "ID of the grid (platform)",
+		},
+		// "guid": {
+		// 	Type:        schema.TypeInt,
+		// 	Computed:    true,
+		// 	Description: "Disk ID on the storage side",
+		// },
+		"image_id": {
+			Type:        schema.TypeInt,
+			Computed:    true,
+			Description: "Image ID",
+		},
+		"images": {
+			Type:     schema.TypeList,
+			Computed: true,
+			Elem: &schema.Schema{
+				Type: schema.TypeInt,
+			},
+			Description: "IDs of images using the disk",
+		},
+		"iotune": {
+			Type:     schema.TypeList,
+			Computed: true,
+			Elem: &schema.Resource{
+				Schema: map[string]*schema.Schema{
+					"read_bytes_sec": {
+						Type:        schema.TypeInt,
+						Computed:    true,
+						Description: "Number of bytes to read per second",
+					},
+					"read_bytes_sec_max": {
+						Type:        schema.TypeInt,
+						Computed:    true,
+						Description: "Maximum number of bytes to read",
+					},
+					"read_iops_sec": {
+						Type:        schema.TypeInt,
+						Computed:    true,
+						Description: "Number of io read operations per second",
+					},
+					"read_iops_sec_max": {
+						Type:        schema.TypeInt,
+						Computed:    true,
+						Description: "Maximum number of io read operations",
+					},
+					"size_iops_sec": {
+						Type:        schema.TypeInt,
+						Computed:    true,
+						Description: "Size of io operations",
+					},
+					"total_bytes_sec": {
+						Type:        schema.TypeInt,
+						Computed:    true,
+						Description: "Total size bytes per second",
+					},
+					"total_bytes_sec_max": {
+						Type:        schema.TypeInt,
+						Computed:    true,
+						Description: "Maximum total size of bytes per second",
+					},
+					"total_iops_sec": {
+						Type:        schema.TypeInt,
+						Computed:    true,
+						Description: "Total number of io operations per second",
+					},
+					"total_iops_sec_max": {
+						Type:        schema.TypeInt,
+						Computed:    true,
+						Description: "Maximum total number of io operations per second",
+					},
+					"write_bytes_sec": {
+						Type:        schema.TypeInt,
+						Computed:    true,
+						Description: "Number of bytes to write per second",
+					},
+					"write_bytes_sec_max": {
+						Type:        schema.TypeInt,
+						Computed:    true,
+						Description: "Maximum number of bytes to write per second",
+					},
+					"write_iops_sec": {
+						Type:        schema.TypeInt,
+						Computed:    true,
+						Description: "Number of write operations per second",
+					},
+					"write_iops_sec_max": {
+						Type:        schema.TypeInt,
+						Computed:    true,
+						Description: "Maximum number of write operations per second",
+					},
+				},
+			},
+		},
+		// "iqn": {
+		// 	Type:        schema.TypeString,
+		// 	Computed:    true,
+		// 	Description: "Disk IQN",
+		// },
+		// "login": {
+		// 	Type:        schema.TypeString,
+		// 	Computed:    true,
+		// 	Description: "Login to access the disk",
+		// },
+		// "milestones": {
+		// 	Type:        schema.TypeInt,
+		// 	Computed:    true,
+		// 	Description: "Milestones",
+		// },
+		"order": {
+			Type:        schema.TypeInt,
+			Computed:    true,
+			Description: "Disk order",
+		},
+		"params": {
+			Type:        schema.TypeString,
+			Computed:    true,
+			Description: "Disk params",
+		},
+		"parent_id": {
+			Type:        schema.TypeInt,
+			Computed:    true,
+			Description: "ID of the parent disk",
+		},
+		// "passwd": {
+		// 	Type:        schema.TypeString,
+		// 	Computed:    true,
+		// 	Description: "Password to access the disk",
+		// },
+		"pci_slot": {
+			Type:        schema.TypeInt,
+			Computed:    true,
+			Description: "ID of the pci slot to which the disk is connected",
+		},
+		"present_to": {
+			Type:     schema.TypeMap,
+			Computed: true,
+			Elem: &schema.Schema{
+				Type: schema.TypeInt,
+			},
+		},
+		// "purge_attempts": {
+		// 	Type:        schema.TypeInt,
+		// 	Computed:    true,
+		// 	Description: "Number of deletion attempts",
+		// },
+		"purge_time": {
+			Type:        schema.TypeInt,
+			Computed:    true,
+			Description: "Time of the last deletion attempt",
+		},
+		"replication": {
+			Type:     schema.TypeList,
+			Computed: true,
+			Elem: &schema.Resource{
+				Schema: map[string]*schema.Schema{
+					"disk_id": {
+						Type:     schema.TypeInt,
+						Computed: true,
+					},
+					"pool_id": {
+						Type:     schema.TypeString,
+						Computed: true,
+					},
+					"role": {
+						Type:     schema.TypeString,
+						Computed: true,
+					},
+					"self_volume_id": {
+						Type:     schema.TypeString,
+						Computed: true,
+					},
+					"storage_id": {
+						Type:     schema.TypeString,
+						Computed: true,
+					},
+					"volume_id": {
+						Type:     schema.TypeString,
+						Computed: true,
+					},
+				},
+			},
+			Description: "Replication status",
+		},
+		// "reality_device_number": {
+		// 	Type:        schema.TypeInt,
+		// 	Computed:    true,
+		// 	Description: "Reality device number",
+		// },
+		// "reference_id": {
+		// 	Type:        schema.TypeString,
+		// 	Computed:    true,
+		// 	Description: "ID of the reference to the disk",
+		// },
+		"res_id": {
+			Type:        schema.TypeString,
+			Computed:    true,
+			Description: "Resource ID",
+		},
+		"res_name": {
+			Type:        schema.TypeString,
+			Computed:    true,
+			Description: "Name of the resource",
+		},
+		"role": {
+			Type:        schema.TypeString,
+			Computed:    true,
+			Description: "Disk role",
+		},
+		"sep_type": {
+			Type:        schema.TypeString,
+			Computed:    true,
+			Description: "Type SEP. Defines the type of storage system and contains one of the values set in the cloud platform",
+		},
+		"shareable": {
+			Type:     schema.TypeBool,
+			Computed: true,
+		},
+		"size_max": {
+			Type:        schema.TypeInt,
+			Computed:    true,
+			Description: "Size in GB",
+		},
+		"size_used": {
+			Type:        schema.TypeFloat,
+			Computed:    true,
+			Description: "Number of used space, in GB",
+		},
+		"snapshots": {
+			Type:     schema.TypeList,
+			Computed: true,
+			Elem: &schema.Resource{
+				Schema: map[string]*schema.Schema{
+					"guid": {
+						Type:        schema.TypeString,
+						Computed:    true,
+						Description: "ID of the snapshot",
+					},
+					"label": {
+						Type:        schema.TypeString,
+						Computed:    true,
+						Description: "Name of the snapshot",
+					},
+					"res_id": {
+						Type:        schema.TypeString,
+						Computed:    true,
+						Description: "Reference to the snapshot",
+					},
+					"snap_set_guid": {
+						Type:        schema.TypeString,
+						Computed:    true,
+						Description: "The set snapshot ID",
+					},
+					"snap_set_time": {
+						Type:        schema.TypeInt,
+						Computed:    true,
+						Description: "The set time of the snapshot",
+					},
+					"timestamp": {
+						Type:        schema.TypeInt,
+						Computed:    true,
+						Description: "Snapshot time",
+					},
+				},
+			},
+		},
+		"status": {
+			Type:        schema.TypeString,
+			Computed:    true,
+			Description: "Disk status",
+		},
+		"tech_status": {
+			Type:        schema.TypeString,
+			Computed:    true,
+			Description: "Technical status of the disk",
+		},
+		"vmid": {
+			Type:        schema.TypeInt,
+			Computed:    true,
+			Description: "Virtual Machine ID (Deprecated)",
+		},
+	}
+
+	return rets
+}
+
+func ResourceDiskReplication() *schema.Resource {
+	return &schema.Resource{
+		SchemaVersion: 1,
+
+		CreateContext: resourceDiskReplicationCreate,
+		ReadContext:   resourceDiskReplicationRead,
+		UpdateContext: resourceDiskReplicationUpdate,
+		DeleteContext: resourceDiskReplicationDelete,
+
+		Importer: &schema.ResourceImporter{
+			StateContext: schema.ImportStatePassthroughContext,
+		},
+
+		Timeouts: &schema.ResourceTimeout{
+			Create:  &constants.Timeout600s,
+			Read:    &constants.Timeout300s,
+			Update:  &constants.Timeout300s,
+			Delete:  &constants.Timeout300s,
+			Default: &constants.Timeout300s,
+		},
+
+		Schema: resourceDiskReplicationSchemaMake(),
+	}
+}

internal/service/cloudapi/disks/resource_disk_snapshot.go

@@ -0,0 +1,243 @@
+/*
+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 disks
+
+import (
+	"context"
+
+	"github.com/hashicorp/terraform-plugin-sdk/v2/diag"
+	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
+	log "github.com/sirupsen/logrus"
+	"repository.basistech.ru/BASIS/decort-golang-sdk/pkg/cloudapi/disks"
+	"repository.basistech.ru/BASIS/terraform-provider-decort/internal/constants"
+	"repository.basistech.ru/BASIS/terraform-provider-decort/internal/controller"
+)
+
+func resourceDiskSnapshotCreate(ctx context.Context, d *schema.ResourceData, m interface{}) diag.Diagnostics {
+	c := m.(*controller.ControllerCfg)
+
+	disk, err := utilityDiskCheckPresence(ctx, d, m)
+	if err != nil {
+		return diag.FromErr(err)
+	}
+
+	snapshots := disk.Snapshots
+	snapshot := disks.ItemSnapshot{}
+	label := d.Get("label").(string)
+	for _, sn := range snapshots {
+		if label == sn.Label {
+			snapshot = sn
+			break
+		}
+	}
+	if label != snapshot.Label {
+		return diag.Errorf("Snapshot with label \"%v\" not found", label)
+	}
+
+	if rollback := d.Get("rollback").(bool); rollback {
+		req := disks.SnapshotRollbackRequest{
+			DiskID:    disk.ID,
+			Label:     label,
+			TimeStamp: uint64(d.Get("timestamp").(int)),
+		}
+
+		log.Debugf("resourceDiskCreate: Snapshot rollback with label %s", label)
+		_, err := c.CloudAPI().Disks().SnapshotRollback(ctx, req)
+		if err != nil {
+			return diag.FromErr(err)
+		}
+	}
+	return resourceDiskSnapshotRead(ctx, d, m)
+}
+
+func resourceDiskSnapshotRead(ctx context.Context, d *schema.ResourceData, m interface{}) diag.Diagnostics {
+	disk, err := utilityDiskCheckPresence(ctx, d, m)
+	if err != nil {
+		d.SetId("")
+		return diag.FromErr(err)
+	}
+
+	snapshots := disk.Snapshots
+	snapshot := disks.ItemSnapshot{}
+	label := d.Get("label").(string)
+	for _, sn := range snapshots {
+		if label == sn.Label {
+			snapshot = sn
+			break
+		}
+	}
+	if label != snapshot.Label {
+		return diag.Errorf("Snapshot with label \"%v\" not found", label)
+	}
+
+	flattenDiskSnapshot(d, snapshot)
+
+	return nil
+}
+
+func resourceDiskSnapshotUpdate(ctx context.Context, d *schema.ResourceData, m interface{}) diag.Diagnostics {
+	c := m.(*controller.ControllerCfg)
+	disk, err := utilityDiskCheckPresence(ctx, d, m)
+	if err != nil {
+		return diag.FromErr(err)
+	}
+
+	snapshots := disk.Snapshots
+	snapshot := disks.ItemSnapshot{}
+	label := d.Get("label").(string)
+	for _, sn := range snapshots {
+		if label == sn.Label {
+			snapshot = sn
+			break
+		}
+	}
+
+	if label != snapshot.Label {
+		return diag.Errorf("Snapshot with label \"%v\" not found", label)
+	}
+
+	if d.HasChange("rollback") && d.Get("rollback").(bool) == true {
+		req := disks.SnapshotRollbackRequest{
+			DiskID:    disk.ID,
+			Label:     label,
+			TimeStamp: uint64(d.Get("timestamp").(int)),
+		}
+
+		log.Debugf("resourceDiskUpdtae: Snapshot rollback with label %s", label)
+		_, err := c.CloudAPI().Disks().SnapshotRollback(ctx, req)
+		if err != nil {
+			return diag.FromErr(err)
+		}
+	}
+
+	return resourceDiskSnapshotRead(ctx, d, m)
+}
+
+func resourceDiskSnapshotDelete(ctx context.Context, d *schema.ResourceData, m interface{}) diag.Diagnostics {
+	c := m.(*controller.ControllerCfg)
+
+	disk, err := utilityDiskCheckPresence(ctx, d, m)
+	if err != nil {
+		d.SetId("")
+		return diag.FromErr(err)
+	}
+
+	req := disks.SnapshotDeleteRequest{
+		DiskID: disk.ID,
+		Label:  d.Get("label").(string),
+	}
+
+	_, err = c.CloudAPI().Disks().SnapshotDelete(ctx, req)
+	if err != nil {
+		return diag.FromErr(err)
+	}
+
+	d.SetId("")
+
+	return nil
+}
+
+func resourceDiskSnapshotSchemaMake() map[string]*schema.Schema {
+	rets := map[string]*schema.Schema{
+		"disk_id": {
+			Type:     schema.TypeInt,
+			Required: true,
+			//ForceNew:    true,
+			Description: "The unique ID of the subscriber-owner of the disk",
+		},
+		"label": {
+			Type:     schema.TypeString,
+			Required: true,
+			//ForceNew:    true,
+			Description: "Name of the snapshot",
+		},
+		"rollback": {
+			Type:        schema.TypeBool,
+			Optional:    true,
+			Default:     false,
+			Description: "Needed in order to make a snapshot rollback",
+		},
+		"timestamp": {
+			Type:        schema.TypeInt,
+			Optional:    true,
+			Computed:    true,
+			Description: "Snapshot time",
+		},
+		"guid": {
+			Type:        schema.TypeString,
+			Computed:    true,
+			Description: "ID of the snapshot",
+		},
+		"res_id": {
+			Type:        schema.TypeString,
+			Computed:    true,
+			Description: "Reference to the snapshot",
+		},
+		"snap_set_guid": {
+			Type:        schema.TypeString,
+			Computed:    true,
+			Description: "The set snapshot ID",
+		},
+		"snap_set_time": {
+			Type:        schema.TypeInt,
+			Computed:    true,
+			Description: "The set time of the snapshot",
+		},
+	}
+	return rets
+}
+
+func ResourceDiskSnapshot() *schema.Resource {
+	return &schema.Resource{
+		SchemaVersion: 1,
+
+		CreateContext: resourceDiskSnapshotCreate,
+		ReadContext:   resourceDiskSnapshotRead,
+		UpdateContext: resourceDiskSnapshotUpdate,
+		DeleteContext: resourceDiskSnapshotDelete,
+
+		Importer: &schema.ResourceImporter{
+			StateContext: schema.ImportStatePassthroughContext,
+		},
+
+		Timeouts: &schema.ResourceTimeout{
+			Create:  &constants.Timeout600s,
+			Read:    &constants.Timeout300s,
+			Update:  &constants.Timeout300s,
+			Delete:  &constants.Timeout300s,
+			Default: &constants.Timeout300s,
+		},
+
+		Schema: resourceDiskSnapshotSchemaMake(),
+	}
+}

internal/service/cloudapi/disks/state_upgraders.go

@@ -0,0 +1,28 @@
+package disks
+
+import (
+	"context"
+
+	log "github.com/sirupsen/logrus"
+)
+
+func resourceDiskUpgradeV1(ctx context.Context, rawState map[string]interface{}, meta any) (map[string]interface{}, error) {
+	log.Debug("resourceDiskUpgradeV1: upgrading state")
+	rawState["present_to"] = make(map[string]uint64)
+
+	return rawState, nil
+}
+
+func resourceDiskUpgradeV2(ctx context.Context, rawState map[string]interface{}, meta any) (map[string]interface{}, error) {
+	log.Debug("resourceDiskUpgradeV2: upgrading state")
+	if v, ok := rawState["blk_discard"].(bool); ok {
+		if v {
+			rawState["discard"] = "unmap"
+		} else {
+			rawState["discard"] = "ignore"
+		}
+	}
+	delete(rawState, "blk_discard")
+
+	return rawState, nil
+}

internal/service/cloudapi/disks/utility_disk.go

@@ -0,0 +1,69 @@
+/*
+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 disks
+
+import (
+	"context"
+	"strconv"
+
+	log "github.com/sirupsen/logrus"
+	"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 utilityDiskCheckPresence(ctx context.Context, d *schema.ResourceData, m interface{}) (*disks.RecordDisk, error) {
+	c := m.(*controller.ControllerCfg)
+	req := disks.GetRequest{}
+
+	if d.Get("disk_id") != nil {
+		if d.Get("disk_id").(int) == 0 {
+			id, _ := strconv.ParseUint(d.Id(), 10, 64)
+			req.DiskID = id
+		} else {
+			req.DiskID = uint64(d.Get("disk_id").(int))
+		}
+	} else {
+		id, _ := strconv.ParseUint(d.Id(), 10, 64)
+		req.DiskID = id
+	}
+
+	log.Debugf("utilityDiskCheckPresence: load disk")
+	disk, err := c.CloudAPI().Disks().Get(ctx, req)
+	if err != nil {
+		return nil, err
+	}
+
+	return disk, nil
+}

internal/service/cloudapi/disks/utility_disk_list.go

@@ -0,0 +1,102 @@
+/*
+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 disks
+
+import (
+	"context"
+
+	log "github.com/sirupsen/logrus"
+	"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 utilityDiskListCheckPresence(ctx context.Context, d *schema.ResourceData, m interface{}) (*disks.ListDisks, error) {
+	c := m.(*controller.ControllerCfg)
+	req := disks.ListRequest{}
+
+	if by_id, ok := d.GetOk("by_id"); ok {
+		req.ByID = uint64(by_id.(int))
+	}
+	if name, ok := d.GetOk("name"); ok {
+		req.Name = name.(string)
+	}
+	if account_name, ok := d.GetOk("account_name"); ok {
+		req.AccountName = account_name.(string)
+	}
+	if disk_max_size, ok := d.GetOk("disk_max_size"); ok {
+		req.DiskMaxSize = int64(disk_max_size.(int))
+	}
+	if status, ok := d.GetOk("status"); ok {
+		req.Status = status.(string)
+	}
+	if shared, ok := d.GetOk("shared"); ok {
+		req.Shared = shared.(bool)
+	}
+	if accountId, ok := d.GetOk("account_id"); ok {
+		req.AccountID = uint64(accountId.(int))
+	}
+	if sepId, ok := d.GetOk("sep_id"); ok {
+		req.AccountID = uint64(sepId.(int))
+	}
+	if pool_name, ok := d.GetOk("pool_name"); ok {
+		req.Pool = pool_name.(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 storagePolicyID, ok := d.GetOk("storage_policy_id"); ok {
+		req.StoragePolicyID = uint64(storagePolicyID.(int))
+	}
+	if rgID, ok := d.GetOk("rg_id"); ok {
+		req.RGID = uint64(rgID.(int))
+	}
+	if computeID, ok := d.GetOk("compute_id"); ok {
+		req.ComputeID = uint64(computeID.(int))
+	}
+
+	log.Debugf("utilityDiskListCheckPresence: load disk list")
+	diskList, err := c.CloudAPI().Disks().List(ctx, req)
+	if err != nil {
+		return nil, err
+	}
+
+	return diskList, nil
+}

internal/service/cloudapi/disks/utility_disk_list_deleted.go

@@ -0,0 +1,92 @@
+/*
+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 disks
+
+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/disks"
+	"repository.basistech.ru/BASIS/terraform-provider-decort/internal/controller"
+)
+
+func utilityDiskListDeletedCheckPresence(ctx context.Context, d *schema.ResourceData, m interface{}) (*disks.ListDisks, error) {
+	c := m.(*controller.ControllerCfg)
+	req := disks.ListDeletedRequest{}
+
+	if account_id, ok := d.GetOk("account_id"); ok {
+		req.AccountID = uint64(account_id.(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))
+	}
+
+	if by_id, ok := d.GetOk("by_id"); ok {
+		req.ByID = uint64(by_id.(int))
+	}
+
+	if name, ok := d.GetOk("name"); ok {
+		req.Name = name.(string)
+	}
+
+	if account_name, ok := d.GetOk("account_name"); ok {
+		req.AccountName = account_name.(string)
+	}
+
+	if disk_max_size, ok := d.GetOk("disk_max_size"); ok {
+		req.DiskMaxSize = int64(disk_max_size.(int))
+	}
+
+	if shared, ok := d.GetOk("shared"); ok {
+		req.Shared = shared.(bool)
+	}
+
+	log.Debugf("utilityDiskListDeletedCheckPresence: load disk list")
+	diskList, err := c.CloudAPI().Disks().ListDeleted(ctx, req)
+	if err != nil {
+		return nil, err
+	}
+
+	return diskList, nil
+}

internal/service/cloudapi/disks/utility_disk_list_unattached.go

@@ -0,0 +1,57 @@
+package disks
+
+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/disks"
+	"repository.basistech.ru/BASIS/terraform-provider-decort/internal/controller"
+)
+
+func utilityDiskListUnattachedCheckPresence(ctx context.Context, d *schema.ResourceData, m interface{}) (*disks.ListDisksUnattached, error) {
+	c := m.(*controller.ControllerCfg)
+	req := disks.ListUnattachedRequest{}
+
+	if by_id, ok := d.GetOk("by_id"); ok {
+		req.ByID = uint64(by_id.(int))
+	}
+	if account_name, ok := d.GetOk("account_name"); ok {
+		req.AccountName = account_name.(string)
+	}
+	if disk_max_size, ok := d.GetOk("disk_max_size"); ok {
+		req.DiskMaxSize = int64(disk_max_size.(int))
+	}
+	if status, ok := d.GetOk("status"); ok {
+		req.Status = status.(string)
+	}
+	if accountId, ok := d.GetOk("account_id"); ok {
+		req.AccountID = uint64(accountId.(int))
+	}
+	if sepId, ok := d.GetOk("sep_id"); ok {
+		req.AccountID = uint64(sepId.(int))
+	}
+	if pool_name, ok := d.GetOk("pool_name"); ok {
+		req.Pool = pool_name.(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 storagePolicyID, ok := d.GetOk("storage_policy_id"); ok {
+		req.StoragePolicyID = uint64(storagePolicyID.(int))
+	}
+
+	log.Debugf("utilityDiskListUnattachedCheckPresence: load disk Unattached list")
+	unattachedList, err := c.CloudAPI().Disks().ListUnattached(ctx, req)
+	if err != nil {
+		return nil, err
+	}
+
+	return unattachedList, nil
+}

internal/service/cloudapi/disks/utility_disk_replica.go

@@ -0,0 +1,174 @@
+/*
+Copyright (c) 2019-2024 Digital Energy Cloud Solutions LLC. All Rights Reserved.
+Authors:
+Petr Krutov, <petr.krutov@digitalenergy.online>
+Stanislav Solovev, <spsolovev@digitalenergy.online>
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+/*
+Terraform DECORT provider - manage resources provided by DECORT (Digital Energy Cloud
+Orchestration Technology) with Terraform by Hashicorp.
+
+Source code: https://repository.basistech.ru/BASIS/terraform-provider-decort
+
+Please see README.md to learn where to place source code so that it
+builds seamlessly.
+
+Documentation: https://repository.basistech.ru/BASIS/terraform-provider-decort/wiki
+*/
+
+package disks
+
+import (
+	"context"
+	"strconv"
+
+	log "github.com/sirupsen/logrus"
+	"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 utilityDiskReplicationUpdateStartStop(ctx context.Context, d *schema.ResourceData, m interface{}) error {
+	diskId := uint64(d.Get("disk_id").(int))
+	targetDiskId, _ := strconv.ParseUint(d.Id(), 10, 64)
+
+	log.Debugf("utilityDiskReplicationUpdateStartStop: start update for disk replica with ID: %d", diskId)
+	c := m.(*controller.ControllerCfg)
+
+	start, ok := d.GetOk("start")
+
+	if ok && start.(bool) {
+		log.Debugf("utilityDiskReplicationUpdateStartStop: start disk replication from Disk with ID: %d to Disk with ID: %d", diskId, targetDiskId)
+		req := disks.ReplicationStartRequest{
+			DiskID: diskId,
+			TargetDiskID: targetDiskId,
+		}
+		_, err := c.CloudAPI().Disks().ReplicationStart(ctx, req)
+		if err != nil {
+			return err
+		}
+		log.Debugf("utilityDiskReplicationUpdateStartStop: start disk replication from Disk with ID: %d to Disk with ID: %d, complete", diskId, targetDiskId)
+	}
+
+	if ok && !start.(bool) {
+		log.Debugf("utilityDiskReplicationUpdateStartStop: stop disk replication from Disk with ID: %d to Disk with ID: %d", targetDiskId, diskId)
+		req := disks.ReplicationStopRequest{
+			DiskID: targetDiskId,
+		}
+		_, err := c.CloudAPI().Disks().ReplicationStop(ctx, req)
+		if err != nil {
+			return err
+		}
+		log.Debugf("utilityDiskReplicationUpdateStartStop: stop disk replication from Disk with ID: %d to Disk with ID: %d, complete", targetDiskId, diskId)
+	}
+
+	log.Debugf("utilityDiskReplicationUpdateStartStop: complete update for disk replica with ID: %d", diskId)
+	return nil
+}
+
+func utilityDiskReplicationUpdatePause(ctx context.Context, d *schema.ResourceData, m interface{}) error {
+	diskId := uint64(d.Get("disk_id").(int))
+	log.Debugf("utilityDiskReplicationUpdatePause: start update for disk replica with ID: %d", diskId)
+	c := m.(*controller.ControllerCfg)
+
+	pause, ok := d.GetOk("pause")
+
+	if ok && pause.(bool) {
+		log.Debugf("utilityDiskReplicationUpdatePause: pause disk replication with ID: %d", diskId)
+		req := disks.ReplicationSuspendRequest{
+			DiskID: diskId,
+		}
+		_, err := c.CloudAPI().Disks().ReplicationSuspend(ctx, req)
+		if err != nil {
+			return err
+		}
+		log.Debugf("utilityDiskReplicationUpdatePause: pause disk replication with ID: %d, complete", diskId)
+	}
+
+	if ok && !pause.(bool) {
+		log.Debugf("utilityDiskReplicationUpdatePause: resume disk replication with ID: %d", diskId)
+		req := disks.ReplicationResumeRequest{
+			DiskID: diskId,
+		}
+		_, err := c.CloudAPI().Disks().ReplicationResume(ctx, req)
+		if err != nil {
+			return err
+		}
+		log.Debugf("utilityDiskReplicationUpdatePause: resume disk replication with ID: %d, complete", diskId)
+	}
+
+	log.Debugf("utilityDiskReplicationUpdatePause: complete update for disk replica with ID: %d", diskId)
+	return nil
+}
+
+func utilityDiskReplicationUpdateReverse(ctx context.Context, d *schema.ResourceData, m interface{}) error {
+	diskId := uint64(d.Get("disk_id").(int))
+	targetDiskId, _ := strconv.ParseUint(d.Id(), 10, 64)
+
+	log.Debugf("utilityDiskReplicaUpdateReverse: start update for disk replica with ID: %d", diskId)
+	c := m.(*controller.ControllerCfg)
+
+	reverse, ok := d.GetOk("reverse")
+
+	if ok && reverse.(bool) {
+		log.Debugf("utilityDiskReplicaUpdateReverse: reverse disk replication from Disk with ID: %d to Disk with ID: %d", diskId, targetDiskId)
+		req := disks.ReplicationReverseRequest{
+			DiskID: diskId,
+		}
+		_, err := c.CloudAPI().Disks().ReplicationReverse(ctx, req)
+		if err != nil {
+			return err
+		}
+		log.Debugf("utilityDiskReplicaUpdateReverse: reverse disk replication from Disk with ID: %d to Disk with ID: %d, complete", diskId, targetDiskId)
+	}
+
+	if ok && !reverse.(bool) {
+		log.Debugf("utilityDiskReplicaUpdateReverse: reverse disk replication from Disk with ID: %d to Disk with ID: %d", targetDiskId, diskId)
+		req := disks.ReplicationReverseRequest{
+			DiskID: targetDiskId,
+		}
+		_, err := c.CloudAPI().Disks().ReplicationReverse(ctx, req)
+		if err != nil {
+			return err
+		}
+		log.Debugf("utilityDiskReplicaUpdateReverse: reverse disk replication from Disk with ID: %d to Disk with ID: %d, complete", targetDiskId, diskId)
+	}
+
+	log.Debugf("utilityDiskReplicaUpdateReverse: complete update for disk replica with ID: %d", diskId)
+	return nil
+}
+
+func utilityDiskReplicaCheckPresence(ctx context.Context, d *schema.ResourceData, m interface{}) (*disks.RecordDisk, error) {
+	c := m.(*controller.ControllerCfg)
+
+	req := disks.GetRequest{}
+
+	if d.Id() != "" {
+		diskId, _ := strconv.ParseUint(d.Id(), 10, 64)
+		req.DiskID = diskId
+	} else {
+		req.DiskID = uint64(d.Get("replica_disk_id").(int))
+	}
+
+	log.Debugf("utilityDiskReplicaCheckPresence: load disk")
+	disk, err := c.CloudAPI().Disks().Get(ctx, req)
+	if err != nil {
+		return nil, err
+	}
+
+	return disk, nil
+}