4.13.1

2026-10-30 16:23:20 +03:00
parent 2b229a84fb
commit cd3310836b
63 changed files with 2375 additions and 1029 deletions
--- a/internal/service/cloudbroker/grid/flattens.go
+++ b/internal/service/cloudbroker/grid/flattens.go
@@ -21,6 +21,7 @@ func flattenGrid(d *schema.ResourceData, grid *grid.RecordGrid) {
 	d.Set("reserved_ram", grid.ReservedRAM)
 	d.Set("sdn_support", grid.SDNSupport)
 	d.Set("zero_access_enabled", grid.ZeroAccessEnabled)
+	d.Set("vm_folders_enabled", grid.VMFoldersEnabled)
 }

 func flattenGridList(gl *grid.ListGrids) []map[string]interface{} {
@@ -41,6 +42,7 @@ func flattenGridList(gl *grid.ListGrids) []map[string]interface{} {
 			"sdn_support":         item.SDNSupport,
 			"zero_access_enabled": item.ZeroAccessEnabled,
 			"bro_enabled":         item.BROEnabled,
+			"vm_folders_enabled":  item.VMFoldersEnabled,
 		}
 		res = append(res, temp)
 	}
--- a/internal/service/cloudbroker/grid/schema.go
+++ b/internal/service/cloudbroker/grid/schema.go
@@ -62,6 +62,10 @@ func dataSourceGetGridSchemaMake() map[string]*schema.Schema {
 			Type:     schema.TypeBool,
 			Computed: true,
 		},
+		"vm_folders_enabled": {
+			Type:     schema.TypeBool,
+			Computed: true,
+		},
 	}
 }

@@ -278,6 +282,10 @@ func dataSourceGridListSchemaMake() map[string]*schema.Schema {
 						Type:     schema.TypeBool,
 						Computed: true,
 					},
+					"vm_folders_enabled": {
+						Type:     schema.TypeBool,
+						Computed: true,
+					},
 				},
 			},
 		},
--- a/internal/service/cloudbroker/kvmvm/flattens.go
+++ b/internal/service/cloudbroker/kvmvm/flattens.go
@@ -112,6 +112,7 @@ func flattenCompute(d *schema.ResourceData, computeRec *compute.RecordCompute, p
 	d.Set("hot_resize", computeRec.HotResize)
 	d.Set("network_interface_naming", computeRec.NetworkInterfaceNaming)
 	d.Set("zone_id", computeRec.ZoneID)
+	d.Set("folder_id", computeRec.FolderID)
 	d.Set("os_version", computeRec.OSVersion)
 	d.Set("cpu_pin", computeRec.CPUPin)
 	d.Set("cpu_alignment_profile", computeRec.CPUAlignmentProfile.Name)
@@ -436,6 +437,7 @@ func flattenComputeList(computes *compute.ListComputes) []map[string]interface{}
 			"hot_resize":               computeItem.HotResize,
 			"network_interface_naming": computeItem.NetworkInterfaceNaming,
 			"zone_id":                  computeItem.ZoneID,
+			"folder_id":                computeItem.FolderID,
 			"weight":                   computeItem.Weight,
 		}
 		res = append(res, temp)
@@ -527,6 +529,7 @@ func flattenDeletedComputeList(computes *compute.ListDeletedComputes) []map[stri
 			"hot_resize":               computeItem.HotResize,
 			"network_interface_naming": computeItem.NetworkInterfaceNaming,
 			"zone_id":                  computeItem.ZoneID,
+			"folder_id":                computeItem.FolderID,
 			"weight":                   computeItem.Weight,
 		}
 		res = append(res, temp)
@@ -877,6 +880,7 @@ func flattenDataCompute(d *schema.ResourceData, compFacts *compute.RecordCompute
 	d.Set("hot_resize", compFacts.HotResize)
 	d.Set("network_interface_naming", compFacts.NetworkInterfaceNaming)
 	d.Set("zone_id", compFacts.ZoneID)
+	d.Set("folder_id", compFacts.FolderID)
 	d.Set("loader_meta_iso", flattenLoaderMetaIso(compFacts.LoaderMetaIso))
 	d.Set("os_version", compFacts.OSVersion)
 	d.Set("weight", compFacts.Weight)
--- a/internal/service/cloudbroker/kvmvm/schema.go
+++ b/internal/service/cloudbroker/kvmvm/schema.go
@@ -1233,6 +1233,10 @@ func dataSourceComputeSchemaMake() map[string]*schema.Schema {
 			Type:     schema.TypeInt,
 			Computed: true,
 		},
+		"folder_id": {
+			Type:     schema.TypeInt,
+			Computed: true,
+		},
 		"weight": {
 			Type:     schema.TypeInt,
 			Computed: true,
@@ -1330,6 +1334,16 @@ func dataSourceComputeListSchemaMake() map[string]*schema.Schema {
 			Optional:    true,
 			Description: "Zone ID",
 		},
+		"folder_id": {
+			Type:        schema.TypeInt,
+			Optional:    true,
+			Description: "Find by VM folder ID",
+		},
+		"include_descendants": {
+			Type:        schema.TypeBool,
+			Optional:    true,
+			Description: "Include computes from descendant folders",
+		},
 		"ignore_k8s": {
 			Type:        schema.TypeBool,
 			Optional:    true,
@@ -1837,6 +1851,10 @@ func dataSourceComputeListSchemaMake() map[string]*schema.Schema {
 						Type:     schema.TypeInt,
 						Computed: true,
 					},
+					"folder_id": {
+						Type:     schema.TypeInt,
+						Computed: true,
+					},
 					"weight": {
 						Type:     schema.TypeInt,
 						Computed: true,
@@ -2396,6 +2414,10 @@ func dataSourceComputeListDeletedSchemaMake() map[string]*schema.Schema {
 						Type:     schema.TypeInt,
 						Computed: true,
 					},
+					"folder_id": {
+						Type:     schema.TypeInt,
+						Computed: true,
+					},
 					"weight": {
 						Type:     schema.TypeInt,
 						Computed: true,
@@ -4929,6 +4951,10 @@ func resourceComputeSchemaMake() map[string]*schema.Schema {
 			Type:     schema.TypeString,
 			Computed: true,
 		},
+		"folder_id": {
+			Type:     schema.TypeInt,
+			Computed: true,
+		},
 		"vgpus": {
 			Type:        schema.TypeList,
 			Computed:    true,
--- a/internal/service/cloudbroker/kvmvm/utility_compute_list.go
+++ b/internal/service/cloudbroker/kvmvm/utility_compute_list.go
@@ -99,6 +99,12 @@ func utilityDataComputeListCheckPresence(ctx context.Context, d *schema.Resource
 	if zoneID, ok := d.GetOk("zone_id"); ok {
 		req.ZoneID = uint64(zoneID.(int))
 	}
+	if folderID, ok := d.GetOk("folder_id"); ok {
+		req.FolderID = uint64(folderID.(int))
+	}
+	if includeDescendants, ok := d.GetOkExists("include_descendants"); ok {
+		req.IncludeDescendants = includeDescendants.(bool)
+	}

 	listComputes, err := c.CloudBroker().Compute().List(ctx, req)
 	if err != nil {
--- a/internal/service/cloudbroker/vmfolder/data_source_vm_folder.go
+++ b/internal/service/cloudbroker/vmfolder/data_source_vm_folder.go
@@ -0,0 +1,44 @@
+package vmfolder
+
+import (
+	"context"
+
+	"github.com/google/uuid"
+	"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/terraform-provider-decort/internal/constants"
+	"repository.basistech.ru/BASIS/terraform-provider-decort/internal/dc"
+)
+
+func dataSourceVMFolderRead(ctx context.Context, d *schema.ResourceData, m interface{}) diag.Diagnostics {
+	log.Debugf("dataSourceVMFolderRead: called with folder_id %d", d.Get("folder_id").(int))
+
+	w := dc.Warnings{}
+	folder, err := utilityVMFolderCheckPresence(ctx, d, m)
+	if err != nil {
+		d.SetId("")
+		return diag.FromErr(err)
+	}
+
+	id := uuid.New()
+	d.SetId(id.String())
+	flattenVMFolder(d, folder)
+
+	return w.Get()
+}
+
+func DataSourceVMFolder() *schema.Resource {
+	return &schema.Resource{
+		SchemaVersion: 1,
+
+		ReadContext: dataSourceVMFolderRead,
+
+		Timeouts: &schema.ResourceTimeout{
+			Read:    &constants.Timeout30s,
+			Default: &constants.Timeout60s,
+		},
+
+		Schema: dataSourceVMFolderSchemaMake(),
+	}
+}
--- a/internal/service/cloudbroker/vmfolder/data_source_vm_folder_list.go
+++ b/internal/service/cloudbroker/vmfolder/data_source_vm_folder_list.go
@@ -0,0 +1,43 @@
+package vmfolder
+
+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"
+	"repository.basistech.ru/BASIS/terraform-provider-decort/internal/dc"
+)
+
+func dataSourceVMFolderListRead(ctx context.Context, d *schema.ResourceData, m interface{}) diag.Diagnostics {
+	w := dc.Warnings{}
+	folderList, err := utilityVMFolderListCheckPresence(ctx, d, m)
+	if err != nil {
+		d.SetId("")
+		return diag.FromErr(err)
+	}
+
+	id := uuid.New()
+	d.SetId(id.String())
+
+	d.Set("items", flattenVMFolderList(folderList))
+	d.Set("entry_count", folderList.EntryCount)
+
+	return w.Get()
+}
+
+func DataSourceVMFolderList() *schema.Resource {
+	return &schema.Resource{
+		SchemaVersion: 1,
+
+		ReadContext: dataSourceVMFolderListRead,
+
+		Timeouts: &schema.ResourceTimeout{
+			Read:    &constants.Timeout30s,
+			Default: &constants.Timeout60s,
+		},
+
+		Schema: dataSourceVMFolderListSchemaMake(),
+	}
+}
--- a/internal/service/cloudbroker/vmfolder/flattens.go
+++ b/internal/service/cloudbroker/vmfolder/flattens.go
@@ -0,0 +1,55 @@
+package vmfolder
+
+import (
+	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
+	log "github.com/sirupsen/logrus"
+	"repository.basistech.ru/BASIS/decort-golang-sdk/pkg/cloudbroker/vmfolder"
+)
+
+func flattenVMFolder(d *schema.ResourceData, folder *vmfolder.RecordVMFolder) {
+	log.Debugf("flattenVMFolder: decoded vm folder ID %d", folder.ID)
+
+	d.Set("folder_id", folder.ID)
+	d.Set("rg_id", folder.RGID)
+	d.Set("gid", folder.GID)
+	d.Set("name", folder.Name)
+	d.Set("acl", flattenVMFolderACL(folder.ACL))
+	d.Set("created_time", folder.CreatedTime)
+	d.Set("parent_id", folder.ParentID)
+	d.Set("status", folder.Status)
+	d.Set("compute_ids", folder.ComputeIDs)
+	d.Set("updated_time", folder.UpdatedTime)
+}
+
+func flattenVMFolderACL(acl []vmfolder.ACL) []map[string]interface{} {
+	res := make([]map[string]interface{}, 0, len(acl))
+	for _, item := range acl {
+		temp := map[string]interface{}{
+			"explicit":      item.Explicit,
+			"right":         item.Right,
+			"status":        item.Status,
+			"type":          item.Type,
+			"user_group_id": item.UserGroupID,
+		}
+		res = append(res, temp)
+	}
+
+	return res
+}
+
+func flattenVMFolderList(folderList *vmfolder.ListVMFolder) []map[string]interface{} {
+	res := make([]map[string]interface{}, 0, len(folderList.Data))
+	for _, item := range folderList.Data {
+		temp := map[string]interface{}{
+			"id":        item.ID,
+			"parent_id": item.ParentID,
+			"name":      item.Name,
+			"acl":       flattenVMFolderACL(item.ACL),
+			"status":    item.Status,
+			"vm_count":  item.VMCount,
+		}
+		res = append(res, temp)
+	}
+
+	return res
+}
--- a/internal/service/cloudbroker/vmfolder/resource_vm_folder.go
+++ b/internal/service/cloudbroker/vmfolder/resource_vm_folder.go
@@ -0,0 +1,182 @@
+package vmfolder
+
+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/vmfolder"
+	"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"
+)
+
+func resourceVMFolderCreate(ctx context.Context, d *schema.ResourceData, m interface{}) diag.Diagnostics {
+	log.Debugf("resourceVMFolderCreate: called with name %s, rg_id %d", d.Get("name").(string), d.Get("rg_id").(int))
+
+	c := m.(*controller.ControllerCfg)
+
+	warnings := dc.Warnings{}
+
+	req := vmfolder.CreateRequest{
+		RGID: uint64(d.Get("rg_id").(int)),
+		Name: d.Get("name").(string),
+	}
+
+	if parentID, ok := d.GetOk("parent_id"); ok {
+		req.ParentID = uint64(parentID.(int))
+	}
+
+	folderID, err := c.CloudBroker().VMFolder().Create(ctx, req)
+	if err != nil {
+		return diag.FromErr(err)
+	}
+
+	d.SetId(strconv.FormatUint(folderID, 10))
+	d.Set("folder_id", folderID)
+
+	if aclAccess, ok := d.GetOk("acl_access"); ok {
+		if err := utilityVMFolderACLAccessAdd(ctx, m, folderID, aclAccess.(*schema.Set).List()); err != nil {
+			warnings.Add(err)
+		}
+	}
+
+	if _, ok := d.GetOk("computes_move"); ok {
+		if err := utilityVMFolderComputesMove(ctx, d, m, folderID); err != nil {
+			warnings.Add(err)
+		}
+	}
+
+	return append(warnings.Get(), resourceVMFolderRead(ctx, d, m)...)
+}
+
+func resourceVMFolderRead(ctx context.Context, d *schema.ResourceData, m interface{}) diag.Diagnostics {
+	log.Debugf("resourceVMFolderRead: called with id %s", d.Id())
+
+	w := dc.Warnings{}
+
+	folder, err := utilityVMFolderCheckPresence(ctx, d, m)
+	if err != nil {
+		d.SetId("")
+		return diag.FromErr(err)
+	}
+
+	flattenVMFolder(d, folder)
+
+	return w.Get()
+}
+
+func resourceVMFolderUpdate(ctx context.Context, d *schema.ResourceData, m interface{}) diag.Diagnostics {
+	log.Debugf("resourceVMFolderUpdate: called with id %s", d.Id())
+
+	if d.HasChange("rg_id") {
+		return diag.Errorf("resourceVMFolderUpdate: rg_id can't be changed")
+	}
+
+	c := m.(*controller.ControllerCfg)
+
+	folderID, err := strconv.ParseUint(d.Id(), 10, 64)
+	if err != nil {
+		return diag.FromErr(err)
+	}
+
+	if d.HasChange("name") {
+		req := vmfolder.RenameRequest{
+			FolderID: folderID,
+			Name:     d.Get("name").(string),
+		}
+
+		if _, err := c.CloudBroker().VMFolder().Rename(ctx, req); err != nil {
+			return diag.FromErr(err)
+		}
+	}
+
+	if d.HasChange("parent_id") {
+		req := vmfolder.MoveRequest{
+			FolderID:    folderID,
+			NewParentID: uint64(d.Get("parent_id").(int)),
+		}
+
+		if _, err := c.CloudBroker().VMFolder().Move(ctx, req); err != nil {
+			return diag.FromErr(err)
+		}
+	}
+
+	if d.HasChange("acl_access") {
+		if err := utilityVMFolderACLAccessUpdate(ctx, d, m, folderID); err != nil {
+			return diag.FromErr(err)
+		}
+	}
+
+	if d.HasChanges("computes_move.#", "computes_move.0.compute_ids", "computes_move.0.folder_id") {
+		if err := utilityVMFolderComputesMove(ctx, d, m, folderID); err != nil {
+			return diag.FromErr(err)
+		}
+	}
+
+	return resourceVMFolderRead(ctx, d, m)
+}
+
+func resourceVMFolderDelete(ctx context.Context, d *schema.ResourceData, m interface{}) diag.Diagnostics {
+	log.Debugf("resourceVMFolderDelete: called with id %s", d.Id())
+
+	folder, err := utilityVMFolderCheckPresence(ctx, d, m)
+	if err != nil {
+		d.SetId("")
+		return diag.FromErr(err)
+	}
+
+	c := m.(*controller.ControllerCfg)
+
+	req := vmfolder.DeleteRequest{
+		FolderID: folder.ID,
+	}
+
+	if _, err := c.CloudBroker().VMFolder().Delete(ctx, req); err != nil {
+		return diag.FromErr(err)
+	}
+
+	d.SetId("")
+
+	return nil
+}
+
+func ResourceVMFolder() *schema.Resource {
+	return &schema.Resource{
+		SchemaVersion: 1,
+
+		CustomizeDiff: func(ctx context.Context, diff *schema.ResourceDiff, i interface{}) error {
+			if diff.HasChanges("name", "parent_id", "acl_access", "computes_move.#", "computes_move.0.compute_ids", "computes_move.0.folder_id") {
+				diff.SetNewComputed("updated_time")
+			}
+			if diff.HasChange("acl_access") {
+				diff.SetNewComputed("acl")
+			}
+			if diff.HasChanges("computes_move.#", "computes_move.0.compute_ids", "computes_move.0.folder_id") {
+				diff.SetNewComputed("compute_ids")
+			}
+			return nil
+		},
+
+		CreateContext: resourceVMFolderCreate,
+		ReadContext:   resourceVMFolderRead,
+		UpdateContext: resourceVMFolderUpdate,
+		DeleteContext: resourceVMFolderDelete,
+
+		Importer: &schema.ResourceImporter{
+			StateContext: schema.ImportStatePassthroughContext,
+		},
+
+		Timeouts: &schema.ResourceTimeout{
+			Create:  &constants.Timeout600s,
+			Read:    &constants.Timeout600s,
+			Update:  &constants.Timeout600s,
+			Delete:  &constants.Timeout600s,
+			Default: &constants.Timeout600s,
+		},
+
+		Schema: resourceVMFolderSchemaMake(),
+	}
+}
--- a/internal/service/cloudbroker/vmfolder/schema.go
+++ b/internal/service/cloudbroker/vmfolder/schema.go
@@ -0,0 +1,266 @@
+package vmfolder
+
+import (
+	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
+	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/validation"
+)
+
+func resourceVMFolderSchemaMake() map[string]*schema.Schema {
+	return map[string]*schema.Schema{
+		"rg_id": {
+			Type:        schema.TypeInt,
+			Required:    true,
+			Description: "ID of the resource group",
+		},
+		"name": {
+			Type:        schema.TypeString,
+			Required:    true,
+			Description: "Name of the vm folder",
+		},
+		"parent_id": {
+			Type:        schema.TypeInt,
+			Optional:    true,
+			Description: "ID of the parent vm folder",
+		},
+		"computes_move": {
+			Type:     schema.TypeList,
+			Optional: true,
+			MaxItems: 1,
+			Elem: &schema.Resource{
+				Schema: map[string]*schema.Schema{
+					"compute_ids": {
+						Type:     schema.TypeSet,
+						Optional: true,
+						Elem: &schema.Schema{
+							Type: schema.TypeInt,
+						},
+						Description: "IDs of computes to move",
+					},
+					"folder_id": {
+						Type:        schema.TypeInt,
+						Optional:    true,
+						Description: "ID of the target vm folder. If not set, computes are moved to this vm folder",
+					},
+				},
+			},
+			Description: "Move computes to the vm folder",
+		},
+		"acl_access": {
+			Type:     schema.TypeSet,
+			Optional: true,
+			Elem: &schema.Resource{
+				Schema: map[string]*schema.Schema{
+					"user": {
+						Type:        schema.TypeString,
+						Required:    true,
+						Description: "User or group name to grant access",
+					},
+					"right": {
+						Type:         schema.TypeString,
+						Required:     true,
+						ValidateFunc: validation.StringInSlice([]string{"R", "RCX", "ARCXDU"}, false),
+						Description:  "Access rights to set, one of 'R', 'RCX' or 'ARCXDU'",
+					},
+				},
+			},
+			Description: "ACL access rules for the vm folder",
+		},
+		"folder_id": {
+			Type:        schema.TypeInt,
+			Computed:    true,
+			Description: "ID of the vm folder",
+		},
+		"gid": {
+			Type:        schema.TypeInt,
+			Computed:    true,
+			Description: "Grid ID",
+		},
+		"acl": {
+			Type:     schema.TypeList,
+			Computed: true,
+			Elem: &schema.Resource{
+				Schema: aclSchemaMake(),
+			},
+			Description: "Access control list of the vm folder",
+		},
+		"created_time": {
+			Type:        schema.TypeInt,
+			Computed:    true,
+			Description: "Time of creation",
+		},
+		"status": {
+			Type:        schema.TypeString,
+			Computed:    true,
+			Description: "Status of the vm folder",
+		},
+		"compute_ids": {
+			Type:     schema.TypeList,
+			Computed: true,
+			Elem: &schema.Schema{
+				Type: schema.TypeInt,
+			},
+			Description: "IDs of computes in the vm folder",
+		},
+		"updated_time": {
+			Type:        schema.TypeInt,
+			Computed:    true,
+			Description: "Time of update",
+		},
+	}
+}
+
+func dataSourceVMFolderSchemaMake() map[string]*schema.Schema {
+	return map[string]*schema.Schema{
+		"folder_id": {
+			Type:        schema.TypeInt,
+			Required:    true,
+			Description: "ID of the vm folder",
+		},
+		"rg_id": {
+			Type:        schema.TypeInt,
+			Computed:    true,
+			Description: "ID of the resource group",
+		},
+		"gid": {
+			Type:        schema.TypeInt,
+			Computed:    true,
+			Description: "Grid ID",
+		},
+		"name": {
+			Type:        schema.TypeString,
+			Computed:    true,
+			Description: "Name of the vm folder",
+		},
+		"acl": {
+			Type:     schema.TypeList,
+			Computed: true,
+			Elem: &schema.Resource{
+				Schema: aclSchemaMake(),
+			},
+			Description: "Access control list of the vm folder",
+		},
+		"created_time": {
+			Type:        schema.TypeInt,
+			Computed:    true,
+			Description: "Time of creation",
+		},
+		"parent_id": {
+			Type:        schema.TypeInt,
+			Computed:    true,
+			Description: "ID of the parent vm folder",
+		},
+		"status": {
+			Type:        schema.TypeString,
+			Computed:    true,
+			Description: "Status of the vm folder",
+		},
+		"compute_ids": {
+			Type:     schema.TypeList,
+			Computed: true,
+			Elem: &schema.Schema{
+				Type: schema.TypeInt,
+			},
+			Description: "IDs of computes in the vm folder",
+		},
+		"updated_time": {
+			Type:        schema.TypeInt,
+			Computed:    true,
+			Description: "Time of update",
+		},
+	}
+}
+
+func dataSourceVMFolderListSchemaMake() map[string]*schema.Schema {
+	return map[string]*schema.Schema{
+		"rg_id": {
+			Type:        schema.TypeInt,
+			Required:    true,
+			Description: "Find by resource group ID",
+		},
+		"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{
+					"id": {
+						Type:        schema.TypeInt,
+						Computed:    true,
+						Description: "ID of the vm folder",
+					},
+					"parent_id": {
+						Type:        schema.TypeInt,
+						Computed:    true,
+						Description: "ID of the parent vm folder",
+					},
+					"name": {
+						Type:        schema.TypeString,
+						Computed:    true,
+						Description: "Name of the vm folder",
+					},
+					"acl": {
+						Type:     schema.TypeList,
+						Computed: true,
+						Elem: &schema.Resource{
+							Schema: aclSchemaMake(),
+						},
+						Description: "Access control list of the vm folder",
+					},
+					"status": {
+						Type:        schema.TypeString,
+						Computed:    true,
+						Description: "Status of the vm folder",
+					},
+					"vm_count": {
+						Type:        schema.TypeInt,
+						Computed:    true,
+						Description: "Number of computes in the vm folder",
+					},
+				},
+			},
+		},
+		"entry_count": {
+			Type:     schema.TypeInt,
+			Computed: true,
+		},
+	}
+}
+
+func aclSchemaMake() map[string]*schema.Schema {
+	return map[string]*schema.Schema{
+		"explicit": {
+			Type:        schema.TypeBool,
+			Computed:    true,
+			Description: "Whether the access is explicit",
+		},
+		"right": {
+			Type:        schema.TypeString,
+			Computed:    true,
+			Description: "Access rights",
+		},
+		"status": {
+			Type:        schema.TypeString,
+			Computed:    true,
+			Description: "Access status",
+		},
+		"type": {
+			Type:        schema.TypeString,
+			Computed:    true,
+			Description: "Access type",
+		},
+		"user_group_id": {
+			Type:        schema.TypeString,
+			Computed:    true,
+			Description: "User or group ID",
+		},
+	}
+}
--- a/internal/service/cloudbroker/vmfolder/utility_vm_folder.go
+++ b/internal/service/cloudbroker/vmfolder/utility_vm_folder.go
@@ -0,0 +1,117 @@
+package vmfolder
+
+import (
+	"context"
+	"strconv"
+
+	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
+	log "github.com/sirupsen/logrus"
+	"repository.basistech.ru/BASIS/decort-golang-sdk/pkg/cloudbroker/vmfolder"
+	"repository.basistech.ru/BASIS/terraform-provider-decort/internal/controller"
+)
+
+func utilityVMFolderCheckPresence(ctx context.Context, d *schema.ResourceData, m interface{}) (*vmfolder.RecordVMFolder, error) {
+	c := m.(*controller.ControllerCfg)
+	req := vmfolder.GetRequest{}
+
+	if d.Id() != "" {
+		id, err := strconv.ParseUint(d.Id(), 10, 64)
+		if err != nil {
+			return nil, err
+		}
+
+		req.FolderID = id
+	} else {
+		req.FolderID = uint64(d.Get("folder_id").(int))
+	}
+
+	log.Debugf("utilityVMFolderCheckPresence: get vm folder with ID %d", req.FolderID)
+
+	folder, err := c.CloudBroker().VMFolder().Get(ctx, req)
+	if err != nil {
+		return nil, err
+	}
+
+	return folder, nil
+}
+
+func utilityVMFolderComputesMove(ctx context.Context, d *schema.ResourceData, m interface{}, folderID uint64) error {
+	c := m.(*controller.ControllerCfg)
+
+	computesMove := d.Get("computes_move").([]interface{})
+	if len(computesMove) == 0 || computesMove[0] == nil {
+		return nil
+	}
+
+	item := computesMove[0].(map[string]interface{})
+
+	computeIDs := make([]uint64, 0)
+	for _, id := range item["compute_ids"].(*schema.Set).List() {
+		computeIDs = append(computeIDs, uint64(id.(int)))
+	}
+	if len(computeIDs) == 0 {
+		return nil
+	}
+
+	req := vmfolder.ComputesMoveRequest{
+		ComputeIDs: computeIDs,
+		FolderID:   folderID,
+	}
+	if targetFolderID := item["folder_id"].(int); targetFolderID != 0 {
+		req.FolderID = uint64(targetFolderID)
+	}
+
+	log.Debugf("utilityVMFolderComputesMove: move computes %v to vm folder with ID %d", computeIDs, req.FolderID)
+
+	_, err := c.CloudBroker().VMFolder().ComputesMove(ctx, req)
+
+	return err
+}
+
+func utilityVMFolderACLAccessAdd(ctx context.Context, m interface{}, folderID uint64, aclAccess []interface{}) error {
+	c := m.(*controller.ControllerCfg)
+
+	for _, aclInterface := range aclAccess {
+		aclItem := aclInterface.(map[string]interface{})
+
+		req := vmfolder.AddACLAccessRequest{
+			FolderID: folderID,
+			User:     aclItem["user"].(string),
+			Right:    aclItem["right"].(string),
+		}
+
+		log.Debugf("utilityVMFolderACLAccessAdd: add ACL access %s for user %s to vm folder with ID %d", req.Right, req.User, folderID)
+
+		if _, err := c.CloudBroker().VMFolder().AddACLAccess(ctx, req); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func utilityVMFolderACLAccessUpdate(ctx context.Context, d *schema.ResourceData, m interface{}, folderID uint64) error {
+	c := m.(*controller.ControllerCfg)
+
+	oldSet, newSet := d.GetChange("acl_access")
+
+	deletedAccess := (oldSet.(*schema.Set).Difference(newSet.(*schema.Set))).List()
+	for _, deletedInterface := range deletedAccess {
+		deletedItem := deletedInterface.(map[string]interface{})
+
+		req := vmfolder.DelACLAccessRequest{
+			FolderID: folderID,
+			User:     deletedItem["user"].(string),
+		}
+
+		log.Debugf("utilityVMFolderACLAccessUpdate: delete ACL access for user %s from vm folder with ID %d", req.User, folderID)
+
+		if _, err := c.CloudBroker().VMFolder().DeleteACLAccess(ctx, req); err != nil {
+			return err
+		}
+	}
+
+	addedAccess := (newSet.(*schema.Set).Difference(oldSet.(*schema.Set))).List()
+
+	return utilityVMFolderACLAccessAdd(ctx, m, folderID, addedAccess)
+}
--- a/internal/service/cloudbroker/vmfolder/utility_vm_folder_list.go
+++ b/internal/service/cloudbroker/vmfolder/utility_vm_folder_list.go
@@ -0,0 +1,33 @@
+package vmfolder
+
+import (
+	"context"
+
+	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
+	log "github.com/sirupsen/logrus"
+	"repository.basistech.ru/BASIS/decort-golang-sdk/pkg/cloudbroker/vmfolder"
+	"repository.basistech.ru/BASIS/terraform-provider-decort/internal/controller"
+)
+
+func utilityVMFolderListCheckPresence(ctx context.Context, d *schema.ResourceData, m interface{}) (*vmfolder.ListVMFolder, error) {
+	c := m.(*controller.ControllerCfg)
+	req := vmfolder.ListRequest{
+		RGID: uint64(d.Get("rg_id").(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("utilityVMFolderListCheckPresence: load vm folder list")
+
+	folderList, err := c.CloudBroker().VMFolder().List(ctx, req)
+	if err != nil {
+		return nil, err
+	}
+
+	return folderList, nil
+}