git test

internal/service/cloudapi/bservice/data_source_bservice.go

@@ -0,0 +1,302 @@
+/*
+Copyright (c) 2019-2022 Digital Energy Cloud Solutions LLC. All Rights Reserved.
+Authors:
+Petr Krutov, <petr.krutov@digitalenergy.online>
+Stanislav Solovev, <spsolovev@digitalenergy.online>
+Kasim Baybikov, <kmbaybikov@basistech.ru>
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+/*
+Terraform DECORT provider - manage resources provided by DECORT (Digital Energy Cloud
+Orchestration Technology) with Terraform by Hashicorp.
+
+Source code: https://repository.basistech.ru/BASIS/terraform-provider-decort
+
+Please see README.md to learn where to place source code so that it
+builds seamlessly.
+
+Documentation: https://repository.basistech.ru/BASIS/terraform-provider-decort/wiki
+*/
+
+package bservice
+
+import (
+	"context"
+	"strconv"
+
+	"github.com/hashicorp/terraform-plugin-sdk/v2/diag"
+	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
+	"repository.basistech.ru/BASIS/terraform-provider-decort/internal/constants"
+)
+
+func dataSourceBasicServiceRead(ctx context.Context, d *schema.ResourceData, m interface{}) diag.Diagnostics {
+	bs, err := utilityBasicServiceCheckPresence(ctx, d, m)
+	if err != nil {
+		d.SetId("")
+		return diag.FromErr(err)
+	}
+
+	d.SetId(strconv.FormatUint(bs.ID, 10))
+
+	flattenService(d, bs)
+
+	return nil
+}
+
+func dataSourceBasicServiceSchemaMake() map[string]*schema.Schema {
+	res := map[string]*schema.Schema{
+		"service_id": {
+			Type:     schema.TypeInt,
+			Required: true,
+		},
+		"account_id": {
+			Type:     schema.TypeInt,
+			Computed: true,
+		},
+		"account_name": {
+			Type:     schema.TypeString,
+			Computed: true,
+		},
+		"base_domain": {
+			Type:     schema.TypeString,
+			Computed: true,
+		},
+		"zone_id": {
+			Type:     schema.TypeInt,
+			Computed: true,
+		},
+		"computes": {
+			Type:     schema.TypeList,
+			Computed: true,
+			Elem: &schema.Resource{
+				Schema: map[string]*schema.Schema{
+					"account_id": {
+						Type:     schema.TypeInt,
+						Computed: true,
+					},
+					"architecture": {
+						Type:     schema.TypeString,
+						Computed: true,
+					},
+					"compgroup_id": {
+						Type:     schema.TypeInt,
+						Computed: true,
+					},
+					"compgroup_name": {
+						Type:     schema.TypeString,
+						Computed: true,
+					},
+					"compgroup_role": {
+						Type:     schema.TypeString,
+						Computed: true,
+					},
+					"id": {
+						Type:     schema.TypeInt,
+						Computed: true,
+					},
+					"rg_id": {
+						Type:     schema.TypeInt,
+						Computed: true,
+					},
+					"node_id": {
+						Type:     schema.TypeInt,
+						Computed: true,
+					},
+					"name": {
+						Type:     schema.TypeString,
+						Computed: true,
+					},
+					"status": {
+						Type:     schema.TypeString,
+						Computed: true,
+					},
+					"tech_status": {
+						Type:     schema.TypeString,
+						Computed: true,
+					},
+				},
+			},
+		},
+
+		"cpu_total": {
+			Type:     schema.TypeInt,
+			Computed: true,
+		},
+		"created_by": {
+			Type:     schema.TypeString,
+			Computed: true,
+		},
+		"created_time": {
+			Type:     schema.TypeInt,
+			Computed: true,
+		},
+		"deleted_by": {
+			Type:     schema.TypeString,
+			Computed: true,
+		},
+		"deleted_time": {
+			Type:     schema.TypeInt,
+			Computed: true,
+		},
+		"disk_total": {
+			Type:     schema.TypeInt,
+			Computed: true,
+		},
+		"gid": {
+			Type:     schema.TypeInt,
+			Computed: true,
+		},
+		"groups": {
+			Type:     schema.TypeList,
+			Computed: true,
+			Elem: &schema.Resource{
+				Schema: map[string]*schema.Schema{
+					"computes": {
+						Type:     schema.TypeInt,
+						Computed: true,
+					},
+					"consistency": {
+						Type:     schema.TypeBool,
+						Computed: true,
+					},
+					"id": {
+						Type:     schema.TypeInt,
+						Computed: true,
+					},
+					"name": {
+						Type:     schema.TypeString,
+						Computed: true,
+					},
+					"status": {
+						Type:     schema.TypeString,
+						Computed: true,
+					},
+					"tech_status": {
+						Type:     schema.TypeString,
+						Computed: true,
+					},
+				},
+			},
+		},
+		// "groups_name": {
+		// 	Type:     schema.TypeList,
+		// 	Computed: true,
+		// 	Elem: &schema.Schema{
+		// 		Type: schema.TypeString,
+		// 	},
+		// },
+		"guid": {
+			Type:     schema.TypeInt,
+			Computed: true,
+		},
+		"milestones": {
+			Type:     schema.TypeInt,
+			Computed: true,
+		},
+		"service_name": {
+			Type:     schema.TypeString,
+			Computed: true,
+		},
+		"parent_srv_id": {
+			Type:     schema.TypeInt,
+			Computed: true,
+		},
+		"parent_srv_type": {
+			Type:     schema.TypeString,
+			Computed: true,
+		},
+		"ram_total": {
+			Type:     schema.TypeInt,
+			Computed: true,
+		},
+		"rg_id": {
+			Type:     schema.TypeInt,
+			Computed: true,
+		},
+		"rg_name": {
+			Type:     schema.TypeString,
+			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,
+					},
+					"timestamp": {
+						Type:     schema.TypeInt,
+						Computed: true,
+					},
+					"valid": {
+						Type:     schema.TypeBool,
+						Computed: true,
+					},
+				},
+			},
+		},
+
+		"ssh_key": {
+			Type:     schema.TypeString,
+			Computed: true,
+		},
+		"ssh_user": {
+			Type:     schema.TypeString,
+			Computed: true,
+		},
+		"status": {
+			Type:     schema.TypeString,
+			Computed: true,
+		},
+		"tech_status": {
+			Type:     schema.TypeString,
+			Computed: true,
+		},
+		"updated_by": {
+			Type:     schema.TypeString,
+			Computed: true,
+		},
+		"updated_time": {
+			Type:     schema.TypeInt,
+			Computed: true,
+		},
+		"user_managed": {
+			Type:     schema.TypeBool,
+			Computed: true,
+		},
+	}
+	return res
+}
+
+func DataSourceBasicService() *schema.Resource {
+	return &schema.Resource{
+		SchemaVersion: 1,
+
+		ReadContext: dataSourceBasicServiceRead,
+
+		Timeouts: &schema.ResourceTimeout{
+			Read:    &constants.Timeout30s,
+			Default: &constants.Timeout60s,
+		},
+
+		Schema: dataSourceBasicServiceSchemaMake(),
+	}
+}

internal/service/cloudapi/bservice/data_source_bservice_deleted_list.go

@@ -0,0 +1,85 @@
+/*
+Copyright (c) 2019-2022 Digital Energy Cloud Solutions LLC. All Rights Reserved.
+Authors:
+Petr Krutov, <petr.krutov@digitalenergy.online>
+Stanislav Solovev, <spsolovev@digitalenergy.online>
+Kasim Baybikov, <kmbaybikov@basistech.ru>
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+/*
+Terraform DECORT provider - manage resources provided by DECORT (Digital Energy Cloud
+Orchestration Technology) with Terraform by Hashicorp.
+
+Source code: https://repository.basistech.ru/BASIS/terraform-provider-decort
+
+Please see README.md to learn where to place source code so that it
+builds seamlessly.
+
+Documentation: https://repository.basistech.ru/BASIS/terraform-provider-decort/wiki
+*/
+
+package bservice
+
+import (
+	"context"
+
+	"github.com/google/uuid"
+	"github.com/hashicorp/terraform-plugin-sdk/v2/diag"
+	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
+	"repository.basistech.ru/BASIS/terraform-provider-decort/internal/constants"
+)
+
+func dataSourceBasicServiceDeletedListRead(ctx context.Context, d *schema.ResourceData, m interface{}) diag.Diagnostics {
+	basicServiceDeletedList, err := utilityBasicServiceDeletedListCheckPresence(ctx, d, m)
+	if err != nil {
+		d.SetId("")
+		return diag.FromErr(err)
+	}
+
+	id := uuid.New()
+	d.SetId(id.String())
+	d.Set("items", flattenBasicServiceList(basicServiceDeletedList))
+	d.Set("entry_count", basicServiceDeletedList.EntryCount)
+
+	return nil
+}
+
+func dataSourceBasicServiceDeletedListSchemaMake() map[string]*schema.Schema {
+	temp := dataSourceBasicServiceListSchemaMake()
+
+	delete(temp, "by_id")
+	delete(temp, "name")
+	delete(temp, "rg_name")
+	delete(temp, "status")
+	delete(temp, "tech_status")
+	delete(temp, "account_name")
+
+	return temp
+}
+
+func DataSourceBasicServiceDeletedList() *schema.Resource {
+	return &schema.Resource{
+		SchemaVersion: 1,
+
+		ReadContext: dataSourceBasicServiceDeletedListRead,
+
+		Timeouts: &schema.ResourceTimeout{
+			Read:    &constants.Timeout30s,
+			Default: &constants.Timeout60s,
+		},
+
+		Schema: dataSourceBasicServiceDeletedListSchemaMake(),
+	}
+}

internal/service/cloudapi/bservice/data_source_bservice_group.go

@@ -0,0 +1,310 @@
+/*
+Copyright (c) 2019-2022 Digital Energy Cloud Solutions LLC. All Rights Reserved.
+Authors:
+Petr Krutov, <petr.krutov@digitalenergy.online>
+Stanislav Solovev, <spsolovev@digitalenergy.online>
+Kasim Baybikov, <kmbaybikov@basistech.ru>
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+/*
+Terraform DECORT provider - manage resources provided by DECORT (Digital Energy Cloud
+Orchestration Technology) with Terraform by Hashicorp.
+
+Source code: https://repository.basistech.ru/BASIS/terraform-provider-decort
+
+Please see README.md to learn where to place source code so that it
+builds seamlessly.
+
+Documentation: https://repository.basistech.ru/BASIS/terraform-provider-decort/wiki
+*/
+
+package bservice
+
+import (
+	"context"
+
+	"github.com/google/uuid"
+	"github.com/hashicorp/terraform-plugin-sdk/v2/diag"
+	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
+	"repository.basistech.ru/BASIS/decort-golang-sdk/pkg/cloudapi/bservice"
+	"repository.basistech.ru/BASIS/terraform-provider-decort/internal/constants"
+)
+
+func dataSourceBasicServiceGroupRead(ctx context.Context, d *schema.ResourceData, m interface{}) diag.Diagnostics {
+	bsg, err := utilityBasicServiceGroupCheckPresence(ctx, d, m)
+	if err != nil {
+		d.SetId("")
+		return diag.FromErr(err)
+	}
+
+	id := uuid.New()
+	d.SetId(id.String())
+	d.Set("account_id", bsg.AccountID)
+	d.Set("account_name", bsg.AccountName)
+	d.Set("computes", flattenBSGroupComputes(bsg.Computes))
+	d.Set("consistency", bsg.Consistency)
+	d.Set("cpu", bsg.CPU)
+	d.Set("created_by", bsg.CreatedBy)
+	d.Set("created_time", bsg.CreatedTime)
+	d.Set("deleted_by", bsg.DeletedBy)
+	d.Set("deleted_time", bsg.DeletedTime)
+	d.Set("disk", bsg.Disk)
+	d.Set("driver", bsg.Driver)
+	d.Set("extnets", bsg.ExtNets)
+	d.Set("gid", bsg.GID)
+	d.Set("guid", bsg.GUID)
+	d.Set("image_id", bsg.ImageID)
+	d.Set("milestones", bsg.Milestones)
+	d.Set("compgroup_name", bsg.Name)
+	d.Set("parents", bsg.Parents)
+	d.Set("ram", bsg.RAM)
+	d.Set("rg_id", bsg.RGID)
+	d.Set("rg_name", bsg.RGName)
+	d.Set("role", bsg.Role)
+	d.Set("sep_id", bsg.SEPID)
+	d.Set("seq_no", bsg.SeqNo)
+	d.Set("status", bsg.Status)
+	d.Set("tech_status", bsg.TechStatus)
+	d.Set("timeout_start", bsg.TimeoutStart)
+	d.Set("updated_by", bsg.UpdatedBy)
+	d.Set("updated_time", bsg.UpdatedTime)
+	d.Set("vinses", bsg.VINSes)
+	return nil
+}
+
+func flattenBSGroupOSUsers(bsgosus bservice.ListOSUsers) []map[string]interface{} {
+	res := make([]map[string]interface{}, 0)
+	for _, bsgosu := range bsgosus {
+		temp := map[string]interface{}{
+			"login":    bsgosu.Login,
+			"password": bsgosu.Password,
+		}
+		res = append(res, temp)
+	}
+
+	return res
+}
+
+func flattenBSGroupComputes(bsgcs bservice.ListGroupComputes) []map[string]interface{} {
+	res := make([]map[string]interface{}, 0)
+	for _, bsgc := range bsgcs {
+		temp := map[string]interface{}{
+			"id":           bsgc.ID,
+			"ip_addresses": bsgc.IPAddresses,
+			"name":         bsgc.Name,
+			"os_users":     flattenBSGroupOSUsers(bsgc.OSUsers),
+			"chipset":      bsgc.Chipset,
+		}
+		res = append(res, temp)
+	}
+	return res
+}
+
+func dataSourceBasicServiceGroupSchemaMake() map[string]*schema.Schema {
+	res := map[string]*schema.Schema{
+		"service_id": {
+			Type:     schema.TypeInt,
+			Required: true,
+		},
+		"compgroup_id": {
+			Type:     schema.TypeInt,
+			Required: true,
+		},
+		"account_id": {
+			Type:     schema.TypeInt,
+			Computed: true,
+		},
+		"account_name": {
+			Type:     schema.TypeString,
+			Computed: true,
+		},
+		"computes": {
+			Type:     schema.TypeList,
+			Computed: true,
+			Elem: &schema.Resource{
+				Schema: map[string]*schema.Schema{
+					"id": {
+						Type:     schema.TypeInt,
+						Computed: true,
+					},
+					"ip_addresses": {
+						Type:     schema.TypeList,
+						Computed: true,
+						Elem: &schema.Schema{
+							Type: schema.TypeString,
+						},
+					},
+					"name": {
+						Type:     schema.TypeString,
+						Computed: true,
+					},
+					"chipset": {
+						Type:     schema.TypeString,
+						Computed: true,
+					},
+					"os_users": {
+						Type:     schema.TypeList,
+						Computed: true,
+						Elem: &schema.Resource{
+							Schema: map[string]*schema.Schema{
+								"login": {
+									Type:     schema.TypeString,
+									Computed: true,
+								},
+								"password": {
+									Type:     schema.TypeString,
+									Computed: true,
+								},
+							},
+						},
+					},
+				},
+			},
+		},
+		"consistency": {
+			Type:     schema.TypeBool,
+			Computed: true,
+		},
+		"cpu": {
+			Type:     schema.TypeInt,
+			Computed: true,
+		},
+		"created_by": {
+			Type:     schema.TypeString,
+			Computed: true,
+		},
+		"created_time": {
+			Type:     schema.TypeInt,
+			Computed: true,
+		},
+		"deleted_by": {
+			Type:     schema.TypeString,
+			Computed: true,
+		},
+		"deleted_time": {
+			Type:     schema.TypeInt,
+			Computed: true,
+		},
+		"disk": {
+			Type:     schema.TypeInt,
+			Computed: true,
+		},
+		"driver": {
+			Type:     schema.TypeString,
+			Computed: true,
+		},
+		"extnets": {
+			Type:     schema.TypeList,
+			Computed: true,
+			Elem: &schema.Schema{
+				Type: schema.TypeInt,
+			},
+		},
+		"gid": {
+			Type:     schema.TypeInt,
+			Computed: true,
+		},
+		"guid": {
+			Type:     schema.TypeInt,
+			Computed: true,
+		},
+		"image_id": {
+			Type:     schema.TypeInt,
+			Computed: true,
+		},
+		"milestones": {
+			Type:     schema.TypeInt,
+			Computed: true,
+		},
+		"compgroup_name": {
+			Type:     schema.TypeString,
+			Computed: true,
+		},
+		"parents": {
+			Type:     schema.TypeList,
+			Computed: true,
+			Elem: &schema.Schema{
+				Type: schema.TypeInt,
+			},
+		},
+		"ram": {
+			Type:     schema.TypeInt,
+			Computed: true,
+		},
+		"rg_id": {
+			Type:     schema.TypeInt,
+			Computed: true,
+		},
+		"rg_name": {
+			Type:     schema.TypeString,
+			Computed: true,
+		},
+		"role": {
+			Type:     schema.TypeString,
+			Computed: true,
+		},
+		"sep_id": {
+			Type:     schema.TypeInt,
+			Computed: true,
+		},
+		"seq_no": {
+			Type:     schema.TypeInt,
+			Computed: true,
+		},
+		"status": {
+			Type:     schema.TypeString,
+			Computed: true,
+		},
+		"tech_status": {
+			Type:     schema.TypeString,
+			Computed: true,
+		},
+		"timeout_start": {
+			Type:     schema.TypeInt,
+			Computed: true,
+		},
+		"updated_by": {
+			Type:     schema.TypeString,
+			Computed: true,
+		},
+		"updated_time": {
+			Type:     schema.TypeInt,
+			Computed: true,
+		},
+		"vinses": {
+			Type:     schema.TypeList,
+			Computed: true,
+			Elem: &schema.Schema{
+				Type: schema.TypeInt,
+			},
+		},
+	}
+	return res
+}
+
+func DataSourceBasicServiceGroup() *schema.Resource {
+	return &schema.Resource{
+		SchemaVersion: 1,
+
+		ReadContext: dataSourceBasicServiceGroupRead,
+
+		Timeouts: &schema.ResourceTimeout{
+			Read:    &constants.Timeout30s,
+			Default: &constants.Timeout60s,
+		},
+
+		Schema: dataSourceBasicServiceGroupSchemaMake(),
+	}
+}

internal/service/cloudapi/bservice/data_source_bservice_list.go

@@ -0,0 +1,279 @@
+/*
+Copyright (c) 2019-2022 Digital Energy Cloud Solutions LLC. All Rights Reserved.
+Authors:
+Petr Krutov, <petr.krutov@digitalenergy.online>
+Stanislav Solovev, <spsolovev@digitalenergy.online>
+Kasim Baybikov, <kmbaybikov@basistech.ru>
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+/*
+Terraform DECORT provider - manage resources provided by DECORT (Digital Energy Cloud
+Orchestration Technology) with Terraform by Hashicorp.
+
+Source code: https://repository.basistech.ru/BASIS/terraform-provider-decort
+
+Please see README.md to learn where to place source code so that it
+builds seamlessly.
+
+Documentation: https://repository.basistech.ru/BASIS/terraform-provider-decort/wiki
+*/
+
+package bservice
+
+import (
+	"context"
+
+	"github.com/google/uuid"
+	"github.com/hashicorp/terraform-plugin-sdk/v2/diag"
+	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
+	"repository.basistech.ru/BASIS/decort-golang-sdk/pkg/cloudapi/bservice"
+	"repository.basistech.ru/BASIS/terraform-provider-decort/internal/constants"
+)
+
+func flattenBasicServiceList(bsl *bservice.ListBasicServices) []map[string]interface{} {
+	res := make([]map[string]interface{}, 0)
+	for _, bs := range bsl.Data {
+		temp := map[string]interface{}{
+			"account_id":      bs.AccountID,
+			"account_name":    bs.AccountName,
+			"base_domain":     bs.BaseDomain,
+			"created_by":      bs.CreatedBy,
+			"created_time":    bs.CreatedTime,
+			"deleted_by":      bs.DeletedBy,
+			"deleted_time":    bs.DeletedTime,
+			"gid":             bs.GID,
+			"groups":          bs.Groups,
+			"guid":            bs.GUID,
+			"service_id":      bs.ID,
+			"service_name":    bs.Name,
+			"parent_srv_id":   bs.ParentSrvID,
+			"parent_srv_type": bs.ParentSrvType,
+			"rg_id":           bs.RGID,
+			"rg_name":         bs.RGName,
+			"ssh_user":        bs.SSHUser,
+			"status":          bs.Status,
+			"tech_status":     bs.TechStatus,
+			"updated_by":      bs.UpdatedBy,
+			"updated_time":    bs.UpdatedTime,
+			"user_managed":    bs.UserManaged,
+			"zone_id":         bs.ZoneID,
+		}
+		res = append(res, temp)
+	}
+	return res
+}
+
+func dataSourceBasicServiceListRead(ctx context.Context, d *schema.ResourceData, m interface{}) diag.Diagnostics {
+	basicServiceList, err := utilityBasicServiceListCheckPresence(ctx, d, m)
+	if err != nil {
+		d.SetId("")
+		return diag.FromErr(err)
+	}
+
+	id := uuid.New()
+	d.SetId(id.String())
+	d.Set("items", flattenBasicServiceList(basicServiceList))
+	d.Set("entry_count", basicServiceList.EntryCount)
+
+	return nil
+}
+
+func dataSourceBasicServiceListSchemaMake() map[string]*schema.Schema {
+	res := map[string]*schema.Schema{
+		"by_id": {
+			Type:        schema.TypeInt,
+			Optional:    true,
+			Description: "Filter by ID",
+		},
+		"name": {
+			Type:        schema.TypeString,
+			Optional:    true,
+			Description: "Filter by bservice name",
+		},
+		"rg_name": {
+			Type:        schema.TypeString,
+			Optional:    true,
+			Description: "Filter by resource group name",
+		},
+		"status": {
+			Type:        schema.TypeString,
+			Optional:    true,
+			Description: "Filter by status",
+		},
+		"tech_status": {
+			Type:        schema.TypeString,
+			Optional:    true,
+			Description: "Filter by tech status",
+		},
+		"account_name": {
+			Type:        schema.TypeString,
+			Optional:    true,
+			Description: "Filter by account name",
+		},
+		"account_id": {
+			Type:        schema.TypeInt,
+			Optional:    true,
+			Description: "ID of the account to query for BasicService instances",
+		},
+		"rg_id": {
+			Type:        schema.TypeInt,
+			Optional:    true,
+			Description: "ID of the resource group to query for BasicService instances",
+		},
+		"sort_by": {
+			Type:        schema.TypeString,
+			Optional:    true,
+			Description: "sort by one of supported fields, format +|-(field)",
+		},
+		"page": {
+			Type:        schema.TypeInt,
+			Optional:    true,
+			Description: "Page number",
+		},
+		"size": {
+			Type:        schema.TypeInt,
+			Optional:    true,
+			Description: "Page size",
+		},
+		"zone_id": {
+			Type:        schema.TypeInt,
+			Optional:    true,
+			Description: "Zone ID",
+		},
+		"items": {
+			Type:     schema.TypeList,
+			Computed: true,
+			Elem: &schema.Resource{
+				Schema: map[string]*schema.Schema{
+					"account_id": {
+						Type:     schema.TypeInt,
+						Computed: true,
+					},
+					"account_name": {
+						Type:     schema.TypeString,
+						Computed: true,
+					},
+					"base_domain": {
+						Type:     schema.TypeString,
+						Computed: true,
+					},
+					"created_by": {
+						Type:     schema.TypeString,
+						Computed: true,
+					},
+					"created_time": {
+						Type:     schema.TypeInt,
+						Computed: true,
+					},
+					"deleted_by": {
+						Type:     schema.TypeString,
+						Computed: true,
+					},
+					"deleted_time": {
+						Type:     schema.TypeInt,
+						Computed: true,
+					},
+					"gid": {
+						Type:     schema.TypeInt,
+						Computed: true,
+					},
+					"zone_id": {
+						Type:     schema.TypeInt,
+						Computed: true,
+					},
+					"groups": {
+						Type:     schema.TypeList,
+						Computed: true,
+						Elem: &schema.Schema{
+							Type: schema.TypeInt,
+						},
+					},
+					"guid": {
+						Type:     schema.TypeInt,
+						Computed: true,
+					},
+					"service_id": {
+						Type:     schema.TypeInt,
+						Computed: true,
+					},
+					"service_name": {
+						Type:     schema.TypeString,
+						Computed: true,
+					},
+					"parent_srv_id": {
+						Type:     schema.TypeInt,
+						Computed: true,
+					},
+					"parent_srv_type": {
+						Type:     schema.TypeString,
+						Computed: true,
+					},
+					"rg_id": {
+						Type:     schema.TypeInt,
+						Computed: true,
+					},
+					"rg_name": {
+						Type:     schema.TypeString,
+						Computed: true,
+					},
+					"ssh_user": {
+						Type:     schema.TypeString,
+						Computed: true,
+					},
+					"status": {
+						Type:     schema.TypeString,
+						Computed: true,
+					},
+					"tech_status": {
+						Type:     schema.TypeString,
+						Computed: true,
+					},
+					"updated_by": {
+						Type:     schema.TypeString,
+						Computed: true,
+					},
+					"updated_time": {
+						Type:     schema.TypeInt,
+						Computed: true,
+					},
+					"user_managed": {
+						Type:     schema.TypeBool,
+						Computed: true,
+					},
+				},
+			},
+		},
+		"entry_count": {
+			Type:     schema.TypeInt,
+			Computed: true,
+		},
+	}
+	return res
+}
+
+func DataSourceBasicServiceList() *schema.Resource {
+	return &schema.Resource{
+		SchemaVersion: 1,
+
+		ReadContext: dataSourceBasicServiceListRead,
+
+		Timeouts: &schema.ResourceTimeout{
+			Read:    &constants.Timeout30s,
+			Default: &constants.Timeout60s,
+		},
+
+		Schema: dataSourceBasicServiceListSchemaMake(),
+	}
+}

internal/service/cloudapi/bservice/data_source_bservice_snapshot_list.go

@@ -0,0 +1,110 @@
+/*
+Copyright (c) 2019-2022 Digital Energy Cloud Solutions LLC. All Rights Reserved.
+Authors:
+Petr Krutov, <petr.krutov@digitalenergy.online>
+Stanislav Solovev, <spsolovev@digitalenergy.online>
+Kasim Baybikov, <kmbaybikov@basistech.ru>
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+/*
+Terraform DECORT provider - manage resources provided by DECORT (Digital Energy Cloud
+Orchestration Technology) with Terraform by Hashicorp.
+
+Source code: https://repository.basistech.ru/BASIS/terraform-provider-decort
+
+Please see README.md to learn where to place source code so that it
+builds seamlessly.
+
+Documentation: https://repository.basistech.ru/BASIS/terraform-provider-decort/wiki
+*/
+
+package bservice
+
+import (
+	"context"
+
+	"github.com/google/uuid"
+	"github.com/hashicorp/terraform-plugin-sdk/v2/diag"
+	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
+	"repository.basistech.ru/BASIS/terraform-provider-decort/internal/constants"
+)
+
+func dataSourceBasicServiceSnapshotListRead(ctx context.Context, d *schema.ResourceData, m interface{}) diag.Diagnostics {
+	basicServiceSnapshotList, err := utilityBasicServiceSnapshotListCheckPresence(ctx, d, m)
+	if err != nil {
+		d.SetId("")
+		return diag.FromErr(err)
+	}
+
+	id := uuid.New()
+	d.SetId(id.String())
+	d.Set("items", flattenBasicServiceSnapshotsList(basicServiceSnapshotList))
+	d.Set("entry_count", basicServiceSnapshotList.EntryCount)
+	return nil
+}
+
+func dataSourceBasicServiceSnapshotListSchemaMake() map[string]*schema.Schema {
+	res := map[string]*schema.Schema{
+		"service_id": {
+			Type:        schema.TypeInt,
+			Required:    true,
+			Description: "ID of the BasicService instance",
+		},
+		"items": {
+			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,
+					},
+					"timestamp": {
+						Type:     schema.TypeInt,
+						Computed: true,
+					},
+					"valid": {
+						Type:     schema.TypeBool,
+						Computed: true,
+					},
+				},
+			},
+		},
+		"entry_count": {
+			Type:     schema.TypeInt,
+			Computed: true,
+		},
+	}
+	return res
+}
+
+func DataSourceBasicServiceSnapshotList() *schema.Resource {
+	return &schema.Resource{
+		SchemaVersion: 1,
+
+		ReadContext: dataSourceBasicServiceSnapshotListRead,
+
+		Timeouts: &schema.ResourceTimeout{
+			Read:    &constants.Timeout30s,
+			Default: &constants.Timeout60s,
+		},
+
+		Schema: dataSourceBasicServiceSnapshotListSchemaMake(),
+	}
+}

internal/service/cloudapi/bservice/flattens.go

@@ -0,0 +1,140 @@
+package bservice
+
+import (
+	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
+	"repository.basistech.ru/BASIS/decort-golang-sdk/pkg/cloudapi/bservice"
+)
+
+func flattenResourceBasicServiceGroup(d *schema.ResourceData, bsg *bservice.RecordGroup) {
+	d.Set("account_id", bsg.AccountID)
+	d.Set("account_name", bsg.AccountName)
+	d.Set("computes", flattenBSGroupComputes(bsg.Computes))
+	d.Set("consistency", bsg.Consistency)
+	d.Set("cpu", bsg.CPU)
+	d.Set("created_by", bsg.CreatedBy)
+	d.Set("created_time", bsg.CreatedTime)
+	d.Set("deleted_by", bsg.DeletedBy)
+	d.Set("deleted_time", bsg.DeletedTime)
+	d.Set("disk", bsg.Disk)
+	d.Set("driver", bsg.Driver)
+	d.Set("extnets", bsg.ExtNets)
+	d.Set("gid", bsg.GID)
+	d.Set("guid", bsg.GUID)
+	d.Set("image_id", bsg.ImageID)
+	d.Set("milestones", bsg.Milestones)
+	d.Set("compgroup_name", bsg.Name)
+	d.Set("compgroup_id", bsg.ID)
+	d.Set("parents", bsg.Parents)
+	d.Set("ram", bsg.RAM)
+	d.Set("rg_id", bsg.RGID)
+	d.Set("rg_name", bsg.RGName)
+	d.Set("role", bsg.Role)
+	d.Set("sep_id", bsg.SEPID)
+	d.Set("sep_pool", bsg.PoolName)
+	d.Set("seq_no", bsg.SeqNo)
+	d.Set("status", bsg.Status)
+	d.Set("tech_status", bsg.TechStatus)
+	d.Set("timeout_start", bsg.TimeoutStart)
+	d.Set("updated_by", bsg.UpdatedBy)
+	d.Set("updated_time", bsg.UpdatedTime)
+	d.Set("vinses", bsg.VINSes)
+}
+
+func flattenGroups(groups bservice.ListGroups) []map[string]interface{} {
+	res := make([]map[string]interface{}, 0)
+	for _, group := range groups {
+		temp := map[string]interface{}{
+			"computes":    group.Computes,
+			"consistency": group.Consistency,
+			"id":          group.ID,
+			"name":        group.Name,
+			"status":      group.Status,
+			"tech_status": group.TechStatus,
+		}
+		res = append(res, temp)
+	}
+	return res
+}
+
+func flattenService(d *schema.ResourceData, bs *bservice.RecordBasicService) {
+	d.Set("account_id", bs.AccountID)
+	d.Set("account_name", bs.AccountName)
+	d.Set("base_domain", bs.BaseDomain)
+	d.Set("computes", flattenBasicServiceComputes(bs.Computes))
+	d.Set("cpu_total", bs.CPUTotal)
+	d.Set("created_by", bs.CreatedBy)
+	d.Set("created_time", bs.CreatedTime)
+	d.Set("deleted_by", bs.DeletedBy)
+	d.Set("deleted_time", bs.DeletedTime)
+	d.Set("disk_total", bs.DiskTotal)
+	d.Set("gid", bs.GID)
+	d.Set("groups", flattenGroups(bs.Groups))
+	d.Set("guid", bs.GUID)
+	d.Set("milestones", bs.Milestones)
+	d.Set("service_name", bs.Name)
+	d.Set("service_id", bs.ID)
+	d.Set("parent_srv_id", bs.ParentSrvID)
+	d.Set("parent_srv_type", bs.ParentSrvType)
+	d.Set("ram_total", bs.RAMTotal)
+	d.Set("rg_id", bs.RGID)
+	d.Set("rg_name", bs.RGName)
+	d.Set("snapshots", flattenBasicServiceSnapshots(bs.Snapshots))
+	d.Set("ssh_key", bs.SSHKey)
+	d.Set("ssh_user", bs.SSHUser)
+	d.Set("status", bs.Status)
+	d.Set("tech_status", bs.TechStatus)
+	d.Set("updated_by", bs.UpdatedBy)
+	d.Set("updated_time", bs.UpdatedTime)
+	d.Set("user_managed", bs.UserManaged)
+	d.Set("zone_id", bs.ZoneID)
+}
+
+func flattenBasicServiceComputes(bscs bservice.ListComputes) []map[string]interface{} {
+	res := make([]map[string]interface{}, 0)
+	for _, bsc := range bscs {
+		temp := map[string]interface{}{
+			"account_id":     bsc.AccountID,
+			"architecture":   bsc.Architecture,
+			"compgroup_id":   bsc.CompGroupID,
+			"compgroup_name": bsc.CompGroupName,
+			"compgroup_role": bsc.CompGroupRole,
+			"id":             bsc.ID,
+			"name":           bsc.Name,
+			"rg_id":          bsc.RGID,
+			"node_id":        bsc.NodeID,
+			"status":         bsc.Status,
+			"tech_status":    bsc.TechStatus,
+		}
+		res = append(res, temp)
+	}
+
+	return res
+}
+
+func flattenBasicServiceSnapshots(bsrvss bservice.ListSnapshots) []map[string]interface{} {
+	res := make([]map[string]interface{}, 0, len(bsrvss))
+	for _, bsrvs := range bsrvss {
+		temp := map[string]interface{}{
+			"guid":      bsrvs.GUID,
+			"label":     bsrvs.Label,
+			"timestamp": bsrvs.Timestamp,
+			"valid":     bsrvs.Valid,
+		}
+		res = append(res, temp)
+	}
+	return res
+}
+
+func flattenBasicServiceSnapshotsList(bsrvss *bservice.ListInfoSnapshots) []map[string]interface{} {
+	res := make([]map[string]interface{}, 0, len(bsrvss.Data))
+	for _, bsrvs := range bsrvss.Data {
+		temp := map[string]interface{}{
+			"guid":      bsrvs.GUID,
+			"label":     bsrvs.Label,
+			"timestamp": bsrvs.Timestamp,
+			"valid":     bsrvs.Valid,
+		}
+		res = append(res, temp)
+	}
+	return res
+}

internal/service/cloudapi/bservice/resource_bservice.go

@@ -0,0 +1,759 @@
+/*
+Copyright (c) 2019-2022 Digital Energy Cloud Solutions LLC. All Rights Reserved.
+Authors:
+Petr Krutov, <petr.krutov@digitalenergy.online>
+Stanislav Solovev, <spsolovev@digitalenergy.online>
+Kasim Baybikov, <kmbaybikov@basistech.ru>
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+/*
+Terraform DECORT provider - manage resources provided by DECORT (Digital Energy Cloud
+Orchestration Technology) with Terraform by Hashicorp.
+
+Source code: https://repository.basistech.ru/BASIS/terraform-provider-decort
+
+Please see README.md to learn where to place source code so that it
+builds seamlessly.
+
+Documentation: https://repository.basistech.ru/BASIS/terraform-provider-decort/wiki
+*/
+
+package bservice
+
+import (
+	"context"
+	"errors"
+	"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/cloudapi/bservice"
+	"repository.basistech.ru/BASIS/terraform-provider-decort/internal/constants"
+	"repository.basistech.ru/BASIS/terraform-provider-decort/internal/controller"
+	"repository.basistech.ru/BASIS/terraform-provider-decort/internal/dc"
+	"repository.basistech.ru/BASIS/terraform-provider-decort/internal/status"
+)
+
+func resourceBasicServiceCreate(ctx context.Context, d *schema.ResourceData, m interface{}) diag.Diagnostics {
+	log.Debugf("resourceBasicServiceCreate")
+	c := m.(*controller.ControllerCfg)
+	req := bservice.CreateRequest{}
+
+	haveRGID, err := existRGID(ctx, d, m)
+	if err != nil {
+		return diag.FromErr(err)
+	}
+
+	if !haveRGID {
+		return diag.Errorf("resourceBasicServiceCreate: can't create basic service because RGID %d is not allowed or does not exist", d.Get("rg_id").(int))
+	}
+
+	req.Name = d.Get("service_name").(string)
+	req.RGID = uint64(d.Get("rg_id").(int))
+
+	if zoneID, ok := d.GetOk("zone_id"); ok {
+		req.ZoneID = uint64(zoneID.(int))
+	}
+	if sshKey, ok := d.GetOk("ssh_key"); ok {
+		req.SSHKey = sshKey.(string)
+	}
+	if sshUser, ok := d.GetOk("ssh_user"); ok {
+		req.SSHUser = sshUser.(string)
+	}
+
+	serviceId, err := c.CloudAPI().BService().Create(ctx, req)
+	if err != nil {
+		return diag.FromErr(err)
+	}
+
+	d.SetId(strconv.FormatUint(serviceId, 10))
+	d.Set("service_id", serviceId)
+
+	service, err := utilityBasicServiceCheckPresence(ctx, d, m)
+	if err != nil {
+		d.SetId("")
+		return diag.FromErr(err)
+	}
+
+	warnings := dc.Warnings{}
+	enable := d.Get("enable").(bool)
+
+	if enable && (service.Status == status.Disabled || service.Status == status.Created) {
+		log.Debugf("trying to enable bservice %v", serviceId)
+		_, err := c.CloudAPI().BService().Enable(ctx, bservice.EnableRequest{
+			ServiceID: serviceId,
+		})
+
+		if err != nil {
+			warnings.Add(err)
+		}
+	}
+	if d.Get("start").(bool) {
+		log.Debugf("trying to start bservice %v", serviceId)
+
+		if !enable {
+			warnings.Add(errors.New("can not start bservice that is not enabled. Set enable = true and start = true to enable and start bservice"))
+		}
+
+		if enable {
+			_, err := c.CloudAPI().BService().Start(ctx, bservice.StartRequest{
+				ServiceID: serviceId,
+			})
+
+			if err != nil {
+				warnings.Add(err)
+			}
+		}
+	}
+
+	return append(warnings.Get(), resourceBasicServiceRead(ctx, d, m)...)
+}
+
+func resourceBasicServiceRead(ctx context.Context, d *schema.ResourceData, m interface{}) diag.Diagnostics {
+	log.Debugf("resourceBasicServiceRead")
+
+	// c := m.(*controller.ControllerCfg)
+
+	bs, err := utilityBasicServiceCheckPresence(ctx, d, m)
+	if err != nil {
+		d.SetId("")
+		return diag.FromErr(err)
+	}
+
+	hasChanged := false
+
+	switch bs.Status {
+	case status.Modeled:
+		return diag.Errorf("The basic service is in status: %s, please, contact support for more information", bs.Status)
+	case status.Created:
+	case status.Enabled:
+	case status.Enabling:
+	case status.Disabled:
+		log.Debugf("The basic service is in status: %s, troubles can occur with the update. Please, enable bservice first.", bs.Status)
+	case status.Disabling:
+		log.Debugf("The basic service is in status: %s, troubles can occur with the update.", bs.Status)
+	case status.Deleted:
+		// id, _ := strconv.ParseUint(d.Id(), 10, 64)
+		// restoreReq := bservice.RestoreRequest{
+		// 	ServiceID: id,
+		// }
+		// enableReq := bservice.EnableRequest{
+		// 	ServiceID: id,
+		// }
+
+		// _, err := c.CloudAPI().BService().Restore(ctx, restoreReq)
+		// if err != nil {
+		// 	return diag.FromErr(err)
+		// }
+
+		// _, err = c.CloudAPI().BService().Enable(ctx, enableReq)
+		// if err != nil {
+		// 	return diag.FromErr(err)
+		// }
+
+		// hasChanged = true
+	case status.Deleting:
+	case status.Destroyed:
+		d.SetId("")
+		return diag.Errorf("The resource cannot be updated because it has been destroyed")
+		// return resourceBasicServiceCreate(ctx, d, m)
+	case status.Destroying:
+		return diag.Errorf("The basic service is in progress with status: %s", bs.Status)
+	case status.Restoring:
+	case status.Reconfiguring:
+	}
+
+	if hasChanged {
+		bs, err = utilityBasicServiceCheckPresence(ctx, d, m)
+		if err != nil {
+			d.SetId("")
+			return diag.FromErr(err)
+		}
+	}
+
+	flattenService(d, bs)
+
+	return nil
+}
+
+func resourceBasicServiceDelete(ctx context.Context, d *schema.ResourceData, m interface{}) diag.Diagnostics {
+	log.Debugf("resourceBasicServiceDelete")
+	c := m.(*controller.ControllerCfg)
+
+	_, err := utilityBasicServiceCheckPresence(ctx, d, m)
+	if err != nil {
+		return diag.FromErr(err)
+	}
+
+	req := bservice.DeleteRequest{
+		ServiceID:   uint64(d.Get("service_id").(int)),
+		Permanently: d.Get("permanently").(bool),
+	}
+
+	_, err = c.CloudAPI().BService().Delete(ctx, req)
+	if err != nil {
+		return diag.FromErr(err)
+	}
+
+	d.SetId("")
+
+	return nil
+}
+
+func resourceBasicServiceUpdate(ctx context.Context, d *schema.ResourceData, m interface{}) diag.Diagnostics {
+	log.Debugf("resourceBasicServiceUpdate")
+	c := m.(*controller.ControllerCfg)
+
+	haveRGID, err := existRGID(ctx, d, m)
+	if err != nil {
+		return diag.FromErr(err)
+	}
+
+	if !haveRGID {
+		return diag.Errorf("resourceBasicServiceUpdate: can't create basic service because RGID %d is not allowed or does not exist", d.Get("rg_id").(int))
+	}
+
+	bs, err := utilityBasicServiceCheckPresence(ctx, d, m)
+	if err != nil {
+		d.SetId("")
+		return diag.FromErr(err)
+	}
+
+	hasChanged := false
+
+	switch bs.Status {
+	case status.Modeled:
+		return diag.Errorf("The basic service is in status: %s, please, contact support for more information", bs.Status)
+	case status.Created:
+	case status.Enabled:
+	case status.Enabling:
+	case status.Disabled:
+		log.Debugf("The basic service is in status: %s, troubles can occur with the update. Please, enable bservice first.", bs.Status)
+	case status.Disabling:
+		log.Debugf("The basic service is in status: %s, troubles can occur with the update.", bs.Status)
+	case status.Deleted:
+		if d.Get("restore").(bool) {
+			restoreReq := bservice.RestoreRequest{
+				ServiceID: bs.ID,
+			}
+			_, err := c.CloudAPI().BService().Restore(ctx, restoreReq)
+			if err != nil {
+				return diag.FromErr(err)
+			}
+
+			hasChanged = true
+
+			if d.Get("enable").(bool) {
+				enableReq := bservice.EnableRequest{
+					ServiceID: bs.ID,
+				}
+				_, err = c.CloudAPI().BService().Enable(ctx, enableReq)
+				if err != nil {
+					return diag.FromErr(err)
+				}
+			}
+
+			if d.Get("start").(bool) {
+				startReq := bservice.StartRequest{
+					ServiceID: bs.ID,
+				}
+				_, err = c.CloudAPI().BService().Start(ctx, startReq)
+				if err != nil {
+					return diag.FromErr(err)
+				}
+			}
+		}
+	case status.Deleting:
+	case status.Destroyed:
+		d.SetId("")
+		return diag.Errorf("The resource cannot be updated because it has been destroyed")
+		// return resourceBasicServiceCreate(ctx, d, m)
+	case status.Destroying:
+		return diag.Errorf("The basic service is in progress with status: %s", bs.Status)
+	case status.Restoring:
+	case status.Reconfiguring:
+	}
+
+	if hasChanged {
+		bs, err = utilityBasicServiceCheckPresence(ctx, d, m)
+		if err != nil {
+			d.SetId("")
+			return diag.FromErr(err)
+		}
+	}
+
+	if d.HasChange("enable") {
+		if d.Get("enable").(bool) {
+			req := bservice.EnableRequest{
+				ServiceID: uint64(d.Get("service_id").(int)),
+			}
+
+			_, err := c.CloudAPI().BService().Enable(ctx, req)
+			if err != nil {
+				return diag.FromErr(err)
+			}
+		} else {
+			req := bservice.DisableRequest{
+				ServiceID: uint64(d.Get("service_id").(int)),
+			}
+
+			_, err := c.CloudAPI().BService().Disable(ctx, req)
+			if err != nil {
+				return diag.FromErr(err)
+			}
+		}
+	}
+
+	if d.HasChange("zone_id") {
+		zoneID := uint64(d.Get("zone_id").(int))
+
+		start := d.Get("start").(bool)
+		if start {
+			reqStop := bservice.StopRequest{
+				ServiceID: uint64(d.Get("service_id").(int)),
+			}
+
+			_, err := c.CloudAPI().BService().Stop(ctx, reqStop)
+			if err != nil {
+				return diag.FromErr(err)
+			}
+		}
+
+		req := bservice.MigrateToZoneRequest{
+			ServiceID: uint64(d.Get("service_id").(int)),
+			ZoneID:    zoneID,
+		}
+
+		_, err = c.CloudAPI().BService().MigrateToZone(ctx, req)
+		if err != nil {
+			return diag.FromErr(err)
+		}
+
+		if start {
+			startReq := bservice.StartRequest{
+				ServiceID: uint64(d.Get("service_id").(int)),
+			}
+
+			_, err = c.CloudAPI().BService().Start(ctx, startReq)
+			if err != nil {
+				return diag.FromErr(err)
+			}
+		}
+	}
+
+	if d.HasChange("start") {
+		if d.Get("start").(bool) {
+			req := bservice.StartRequest{
+				ServiceID: uint64(d.Get("service_id").(int)),
+			}
+
+			_, err := c.CloudAPI().BService().Start(ctx, req)
+			if err != nil {
+				return diag.FromErr(err)
+			}
+		} else {
+			req := bservice.StopRequest{
+				ServiceID: uint64(d.Get("service_id").(int)),
+			}
+
+			_, err := c.CloudAPI().BService().Stop(ctx, req)
+			if err != nil {
+				return diag.FromErr(err)
+			}
+		}
+	}
+
+	if d.HasChange("snapshots") {
+		deletedSnapshots := make([]interface{}, 0)
+		addedSnapshots := make([]interface{}, 0)
+		updatedSnapshots := make([]interface{}, 0)
+
+		old, new := d.GetChange("snapshots")
+		oldConv := old.([]interface{})
+		newConv := new.([]interface{})
+		for _, el := range oldConv {
+			if !isContainsSnapshot(newConv, el) {
+				deletedSnapshots = append(deletedSnapshots, el)
+			}
+		}
+		for _, el := range newConv {
+			if !isContainsSnapshot(oldConv, el) {
+				addedSnapshots = append(addedSnapshots, el)
+			} else {
+				if isRollback(oldConv, el) {
+					updatedSnapshots = append(updatedSnapshots, el)
+				}
+			}
+		}
+
+		if len(deletedSnapshots) > 0 {
+			for _, snapshot := range deletedSnapshots {
+				snapshotConv := snapshot.(map[string]interface{})
+				req := bservice.SnapshotDeleteRequest{
+					ServiceID: uint64(d.Get("service_id").(int)),
+					Label:     snapshotConv["label"].(string),
+				}
+
+				_, err := c.CloudAPI().BService().SnapshotDelete(ctx, req)
+				if err != nil {
+					return diag.FromErr(err)
+				}
+			}
+		}
+
+		if len(addedSnapshots) > 0 {
+			for _, snapshot := range addedSnapshots {
+				snapshotConv := snapshot.(map[string]interface{})
+				req := bservice.SnapshotCreateRequest{
+					ServiceID: uint64(d.Get("service_id").(int)),
+					Label:     snapshotConv["label"].(string),
+				}
+
+				_, err := c.CloudAPI().BService().SnapshotCreate(ctx, req)
+				if err != nil {
+					return diag.FromErr(err)
+				}
+			}
+		}
+
+		if len(updatedSnapshots) > 0 {
+			for _, snapshot := range updatedSnapshots {
+				snapshotConv := snapshot.(map[string]interface{})
+				req := bservice.SnapshotRollbackRequest{
+					ServiceID: uint64(d.Get("service_id").(int)),
+					Label:     snapshotConv["label"].(string),
+				}
+
+				_, err := c.CloudAPI().BService().SnapshotRollback(ctx, req)
+				if err != nil {
+					return diag.FromErr(err)
+				}
+			}
+		}
+	}
+
+	return resourceBasicServiceRead(ctx, d, m)
+}
+
+func isContainsSnapshot(els []interface{}, el interface{}) bool {
+	for _, elOld := range els {
+		elOldConv := elOld.(map[string]interface{})
+		elConv := el.(map[string]interface{})
+		if elOldConv["guid"].(string) == elConv["guid"].(string) {
+			return true
+		}
+	}
+	return false
+}
+
+func isRollback(els []interface{}, el interface{}) bool {
+	for _, elOld := range els {
+		elOldConv := elOld.(map[string]interface{})
+		elConv := el.(map[string]interface{})
+		if elOldConv["guid"].(string) == elConv["guid"].(string) &&
+			elOldConv["rollback"].(bool) != elConv["rollback"].(bool) &&
+			elConv["rollback"].(bool) {
+			return true
+		}
+	}
+	return false
+}
+
+func resourceBasicServiceSchemaMake() map[string]*schema.Schema {
+	return map[string]*schema.Schema{
+		"service_name": {
+			Type:        schema.TypeString,
+			Required:    true,
+			Description: "Name of the service",
+		},
+		"rg_id": {
+			Type:        schema.TypeInt,
+			Required:    true,
+			Description: "ID of the Resource Group where this service will be placed",
+		},
+		"zone_id": {
+			Type:        schema.TypeInt,
+			Optional:    true,
+			Computed:    true,
+			Description: "ID of the zone where this service will be placed",
+		},
+		"ssh_key": {
+			Type:        schema.TypeString,
+			Optional:    true,
+			Computed:    true,
+			Description: "SSH key to deploy for the specified user. Same key will be deployed to all computes of the service.",
+		},
+		"ssh_user": {
+			Type:        schema.TypeString,
+			Optional:    true,
+			Computed:    true,
+			Description: "name of the user to deploy SSH key for. Pass empty string if no SSH key deployment is required",
+		},
+		"permanently": {
+			Type:        schema.TypeBool,
+			Optional:    true,
+			Default:     false,
+			Description: "if set to False, Basic service will be deleted to recycle bin. Otherwise destroyed immediately",
+		},
+		"enable": {
+			Type:        schema.TypeBool,
+			Optional:    true,
+			Default:     false,
+			Description: "Enable service. Enabling a service technically means setting model status of all computes and service itself to ENABLED. It does not start computes.",
+		},
+		"restore": {
+			Type:        schema.TypeBool,
+			Optional:    true,
+			Default:     false,
+			Description: "Restores BasicService instance",
+		},
+		"start": {
+			Type:        schema.TypeBool,
+			Optional:    true,
+			Default:     false,
+			Description: "Start service. Starting a service technically means starting computes from all service groups according to group relations",
+		},
+		"service_id": {
+			Type:     schema.TypeInt,
+			Optional: true,
+			Computed: true,
+		},
+		"account_id": {
+			Type:     schema.TypeInt,
+			Computed: true,
+		},
+		"account_name": {
+			Type:     schema.TypeString,
+			Computed: true,
+		},
+		"base_domain": {
+			Type:     schema.TypeString,
+			Computed: true,
+		},
+		"computes": {
+			Type:     schema.TypeList,
+			Computed: true,
+			Elem: &schema.Resource{
+				Schema: map[string]*schema.Schema{
+					"account_id": {
+						Type:     schema.TypeInt,
+						Computed: true,
+					},
+					"architecture": {
+						Type:     schema.TypeString,
+						Computed: true,
+					},
+					"compgroup_id": {
+						Type:     schema.TypeInt,
+						Computed: true,
+					},
+					"compgroup_name": {
+						Type:     schema.TypeString,
+						Computed: true,
+					},
+					"compgroup_role": {
+						Type:     schema.TypeString,
+						Computed: true,
+					},
+					"id": {
+						Type:     schema.TypeInt,
+						Computed: true,
+					},
+					"rg_id": {
+						Type:     schema.TypeInt,
+						Computed: true,
+					},
+					"node_id": {
+						Type:     schema.TypeInt,
+						Computed: true,
+					},
+					"name": {
+						Type:     schema.TypeString,
+						Computed: true,
+					},
+					"status": {
+						Type:     schema.TypeString,
+						Computed: true,
+					},
+					"tech_status": {
+						Type:     schema.TypeString,
+						Computed: true,
+					},
+				},
+			},
+		},
+		"cpu_total": {
+			Type:     schema.TypeInt,
+			Computed: true,
+		},
+		"created_by": {
+			Type:     schema.TypeString,
+			Computed: true,
+		},
+		"created_time": {
+			Type:     schema.TypeInt,
+			Computed: true,
+		},
+		"deleted_by": {
+			Type:     schema.TypeString,
+			Computed: true,
+		},
+		"deleted_time": {
+			Type:     schema.TypeInt,
+			Computed: true,
+		},
+		"disk_total": {
+			Type:     schema.TypeInt,
+			Computed: true,
+		},
+		"gid": {
+			Type:     schema.TypeInt,
+			Computed: true,
+		},
+		"groups": {
+			Type:     schema.TypeList,
+			Computed: true,
+			Elem: &schema.Resource{
+				Schema: map[string]*schema.Schema{
+					"computes": {
+						Type:     schema.TypeInt,
+						Computed: true,
+					},
+					"consistency": {
+						Type:     schema.TypeBool,
+						Computed: true,
+					},
+					"id": {
+						Type:     schema.TypeInt,
+						Computed: true,
+					},
+					"name": {
+						Type:     schema.TypeString,
+						Computed: true,
+					},
+					"status": {
+						Type:     schema.TypeString,
+						Computed: true,
+					},
+					"tech_status": {
+						Type:     schema.TypeString,
+						Computed: true,
+					},
+				},
+			},
+		},
+		"guid": {
+			Type:     schema.TypeInt,
+			Computed: true,
+		},
+		"milestones": {
+			Type:     schema.TypeInt,
+			Computed: true,
+		},
+		"parent_srv_id": {
+			Type:     schema.TypeInt,
+			Computed: true,
+		},
+		"parent_srv_type": {
+			Type:     schema.TypeString,
+			Computed: true,
+		},
+		"ram_total": {
+			Type:     schema.TypeInt,
+			Computed: true,
+		},
+		"rg_name": {
+			Type:     schema.TypeString,
+			Computed: true,
+		},
+		"snapshots": {
+			Type:     schema.TypeList,
+			Computed: true,
+			Optional: true,
+			Elem: &schema.Resource{
+				Schema: map[string]*schema.Schema{
+					"guid": {
+						Type:     schema.TypeString,
+						Computed: true,
+					},
+					"label": {
+						Type:     schema.TypeString,
+						Optional: true,
+						Computed: true,
+					},
+					"rollback": {
+						Type:     schema.TypeBool,
+						Optional: true,
+						Default:  false,
+					},
+					"timestamp": {
+						Type:     schema.TypeInt,
+						Computed: true,
+					},
+					"valid": {
+						Type:     schema.TypeBool,
+						Computed: true,
+					},
+				},
+			},
+		},
+		"status": {
+			Type:     schema.TypeString,
+			Computed: true,
+		},
+		"tech_status": {
+			Type:     schema.TypeString,
+			Computed: true,
+		},
+		"updated_by": {
+			Type:     schema.TypeString,
+			Computed: true,
+		},
+		"updated_time": {
+			Type:     schema.TypeInt,
+			Computed: true,
+		},
+		"user_managed": {
+			Type:     schema.TypeBool,
+			Computed: true,
+		},
+	}
+}
+
+func ResourceBasicService() *schema.Resource {
+	return &schema.Resource{
+		SchemaVersion: 1,
+
+		CreateContext: resourceBasicServiceCreate,
+		ReadContext:   resourceBasicServiceRead,
+		UpdateContext: resourceBasicServiceUpdate,
+		DeleteContext: resourceBasicServiceDelete,
+
+		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: resourceBasicServiceSchemaMake(),
+	}
+}

internal/service/cloudapi/bservice/resource_bservice_group.go

@@ -0,0 +1,646 @@
+/*
+Copyright (c) 2019-2022 Digital Energy Cloud Solutions LLC. All Rights Reserved.
+Authors:
+Petr Krutov, <petr.krutov@digitalenergy.online>
+Stanislav Solovev, <spsolovev@digitalenergy.online>
+Kasim Baybikov, <kmbaybikov@basistech.ru>
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+/*
+Terraform DECORT provider - manage resources provided by DECORT (Digital Energy Cloud
+Orchestration Technology) with Terraform by Hashicorp.
+
+Source code: https://repository.basistech.ru/BASIS/terraform-provider-decort
+
+Please see README.md to learn where to place source code so that it
+builds seamlessly.
+
+Documentation: https://repository.basistech.ru/BASIS/terraform-provider-decort/wiki
+*/
+
+package bservice
+
+import (
+	"context"
+	"strconv"
+
+	"github.com/hashicorp/terraform-plugin-sdk/v2/diag"
+	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
+	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/validation"
+	log "github.com/sirupsen/logrus"
+	"repository.basistech.ru/BASIS/decort-golang-sdk/pkg/cloudapi/bservice"
+	"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/validators"
+)
+
+func resourceBasicServiceGroupCreate(ctx context.Context, d *schema.ResourceData, m interface{}) diag.Diagnostics {
+	log.Debugf("resourceBasicServiceGroupCreate")
+
+	c := m.(*controller.ControllerCfg)
+	req := bservice.GroupAddRequest{
+		ServiceID:       uint64(d.Get("service_id").(int)),
+		Name:            d.Get("compgroup_name").(string),
+		Count:           uint64(d.Get("comp_count").(int)),
+		CPU:             uint64(d.Get("cpu").(int)),
+		RAM:             uint64(d.Get("ram").(int)),
+		Disk:            uint64(d.Get("disk").(int)),
+		ImageID:         uint64(d.Get("image_id").(int)),
+		StoragePolicyID: uint64(d.Get("storage_policy_id").(int)),
+	}
+
+	if role, ok := d.GetOk("role"); ok {
+		req.Role = role.(string)
+	}
+
+	if timeoutStart, ok := d.GetOk("timeout_start"); ok {
+		req.TimeoutStart = uint64(timeoutStart.(int))
+	}
+
+	///4.4.0
+	if sepId, ok := d.GetOk("sep_id"); ok {
+		req.SEPID = uint64(sepId.(int))
+	}
+
+	if sepPool, ok := d.GetOk("sep_pool"); ok {
+		req.SEPPool = sepPool.(string)
+	}
+
+	if cloudInit, ok := d.GetOk("cloud_init"); ok {
+		req.UserData = cloudInit.(string)
+	}
+	///
+
+	if vinses, ok := d.GetOk("vinses"); ok {
+		res := []uint64{}
+		for _, vins := range vinses.([]interface{}) {
+			res = append(res, uint64(vins.(int)))
+		}
+
+		req.VINSes = res
+	}
+	if extnets, ok := d.GetOk("extnets"); ok {
+		res := []uint64{}
+		for _, enet := range extnets.([]interface{}) {
+			res = append(res, uint64(enet.(int)))
+		}
+
+		req.ExtNets = res
+	}
+
+	if chipset, ok := d.GetOk("chipset"); ok {
+		req.Chipset = chipset.(string)
+	}
+
+	compgroupId, err := c.CloudAPI().BService().GroupAdd(ctx, req)
+	if err != nil {
+		return diag.FromErr(err)
+	}
+
+	d.SetId(strconv.FormatUint(compgroupId, 10))
+	d.Set("compgroup_id", compgroupId)
+
+	serviceId := uint64(d.Get("service_id").(int))
+
+	if d.Get("start").(bool) {
+		log.Debugf("trying to start bservice group %v", compgroupId)
+		_, err := c.CloudAPI().BService().GroupStart(ctx, bservice.GroupStartRequest{
+			ServiceID:   serviceId,
+			CompGroupID: compgroupId,
+		})
+
+		if err != nil {
+			return diag.FromErr(err)
+		}
+	}
+
+	return resourceBasicServiceGroupRead(ctx, d, m)
+}
+
+func resourceBasicServiceGroupRead(ctx context.Context, d *schema.ResourceData, m interface{}) diag.Diagnostics {
+	log.Debugf("resourceBasicServiceGroupRead")
+
+	bsg, err := utilityBasicServiceGroupCheckPresence(ctx, d, m)
+	if err != nil {
+		d.SetId("")
+		return diag.FromErr(err)
+	}
+
+	flattenResourceBasicServiceGroup(d, bsg)
+
+	return nil
+}
+
+func resourceBasicServiceGroupDelete(ctx context.Context, d *schema.ResourceData, m interface{}) diag.Diagnostics {
+	log.Debugf("resourceBasicServiceGroupDelete")
+
+	bsg, err := utilityBasicServiceGroupCheckPresence(ctx, d, m)
+	if err != nil {
+		d.SetId("")
+		return diag.FromErr(err)
+	}
+
+	c := m.(*controller.ControllerCfg)
+	req := bservice.GroupRemoveRequest{
+		ServiceID:   bsg.ServiceID,
+		CompGroupID: bsg.ID,
+	}
+
+	_, err = c.CloudAPI().BService().GroupRemove(ctx, req)
+	if err != nil {
+		return diag.FromErr(err)
+	}
+	d.SetId("")
+
+	return nil
+}
+
+func resourceBasicServiceGroupUpdate(ctx context.Context, d *schema.ResourceData, m interface{}) diag.Diagnostics {
+	log.Debugf("resourceBasicServiceGroupEdit")
+	c := m.(*controller.ControllerCfg)
+
+	if d.HasChange("comp_count") {
+		req := bservice.GroupResizeRequest{
+			ServiceID:   uint64(d.Get("service_id").(int)),
+			CompGroupID: uint64(d.Get("compgroup_id").(int)),
+			Count:       int64(d.Get("comp_count").(int)),
+			Chipset:     d.Get("chipset").(string),
+			Mode:        d.Get("mode").(string),
+		}
+
+		_, err := c.CloudAPI().BService().GroupResize(ctx, req)
+		if err != nil {
+			return diag.FromErr(err)
+		}
+	}
+
+	if d.HasChange("start") {
+		start := d.Get("start").(bool)
+		if start {
+			req := bservice.GroupStartRequest{
+				ServiceID:   uint64(d.Get("service_id").(int)),
+				CompGroupID: uint64(d.Get("compgroup_id").(int)),
+			}
+
+			_, err := c.CloudAPI().BService().GroupStart(ctx, req)
+			if err != nil {
+				return diag.FromErr(err)
+			}
+		} else {
+			req := bservice.GroupStopRequest{
+				ServiceID:   uint64(d.Get("service_id").(int)),
+				CompGroupID: uint64(d.Get("compgroup_id").(int)),
+				Force:       d.Get("force_stop").(bool),
+			}
+
+			_, err := c.CloudAPI().BService().GroupStop(ctx, req)
+			if err != nil {
+				return diag.FromErr(err)
+			}
+		}
+	}
+
+	if d.HasChanges("compgroup_name", "ram", "cpu", "disk", "role") {
+		req := bservice.GroupUpdateRequest{
+			ServiceID:   uint64(d.Get("service_id").(int)),
+			CompGroupID: uint64(d.Get("compgroup_id").(int)),
+			Name:        d.Get("compgroup_name").(string),
+			Role:        d.Get("role").(string),
+			CPU:         uint64(d.Get("cpu").(int)),
+			RAM:         uint64(d.Get("ram").(int)),
+			Disk:        uint64(d.Get("disk").(int)),
+			Force:       d.Get("force_update").(bool),
+		}
+
+		_, err := c.CloudAPI().BService().GroupUpdate(ctx, req)
+		if err != nil {
+			return diag.FromErr(err)
+		}
+	}
+
+	if d.HasChange("extnets") {
+		extnets := d.Get("extnets").([]interface{})
+
+		res := []uint64{}
+		for _, enet := range extnets {
+			res = append(res, uint64(enet.(int)))
+		}
+
+		req := bservice.GroupUpdateExtNetRequest{
+			ServiceID:   uint64(d.Get("service_id").(int)),
+			CompGroupID: uint64(d.Get("compgroup_id").(int)),
+			ExtNets:     res,
+		}
+
+		_, err := c.CloudAPI().BService().GroupUpdateExtNet(ctx, req)
+		if err != nil {
+			return diag.FromErr(err)
+		}
+	}
+
+	if d.HasChange("vinses") {
+		vinses := d.Get("vinses").([]interface{})
+
+		res := []uint64{}
+		for _, vins := range vinses {
+			res = append(res, uint64(vins.(int)))
+		}
+
+		req := bservice.GroupUpdateVINSRequest{
+			ServiceID:   uint64(d.Get("service_id").(int)),
+			CompGroupID: uint64(d.Get("compgroup_id").(int)),
+			VINSes:      res,
+		}
+
+		_, err := c.CloudAPI().BService().GroupUpdateVINS(ctx, req)
+		if err != nil {
+			return diag.FromErr(err)
+		}
+	}
+
+	if d.HasChange("parents") {
+		deletedParents := make([]interface{}, 0)
+		addedParents := make([]interface{}, 0)
+
+		old, new := d.GetChange("parents")
+		oldConv := old.([]interface{})
+		newConv := new.([]interface{})
+		for _, el := range oldConv {
+			if !isContainsParent(newConv, el) {
+				deletedParents = append(deletedParents, el)
+			}
+		}
+		for _, el := range newConv {
+			if !isContainsParent(oldConv, el) {
+				addedParents = append(addedParents, el)
+			}
+		}
+
+		if len(deletedParents) > 0 {
+			for _, parent := range deletedParents {
+				parentConv := parent.(int)
+
+				req := bservice.GroupParentRemoveRequest{
+					ServiceID:   uint64(d.Get("service_id").(int)),
+					CompGroupID: uint64(d.Get("compgroup_id").(int)),
+					ParentID:    uint64(parentConv),
+				}
+
+				_, err := c.CloudAPI().BService().GroupParentRemove(ctx, req)
+				if err != nil {
+					return diag.FromErr(err)
+				}
+			}
+		}
+
+		if len(addedParents) > 0 {
+			for _, parent := range addedParents {
+				parentConv := parent.(int)
+
+				req := bservice.GroupParentAddRequest{
+					ServiceID:   uint64(d.Get("service_id").(int)),
+					CompGroupID: uint64(d.Get("compgroup_id").(int)),
+					ParentID:    uint64(parentConv),
+				}
+
+				_, err := c.CloudAPI().BService().GroupParentAdd(ctx, req)
+				if err != nil {
+					return diag.FromErr(err)
+				}
+			}
+		}
+	}
+
+	if d.HasChange("remove_computes") {
+		rcs := d.Get("remove_computes").([]interface{})
+		if len(rcs) > 0 {
+			for _, rc := range rcs {
+				req := bservice.GroupComputeRemoveRequest{
+					ServiceID:   uint64(d.Get("service_id").(int)),
+					CompGroupID: uint64(d.Get("compgroup_id").(int)),
+					ComputeID:   uint64(rc.(int)),
+				}
+
+				_, err := c.CloudAPI().BService().GroupComputeRemove(ctx, req)
+				if err != nil {
+					return diag.FromErr(err)
+				}
+			}
+		}
+	}
+
+	return resourceBasicServiceGroupRead(ctx, d, m)
+}
+
+func isContainsParent(els []interface{}, el interface{}) bool {
+	for _, elOld := range els {
+		elOldConv := elOld.(int)
+		elConv := el.(int)
+		if elOldConv == elConv {
+			return true
+		}
+	}
+	return false
+}
+
+func resourceBasicServiceGroupSchemaMake() map[string]*schema.Schema {
+	return map[string]*schema.Schema{
+		"service_id": {
+			Type:        schema.TypeInt,
+			Required:    true,
+			Description: "ID of the Basic Service to add a group to",
+		},
+		"compgroup_name": {
+			Type:        schema.TypeString,
+			Required:    true,
+			Description: "name of the Compute Group to add",
+		},
+		"comp_count": {
+			Type:        schema.TypeInt,
+			Required:    true,
+			Description: "computes number. Defines how many computes must be there in the group",
+		},
+		"cpu": {
+			Type:        schema.TypeInt,
+			Required:    true,
+			Description: "compute CPU number. All computes in the group have the same CPU count",
+		},
+		"ram": {
+			Type:     schema.TypeInt,
+			Required: true,
+			ValidateFunc: validation.All(
+				validation.IntAtLeast(constants.MIN_RAM_PER_COMPUTE),
+				validators.DivisibleBy(constants.RAM_DIVISIBILITY),
+			),
+			Description: "compute RAM volume in MB. All computes in the group have the same RAM volume",
+		},
+		"disk": {
+			Type:        schema.TypeInt,
+			Required:    true,
+			Description: "compute boot disk size in GB",
+		},
+		"image_id": {
+			Type:        schema.TypeInt,
+			Required:    true,
+			Description: "OS image ID to create computes from",
+		},
+		"storage_policy_id": {
+			Type:        schema.TypeInt,
+			Required:    true,
+			Description: "storage policy id of compute. The rules of the specified storage policy will be used.",
+		},
+		///4.4.0
+		"sep_id": {
+			Type:        schema.TypeInt,
+			Optional:    true,
+			Computed:    true,
+			Description: "storage endpoint provider ID",
+		},
+		"sep_pool": {
+			Type:        schema.TypeString,
+			Optional:    true,
+			Computed:    true,
+			Description: "pool to use if sepId is set, can be also empty if needed to be chosen by system",
+		},
+		"cloud_init": {
+			Type:        schema.TypeString,
+			Optional:    true,
+			Description: "Optional cloud_init parameters. Applied when creating new compute instance only, ignored in all other cases.",
+		},
+		"chipset": {
+			Type:         schema.TypeString,
+			Optional:     true,
+			ValidateFunc: validation.StringInSlice([]string{"i440fx", "Q35"}, false),
+			Default:      "Q35",
+			Description:  "Chipset for virtual machines.",
+		},
+		///
+		"role": {
+			Type:        schema.TypeString,
+			Optional:    true,
+			Computed:    true,
+			Description: "group role tag. Can be empty string, does not have to be unique",
+		},
+		"timeout_start": {
+			Type:        schema.TypeInt,
+			Optional:    true,
+			Computed:    true,
+			Description: "time of Compute Group readiness",
+		},
+		"extnets": {
+			Type:     schema.TypeList,
+			Optional: true,
+			Computed: true,
+			Elem: &schema.Schema{
+				Type: schema.TypeInt,
+			},
+			Description: "list of external networks to connect computes to",
+		},
+		"vinses": {
+			Type:     schema.TypeList,
+			Optional: true,
+			Computed: true,
+			Elem: &schema.Schema{
+				Type: schema.TypeInt,
+			},
+			Description: "list of ViNSes to connect computes to",
+		},
+		"mode": {
+			Type:         schema.TypeString,
+			Optional:     true,
+			Default:      "RELATIVE",
+			ValidateFunc: validation.StringInSlice([]string{"RELATIVE", "ABSOLUTE"}, false),
+			Description:  "(RELATIVE;ABSOLUTE) either delta or absolute value of computes",
+		},
+		"start": {
+			Type:        schema.TypeBool,
+			Optional:    true,
+			Default:     false,
+			Description: "Start the specified Compute Group within BasicService",
+		},
+		"force_stop": {
+			Type:        schema.TypeBool,
+			Optional:    true,
+			Default:     false,
+			Description: "force stop Compute Group",
+		},
+		"force_update": {
+			Type:        schema.TypeBool,
+			Optional:    true,
+			Default:     false,
+			Description: "force resize Compute Group",
+		},
+		"parents": {
+			Type:     schema.TypeList,
+			Optional: true,
+			Computed: true,
+			Elem: &schema.Schema{
+				Type: schema.TypeInt,
+			},
+		},
+		"remove_computes": {
+			Type:     schema.TypeList,
+			Optional: true,
+			Elem: &schema.Schema{
+				Type: schema.TypeInt,
+			},
+		},
+		"compgroup_id": {
+			Type:     schema.TypeInt,
+			Optional: true,
+			Computed: true,
+		},
+		"account_id": {
+			Type:     schema.TypeInt,
+			Computed: true,
+		},
+		"account_name": {
+			Type:     schema.TypeString,
+			Computed: true,
+		},
+		"computes": {
+			Type:     schema.TypeList,
+			Computed: true,
+			Elem: &schema.Resource{
+				Schema: map[string]*schema.Schema{
+					"chipset": {
+						Type:     schema.TypeString,
+						Computed: true,
+					},
+					"id": {
+						Type:     schema.TypeInt,
+						Computed: true,
+					},
+					"ip_addresses": {
+						Type:     schema.TypeList,
+						Computed: true,
+						Elem: &schema.Schema{
+							Type: schema.TypeString,
+						},
+					},
+					"name": {
+						Type:     schema.TypeString,
+						Computed: true,
+					},
+					"os_users": {
+						Type:     schema.TypeList,
+						Computed: true,
+						Elem: &schema.Resource{
+							Schema: map[string]*schema.Schema{
+								"login": {
+									Type:     schema.TypeString,
+									Computed: true,
+								},
+								"password": {
+									Type:     schema.TypeString,
+									Computed: true,
+								},
+							},
+						},
+					},
+				},
+			},
+		},
+		"consistency": {
+			Type:     schema.TypeBool,
+			Computed: true,
+		},
+		"created_by": {
+			Type:     schema.TypeString,
+			Computed: true,
+		},
+		"created_time": {
+			Type:     schema.TypeInt,
+			Computed: true,
+		},
+		"deleted_by": {
+			Type:     schema.TypeString,
+			Computed: true,
+		},
+		"deleted_time": {
+			Type:     schema.TypeInt,
+			Computed: true,
+		},
+		"driver": {
+			Type:     schema.TypeString,
+			Computed: true,
+		},
+		"gid": {
+			Type:     schema.TypeInt,
+			Computed: true,
+		},
+		"guid": {
+			Type:     schema.TypeInt,
+			Computed: true,
+		},
+		"milestones": {
+			Type:     schema.TypeInt,
+			Computed: true,
+		},
+		"rg_id": {
+			Type:     schema.TypeInt,
+			Computed: true,
+		},
+		"rg_name": {
+			Type:     schema.TypeString,
+			Computed: true,
+		},
+		"seq_no": {
+			Type:     schema.TypeInt,
+			Computed: true,
+		},
+		"status": {
+			Type:     schema.TypeString,
+			Computed: true,
+		},
+		"tech_status": {
+			Type:     schema.TypeString,
+			Computed: true,
+		},
+		"updated_by": {
+			Type:     schema.TypeString,
+			Computed: true,
+		},
+		"updated_time": {
+			Type:     schema.TypeInt,
+			Computed: true,
+		},
+	}
+}
+
+func ResourceBasicServiceGroup() *schema.Resource {
+	return &schema.Resource{
+		SchemaVersion: 1,
+
+		CreateContext: resourceBasicServiceGroupCreate,
+		ReadContext:   resourceBasicServiceGroupRead,
+		UpdateContext: resourceBasicServiceGroupUpdate,
+		DeleteContext: resourceBasicServiceGroupDelete,
+
+		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: resourceBasicServiceGroupSchemaMake(),
+	}
+}

internal/service/cloudapi/bservice/resource_check_input_values.go

@@ -0,0 +1,24 @@
+package bservice
+
+import (
+	"context"
+
+	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
+	"repository.basistech.ru/BASIS/decort-golang-sdk/pkg/cloudapi/rg"
+	"repository.basistech.ru/BASIS/terraform-provider-decort/internal/controller"
+)
+
+func existRGID(ctx context.Context, d *schema.ResourceData, m interface{}) (bool, error) {
+	c := m.(*controller.ControllerCfg)
+
+	req := rg.ListRequest{}
+
+	rgList, err := c.CloudAPI().RG().List(ctx, req)
+	if err != nil {
+		return false, err
+	}
+
+	rgId := uint64(d.Get("rg_id").(int))
+
+	return len(rgList.FilterByID(rgId).Data) != 0, nil
+}

internal/service/cloudapi/bservice/utility_bservicce_deleted_list.go

@@ -0,0 +1,73 @@
+/*
+Copyright (c) 2019-2022 Digital Energy Cloud Solutions LLC. All Rights Reserved.
+Authors:
+Petr Krutov, <petr.krutov@digitalenergy.online>
+Stanislav Solovev, <spsolovev@digitalenergy.online>
+Kasim Baybikov, <kmbaybikov@basistech.ru>
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+/*
+Terraform DECORT provider - manage resources provided by DECORT (Digital Energy Cloud
+Orchestration Technology) with Terraform by Hashicorp.
+
+Source code: https://repository.basistech.ru/BASIS/terraform-provider-decort
+
+Please see README.md to learn where to place source code so that it
+builds seamlessly.
+
+Documentation: https://repository.basistech.ru/BASIS/terraform-provider-decort/wiki
+*/
+
+package bservice
+
+import (
+	"context"
+
+	log "github.com/sirupsen/logrus"
+	"repository.basistech.ru/BASIS/decort-golang-sdk/pkg/cloudapi/bservice"
+	"repository.basistech.ru/BASIS/terraform-provider-decort/internal/controller"
+
+	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
+)
+
+func utilityBasicServiceDeletedListCheckPresence(ctx context.Context, d *schema.ResourceData, m interface{}) (*bservice.ListBasicServices, error) {
+	c := m.(*controller.ControllerCfg)
+	req := bservice.ListDeletedRequest{}
+
+	if accountId, ok := d.GetOk("account_id"); ok {
+		req.AccountID = uint64(accountId.(int))
+	}
+	if rgId, ok := d.GetOk("rg_id"); ok {
+		req.RGID = uint64(rgId.(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("utilityBasicServiceDeletedListCheckPresence")
+	basicServiceDeletedList, err := c.CloudAPI().BService().ListDeleted(ctx, req)
+	if err != nil {
+		return nil, err
+	}
+
+	return basicServiceDeletedList, nil
+}

internal/service/cloudapi/bservice/utility_bservice.go

@@ -0,0 +1,67 @@
+/*
+Copyright (c) 2019-2022 Digital Energy Cloud Solutions LLC. All Rights Reserved.
+Authors:
+Petr Krutov, <petr.krutov@digitalenergy.online>
+Stanislav Solovev, <spsolovev@digitalenergy.online>
+Kasim Baybikov, <kmbaybikov@basistech.ru>
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+/*
+Terraform DECORT provider - manage resources provided by DECORT (Digital Energy Cloud
+Orchestration Technology) with Terraform by Hashicorp.
+
+Source code: https://repository.basistech.ru/BASIS/terraform-provider-decort
+
+Please see README.md to learn where to place source code so that it
+builds seamlessly.
+
+Documentation: https://repository.basistech.ru/BASIS/terraform-provider-decort/wiki
+*/
+
+package bservice
+
+import (
+	"context"
+	"strconv"
+
+	log "github.com/sirupsen/logrus"
+	"repository.basistech.ru/BASIS/decort-golang-sdk/pkg/cloudapi/bservice"
+	"repository.basistech.ru/BASIS/terraform-provider-decort/internal/controller"
+
+	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
+)
+
+func utilityBasicServiceCheckPresence(ctx context.Context, d *schema.ResourceData, m interface{}) (*bservice.RecordBasicService, error) {
+	c := m.(*controller.ControllerCfg)
+	var id uint64
+
+	if (strconv.Itoa(d.Get("service_id").(int))) != "0" {
+		id = uint64(d.Get("service_id").(int))
+	} else {
+		id, _ = strconv.ParseUint(d.Id(), 10, 64)
+	}
+
+	req := bservice.GetRequest{
+		ServiceID: id,
+	}
+
+	log.Debugf("utilityBasicServiceCheckPresence")
+	bservice, err := c.CloudAPI().BService().Get(ctx, req)
+	if err != nil {
+		return nil, err
+	}
+
+	return bservice, nil
+}

internal/service/cloudapi/bservice/utility_bservice_group.go

@@ -0,0 +1,67 @@
+/*
+Copyright (c) 2019-2022 Digital Energy Cloud Solutions LLC. All Rights Reserved.
+Authors:
+Petr Krutov, <petr.krutov@digitalenergy.online>
+Stanislav Solovev, <spsolovev@digitalenergy.online>
+Kasim Baybikov, <kmbaybikov@basistech.ru>
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+/*
+Terraform DECORT provider - manage resources provided by DECORT (Digital Energy Cloud
+Orchestration Technology) with Terraform by Hashicorp.
+
+Source code: https://repository.basistech.ru/BASIS/terraform-provider-decort
+
+Please see README.md to learn where to place source code so that it
+builds seamlessly.
+
+Documentation: https://repository.basistech.ru/BASIS/terraform-provider-decort/wiki
+*/
+
+package bservice
+
+import (
+	"context"
+	"strconv"
+
+	log "github.com/sirupsen/logrus"
+	"repository.basistech.ru/BASIS/decort-golang-sdk/pkg/cloudapi/bservice"
+	"repository.basistech.ru/BASIS/terraform-provider-decort/internal/controller"
+
+	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
+)
+
+func utilityBasicServiceGroupCheckPresence(ctx context.Context, d *schema.ResourceData, m interface{}) (*bservice.RecordGroup, error) {
+	c := m.(*controller.ControllerCfg)
+
+	req := bservice.GroupGetRequest{
+		ServiceID: uint64(d.Get("service_id").(int)),
+	}
+
+	if (strconv.Itoa(d.Get("compgroup_id").(int))) != "0" {
+		req.CompGroupID = uint64(d.Get("compgroup_id").(int))
+	} else {
+		comGroupID, _ := strconv.ParseUint(d.Id(), 10, 64)
+		req.CompGroupID = comGroupID
+	}
+
+	log.Debugf("utilityBasicServiceGroupCheckPresence")
+	bserviceGroup, err := c.CloudAPI().BService().GroupGet(ctx, req)
+	if err != nil {
+		return nil, err
+	}
+
+	return bserviceGroup, nil
+}

internal/service/cloudapi/bservice/utility_bservice_list.go

@@ -0,0 +1,99 @@
+/*
+Copyright (c) 2019-2022 Digital Energy Cloud Solutions LLC. All Rights Reserved.
+Authors:
+Petr Krutov, <petr.krutov@digitalenergy.online>
+Stanislav Solovev, <spsolovev@digitalenergy.online>
+Kasim Baybikov, <kmbaybikov@basistech.ru>
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+/*
+Terraform DECORT provider - manage resources provided by DECORT (Digital Energy Cloud
+Orchestration Technology) with Terraform by Hashicorp.
+
+Source code: https://repository.basistech.ru/BASIS/terraform-provider-decort
+
+Please see README.md to learn where to place source code so that it
+builds seamlessly.
+
+Documentation: https://repository.basistech.ru/BASIS/terraform-provider-decort/wiki
+*/
+
+package bservice
+
+import (
+	"context"
+
+	log "github.com/sirupsen/logrus"
+	"repository.basistech.ru/BASIS/decort-golang-sdk/pkg/cloudapi/bservice"
+	"repository.basistech.ru/BASIS/terraform-provider-decort/internal/controller"
+
+	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
+)
+
+func utilityBasicServiceListCheckPresence(ctx context.Context, d *schema.ResourceData, m interface{}) (*bservice.ListBasicServices, error) {
+	c := m.(*controller.ControllerCfg)
+	req := bservice.ListRequest{}
+
+	if accountId, ok := d.GetOk("account_id"); ok {
+		req.AccountID = uint64(accountId.(int))
+	}
+	if rgId, ok := d.GetOk("rg_id"); ok {
+		req.RGID = uint64(rgId.(int))
+	}
+	if sortBy, ok := d.GetOk("sort_by"); ok {
+		req.SortBy = sortBy.(string)
+	}
+	if page, ok := d.GetOk("page"); ok {
+		req.Page = uint64(page.(int))
+	}
+	if size, ok := d.GetOk("size"); ok {
+		req.Size = uint64(size.(int))
+	}
+
+	if by_id, ok := d.GetOk("by_id"); ok {
+		req.ByID = uint64(by_id.(int))
+	}
+
+	if name, ok := d.GetOk("name"); ok {
+		req.Name = name.(string)
+	}
+
+	if rg_name, ok := d.GetOk("rg_name"); ok {
+		req.RGName = rg_name.(string)
+	}
+
+	if tech_status, ok := d.GetOk("tech_status"); ok {
+		req.TechStatus = tech_status.(string)
+	}
+
+	if status, ok := d.GetOk("status"); ok {
+		req.Status = status.(string)
+	}
+
+	if acc_name, ok := d.GetOk("account_name"); ok {
+		req.AccountName = acc_name.(string)
+	}
+	if zoneID, ok := d.GetOk("zone_id"); ok {
+		req.ZoneID = uint64(zoneID.(int))
+	}
+
+	log.Debugf("utilityBasicServiceListCheckPresence")
+	basicServiceList, err := c.CloudAPI().BService().List(ctx, req)
+	if err != nil {
+		return nil, err
+	}
+
+	return basicServiceList, nil
+}

internal/service/cloudapi/bservice/utility_bservice_snapshot_list.go

@@ -0,0 +1,64 @@
+/*
+Copyright (c) 2019-2022 Digital Energy Cloud Solutions LLC. All Rights Reserved.
+Authors:
+Petr Krutov, <petr.krutov@digitalenergy.online>
+Stanislav Solovev, <spsolovev@digitalenergy.online>
+Kasim Baybikov, <kmbaybikov@basistech.ru>
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+/*
+Terraform DECORT provider - manage resources provided by DECORT (Digital Energy Cloud
+Orchestration Technology) with Terraform by Hashicorp.
+
+Source code: https://repository.basistech.ru/BASIS/terraform-provider-decort
+
+Please see README.md to learn where to place source code so that it
+builds seamlessly.
+
+Documentation: https://repository.basistech.ru/BASIS/terraform-provider-decort/wiki
+*/
+
+package bservice
+
+import (
+	"context"
+
+	log "github.com/sirupsen/logrus"
+	"repository.basistech.ru/BASIS/decort-golang-sdk/pkg/cloudapi/bservice"
+	"repository.basistech.ru/BASIS/terraform-provider-decort/internal/controller"
+
+	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
+)
+
+func utilityBasicServiceSnapshotListCheckPresence(ctx context.Context, d *schema.ResourceData, m interface{}) (*bservice.ListInfoSnapshots, error) {
+	c := m.(*controller.ControllerCfg)
+	var id uint64
+
+	if serviceId, ok := d.GetOk("service_id"); ok {
+		id = uint64(serviceId.(int))
+	}
+
+	req := bservice.SnapshotListRequest{
+		ServiceID: id,
+	}
+
+	log.Debugf("utilityBasicServiceSnapshotListCheckPresence")
+	basicServiceSnapshotList, err := c.CloudAPI().BService().SnapshotList(ctx, req)
+	if err != nil {
+		return nil, err
+	}
+
+	return basicServiceSnapshotList, nil
+}