4.6.0

internal/service/cloudbroker/disks/data_source_disk_replication.go

@@ -0,0 +1,90 @@
+/*
+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 DataSourceDiskReplication() *schema.Resource {
+	return &schema.Resource{
+		SchemaVersion: 1,
+
+		ReadContext: dataSourceDiskReplicationRead,
+
+		Timeouts: &schema.ResourceTimeout{
+			Read:    &constants.Timeout30s,
+			Default: &constants.Timeout60s,
+		},
+
+		Schema: dataSourceDiskReplicationSchemaMake(),
+	}
+}

internal/service/cloudbroker/disks/flattens.go

@@ -10,7 +10,6 @@ import (
 
 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))
@@ -41,6 +40,7 @@ func flattenDisk(d *schema.ResourceData, disk *disks.RecordDisk) {
 	d.Set("purge_attempts", disk.PurgeAttempts)
 	d.Set("present_to", disk.PresentTo)
 	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)
@@ -58,6 +58,71 @@ func flattenDisk(d *schema.ResourceData, disk *disks.RecordDisk) {
 	d.Set("vmid", disk.VMID)
 }
 
+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.Password)
+	d.Set("pci_slot", disk.PCISlot)
+	d.Set("pool", disk.Pool)
+	d.Set("purge_attempts", disk.PurgeAttempts)
+	d.Set("present_to", disk.PresentTo)
+	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("shareable", disk.Shareable)
+	d.Set("size_max", disk.SizeMax)
+	d.Set("size_used", disk.SizeUsed)
+	d.Set("snapshots", flattendDiskSnapshotList(disk.Snapshots))
+	d.Set("status", disk.Status)
+	d.Set("status_replication", statusReplication)
+	d.Set("tech_status", disk.TechStatus)
+	d.Set("type", disk.Type)
+	d.Set("vmid", disk.VMID)
+}
+
+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 flattenDiskSnapshot(d *schema.ResourceData, snapshot disks.ItemSnapshot) {
 	d.Set("timestamp", snapshot.Timestamp)
 	d.Set("guid", snapshot.GUID)
@@ -137,6 +202,7 @@ func flattenDiskList(dl *disks.ListDisks) []map[string]interface{} {
 			"pool":                  disk.Pool,
 			"purge_attempts":        disk.PurgeAttempts,
 			"purge_time":            disk.PurgeTime,
+			"replication":           flattenDiskReplication(disk.Replication),
 			"reality_device_number": disk.RealityDeviceNumber,
 			"reference_id":          disk.ReferenceID,
 			"res_id":                disk.ResID,

internal/service/cloudbroker/disks/resource_disk.go

@@ -33,6 +33,7 @@ package disks
 
 import (
 	"context"
+	"errors"
 	"fmt"
 	"strconv"
 
@@ -94,6 +95,14 @@ func resourceDiskCreate(ctx context.Context, d *schema.ResourceData, m interface
 
 	w := dc.Warnings{}
 
+	if _, ok := d.GetOk("node_ids"); ok {
+		log.Debugf("resourceDiskCreate: present for disk %d", d.Get("disk_id"))
+		if err := resourceDiskChangeNodes(ctx, d, m, true); err != nil {
+			w.Add(err)
+		}
+		log.Debugf("resourceDiskCreate: finished present for disk %d", d.Get("disk_id"))
+	}
+
 	if _, ok := d.GetOk("iotune"); ok {
 		if err := resourceDiskChangeIotune(ctx, d, m); err != nil {
 			w.Add(err)
@@ -208,26 +217,34 @@ func resourceDiskUpdate(ctx context.Context, d *schema.ResourceData, m interface
 		log.Debugf("resourceDiskUpdate: resizing disk ID %s - %d GB -> %d GB",
 			d.Id(), oldSize.(int), newSize.(int))
 		if err := resourceDiskChangeSize(ctx, d, m); err != nil {
-			w.Add(err)
+			return diag.FromErr(err)
 		}
 	}
 
 	if d.HasChange("disk_name") {
 		if err := resourceDiskChangeDiskName(ctx, d, m); err != nil {
-			w.Add(err)
+			return diag.FromErr(err)
 		}
 	}
 
 	if d.HasChange("iotune") {
 		if err := resourceDiskChangeIotune(ctx, d, m); err != nil {
-			w.Add(err)
+			return diag.FromErr(err)
 		}
 	}
 
 	if d.HasChange("shareable") {
 		if err := resourceDiskChangeShareable(ctx, d, m); err != nil {
+			return diag.FromErr(err)
+		}
+	}
+
+	if d.HasChange("node_ids") {
+		log.Debugf("resourceDiskUpdate: present for disk %d", d.Get("disk_id"))
+		if err := resourceDiskChangeNodes(ctx, d, m, false); err != nil {
 			w.Add(err)
 		}
+		log.Debugf("resourceDiskUpdate: finished present for disk %d", d.Get("disk_id"))
 	}
 
 	return append(w.Get(), resourceDiskRead(ctx, d, m)...)
@@ -347,6 +364,60 @@ func resourceDiskChangeSize(ctx context.Context, d *schema.ResourceData, m inter
 	return err
 }
 
+func resourceDiskChangeNodes(ctx context.Context, d *schema.ResourceData, m interface{}, afterCreate bool) error {
+	c := m.(*controller.ControllerCfg)
+	diskID := uint64(d.Get("disk_id").(int))
+	presentIDs := make([]interface{}, 0)
+	var errs error
+	var oldNodes, newNodes interface{}
+
+	if afterCreate {
+		nodeIDs := d.Get("node_ids").(*schema.Set).List()
+		presentIDs = nodeIDs
+	} else {
+		oldNodes, newNodes = d.GetChange("node_ids")
+		nodeIDs := (newNodes.(*schema.Set).Difference(oldNodes.(*schema.Set))).List()
+		presentIDs = nodeIDs
+	}
+
+	for _, presentID := range presentIDs {
+		nodeID := uint64(presentID.(int))
+
+		req := disks.PresentRequest{
+			DiskID: diskID,
+			NodeID: nodeID,
+		}
+
+		_, err := c.CloudBroker().Disks().Present(ctx, req)
+		if err != nil {
+			errs = errors.Join(err)
+		}
+	}
+
+	if afterCreate {
+		return errs
+	}
+
+	depresentIDs := (oldNodes.(*schema.Set).Difference(newNodes.(*schema.Set))).List()
+	if len(depresentIDs) > 0 {
+		for _, depresentID := range depresentIDs {
+			nodeID := uint64(depresentID.(int))
+
+			req := disks.DepresentRequest{
+				DiskID: diskID,
+				NodeID: nodeID,
+			}
+
+			_, err := c.CloudBroker().Disks().Depresent(ctx, req)
+			if err != nil {
+				errs = errors.Join(err)
+			}
+		}
+	}
+
+	return errs
+}
+
 func ResourceDisk() *schema.Resource {
 	return &schema.Resource{
 		SchemaVersion: 1,

internal/service/cloudbroker/disks/resource_disk_replication.go

@@ -0,0 +1,218 @@
+/*
+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"
+
+	"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/cloudbroker/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/service/cloudbroker/ic"
+)
+
+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 := ic.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.CloudBroker().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.CloudBroker().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.CloudBroker().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 := ic.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.CloudBroker().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),
+		Reason:      d.Get("reason").(string),
+	}
+
+	log.Debugf("resourceDiskReplicationDelete: delete disk replica for disk with ID: %d", diskId)
+	_, err = c.CloudBroker().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 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/cloudbroker/disks/schema.go

@@ -201,6 +201,39 @@ func dataSourceDiskSchemaMake() map[string]*schema.Schema {
 			Type:     schema.TypeInt,
 			Computed: true,
 		},
+		"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,
@@ -350,6 +383,11 @@ func dataSourceDiskListSchemaMake() map[string]*schema.Schema {
 			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,
@@ -567,6 +605,39 @@ func dataSourceDiskListSchemaMake() map[string]*schema.Schema {
 						Type:     schema.TypeInt,
 						Computed: true,
 					},
+					"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,
@@ -707,6 +778,11 @@ func dataSourceDiskListDeletedSchemaMake() map[string]*schema.Schema {
 			Optional:    true,
 			Description: "type of the disks",
 		},
+		"sort_by": {
+			Type:        schema.TypeString,
+			Optional:    true,
+			Description: "sort by one of supported fields, format +|-(field)",
+		},
 		"page": {
 			Type:        schema.TypeInt,
 			Optional:    true,
@@ -924,6 +1000,39 @@ func dataSourceDiskListDeletedSchemaMake() map[string]*schema.Schema {
 						Type:     schema.TypeInt,
 						Computed: true,
 					},
+					"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,
@@ -1029,6 +1138,11 @@ func dataSourceDiskListDeletedSchemaMake() map[string]*schema.Schema {
 
 func dataSourceDiskListTypesSchemaMake() map[string]*schema.Schema {
 	res := map[string]*schema.Schema{
+		"sort_by": {
+			Type:        schema.TypeString,
+			Optional:    true,
+			Description: "sort by one of supported fields, format +|-(field)",
+		},
 		"page": {
 			Type:        schema.TypeInt,
 			Optional:    true,
@@ -1057,6 +1171,11 @@ func dataSourceDiskListTypesSchemaMake() map[string]*schema.Schema {
 
 func dataSourceDiskListTypesDetailedSchemaMake() map[string]*schema.Schema {
 	return map[string]*schema.Schema{
+		"sort_by": {
+			Type:        schema.TypeString,
+			Optional:    true,
+			Description: "sort by one of supported fields, format +|-(field)",
+		},
 		"page": {
 			Type:        schema.TypeInt,
 			Optional:    true,
@@ -1157,6 +1276,11 @@ func dataSourceDiskListUnattachedSchemaMake() map[string]*schema.Schema {
 			Type:     schema.TypeString,
 			Optional: true,
 		},
+		"sort_by": {
+			Type:        schema.TypeString,
+			Optional:    true,
+			Description: "sort by one of supported fields, format +|-(field)",
+		},
 		"page": {
 			Type:        schema.TypeInt,
 			Optional:    true,
@@ -1716,6 +1840,13 @@ func resourceDiskSchemaMake() map[string]*schema.Schema {
 			Optional: true,
 			Computed: true,
 		},
+		"node_ids": {
+			Type:     schema.TypeSet,
+			Optional: true,
+			Elem: &schema.Schema{
+				Type: schema.TypeInt,
+			},
+		},
 		"detach": {
 			Type:        schema.TypeBool,
 			Optional:    true,
@@ -1935,6 +2066,39 @@ func resourceDiskSchemaMake() map[string]*schema.Schema {
 			Type:     schema.TypeInt,
 			Computed: true,
 		},
+		"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,
@@ -2015,3 +2179,714 @@ func resourceDiskSchemaMake() map[string]*schema.Schema {
 
 	return rets
 }
+
+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,
+		},
+		"account_name": {
+			Type:     schema.TypeString,
+			Computed: true,
+		},
+		"acl": {
+			Type:     schema.TypeString,
+			Computed: true,
+		},
+		"boot_partition": {
+			Type:     schema.TypeInt,
+			Computed: true,
+		},
+		"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,
+		},
+		"deleted_time": {
+			Type:     schema.TypeInt,
+			Computed: true,
+		},
+		"desc": {
+			Type:     schema.TypeString,
+			Computed: true,
+		},
+		"destruction_time": {
+			Type:     schema.TypeInt,
+			Computed: true,
+		},
+		"devicename": {
+			Type:     schema.TypeString,
+			Computed: true,
+		},
+		"disk_path": {
+			Type:     schema.TypeString,
+			Computed: true,
+		},
+		"gid": {
+			Type:     schema.TypeInt,
+			Computed: true,
+		},
+		"guid": {
+			Type:     schema.TypeInt,
+			Computed: true,
+		},
+		"image_id": {
+			Type:     schema.TypeInt,
+			Computed: true,
+		},
+		"images": {
+			Type:     schema.TypeList,
+			Computed: true,
+			Elem: &schema.Schema{
+				Type: schema.TypeInt,
+			},
+		},
+		"iotune": {
+			Type:     schema.TypeList,
+			Computed: true,
+			Elem: &schema.Resource{
+				Schema: map[string]*schema.Schema{
+					"read_bytes_sec": {
+						Type:     schema.TypeInt,
+						Computed: true,
+					},
+					"read_bytes_sec_max": {
+						Type:     schema.TypeInt,
+						Computed: true,
+					},
+					"read_iops_sec": {
+						Type:     schema.TypeInt,
+						Computed: true,
+					},
+					"read_iops_sec_max": {
+						Type:     schema.TypeInt,
+						Computed: true,
+					},
+					"size_iops_sec": {
+						Type:     schema.TypeInt,
+						Computed: true,
+					},
+					"total_bytes_sec": {
+						Type:     schema.TypeInt,
+						Computed: true,
+					},
+					"total_bytes_sec_max": {
+						Type:     schema.TypeInt,
+						Computed: true,
+					},
+					"total_iops_sec": {
+						Type:     schema.TypeInt,
+						Computed: true,
+					},
+					"total_iops_sec_max": {
+						Type:     schema.TypeInt,
+						Computed: true,
+					},
+					"write_bytes_sec": {
+						Type:     schema.TypeInt,
+						Computed: true,
+					},
+					"write_bytes_sec_max": {
+						Type:     schema.TypeInt,
+						Computed: true,
+					},
+					"write_iops_sec": {
+						Type:     schema.TypeInt,
+						Computed: true,
+					},
+					"write_iops_sec_max": {
+						Type:     schema.TypeInt,
+						Computed: true,
+					},
+				},
+			},
+		},
+		"iqn": {
+			Type:     schema.TypeString,
+			Computed: true,
+		},
+		"login": {
+			Type:     schema.TypeString,
+			Computed: true,
+		},
+		"milestones": {
+			Type:     schema.TypeInt,
+			Computed: true,
+		},
+		"disk_name": {
+			Type:     schema.TypeString,
+			Computed: true,
+		},
+		"order": {
+			Type:     schema.TypeInt,
+			Computed: true,
+		},
+		"params": {
+			Type:     schema.TypeString,
+			Computed: true,
+		},
+		"parent_id": {
+			Type:     schema.TypeInt,
+			Computed: true,
+		},
+		"passwd": {
+			Type:     schema.TypeString,
+			Computed: true,
+		},
+		"pci_slot": {
+			Type:     schema.TypeInt,
+			Computed: true,
+		},
+		"pool": {
+			Type:     schema.TypeString,
+			Computed: true,
+		},
+		"present_to": {
+			Type:     schema.TypeList,
+			Computed: true,
+			Elem: &schema.Schema{
+				Type: schema.TypeInt,
+			},
+		},
+		"purge_attempts": {
+			Type:     schema.TypeInt,
+			Computed: true,
+		},
+		"purge_time": {
+			Type:     schema.TypeInt,
+			Computed: true,
+		},
+		"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,
+		},
+		"reference_id": {
+			Type:     schema.TypeString,
+			Computed: true,
+		},
+		"res_id": {
+			Type:     schema.TypeString,
+			Computed: true,
+		},
+		"res_name": {
+			Type:     schema.TypeString,
+			Computed: true,
+		},
+		"role": {
+			Type:     schema.TypeString,
+			Computed: true,
+		},
+		"sep_id": {
+			Type:     schema.TypeInt,
+			Computed: true,
+		},
+		"sep_type": {
+			Type:     schema.TypeString,
+			Computed: true,
+		},
+		"shareable": {
+			Type:     schema.TypeBool,
+			Computed: true,
+		},
+		"size_max": {
+			Type:     schema.TypeInt,
+			Computed: true,
+		},
+		"size_used": {
+			Type:     schema.TypeFloat,
+			Computed: true,
+		},
+		"snapshots": {
+			Type:     schema.TypeList,
+			Computed: true,
+			Elem: &schema.Resource{
+				Schema: map[string]*schema.Schema{
+					"guid": {
+						Type:     schema.TypeString,
+						Computed: true,
+					},
+					"label": {
+						Type:     schema.TypeString,
+						Computed: true,
+					},
+					"reference_id": {
+						Type:     schema.TypeString,
+						Computed: true,
+					},
+					"res_id": {
+						Type:     schema.TypeString,
+						Computed: true,
+					},
+					"snap_set_guid": {
+						Type:     schema.TypeString,
+						Computed: true,
+					},
+					"snap_set_time": {
+						Type:     schema.TypeInt,
+						Computed: true,
+					},
+					"timestamp": {
+						Type:     schema.TypeInt,
+						Computed: true,
+					},
+				},
+			},
+		},
+		"status": {
+			Type:     schema.TypeString,
+			Computed: true,
+		},
+		"tech_status": {
+			Type:     schema.TypeString,
+			Computed: true,
+		},
+		"type": {
+			Type:     schema.TypeString,
+			Computed: true,
+		},
+		"vmid": {
+			Type:     schema.TypeInt,
+			Computed: true,
+		},
+	}
+
+	return rets
+}
+
+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",
+		},
+		"reason": {
+			Type:        schema.TypeString,
+			Optional:    true,
+			Description: "Reason for disk deletion",
+		},
+		"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,
+		},
+		"account_name": {
+			Type:     schema.TypeString,
+			Computed: true,
+		},
+		"acl": {
+			Type:     schema.TypeString,
+			Computed: true,
+		},
+		"boot_partition": {
+			Type:     schema.TypeInt,
+			Computed: true,
+		},
+		"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,
+		},
+		"deleted_time": {
+			Type:     schema.TypeInt,
+			Computed: true,
+		},
+		"desc": {
+			Type:     schema.TypeString,
+			Computed: true,
+		},
+		"destruction_time": {
+			Type:     schema.TypeInt,
+			Computed: true,
+		},
+		"devicename": {
+			Type:     schema.TypeString,
+			Computed: true,
+		},
+		"disk_path": {
+			Type:     schema.TypeString,
+			Computed: true,
+		},
+		"gid": {
+			Type:     schema.TypeInt,
+			Computed: true,
+		},
+		"guid": {
+			Type:     schema.TypeInt,
+			Computed: true,
+		},
+		"image_id": {
+			Type:     schema.TypeInt,
+			Computed: true,
+		},
+		"images": {
+			Type:     schema.TypeList,
+			Computed: true,
+			Elem: &schema.Schema{
+				Type: schema.TypeInt,
+			},
+		},
+		"iotune": {
+			Type:     schema.TypeList,
+			Computed: true,
+			Elem: &schema.Resource{
+				Schema: map[string]*schema.Schema{
+					"read_bytes_sec": {
+						Type:     schema.TypeInt,
+						Computed: true,
+					},
+					"read_bytes_sec_max": {
+						Type:     schema.TypeInt,
+						Computed: true,
+					},
+					"read_iops_sec": {
+						Type:     schema.TypeInt,
+						Computed: true,
+					},
+					"read_iops_sec_max": {
+						Type:     schema.TypeInt,
+						Computed: true,
+					},
+					"size_iops_sec": {
+						Type:     schema.TypeInt,
+						Computed: true,
+					},
+					"total_bytes_sec": {
+						Type:     schema.TypeInt,
+						Computed: true,
+					},
+					"total_bytes_sec_max": {
+						Type:     schema.TypeInt,
+						Computed: true,
+					},
+					"total_iops_sec": {
+						Type:     schema.TypeInt,
+						Computed: true,
+					},
+					"total_iops_sec_max": {
+						Type:     schema.TypeInt,
+						Computed: true,
+					},
+					"write_bytes_sec": {
+						Type:     schema.TypeInt,
+						Computed: true,
+					},
+					"write_bytes_sec_max": {
+						Type:     schema.TypeInt,
+						Computed: true,
+					},
+					"write_iops_sec": {
+						Type:     schema.TypeInt,
+						Computed: true,
+					},
+					"write_iops_sec_max": {
+						Type:     schema.TypeInt,
+						Computed: true,
+					},
+				},
+			},
+		},
+		"iqn": {
+			Type:     schema.TypeString,
+			Computed: true,
+		},
+		"login": {
+			Type:     schema.TypeString,
+			Computed: true,
+		},
+		"milestones": {
+			Type:     schema.TypeInt,
+			Computed: true,
+		},
+		"order": {
+			Type:     schema.TypeInt,
+			Computed: true,
+		},
+		"params": {
+			Type:     schema.TypeString,
+			Computed: true,
+		},
+		"parent_id": {
+			Type:     schema.TypeInt,
+			Computed: true,
+		},
+		"passwd": {
+			Type:     schema.TypeString,
+			Computed: true,
+		},
+		"pci_slot": {
+			Type:     schema.TypeInt,
+			Computed: true,
+		},
+		"present_to": {
+			Type:     schema.TypeList,
+			Computed: true,
+			Elem: &schema.Schema{
+				Type: schema.TypeInt,
+			},
+		},
+		"purge_attempts": {
+			Type:     schema.TypeInt,
+			Computed: true,
+		},
+		"purge_time": {
+			Type:     schema.TypeInt,
+			Computed: true,
+		},
+		"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,
+		},
+		"reference_id": {
+			Type:     schema.TypeString,
+			Computed: true,
+		},
+		"res_id": {
+			Type:     schema.TypeString,
+			Computed: true,
+		},
+		"res_name": {
+			Type:     schema.TypeString,
+			Computed: true,
+		},
+		"role": {
+			Type:     schema.TypeString,
+			Computed: true,
+		},
+		"sep_type": {
+			Type:     schema.TypeString,
+			Computed: true,
+		},
+		"shareable": {
+			Type:     schema.TypeBool,
+			Computed: true,
+		},
+		"size_max": {
+			Type:     schema.TypeInt,
+			Computed: true,
+		},
+		"size_used": {
+			Type:     schema.TypeFloat,
+			Computed: true,
+		},
+		"snapshots": {
+			Type:     schema.TypeList,
+			Computed: true,
+			Elem: &schema.Resource{
+				Schema: map[string]*schema.Schema{
+					"guid": {
+						Type:     schema.TypeString,
+						Computed: true,
+					},
+					"label": {
+						Type:     schema.TypeString,
+						Computed: true,
+					},
+					"reference_id": {
+						Type:     schema.TypeString,
+						Computed: true,
+					},
+					"res_id": {
+						Type:     schema.TypeString,
+						Computed: true,
+					},
+					"snap_set_guid": {
+						Type:     schema.TypeString,
+						Computed: true,
+					},
+					"snap_set_time": {
+						Type:     schema.TypeInt,
+						Computed: true,
+					},
+					"timestamp": {
+						Type:     schema.TypeInt,
+						Computed: true,
+					},
+				},
+			},
+		},
+		"status": {
+			Type:     schema.TypeString,
+			Computed: true,
+		},
+		"tech_status": {
+			Type:     schema.TypeString,
+			Computed: true,
+		},
+		"type": {
+			Type:     schema.TypeString,
+			Computed: true,
+		},
+		"vmid": {
+			Type:     schema.TypeInt,
+			Computed: true,
+		},
+	}
+
+	return rets
+}

internal/service/cloudbroker/disks/utility_disk_list.go

@@ -1,93 +1,96 @@
-/*
-Copyright (c) 2019-2022 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"
-	"strings"
-
-	log "github.com/sirupsen/logrus"
-	"repository.basistech.ru/BASIS/decort-golang-sdk/pkg/cloudbroker/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 diskType, ok := d.GetOk("type"); ok {
-		req.Type = strings.ToUpper(diskType.(string))
-	}
-	if pool, ok := d.GetOk("pool"); ok {
-		req.Pool = pool.(string)
-	}
-	if sepID, ok := d.GetOk("sep_id"); ok {
-		req.SEPID = uint64(sepID.(int))
-	}
-	if page, ok := d.GetOk("page"); ok {
-		req.Page = uint64(page.(int))
-	}
-	if size, ok := d.GetOk("size"); ok {
-		req.Size = uint64(size.(int))
-	}
-
-	log.Debugf("utilityDiskListCheckPresence: load disk list")
-	diskList, err := c.CloudBroker().Disks().List(ctx, req)
-	if err != nil {
-		return nil, err
-	}
-
-	return diskList, nil
-}
+/*
+Copyright (c) 2019-2022 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"
+	"strings"
+
+	log "github.com/sirupsen/logrus"
+	"repository.basistech.ru/BASIS/decort-golang-sdk/pkg/cloudbroker/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 diskType, ok := d.GetOk("type"); ok {
+		req.Type = strings.ToUpper(diskType.(string))
+	}
+	if pool, ok := d.GetOk("pool"); ok {
+		req.Pool = pool.(string)
+	}
+	if sepID, ok := d.GetOk("sep_id"); ok {
+		req.SEPID = uint64(sepID.(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))
+	}
+
+	log.Debugf("utilityDiskListCheckPresence: load disk list")
+	diskList, err := c.CloudBroker().Disks().List(ctx, req)
+	if err != nil {
+		return nil, err
+	}
+
+	return diskList, nil
+}

internal/service/cloudbroker/disks/utility_disk_list_deleted.go

@@ -68,6 +68,9 @@ func utilityDiskListDeletedCheckPresence(ctx context.Context, d *schema.Resource
 	if typev, ok := d.GetOk("type"); ok {
 		req.Type = typev.(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))
 	}

internal/service/cloudbroker/disks/utility_disk_list_types.go

@@ -15,6 +15,9 @@ func utilityDiskListTypesCheckPresence(ctx context.Context, d *schema.ResourceDa
 		Detailed: false,
 	}
 
+	if sortBy, ok := d.GetOk("sort_by"); ok {
+		req.SortBy = sortBy.(string)
+	}
 	if page, ok := d.GetOk("page"); ok {
 		req.Page = uint64(page.(int))
 	}

internal/service/cloudbroker/disks/utility_disk_list_types_detailed.go

@@ -15,6 +15,9 @@ func utilityDiskListTypesDetailedCheckPresence(ctx context.Context, d *schema.Re
 	req := disks.ListTypesRequest{
 		Detailed: true,
 	}
+	if sortBy, ok := d.GetOk("sort_by"); ok {
+		req.SortBy = sortBy.(string)
+	}
 	if page, ok := d.GetOk("page"); ok {
 		req.Page = uint64(page.(int))
 	}

internal/service/cloudbroker/disks/utility_disk_list_unattached.go

@@ -37,6 +37,9 @@ func utilityDiskListUnattachedCheckPresence(ctx context.Context, d *schema.Resou
 	if pool, ok := d.GetOk("pool"); ok {
 		req.Pool = pool.(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))
 	}

internal/service/cloudbroker/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/cloudbroker/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.CloudBroker().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.CloudBroker().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.CloudBroker().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.CloudBroker().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.CloudBroker().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.CloudBroker().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.CloudBroker().Disks().Get(ctx, req)
+	if err != nil {
+		return nil, err
+	}
+
+	return disk, nil
+}