BASIS/terraform-provider-decort
9
0
Fork 0
Code Issues Pull Requests Packages Projects Releases 84 Wiki Activity

4.13.1

Browse Source 
4.13.1
This commit is contained in:
Алексей Фетисов
2026-10-30 16:23:20 +03:00
parent 2b229a84fb
commit cd3310836b
63 changed files with 2375 additions and 1029 deletions
Download Patch File Download Diff File Expand all files Collapse all files

44
internal/service/cloudbroker/vmfolder/data_source_vm_folder.go Normal file
View File

@@ -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(),
}
}

43
internal/service/cloudbroker/vmfolder/data_source_vm_folder_list.go Normal file
View File

@@ -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(),
}
}

55
internal/service/cloudbroker/vmfolder/flattens.go Normal file
View File

@@ -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
}

182
internal/service/cloudbroker/vmfolder/resource_vm_folder.go Normal file
View File

@@ -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(),
}
}

266
internal/service/cloudbroker/vmfolder/schema.go Normal file
View File

@@ -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",
},
}
}

117
internal/service/cloudbroker/vmfolder/utility_vm_folder.go Normal file
View File

@@ -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)
}

33
internal/service/cloudbroker/vmfolder/utility_vm_folder_list.go Normal file
View File

@@ -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
}