From 8d1b13f7b798143ef13085b24f80904760dd0f81 Mon Sep 17 00:00:00 2001 From: stSolo Date: Fri, 3 Jun 2022 11:22:42 +0300 Subject: [PATCH] Add bservice, extnet, vins --- README.md | 3 +- README_EN.md | 3 +- decort/data_source_bservice.go | 293 ++++++++ decort/data_source_bservice_deleted_list.go | 58 ++ decort/data_source_bservice_group.go | 291 ++++++++ decort/data_source_bservice_list.go | 215 ++++++ decort/data_source_bservice_snapshot_list.go | 93 +++ decort/data_source_extnet.go | 321 +++++++++ decort/data_source_extnet_computes_list.go | 156 +++++ decort/data_source_extnet_default.go | 74 +++ decort/data_source_extnet_list.go | 112 ++++ decort/data_source_vins_list.go | 178 +++++ decort/models_api.go | 258 ++++++++ decort/provider.go | 44 +- decort/resource_account.go | 4 +- decort/resource_bservice.go | 554 ++++++++++++++++ decort/resource_bservice_group.go | 660 +++++++++++++++++++ decort/utility_bservicce_deleted_list.go | 67 ++ decort/utility_bservice.go | 60 ++ decort/utility_bservice_group.go | 61 ++ decort/utility_bservice_list.go | 67 ++ decort/utility_bservice_snapshot_list.go | 58 ++ decort/utility_extnet.go | 56 ++ decort/utility_extnet_computes_list.go | 56 ++ decort/utility_extnet_default.go | 46 ++ decort/utility_extnet_list.go | 64 ++ decort/utility_vins_list.go | 64 ++ samples/README.md | 10 + samples/data_bservice/main.tf | 39 ++ samples/data_bservice_deleted_list/main.tf | 57 ++ samples/data_bservice_group/main.tf | 44 ++ samples/data_bservice_list/main.tf | 58 ++ samples/data_bservice_snapshot_list/main.tf | 39 ++ samples/data_extnet/main.tf | 38 ++ samples/data_extnet_computes_list/main.tf | 37 ++ samples/data_extnet_default/main.tf | 36 + samples/data_extnet_list/main.tf | 48 ++ samples/data_vins_list/main.tf | 51 ++ samples/resource_bservice/main.tf | 110 ++++ samples/resource_bservice_group/main.tf | 150 +++++ 40 files changed, 4613 insertions(+), 20 deletions(-) create mode 100644 decort/data_source_bservice.go create mode 100644 decort/data_source_bservice_deleted_list.go create mode 100644 decort/data_source_bservice_group.go create mode 100644 decort/data_source_bservice_list.go create mode 100644 decort/data_source_bservice_snapshot_list.go create mode 100644 decort/data_source_extnet.go create mode 100644 decort/data_source_extnet_computes_list.go create mode 100644 decort/data_source_extnet_default.go create mode 100644 decort/data_source_extnet_list.go create mode 100644 decort/data_source_vins_list.go create mode 100644 decort/resource_bservice.go create mode 100644 decort/resource_bservice_group.go create mode 100644 decort/utility_bservicce_deleted_list.go create mode 100644 decort/utility_bservice.go create mode 100644 decort/utility_bservice_group.go create mode 100644 decort/utility_bservice_list.go create mode 100644 decort/utility_bservice_snapshot_list.go create mode 100644 decort/utility_extnet.go create mode 100644 decort/utility_extnet_computes_list.go create mode 100644 decort/utility_extnet_default.go create mode 100644 decort/utility_extnet_list.go create mode 100644 decort/utility_vins_list.go create mode 100644 samples/data_bservice/main.tf create mode 100644 samples/data_bservice_deleted_list/main.tf create mode 100644 samples/data_bservice_group/main.tf create mode 100644 samples/data_bservice_list/main.tf create mode 100644 samples/data_bservice_snapshot_list/main.tf create mode 100644 samples/data_extnet/main.tf create mode 100644 samples/data_extnet_computes_list/main.tf create mode 100644 samples/data_extnet_default/main.tf create mode 100644 samples/data_extnet_list/main.tf create mode 100644 samples/data_vins_list/main.tf create mode 100644 samples/resource_bservice/main.tf create mode 100644 samples/resource_bservice_group/main.tf diff --git a/README.md b/README.md index a53f213..3981b12 100644 --- a/README.md +++ b/README.md @@ -18,7 +18,8 @@ Terraform provider для платформы Digital Energy Cloud Orchestration - Работа с snapshots, - Работа с pcidevice, - Работа с sep, -- Работа с vgpu. +- Работа с vgpu, +- Работа с bservice. Вики проекта: https://github.com/rudecs/terraform-provider-decort/wiki diff --git a/README_EN.md b/README_EN.md index db2650f..87bcea6 100644 --- a/README_EN.md +++ b/README_EN.md @@ -17,7 +17,8 @@ NOTE: provider rc-1.25 is designed for DECORT API 3.7.x. For older API versions - Work with snapshots, - Work with pcidevice. - Work with sep, -- Work with vgpu. +- Work with vgpu, +- Work with bservice. This provider supports Import operations on pre-existing resources. diff --git a/decort/data_source_bservice.go b/decort/data_source_bservice.go new file mode 100644 index 0000000..a013981 --- /dev/null +++ b/decort/data_source_bservice.go @@ -0,0 +1,293 @@ +/* +Copyright (c) 2019-2022 Digital Energy Cloud Solutions LLC. All Rights Reserved. +Author: Stanislav Solovev, + +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. +*/ + +/* +This file is part of Terraform (by Hashicorp) provider for Digital Energy Cloud Orchestration +Technology platfom. + +Visit https://github.com/rudecs/terraform-provider-decort for full source code package and updates. +*/ + +package decort + +import ( + "github.com/google/uuid" + "github.com/hashicorp/terraform-plugin-sdk/helper/schema" +) + +func dataSourceBasicServiceRead(d *schema.ResourceData, m interface{}) error { + bs, err := utilityBasicServiceCheckPresence(d, m) + if err != nil { + return err + } + + id := uuid.New() + d.SetId(id.String()) + 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", bs.Groups) + d.Set("groups_name", bs.GroupsName) + d.Set("guid", bs.GUID) + d.Set("milestones", bs.Milestones) + d.Set("service_name", bs.Name) + 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) + return nil +} + +func flattenBasicServiceComputes(bscs BasicServiceComputes) []map[string]interface{} { + res := make([]map[string]interface{}, 0) + for _, bsc := range bscs { + temp := map[string]interface{}{ + "compgroup_id": bsc.CompGroupId, + "compgroup_name": bsc.CompGroupName, + "compgroup_role": bsc.CompGroupRole, + "id": bsc.ID, + "name": bsc.Name, + } + res = append(res, temp) + } + + return res +} + +func flattenBasicServiceSnapshots(bsrvss BasicServiceSnapshots) []map[string]interface{} { + res := make([]map[string]interface{}, 0) + 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 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, + }, + "computes": { + Type: schema.TypeList, + Computed: true, + Elem: &schema.Resource{ + Schema: map[string]*schema.Schema{ + "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, + }, + "name": { + 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.TypeString, + Computed: true, + }, + "gid": { + Type: schema.TypeInt, + Computed: true, + }, + "groups": { + Type: schema.TypeList, + Computed: true, + Elem: &schema.Schema{ + Type: schema.TypeInt, + }, + }, + "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, + + Read: dataSourceBasicServiceRead, + + Timeouts: &schema.ResourceTimeout{ + Read: &Timeout30s, + Default: &Timeout60s, + }, + + Schema: dataSourceBasicServiceSchemaMake(), + } +} diff --git a/decort/data_source_bservice_deleted_list.go b/decort/data_source_bservice_deleted_list.go new file mode 100644 index 0000000..3f4dce8 --- /dev/null +++ b/decort/data_source_bservice_deleted_list.go @@ -0,0 +1,58 @@ +/* +Copyright (c) 2019-2022 Digital Energy Cloud Solutions LLC. All Rights Reserved. +Author: Stanislav Solovev, + +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. +*/ + +/* +This file is part of Terraform (by Hashicorp) provider for Digital Energy Cloud Orchestration +Technology platfom. + +Visit https://github.com/rudecs/terraform-provider-decort for full source code package and updates. +*/ + +package decort + +import ( + "github.com/google/uuid" + "github.com/hashicorp/terraform-plugin-sdk/helper/schema" +) + +func dataSourceBasicServiceDeletedListRead(d *schema.ResourceData, m interface{}) error { + basicServiceDeletedList, err := utilityBasicServiceDeletedListCheckPresence(d, m) + if err != nil { + return err + } + + id := uuid.New() + d.SetId(id.String()) + d.Set("items", flattenBasicServiceList(basicServiceDeletedList)) + + return nil +} + +func dataSourceBasicServiceDeletedList() *schema.Resource { + return &schema.Resource{ + SchemaVersion: 1, + + Read: dataSourceBasicServiceDeletedListRead, + + Timeouts: &schema.ResourceTimeout{ + Read: &Timeout30s, + Default: &Timeout60s, + }, + + Schema: dataSourceBasicServiceListSchemaMake(), + } +} diff --git a/decort/data_source_bservice_group.go b/decort/data_source_bservice_group.go new file mode 100644 index 0000000..b8c3d92 --- /dev/null +++ b/decort/data_source_bservice_group.go @@ -0,0 +1,291 @@ +/* +Copyright (c) 2019-2022 Digital Energy Cloud Solutions LLC. All Rights Reserved. +Author: Stanislav Solovev, + +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. +*/ + +/* +This file is part of Terraform (by Hashicorp) provider for Digital Energy Cloud Orchestration +Technology platfom. + +Visit https://github.com/rudecs/terraform-provider-decort for full source code package and updates. +*/ + +package decort + +import ( + "github.com/google/uuid" + "github.com/hashicorp/terraform-plugin-sdk/helper/schema" +) + +func dataSourceBasicServiceGroupRead(d *schema.ResourceData, m interface{}) error { + bsg, err := utilityBasicServiceGroupCheckPresence(d, m) + if err != nil { + return 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 BasicServiceGroupOSUsers) []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 BasicServiceGroupComputes) []map[string]interface{} { + res := make([]map[string]interface{}, 0) + for _, bsgc := range bsgcs { + temp := map[string]interface{}{ + "id": bsgc.ID, + "ip_addresses": bsgc.IPAdresses, + "name": bsgc.Name, + "os_users": flattenBSGroupOSUsers(bsgc.OSUsers), + } + 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, + }, + "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, + + Read: dataSourceBasicServiceGroupRead, + + Timeouts: &schema.ResourceTimeout{ + Read: &Timeout30s, + Default: &Timeout60s, + }, + + Schema: dataSourceBasicServiceGroupSchemaMake(), + } +} diff --git a/decort/data_source_bservice_list.go b/decort/data_source_bservice_list.go new file mode 100644 index 0000000..21ead41 --- /dev/null +++ b/decort/data_source_bservice_list.go @@ -0,0 +1,215 @@ +/* +Copyright (c) 2019-2022 Digital Energy Cloud Solutions LLC. All Rights Reserved. +Author: Stanislav Solovev, + +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. +*/ + +/* +This file is part of Terraform (by Hashicorp) provider for Digital Energy Cloud Orchestration +Technology platfom. + +Visit https://github.com/rudecs/terraform-provider-decort for full source code package and updates. +*/ + +package decort + +import ( + "github.com/google/uuid" + "github.com/hashicorp/terraform-plugin-sdk/helper/schema" +) + +func flattenBasicServiceList(bsl BasicServiceList) []map[string]interface{} { + res := make([]map[string]interface{}, 0) + for _, bs := range bsl { + 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, + } + res = append(res, temp) + } + return res +} + +func dataSourceBasicServiceListRead(d *schema.ResourceData, m interface{}) error { + basicServiceList, err := utilityBasicServiceListCheckPresence(d, m) + if err != nil { + return err + } + + id := uuid.New() + d.SetId(id.String()) + d.Set("items", flattenBasicServiceList(basicServiceList)) + + return nil +} + +func dataSourceBasicServiceListSchemaMake() map[string]*schema.Schema { + res := map[string]*schema.Schema{ + "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", + }, + "page": { + Type: schema.TypeInt, + Optional: true, + Description: "Page number", + }, + "size": { + Type: schema.TypeInt, + Optional: true, + Description: "Page size", + }, + "items": { + Type: schema.TypeList, + Computed: true, + Elem: &schema.Resource{ + Schema: map[string]*schema.Schema{ + "account_id": { + Type: schema.TypeInt, + Computed: true, + }, + "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, + }, + "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, + }, + }, + }, + }, + } + return res +} + +func dataSourceBasicServiceList() *schema.Resource { + return &schema.Resource{ + SchemaVersion: 1, + + Read: dataSourceBasicServiceListRead, + + Timeouts: &schema.ResourceTimeout{ + Read: &Timeout30s, + Default: &Timeout60s, + }, + + Schema: dataSourceBasicServiceListSchemaMake(), + } +} diff --git a/decort/data_source_bservice_snapshot_list.go b/decort/data_source_bservice_snapshot_list.go new file mode 100644 index 0000000..306ce99 --- /dev/null +++ b/decort/data_source_bservice_snapshot_list.go @@ -0,0 +1,93 @@ +/* +Copyright (c) 2019-2022 Digital Energy Cloud Solutions LLC. All Rights Reserved. +Author: Stanislav Solovev, + +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. +*/ + +/* +This file is part of Terraform (by Hashicorp) provider for Digital Energy Cloud Orchestration +Technology platfom. + +Visit https://github.com/rudecs/terraform-provider-decort for full source code package and updates. +*/ + +package decort + +import ( + "github.com/google/uuid" + "github.com/hashicorp/terraform-plugin-sdk/helper/schema" +) + +func dataSourceBasicServiceSnapshotListRead(d *schema.ResourceData, m interface{}) error { + basicServiceSnapshotList, err := utilityBasicServiceSnapshotListCheckPresence(d, m) + if err != nil { + return err + } + + id := uuid.New() + d.SetId(id.String()) + d.Set("items", flattenBasicServiceSnapshots(basicServiceSnapshotList)) + + 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, + }, + }, + }, + }, + } + return res +} + +func dataSourceBasicServiceSnapshotList() *schema.Resource { + return &schema.Resource{ + SchemaVersion: 1, + + Read: dataSourceBasicServiceSnapshotListRead, + + Timeouts: &schema.ResourceTimeout{ + Read: &Timeout30s, + Default: &Timeout60s, + }, + + Schema: dataSourceBasicServiceSnapshotListSchemaMake(), + } +} diff --git a/decort/data_source_extnet.go b/decort/data_source_extnet.go new file mode 100644 index 0000000..e28445f --- /dev/null +++ b/decort/data_source_extnet.go @@ -0,0 +1,321 @@ +/* +Copyright (c) 2019-2022 Digital Energy Cloud Solutions LLC. All Rights Reserved. +Author: Stanislav Solovev, + +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. +*/ + +/* +This file is part of Terraform (by Hashicorp) provider for Digital Energy Cloud Orchestration +Technology platfom. + +Visit https://github.com/rudecs/terraform-provider-decort for full source code package and updates. +*/ + +package decort + +import ( + "github.com/google/uuid" + "github.com/hashicorp/terraform-plugin-sdk/helper/schema" +) + +func dataSourceExtnetRead(d *schema.ResourceData, m interface{}) error { + e, err := utilityExtnetCheckPresence(d, m) + if err != nil { + return err + } + + id := uuid.New() + d.SetId(id.String()) + d.Set("ckey", e.CKey) + d.Set("meta", flattenMeta(e.Meta)) + d.Set("check__ips", e.CheckIPs) + d.Set("check_ips", e.CheckIps) + d.Set("default", e.Default) + d.Set("default_qos", flattenExtnetDefaultQos(e.DefaultQos)) + d.Set("desc", e.Desc) + d.Set("dns", e.Dns) + d.Set("excluded", e.Excluded) + d.Set("free_ips", e.FreeIps) + d.Set("gateway", e.Gateway) + d.Set("gid", e.GID) + d.Set("guid", e.GUID) + d.Set("ipcidr", e.IPCidr) + d.Set("milestones", e.Milestones) + d.Set("net_name", e.Name) + d.Set("network", e.Network) + d.Set("network_id", e.NetworkId) + d.Set("pre_reservations_num", e.PreReservationsNum) + d.Set("prefix", e.Prefix) + d.Set("pri_vnf_dev_id", e.PriVnfDevId) + d.Set("reservations", flattenExtnetReservations(e.Reservations)) + d.Set("shared_with", e.SharedWith) + d.Set("status", e.Status) + d.Set("vlan_id", e.VlanID) + d.Set("vnfs", flattenExtnetVNFS(e.VNFS)) + return nil +} + +func flattenExtnetReservations(ers ExtnetReservations) []map[string]interface{} { + res := make([]map[string]interface{}, 0) + for _, er := range ers { + temp := map[string]interface{}{ + "client_type": er.ClientType, + "domainname": er.DomainName, + "hostname": er.HostName, + "desc": er.Desc, + "ip": er.IP, + "mac": er.MAC, + "type": er.Type, + "vm_id": er.VMID, + } + res = append(res, temp) + } + + return res +} + +func flattenExtnetDefaultQos(edqos ExtnetQos) []map[string]interface{} { + res := make([]map[string]interface{}, 0) + temp := map[string]interface{}{ + "e_rate": edqos.ERate, + "guid": edqos.GUID, + "in_burst": edqos.InBurst, + "in_rate": edqos.InRate, + } + res = append(res, temp) + return res +} + +func flattenExtnetVNFS(evnfs ExtnetVNFS) []map[string]interface{} { + res := make([]map[string]interface{}, 0) + temp := map[string]interface{}{ + "dhcp": evnfs.DHCP, + } + res = append(res, temp) + return res +} + +func dataSourceExtnetSchemaMake() map[string]*schema.Schema { + res := map[string]*schema.Schema{ + "net_id": { + Type: schema.TypeInt, + Required: true, + }, + "ckey": { + Type: schema.TypeString, + Computed: true, + }, + "meta": { + Type: schema.TypeList, + Computed: true, + Elem: &schema.Schema{ + Type: schema.TypeString, + }, + Description: "meta", + }, + "check__ips": { + Type: schema.TypeList, + Computed: true, + Elem: &schema.Schema{ + Type: schema.TypeString, + }, + }, + "check_ips": { + Type: schema.TypeList, + Computed: true, + Elem: &schema.Schema{ + Type: schema.TypeString, + }, + }, + "default": { + Type: schema.TypeBool, + Computed: true, + }, + "default_qos": { + Type: schema.TypeList, + MaxItems: 1, + Computed: true, + Elem: &schema.Resource{ + Schema: map[string]*schema.Schema{ + "e_rate": { + Type: schema.TypeInt, + Computed: true, + }, + "guid": { + Type: schema.TypeString, + Computed: true, + }, + "in_burst": { + Type: schema.TypeInt, + Computed: true, + }, + "in_rate": { + Type: schema.TypeInt, + Computed: true, + }, + }, + }, + }, + "desc": { + Type: schema.TypeString, + Computed: true, + }, + "dns": { + Type: schema.TypeList, + Computed: true, + Elem: &schema.Schema{ + Type: schema.TypeString, + }, + }, + "excluded": { + Type: schema.TypeList, + Computed: true, + Elem: &schema.Schema{ + Type: schema.TypeString, + }, + }, + "free_ips": { + Type: schema.TypeInt, + Computed: true, + }, + "gateway": { + Type: schema.TypeString, + Computed: true, + }, + "gid": { + Type: schema.TypeInt, + Computed: true, + }, + "guid": { + Type: schema.TypeInt, + Computed: true, + }, + "ipcidr": { + Type: schema.TypeString, + Computed: true, + }, + "milestones": { + Type: schema.TypeInt, + Computed: true, + }, + "net_name": { + Type: schema.TypeString, + Computed: true, + }, + "network": { + Type: schema.TypeString, + Computed: true, + }, + "network_id": { + Type: schema.TypeInt, + Computed: true, + }, + "pre_reservations_num": { + Type: schema.TypeInt, + Computed: true, + }, + "prefix": { + Type: schema.TypeInt, + Computed: true, + }, + "pri_vnf_dev_id": { + Type: schema.TypeInt, + Computed: true, + }, + "reservations": { + Type: schema.TypeList, + Computed: true, + Elem: &schema.Resource{ + Schema: map[string]*schema.Schema{ + "client_type": { + Type: schema.TypeString, + Computed: true, + }, + "domainname": { + Type: schema.TypeString, + Computed: true, + }, + "hostname": { + Type: schema.TypeString, + Computed: true, + }, + "desc": { + Type: schema.TypeString, + Computed: true, + }, + "ip": { + Type: schema.TypeString, + Computed: true, + }, + "mac": { + Type: schema.TypeString, + Computed: true, + }, + "type": { + Type: schema.TypeString, + Computed: true, + }, + "vm_id": { + Type: schema.TypeInt, + Computed: true, + }, + }, + }, + }, + "shared_with": { + Type: schema.TypeList, + Computed: true, + Elem: &schema.Schema{ + Type: schema.TypeInt, + }, + }, + "status": { + Type: schema.TypeString, + Computed: true, + }, + "vlan_id": { + Type: schema.TypeInt, + Computed: true, + }, + "vnfs": { + Type: schema.TypeList, + MaxItems: 1, + Computed: true, + Elem: &schema.Resource{ + Schema: map[string]*schema.Schema{ + "dhcp": { + Type: schema.TypeInt, + Computed: true, + }, + }, + }, + }, + } + return res +} + +func dataSourceExtnet() *schema.Resource { + return &schema.Resource{ + SchemaVersion: 1, + + Read: dataSourceExtnetRead, + + Timeouts: &schema.ResourceTimeout{ + Read: &Timeout30s, + Default: &Timeout60s, + }, + + Schema: dataSourceExtnetSchemaMake(), + } +} diff --git a/decort/data_source_extnet_computes_list.go b/decort/data_source_extnet_computes_list.go new file mode 100644 index 0000000..c963a61 --- /dev/null +++ b/decort/data_source_extnet_computes_list.go @@ -0,0 +1,156 @@ +/* +Copyright (c) 2019-2022 Digital Energy Cloud Solutions LLC. All Rights Reserved. +Author: Stanislav Solovev, + +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. +*/ + +/* +This file is part of Terraform (by Hashicorp) provider for Digital Energy Cloud Orchestration +Technology platfom. + +Visit https://github.com/rudecs/terraform-provider-decort for full source code package and updates. +*/ + +package decort + +import ( + "github.com/google/uuid" + "github.com/hashicorp/terraform-plugin-sdk/helper/schema" +) + +func flattenExtnetsComputes(ecs ExtnetExtendList) []map[string]interface{} { + res := make([]map[string]interface{}, 0) + for _, ec := range ecs { + temp := map[string]interface{}{ + "net_id": ec.ID, + "ipaddr": ec.IPAddr, + "ipcidr": ec.IPCidr, + "name": ec.Name, + } + res = append(res, temp) + } + return res +} + +func flattenExtnetComputesList(ecl ExtnetComputesList) []map[string]interface{} { + res := make([]map[string]interface{}, 0) + for _, ec := range ecl { + temp := map[string]interface{}{ + "account_id": ec.AccountId, + "account_name": ec.AccountName, + "extnets": flattenExtnetsComputes(ec.Extnets), + "id": ec.ID, + "name": ec.Name, + "rg_id": ec.RGID, + "rg_name": ec.RGName, + } + res = append(res, temp) + } + return res +} + +func dataSourceExtnetComputesListRead(d *schema.ResourceData, m interface{}) error { + extnetComputesList, err := utilityExtnetComputesListCheckPresence(d, m) + if err != nil { + return err + } + + id := uuid.New() + d.SetId(id.String()) + d.Set("items", flattenExtnetComputesList(extnetComputesList)) + + return nil +} + +func dataSourceExtnetComputesListSchemaMake() map[string]*schema.Schema { + res := map[string]*schema.Schema{ + "account_id": { + Type: schema.TypeInt, + Required: true, + Description: "filter by account 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, + }, + "extnets": { + Type: schema.TypeList, + Computed: true, + Elem: &schema.Resource{ + Schema: map[string]*schema.Schema{ + "net_id": { + Type: schema.TypeInt, + Computed: true, + }, + "ipaddr": { + Type: schema.TypeString, + Computed: true, + }, + "ipcidr": { + Type: schema.TypeString, + Computed: true, + }, + "name": { + Type: schema.TypeString, + Computed: true, + }, + }, + }, + }, + "id": { + Type: schema.TypeInt, + Computed: true, + }, + "name": { + Type: schema.TypeString, + Computed: true, + }, + "rg_id": { + Type: schema.TypeInt, + Computed: true, + }, + "rg_name": { + Type: schema.TypeString, + Computed: true, + }, + }, + }, + }, + } + return res +} + +func dataSourceExtnetComputesList() *schema.Resource { + return &schema.Resource{ + SchemaVersion: 1, + + Read: dataSourceExtnetComputesListRead, + + Timeouts: &schema.ResourceTimeout{ + Read: &Timeout30s, + Default: &Timeout60s, + }, + + Schema: dataSourceExtnetComputesListSchemaMake(), + } +} diff --git a/decort/data_source_extnet_default.go b/decort/data_source_extnet_default.go new file mode 100644 index 0000000..de5585f --- /dev/null +++ b/decort/data_source_extnet_default.go @@ -0,0 +1,74 @@ +/* +Copyright (c) 2019-2022 Digital Energy Cloud Solutions LLC. All Rights Reserved. +Author: Stanislav Solovev, + +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. +*/ + +/* +This file is part of Terraform (by Hashicorp) provider for Digital Energy Cloud Orchestration +Technology platfom. + +Visit https://github.com/rudecs/terraform-provider-decort for full source code package and updates. +*/ + +package decort + +import ( + "strconv" + + "github.com/google/uuid" + "github.com/hashicorp/terraform-plugin-sdk/helper/schema" +) + +func dataSourceExtnetDefaultRead(d *schema.ResourceData, m interface{}) error { + extnetId, err := utilityExtnetDefaultCheckPresence(d, m) + if err != nil { + return err + } + + id := uuid.New() + d.SetId(id.String()) + extnetIdInt, err := strconv.ParseInt(extnetId, 10, 32) + if err != nil { + return err + } + d.Set("net_id", extnetIdInt) + + return nil +} + +func dataSourceExtnetDefaultSchemaMake() map[string]*schema.Schema { + res := map[string]*schema.Schema{ + "net_id": { + Type: schema.TypeInt, + Computed: true, + }, + } + return res +} + +func dataSourceExtnetDefault() *schema.Resource { + return &schema.Resource{ + SchemaVersion: 1, + + Read: dataSourceExtnetDefaultRead, + + Timeouts: &schema.ResourceTimeout{ + Read: &Timeout30s, + Default: &Timeout60s, + }, + + Schema: dataSourceExtnetDefaultSchemaMake(), + } +} diff --git a/decort/data_source_extnet_list.go b/decort/data_source_extnet_list.go new file mode 100644 index 0000000..4789f33 --- /dev/null +++ b/decort/data_source_extnet_list.go @@ -0,0 +1,112 @@ +/* +Copyright (c) 2019-2022 Digital Energy Cloud Solutions LLC. All Rights Reserved. +Author: Stanislav Solovev, + +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. +*/ + +/* +This file is part of Terraform (by Hashicorp) provider for Digital Energy Cloud Orchestration +Technology platfom. + +Visit https://github.com/rudecs/terraform-provider-decort for full source code package and updates. +*/ + +package decort + +import ( + "github.com/google/uuid" + "github.com/hashicorp/terraform-plugin-sdk/helper/schema" +) + +func flattenExtnetList(el ExtnetList) []map[string]interface{} { + res := make([]map[string]interface{}, 0) + for _, e := range el { + temp := map[string]interface{}{ + "net_id": e.ID, + "ipcidr": e.IPCidr, + "name": e.Name, + } + res = append(res, temp) + } + return res +} + +func dataSourceExtnetListRead(d *schema.ResourceData, m interface{}) error { + extnetList, err := utilityExtnetListCheckPresence(d, m) + if err != nil { + return err + } + + id := uuid.New() + d.SetId(id.String()) + d.Set("items", flattenExtnetList(extnetList)) + + return nil +} + +func dataSourceExtnetListSchemaMake() map[string]*schema.Schema { + res := map[string]*schema.Schema{ + "account_id": { + Type: schema.TypeInt, + Optional: true, + Description: "filter by account 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{ + "net_id": { + Type: schema.TypeInt, + Computed: true, + }, + "ipcidr": { + Type: schema.TypeString, + Computed: true, + }, + "name": { + Type: schema.TypeString, + Computed: true, + }, + }, + }, + }, + } + return res +} + +func dataSourceExtnetList() *schema.Resource { + return &schema.Resource{ + SchemaVersion: 1, + + Read: dataSourceExtnetListRead, + + Timeouts: &schema.ResourceTimeout{ + Read: &Timeout30s, + Default: &Timeout60s, + }, + + Schema: dataSourceExtnetListSchemaMake(), + } +} diff --git a/decort/data_source_vins_list.go b/decort/data_source_vins_list.go new file mode 100644 index 0000000..84a2c0b --- /dev/null +++ b/decort/data_source_vins_list.go @@ -0,0 +1,178 @@ +/* +Copyright (c) 2019-2022 Digital Energy Cloud Solutions LLC. All Rights Reserved. +Author: Stanislav Solovev, + +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. +*/ + +/* +This file is part of Terraform (by Hashicorp) provider for Digital Energy Cloud Orchestration +Technology platfom. + +Visit https://github.com/rudecs/terraform-provider-decort for full source code package and updates. +*/ + +package decort + +import ( + "github.com/google/uuid" + "github.com/hashicorp/terraform-plugin-sdk/helper/schema" +) + +func flattenVinsList(vl VinsList) []map[string]interface{} { + res := make([]map[string]interface{}, 0) + for _, v := range vl { + temp := map[string]interface{}{ + "account_id": v.AccountId, + "account_name": v.AccountName, + "created_by": v.CreatedBy, + "created_time": v.CreatedTime, + "deleted_by": v.DeletedBy, + "deleted_time": v.DeletedTime, + "external_ip": v.ExternalIP, + "vins_id": v.ID, + "vins_name": v.Name, + "network": v.Network, + "rg_id": v.RGID, + "rg_name": v.RGName, + "status": v.Status, + "updated_by": v.UpdatedBy, + "updated_time": v.UpdatedTime, + "vxlan_id": v.VXLanID, + } + res = append(res, temp) + } + return res +} + +func dataSourceVinsListRead(d *schema.ResourceData, m interface{}) error { + vinsList, err := utilityVinsListCheckPresence(d, m) + if err != nil { + return err + } + + id := uuid.New() + d.SetId(id.String()) + d.Set("items", flattenVinsList(vinsList)) + + return nil +} + +func dataSourceVinsListSchemaMake() map[string]*schema.Schema { + res := map[string]*schema.Schema{ + "include_deleted": { + Type: schema.TypeBool, + Optional: true, + Default: false, + Description: "include deleted computes", + }, + "page": { + Type: schema.TypeInt, + Optional: true, + Description: "Page number", + }, + "size": { + Type: schema.TypeInt, + Optional: true, + Description: "Page size", + }, + "items": { + Type: schema.TypeList, + Computed: true, + Elem: &schema.Resource{ + Schema: map[string]*schema.Schema{ + "account_id": { + Type: schema.TypeInt, + Computed: true, + }, + "account_name": { + 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, + }, + "external_ip": { + Type: schema.TypeString, + Computed: true, + }, + "vins_id": { + Type: schema.TypeInt, + Computed: true, + }, + "vins_name": { + Type: schema.TypeString, + Computed: true, + }, + "network": { + Type: schema.TypeString, + Computed: true, + }, + "rg_id": { + Type: schema.TypeInt, + Computed: true, + }, + "rg_name": { + Type: schema.TypeString, + Computed: true, + }, + "status": { + Type: schema.TypeString, + Computed: true, + }, + "updated_by": { + Type: schema.TypeString, + Computed: true, + }, + "updated_time": { + Type: schema.TypeInt, + Computed: true, + }, + "vxlan_id": { + Type: schema.TypeInt, + Computed: true, + }, + }, + }, + }, + } + return res +} + +func dataSourceVinsList() *schema.Resource { + return &schema.Resource{ + SchemaVersion: 1, + + Read: dataSourceVinsListRead, + + Timeouts: &schema.ResourceTimeout{ + Read: &Timeout30s, + Default: &Timeout60s, + }, + + Schema: dataSourceVinsListSchemaMake(), + } +} diff --git a/decort/models_api.go b/decort/models_api.go index 119f11e..89e8676 100644 --- a/decort/models_api.go +++ b/decort/models_api.go @@ -1226,3 +1226,261 @@ type AccountFlipGroup struct { } type AccountFlipGroupsList []AccountFlipGroup + +//////////////////// +//// BSERVICE //// +//////////////////// + +const bserviceCreateAPI = "/restmachine/cloudapi/bservice/create" +const bserviceDeleteAPI = "/restmachine/cloudapi/bservice/delete" +const bserviceDisableAPI = "/restmachine/cloudapi/bservice/disable" +const bserviceEnableAPI = "/restmachine/cloudapi/bservice/enable" +const bserviceGetAPI = "/restmachine/cloudapi/bservice/get" +const bserviceGroupAddAPI = "/restmachine/cloudapi/bservice/groupAdd" +const bserviceGroupComputeRemoveAPI = "/restmachine/cloudapi/bservice/groupComputeRemove" +const bserviceGroupGetAPI = "/restmachine/cloudapi/bservice/groupGet" +const bserviceGroupParentAddAPI = "/restmachine/cloudapi/bservice/groupParentAdd" +const bserviceGroupParentRemoveAPI = "/restmachine/cloudapi/bservice/groupParentRemove" +const bserviceGroupRemoveAPI = "/restmachine/cloudapi/bservice/groupRemove" +const bserviceGroupResizeAPI = "/restmachine/cloudapi/bservice/groupResize" +const bserviceGroupStartAPI = "/restmachine/cloudapi/bservice/groupStart" +const bserviceGroupStopAPI = "/restmachine/cloudapi/bservice/groupStop" +const bserviceGroupUpdateAPI = "/restmachine/cloudapi/bservice/groupUpdate" +const bserviceGroupUpdateExtnetAPI = "/restmachine/cloudapi/bservice/groupUpdateExtnet" +const bserviceGroupUpdateVinsAPI = "/restmachine/cloudapi/bservice/groupUpdateVins" +const bserviceListAPI = "/restmachine/cloudapi/bservice/list" +const bserviceListDeletedAPI = "/restmachine/cloudapi/bservice/listDeleted" +const bserviceRestoreAPI = "/restmachine/cloudapi/bservice/restore" +const bserviceSnapshotCreateAPI = "/restmachine/cloudapi/bservice/snapshotCreate" +const bserviceSnapshotDeleteAPI = "/restmachine/cloudapi/bservice/snapshotDelete" +const bserviceSnapshotListAPI = "/restmachine/cloudapi/bservice/snapshotList" +const bserviceSnapshotRollbackAPI = "/restmachine/cloudapi/bservice/snapshotRollback" +const bserviceStartAPI = "/restmachine/cloudapi/bservice/start" +const bserviceStopAPI = "/restmachine/cloudapi/bservice/stop" + +///Structs + +type BasicServiceCompute struct { + CompGroupId int `json:"compgroupId"` + CompGroupName string `json:"compgroupName"` + CompGroupRole string `json:"compgroupRole"` + ID int `json:"id"` + Name string `json:"name"` +} + +type BasicServiceComputes []BasicServiceCompute + +type BasicServiceSnapshot struct { + GUID string `json:"guid"` + Label string `json:"label"` + Timestamp int `json:"timestamp"` + Valid bool `json:"valid"` +} + +type BasicServiceSnapshots []BasicServiceSnapshot + +type BasicService struct { + AccountId int `json:"accountId"` + AccountName string `json:"accountName"` + BaseDomain string `json:"baseDomain"` + + CreatedBy string `json:"createdBy"` + CreatedTime int `json:"createdTime"` + DeletedBy string `json:"deletedBy"` + DeletedTime int `json:"deletedTime"` + GID int `json:"gid"` + Groups []int `json:"groups"` + GUID int `json:"guid"` + ID int `json:"id"` + Name string `json:"name"` + ParentSrvId int `json:"parentSrvId"` + ParentSrvType string `json:"parentSrvType"` + RGID int `json:"rgId"` + RGName string `json:"rgName"` + SSHUser string `json:"sshUser"` + Status string `json:"status"` + TechStatus string `json:"techStatus"` + UpdatedBy string `json:"updatedBy"` + UpdatedTime int `json:"updatedTime"` + UserManaged bool `json:"userManaged"` +} + +type BasicServiceList []BasicService + +type BasicServiceExtend struct { + BasicService + Computes BasicServiceComputes `json:"computes"` + CPUTotal int `json:"cpuTotal"` + DiskTotal int `json:"diskTotal"` + GroupsName []string `json:"groupsName"` + Milestones int `json:"milestones"` + RamTotal int `json:"ramTotal"` + Snapshots BasicServiceSnapshots `json:"snapshots"` + SSHKey string `json:"sshKey"` +} + +type BasicServiceGroupOSUser struct { + Login string `json:"login"` + Password string `json:"password"` +} + +type BasicServiceGroupOSUsers []BasicServiceGroupOSUser + +type BasicServicceGroupCompute struct { + ID int `json:"id"` + IPAdresses []string `json:"ipAddresses"` + Name string `json:"name"` + OSUsers BasicServiceGroupOSUsers `json:"osUsers"` +} + +type BasicServiceGroupComputes []BasicServicceGroupCompute + +type BasicServiceGroup struct { + AccountId int `json:"accountId"` + AccountName string `json:"accountName"` + Computes BasicServiceGroupComputes `json:"computes"` + Consistency bool `json:"consistency"` + CPU int `json:"cpu"` + CreatedBy string `json:"createdBy"` + CreatedTime int `json:"createdTime"` + DeletedBy string `json:"deletedBy"` + DeletedTime int `json:"deletedTime"` + Disk int `json:"disk"` + Driver string `json:"driver"` + Extnets []int `json:"extnets"` + GID int `json:"gid"` + GUID int `json:"guid"` + ID int `json:"id"` + ImageId int `json:"imageId"` + Milestones int `json:"milestones"` + Name string `json:"name"` + Parents []int `json:"parents"` + RAM int `json:"ram"` + RGID int `json:"rgId"` + RGName string `json:"rgName"` + Role string `json:"role"` + SepId int `json:"sepId"` + SeqNo int `json:"seqNo"` + ServiceId int `json:"serviceId"` + Status string `json:"status"` + TechStatus string `json:"techStatus"` + TimeoutStart int `json:"timeoutStart"` + UpdatedBy string `json:"updatedBy"` + UpdatedTime int `json:"updatedTime"` + Vinses []int `json:"vinses"` +} + +/////////////////// +///// EXTNET ///// +/////////////////// + +const extnetListAPI = "/restmachine/cloudapi/extnet/list" +const extnetListComputesAPI = "/restmachine/cloudapi/extnet/listComputes" +const extnetGetDefaultAPI = "/restmachine/cloudapi/extnet/getDefault" +const extnetGetAPI = "/restmachine/cloudapi/extnet/get" + +type Extnet struct { + ID int `json:"id"` + IPCidr string `json:"ipcidr"` + Name string `json:"name"` +} +type ExtnetExtend struct { + Extnet + IPAddr string `json:"ipaddr"` +} + +type ExtnetList []Extnet +type ExtnetExtendList []ExtnetExtend + +type ExtnetComputes struct { + AccountId int `json:"accountId"` + AccountName string `json:"accountName"` + Extnets ExtnetExtendList `json:"extnets"` + ID int `json:"id"` + Name string `json:"name"` + RGID int `json:"rgId"` + RGName string `json:"rgName"` +} + +type ExtnetComputesList []ExtnetComputes + +type ExtnetQos struct { + ERate int `json:"eRate"` + GUID string `json:"guid"` + InBurst int `json:"inBurst"` + InRate int `json:"inRate"` +} + +type ExtnetReservation struct { + ClientType string `json:"clientType"` + Desc string `json:"desc"` + DomainName string `json:"domainname"` + HostName string `json:"hostname"` + IP string `json:"ip"` + MAC string `json:"mac"` + Type string `json:"type"` + VMID int `json:"vmId"` +} + +type ExtnetReservations []ExtnetReservation + +type ExtnetVNFS struct { + DHCP int `json:"dhcp"` +} + +type ExtnetDetailed struct { + CKey string `json:"_ckey"` + Meta []interface{} `json:"_meta"` + CheckIPs []string `json:"checkIPs"` + CheckIps []string `json:"checkIps"` + Default bool `json:"default"` + DefaultQos ExtnetQos `json:"defaultQos"` + Desc string `json:"desc"` + Dns []string `json:"dns"` + Excluded []string `json:"excluded"` + FreeIps int `json:"free_ips"` + Gateway string `json:"gateway"` + GID int `json:"gid"` + GUID int `json:"guid"` + ID int `json:"id"` + IPCidr string `json:"ipcidr"` + Milestones int `json:"milestones"` + Name string `json:"name"` + Network string `json:"network"` + NetworkId int `json:"networkId"` + PreReservationsNum int `json:"preReservationsNum"` + Prefix int `json:"prefix"` + PriVnfDevId int `json:"priVnfDevId"` + Reservations ExtnetReservations `json:"reservations"` + SharedWith []int `json:"sharedWith"` + Status string `json:"status"` + VlanID int `json:"vlanId"` + VNFS ExtnetVNFS `json:"vnfs"` +} + +////////////// +//// VINS //// +////////////// + +const vinsListAPI = "/restmachine/cloudapi/vins/list" + +type Vins struct { + AccountId int `json:"accountId"` + AccountName string `json:"accountName"` + CreatedBy string `json:"createdBy"` + CreatedTime int `json:"createdTime"` + DeletedBy string `json:"deletedBy"` + DeletedTime int `json:"deletedTime"` + ExternalIP string `json:"externalIP"` + ID int `json:"id"` + Name string `json:"name"` + Network string `json:"network"` + RGID int `json:"rgId"` + RGName string `json:"rgName"` + Status string `json:"status"` + UpdatedBy string `json:"updatedBy"` + UpdatedTime int `json:"updatedTime"` + VXLanID int `json:"vxlanId"` +} + +type VinsList []Vins diff --git a/decort/provider.go b/decort/provider.go index 030b263..eea3dda 100644 --- a/decort/provider.go +++ b/decort/provider.go @@ -99,22 +99,24 @@ func Provider() *schema.Provider { }, ResourcesMap: map[string]*schema.Resource{ - "decort_resgroup": resourceResgroup(), - "decort_kvmvm": resourceCompute(), - "decort_disk": resourceDisk(), - "decort_vins": resourceVins(), - "decort_pfw": resourcePfw(), - "decort_k8s": resourceK8s(), - "decort_k8s_wg": resourceK8sWg(), - "decort_image": resourceImage(), - "decort_virtual_image": resourceVirtualImage(), - "decort_cdrom_image": resourceCDROMImage(), - "decort_delete_images": resourceDeleteImages(), - "decort_snapshot": resourceSnapshot(), - "decort_pcidevice": resourcePcidevice(), - "decort_sep": resourceSep(), - "decort_sep_config": resourceSepConfig(), - "decort_account": resourceAccount(), + "decort_resgroup": resourceResgroup(), + "decort_kvmvm": resourceCompute(), + "decort_disk": resourceDisk(), + "decort_vins": resourceVins(), + "decort_pfw": resourcePfw(), + "decort_k8s": resourceK8s(), + "decort_k8s_wg": resourceK8sWg(), + "decort_image": resourceImage(), + "decort_virtual_image": resourceVirtualImage(), + "decort_cdrom_image": resourceCDROMImage(), + "decort_delete_images": resourceDeleteImages(), + "decort_snapshot": resourceSnapshot(), + "decort_pcidevice": resourcePcidevice(), + "decort_sep": resourceSep(), + "decort_sep_config": resourceSepConfig(), + "decort_account": resourceAccount(), + "decort_bservice": resourceBasicService(), + "decort_bservice_group": resourceBasicServiceGroup(), }, DataSourcesMap: map[string]*schema.Resource{ @@ -152,6 +154,16 @@ func Provider() *schema.Provider { "decort_account_templates_list": dataSourceAccountTemplatessList(), "decort_account_deleted_list": dataSourceAccountDeletedList(), "decort_account_flipgroups_list": dataSourceAccountFlipGroupsList(), + "decort_bservice_list": dataSourceBasicServiceList(), + "decort_bservice": dataSourceBasicService(), + "decort_bservice_snapshot_list": dataSourceBasicServiceSnapshotList(), + "decort_bservice_group": dataSourceBasicServiceGroup(), + "decort_bservice_deleted_list": dataSourceBasicServiceDeletedList(), + "decort_extnet_list": dataSourceExtnetList(), + "decort_extnet_computes_list": dataSourceExtnetComputesList(), + "decort_extnet": dataSourceExtnet(), + "decort_extnet_default": dataSourceExtnetDefault(), + "decort_vins_list": dataSourceVinsList(), // "decort_pfw": dataSourcePfw(), }, diff --git a/decort/resource_account.go b/decort/resource_account.go index a113092..e266560 100644 --- a/decort/resource_account.go +++ b/decort/resource_account.go @@ -51,7 +51,7 @@ func resourceAccountCreate(d *schema.ResourceData, m interface{}) error { return nil } - return errors.New("provided sep id does not exist") + return errors.New("provided account id does not exist") } controller := m.(*ControllerCfg) @@ -142,7 +142,7 @@ func resourceAccountCreate(d *schema.ResourceData, m interface{}) error { } func resourceAccountRead(d *schema.ResourceData, m interface{}) error { - log.Debugf("resourceSepRead") + log.Debugf("resourceAccountRead") acc, err := utilityAccountCheckPresence(d, m) if acc == nil { diff --git a/decort/resource_bservice.go b/decort/resource_bservice.go new file mode 100644 index 0000000..9f0df09 --- /dev/null +++ b/decort/resource_bservice.go @@ -0,0 +1,554 @@ +/* +Copyright (c) 2019-2022 Digital Energy Cloud Solutions LLC. All Rights Reserved. +Author: Stanislav Solovev, + +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. +*/ + +/* +This file is part of Terraform (by Hashicorp) provider for Digital Energy Cloud Orchestration +Technology platfom. + +Visit https://github.com/rudecs/terraform-provider-decort for full source code package and updates. +*/ + +package decort + +import ( + "errors" + "net/url" + "strconv" + + "github.com/google/uuid" + "github.com/hashicorp/terraform-plugin-sdk/helper/schema" + log "github.com/sirupsen/logrus" +) + +func resourceBasicServiceCreate(d *schema.ResourceData, m interface{}) error { + log.Debugf("resourceBasicServiceCreate") + + if serviceId, ok := d.GetOk("service_id"); ok { + if exists, err := resourceBasicServiceExists(d, m); exists { + if err != nil { + return err + } + id := uuid.New() + d.SetId(strconv.Itoa(serviceId.(int))) + d.Set("service_id", strconv.Itoa(serviceId.(int))) + err = resourceBasicServiceRead(d, m) + if err != nil { + return err + } + d.SetId(id.String()) + return nil + } + return errors.New("provided service id does not exist") + } + + controller := m.(*ControllerCfg) + urlValues := &url.Values{} + + urlValues.Add("name", d.Get("service_name").(string)) + urlValues.Add("rgId", strconv.Itoa(d.Get("rg_id").(int))) + + if sshKey, ok := d.GetOk("ssh_key"); ok { + urlValues.Add("sshKey", sshKey.(string)) + } + if sshUser, ok := d.GetOk("ssh_user"); ok { + urlValues.Add("sshUser", sshUser.(string)) + } + + serviceId, err := controller.decortAPICall("POST", bserviceCreateAPI, urlValues) + if err != nil { + return err + } + + id := uuid.New() + d.SetId(serviceId) + d.Set("service_id", serviceId) + + err = resourceBasicServiceRead(d, m) + if err != nil { + return err + } + + d.SetId(id.String()) + + return nil +} + +func resourceBasicServiceRead(d *schema.ResourceData, m interface{}) error { + log.Debugf("resourceBasicServiceRead") + + bs, err := utilityBasicServiceCheckPresence(d, m) + if bs == nil { + d.SetId("") + return err + } + + 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", bs.Groups) + d.Set("groups_name", bs.GroupsName) + 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) + + return nil +} + +func resourceBasicServiceDelete(d *schema.ResourceData, m interface{}) error { + log.Debugf("resourceBasicServiceDelete") + + bs, err := utilityBasicServiceCheckPresence(d, m) + if bs == nil { + if err != nil { + return err + } + return nil + } + + controller := m.(*ControllerCfg) + urlValues := &url.Values{} + urlValues.Add("serviceId", strconv.Itoa(d.Get("service_id").(int))) + urlValues.Add("permanently", strconv.FormatBool(d.Get("permanently").(bool))) + + _, err = controller.decortAPICall("POST", bserviceDeleteAPI, urlValues) + if err != nil { + return err + } + d.SetId("") + + return nil +} + +func resourceBasicServiceExists(d *schema.ResourceData, m interface{}) (bool, error) { + log.Debugf("resourceBasicServiceExists") + + bservice, err := utilityBasicServiceCheckPresence(d, m) + if bservice == nil { + if err != nil { + return false, err + } + return false, nil + } + + return true, nil +} + +func resourceBasicServiceEdit(d *schema.ResourceData, m interface{}) error { + log.Debugf("resourceBasicServiceEdit") + c := m.(*ControllerCfg) + + urlValues := &url.Values{} + if d.HasChange("enable") { + api := bserviceDisableAPI + enable := d.Get("enable").(bool) + if enable { + api = bserviceEnableAPI + } + urlValues.Add("serviceId", strconv.Itoa(d.Get("service_id").(int))) + + _, err := c.decortAPICall("POST", api, urlValues) + if err != nil { + return err + } + + urlValues = &url.Values{} + } + + if d.HasChange("restore") { + restore := d.Get("restore").(bool) + if restore { + urlValues.Add("serviceId", strconv.Itoa(d.Get("service_id").(int))) + _, err := c.decortAPICall("POST", bserviceRestoreAPI, urlValues) + if err != nil { + return err + } + + urlValues = &url.Values{} + } + } + + if d.HasChange("start") { + api := bserviceStopAPI + start := d.Get("start").(bool) + if start { + api = bserviceStartAPI + } + urlValues.Add("serviceId", strconv.Itoa(d.Get("service_id").(int))) + + _, err := c.decortAPICall("POST", api, urlValues) + if err != nil { + return err + } + + urlValues = &url.Values{} + } + + 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{}) + urlValues.Add("serviceId", strconv.Itoa(d.Get("service_id").(int))) + urlValues.Add("label", snapshotConv["label"].(string)) + _, err := c.decortAPICall("POST", bserviceSnapshotDeleteAPI, urlValues) + if err != nil { + return err + } + + urlValues = &url.Values{} + } + } + + if len(addedSnapshots) > 0 { + for _, snapshot := range addedSnapshots { + snapshotConv := snapshot.(map[string]interface{}) + urlValues.Add("serviceId", strconv.Itoa(d.Get("service_id").(int))) + urlValues.Add("label", snapshotConv["label"].(string)) + _, err := c.decortAPICall("POST", bserviceSnapshotCreateAPI, urlValues) + if err != nil { + return err + } + + urlValues = &url.Values{} + } + } + + if len(updatedSnapshots) > 0 { + for _, snapshot := range updatedSnapshots { + snapshotConv := snapshot.(map[string]interface{}) + urlValues.Add("serviceId", strconv.Itoa(d.Get("service_id").(int))) + urlValues.Add("label", snapshotConv["label"].(string)) + _, err := c.decortAPICall("POST", bserviceSnapshotRollbackAPI, urlValues) + if err != nil { + return err + } + + urlValues = &url.Values{} + } + } + + } + + return nil +} + +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", + }, + "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: "if set to False, Basic service will be deleted to recycle bin. Otherwise destroyed immediately", + }, + "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{ + "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, + }, + "name": { + 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.TypeString, + Computed: true, + }, + "gid": { + Type: schema.TypeInt, + Computed: true, + }, + "groups": { + Type: schema.TypeList, + Computed: true, + Elem: &schema.Schema{ + Type: schema.TypeInt, + }, + }, + "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, + }, + "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, + + Create: resourceBasicServiceCreate, + Read: resourceBasicServiceRead, + Update: resourceBasicServiceEdit, + Delete: resourceBasicServiceDelete, + Exists: resourceBasicServiceExists, + + Importer: &schema.ResourceImporter{ + State: schema.ImportStatePassthrough, + }, + + Timeouts: &schema.ResourceTimeout{ + Create: &Timeout60s, + Read: &Timeout30s, + Update: &Timeout60s, + Delete: &Timeout60s, + Default: &Timeout60s, + }, + + Schema: resourceBasicServiceSchemaMake(), + } +} diff --git a/decort/resource_bservice_group.go b/decort/resource_bservice_group.go new file mode 100644 index 0000000..7d14e16 --- /dev/null +++ b/decort/resource_bservice_group.go @@ -0,0 +1,660 @@ +/* +Copyright (c) 2019-2022 Digital Energy Cloud Solutions LLC. All Rights Reserved. +Author: Stanislav Solovev, + +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. +*/ + +/* +This file is part of Terraform (by Hashicorp) provider for Digital Energy Cloud Orchestration +Technology platfom. + +Visit https://github.com/rudecs/terraform-provider-decort for full source code package and updates. +*/ + +package decort + +import ( + "errors" + "net/url" + "strconv" + "strings" + + "github.com/google/uuid" + "github.com/hashicorp/terraform-plugin-sdk/helper/schema" + "github.com/hashicorp/terraform-plugin-sdk/helper/validation" + log "github.com/sirupsen/logrus" +) + +func resourceBasicServiceGroupCreate(d *schema.ResourceData, m interface{}) error { + log.Debugf("resourceBasicServiceGroupCreate") + + if compgroupId, ok := d.GetOk("compgroup_id"); ok { + if _, ok := d.GetOk("service_id"); ok { + if exists, err := resourceBasicServiceGroupExists(d, m); exists { + if err != nil { + return err + } + id := uuid.New() + d.SetId(strconv.Itoa(compgroupId.(int))) + d.Set("compgroup_id", strconv.Itoa(compgroupId.(int))) + err = resourceBasicServiceGroupRead(d, m) + if err != nil { + return err + } + d.SetId(id.String()) + return nil + } + return errors.New("provided compgroup id does not exist") + } + } + + controller := m.(*ControllerCfg) + urlValues := &url.Values{} + + urlValues.Add("serviceId", strconv.Itoa(d.Get("service_id").(int))) + urlValues.Add("name", d.Get("compgroup_name").(string)) + + urlValues.Add("count", strconv.Itoa(d.Get("comp_count").(int))) + urlValues.Add("cpu", strconv.Itoa(d.Get("cpu").(int))) + urlValues.Add("ram", strconv.Itoa(d.Get("ram").(int))) + urlValues.Add("disk", strconv.Itoa(d.Get("disk").(int))) + urlValues.Add("imageId", strconv.Itoa(d.Get("image_id").(int))) + urlValues.Add("driver", strings.ToUpper(d.Get("driver").(string))) + + if role, ok := d.GetOk("role"); ok { + urlValues.Add("role", role.(string)) + } + + if timeoutStart, ok := d.GetOk("timeout_start"); ok { + urlValues.Add("timeoutStart", strconv.Itoa(timeoutStart.(int))) + } + + if vinses, ok := d.GetOk("vinses"); ok { + vs := vinses.([]interface{}) + temp := "" + l := len(vs) + for i, v := range vs { + s := strconv.Itoa(v.(int)) + if i != (l - 1) { + s += "," + } + temp = temp + s + } + temp = "[" + temp + "]" + urlValues.Add("vinses", temp) + } + if extnets, ok := d.GetOk("extnets"); ok { + es := extnets.([]interface{}) + temp := "" + l := len(es) + for i, e := range es { + s := strconv.Itoa(e.(int)) + if i != (l - 1) { + s += "," + } + temp = temp + s + } + temp = "[" + temp + "]" + urlValues.Add("extnets", temp) + } + + compgroupId, err := controller.decortAPICall("POST", bserviceGroupAddAPI, urlValues) + if err != nil { + return err + } + + id := uuid.New() + d.SetId(compgroupId) + d.Set("compgroup_id", compgroupId) + + err = resourceBasicServiceGroupRead(d, m) + if err != nil { + return err + } + + d.SetId(id.String()) + + return nil +} + +func resourceBasicServiceGroupRead(d *schema.ResourceData, m interface{}) error { + log.Debugf("resourceBasicServiceGroupRead") + + bsg, err := utilityBasicServiceGroupCheckPresence(d, m) + if bsg == nil { + d.SetId("") + return err + } + + 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("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 resourceBasicServiceGroupDelete(d *schema.ResourceData, m interface{}) error { + log.Debugf("resourceBasicServiceGroupDelete") + + bsg, err := utilityBasicServiceGroupCheckPresence(d, m) + if bsg == nil { + if err != nil { + return err + } + return nil + } + + controller := m.(*ControllerCfg) + urlValues := &url.Values{} + urlValues.Add("serviceId", strconv.Itoa(d.Get("service_id").(int))) + urlValues.Add("compgroupId", strconv.Itoa(d.Get("compgroup_id").(int))) + + _, err = controller.decortAPICall("POST", bserviceGroupRemoveAPI, urlValues) + if err != nil { + return err + } + d.SetId("") + + return nil +} + +func resourceBasicServiceGroupExists(d *schema.ResourceData, m interface{}) (bool, error) { + log.Debugf("resourceBasicServiceGroupExists") + + bserviceGroup, err := utilityBasicServiceGroupCheckPresence(d, m) + if bserviceGroup == nil { + if err != nil { + return false, err + } + return false, nil + } + + return true, nil +} + +func resourceBasicServiceGroupEdit(d *schema.ResourceData, m interface{}) error { + log.Debugf("resourceBasicServiceGroupEdit") + c := m.(*ControllerCfg) + + urlValues := &url.Values{} + + if d.HasChange("comp_count") { + urlValues.Add("serviceId", strconv.Itoa(d.Get("service_id").(int))) + urlValues.Add("compgroupId", strconv.Itoa(d.Get("compgroup_id").(int))) + urlValues.Add("count", strconv.Itoa(d.Get("comp_count").(int))) + urlValues.Add("mode", strings.ToUpper(d.Get("mode").(string))) + _, err := c.decortAPICall("POST", bserviceGroupResizeAPI, urlValues) + if err != nil { + return err + } + + urlValues = &url.Values{} + } + + if d.HasChange("start") { + api := bserviceGroupStopAPI + start := d.Get("start").(bool) + if start { + api = bserviceGroupStartAPI + } else { + urlValues.Add("force", strconv.FormatBool(d.Get("force_stop").(bool))) + } + urlValues.Add("serviceId", strconv.Itoa(d.Get("service_id").(int))) + urlValues.Add("compgroupId", strconv.Itoa(d.Get("compgroup_id").(int))) + + _, err := c.decortAPICall("POST", api, urlValues) + if err != nil { + return err + } + + urlValues = &url.Values{} + } + + if d.HasChanges("compgroup_name", "ram", "cpu", "disk", "role") { + urlValues.Add("name", d.Get("compgroup_name").(string)) + urlValues.Add("cpu", strconv.Itoa(d.Get("cpu").(int))) + urlValues.Add("ram", strconv.Itoa(d.Get("ram").(int))) + urlValues.Add("disk", strconv.Itoa(d.Get("disk").(int))) + urlValues.Add("role", d.Get("role").(string)) + urlValues.Add("force", strconv.FormatBool(d.Get("force_update").(bool))) + + urlValues.Add("serviceId", strconv.Itoa(d.Get("service_id").(int))) + urlValues.Add("compgroupId", strconv.Itoa(d.Get("compgroup_id").(int))) + + _, err := c.decortAPICall("POST", bserviceGroupUpdateAPI, urlValues) + if err != nil { + return err + } + + urlValues = &url.Values{} + } + + if d.HasChange("extnets") { + extnets := d.Get("extnets").([]interface{}) + temp := "" + l := len(extnets) + for i, e := range extnets { + s := strconv.Itoa(e.(int)) + if i != (l - 1) { + s += ",\n" + } else { + s += "\n" + } + temp = temp + s + } + temp = "[" + temp + "]" + + urlValues.Add("serviceId", strconv.Itoa(d.Get("service_id").(int))) + urlValues.Add("compgroupId", strconv.Itoa(d.Get("compgroup_id").(int))) + urlValues.Add("extnets", temp) + _, err := c.decortAPICall("POST", bserviceGroupUpdateExtnetAPI, urlValues) + if err != nil { + return err + } + + urlValues = &url.Values{} + } + + if d.HasChange("vinses") { + vinses := d.Get("vinses").([]interface{}) + temp := "" + l := len(vinses) + for i, v := range vinses { + s := strconv.Itoa(v.(int)) + if i != (l - 1) { + s += ",\n" + } else { + s += "\n" + } + temp = temp + s + } + temp = "[" + temp + "]" + + urlValues.Add("serviceId", strconv.Itoa(d.Get("service_id").(int))) + urlValues.Add("compgroupId", strconv.Itoa(d.Get("compgroup_id").(int))) + urlValues.Add("vinses", temp) + _, err := c.decortAPICall("POST", bserviceGroupUpdateVinsAPI, urlValues) + if err != nil { + return err + } + + urlValues = &url.Values{} + } + + 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) + + urlValues.Add("serviceId", strconv.Itoa(d.Get("service_id").(int))) + urlValues.Add("compgroupId", strconv.Itoa(d.Get("compgroup_id").(int))) + urlValues.Add("parentId", strconv.Itoa(parentConv)) + + _, err := c.decortAPICall("POST", bserviceGroupParentRemoveAPI, urlValues) + if err != nil { + return err + } + + urlValues = &url.Values{} + } + } + + if len(addedParents) > 0 { + for _, parent := range addedParents { + parentConv := parent.(int) + urlValues.Add("serviceId", strconv.Itoa(d.Get("service_id").(int))) + urlValues.Add("compgroupId", strconv.Itoa(d.Get("compgroup_id").(int))) + urlValues.Add("parentId", strconv.Itoa(parentConv)) + _, err := c.decortAPICall("POST", bserviceGroupParentAddAPI, urlValues) + if err != nil { + return err + } + + urlValues = &url.Values{} + } + } + } + + if d.HasChange("remove_computes") { + rcs := d.Get("remove_computes").([]interface{}) + if len(rcs) > 0 { + for _, rc := range rcs { + urlValues.Add("serviceId", strconv.Itoa(d.Get("service_id").(int))) + urlValues.Add("compgroupId", strconv.Itoa(d.Get("compgroup_id").(int))) + urlValues.Add("computeId", strconv.Itoa(rc.(int))) + + _, err := c.decortAPICall("POST", bserviceGroupComputeRemoveAPI, urlValues) + if err != nil { + return err + } + + urlValues = &url.Values{} + } + } + } + + return nil +} + +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, + 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", + }, + "driver": { + Type: schema.TypeString, + Required: true, + Description: "compute driver like a KVM_X86, KVM_PPC, etc.", + }, + "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, + }, + "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, + }, + "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, + }, + "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, + }, + "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, + }, + "updated_by": { + Type: schema.TypeString, + Computed: true, + }, + "updated_time": { + Type: schema.TypeInt, + Computed: true, + }, + } +} + +func resourceBasicServiceGroup() *schema.Resource { + return &schema.Resource{ + SchemaVersion: 1, + + Create: resourceBasicServiceGroupCreate, + Read: resourceBasicServiceGroupRead, + Update: resourceBasicServiceGroupEdit, + Delete: resourceBasicServiceGroupDelete, + Exists: resourceBasicServiceGroupExists, + + Importer: &schema.ResourceImporter{ + State: schema.ImportStatePassthrough, + }, + + Timeouts: &schema.ResourceTimeout{ + Create: &Timeout60s, + Read: &Timeout30s, + Update: &Timeout60s, + Delete: &Timeout60s, + Default: &Timeout60s, + }, + + Schema: resourceBasicServiceGroupSchemaMake(), + } +} diff --git a/decort/utility_bservicce_deleted_list.go b/decort/utility_bservicce_deleted_list.go new file mode 100644 index 0000000..d52ebee --- /dev/null +++ b/decort/utility_bservicce_deleted_list.go @@ -0,0 +1,67 @@ +/* +Copyright (c) 2019-2022 Digital Energy Cloud Solutions LLC. All Rights Reserved. +Author: Stanislav Solovev, , + +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. +*/ + +/* +This file is part of Terraform (by Hashicorp) provider for Digital Energy Cloud Orchestration +Technology platfom. + +Visit https://github.com/rudecs/terraform-provider-decort for full source code package and updates. +*/ + +package decort + +import ( + "encoding/json" + "net/url" + "strconv" + + log "github.com/sirupsen/logrus" + + "github.com/hashicorp/terraform-plugin-sdk/helper/schema" +) + +func utilityBasicServiceDeletedListCheckPresence(d *schema.ResourceData, m interface{}) (BasicServiceList, error) { + basicServiceDeletedList := BasicServiceList{} + controller := m.(*ControllerCfg) + urlValues := &url.Values{} + + if accountId, ok := d.GetOk("account_id"); ok { + urlValues.Add("accountId", strconv.Itoa(accountId.(int))) + } + if rgId, ok := d.GetOk("rg_id"); ok { + urlValues.Add("rgId", strconv.Itoa(rgId.(int))) + } + if page, ok := d.GetOk("page"); ok { + urlValues.Add("page", strconv.Itoa(page.(int))) + } + if size, ok := d.GetOk("size"); ok { + urlValues.Add("size", strconv.Itoa(size.(int))) + } + + log.Debugf("utilityBasicServiceDeletedListCheckPresence") + basicServiceDeletedListRaw, err := controller.decortAPICall("POST", bserviceListDeletedAPI, urlValues) + if err != nil { + return nil, err + } + + err = json.Unmarshal([]byte(basicServiceDeletedListRaw), &basicServiceDeletedList) + if err != nil { + return nil, err + } + + return basicServiceDeletedList, nil +} diff --git a/decort/utility_bservice.go b/decort/utility_bservice.go new file mode 100644 index 0000000..65c41d8 --- /dev/null +++ b/decort/utility_bservice.go @@ -0,0 +1,60 @@ +/* +Copyright (c) 2019-2022 Digital Energy Cloud Solutions LLC. All Rights Reserved. +Author: Stanislav Solovev, , + +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. +*/ + +/* +This file is part of Terraform (by Hashicorp) provider for Digital Energy Cloud Orchestration +Technology platfom. + +Visit https://github.com/rudecs/terraform-provider-decort for full source code package and updates. +*/ + +package decort + +import ( + "encoding/json" + "net/url" + "strconv" + + log "github.com/sirupsen/logrus" + + "github.com/hashicorp/terraform-plugin-sdk/helper/schema" +) + +func utilityBasicServiceCheckPresence(d *schema.ResourceData, m interface{}) (*BasicServiceExtend, error) { + bservice := &BasicServiceExtend{} + controller := m.(*ControllerCfg) + urlValues := &url.Values{} + + if (strconv.Itoa(d.Get("service_id").(int))) != "0" { + urlValues.Add("serviceId", strconv.Itoa(d.Get("service_id").(int))) + } else { + urlValues.Add("serviceId", d.Id()) + } + + log.Debugf("utilityBasicServiceCheckPresence") + bserviceRaw, err := controller.decortAPICall("POST", bserviceGetAPI, urlValues) + if err != nil { + return nil, err + } + + err = json.Unmarshal([]byte(bserviceRaw), &bservice) + if err != nil { + return nil, err + } + + return bservice, nil +} diff --git a/decort/utility_bservice_group.go b/decort/utility_bservice_group.go new file mode 100644 index 0000000..6f75dc0 --- /dev/null +++ b/decort/utility_bservice_group.go @@ -0,0 +1,61 @@ +/* +Copyright (c) 2019-2022 Digital Energy Cloud Solutions LLC. All Rights Reserved. +Author: Stanislav Solovev, , + +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. +*/ + +/* +This file is part of Terraform (by Hashicorp) provider for Digital Energy Cloud Orchestration +Technology platfom. + +Visit https://github.com/rudecs/terraform-provider-decort for full source code package and updates. +*/ + +package decort + +import ( + "encoding/json" + "net/url" + "strconv" + + log "github.com/sirupsen/logrus" + + "github.com/hashicorp/terraform-plugin-sdk/helper/schema" +) + +func utilityBasicServiceGroupCheckPresence(d *schema.ResourceData, m interface{}) (*BasicServiceGroup, error) { + bserviceGroup := &BasicServiceGroup{} + controller := m.(*ControllerCfg) + urlValues := &url.Values{} + + urlValues.Add("serviceId", strconv.Itoa(d.Get("service_id").(int))) + if (strconv.Itoa(d.Get("compgroup_id").(int))) != "0" { + urlValues.Add("compgroupId", strconv.Itoa(d.Get("compgroup_id").(int))) + } else { + urlValues.Add("compgroupId", d.Id()) + } + + log.Debugf("utilityBasicServiceGroupCheckPresence") + bserviceGroupRaw, err := controller.decortAPICall("POST", bserviceGroupGetAPI, urlValues) + if err != nil { + return nil, err + } + + err = json.Unmarshal([]byte(bserviceGroupRaw), &bserviceGroup) + if err != nil { + return nil, err + } + + return bserviceGroup, nil +} diff --git a/decort/utility_bservice_list.go b/decort/utility_bservice_list.go new file mode 100644 index 0000000..efbe623 --- /dev/null +++ b/decort/utility_bservice_list.go @@ -0,0 +1,67 @@ +/* +Copyright (c) 2019-2022 Digital Energy Cloud Solutions LLC. All Rights Reserved. +Author: Stanislav Solovev, , + +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. +*/ + +/* +This file is part of Terraform (by Hashicorp) provider for Digital Energy Cloud Orchestration +Technology platfom. + +Visit https://github.com/rudecs/terraform-provider-decort for full source code package and updates. +*/ + +package decort + +import ( + "encoding/json" + "net/url" + "strconv" + + log "github.com/sirupsen/logrus" + + "github.com/hashicorp/terraform-plugin-sdk/helper/schema" +) + +func utilityBasicServiceListCheckPresence(d *schema.ResourceData, m interface{}) (BasicServiceList, error) { + basicServiceList := BasicServiceList{} + controller := m.(*ControllerCfg) + urlValues := &url.Values{} + + if accountId, ok := d.GetOk("account_id"); ok { + urlValues.Add("accountId", strconv.Itoa(accountId.(int))) + } + if rgId, ok := d.GetOk("rg_id"); ok { + urlValues.Add("rgId", strconv.Itoa(rgId.(int))) + } + if page, ok := d.GetOk("page"); ok { + urlValues.Add("page", strconv.Itoa(page.(int))) + } + if size, ok := d.GetOk("size"); ok { + urlValues.Add("size", strconv.Itoa(size.(int))) + } + + log.Debugf("utilityBasicServiceListCheckPresence") + basicServiceListRaw, err := controller.decortAPICall("POST", bserviceListAPI, urlValues) + if err != nil { + return nil, err + } + + err = json.Unmarshal([]byte(basicServiceListRaw), &basicServiceList) + if err != nil { + return nil, err + } + + return basicServiceList, nil +} diff --git a/decort/utility_bservice_snapshot_list.go b/decort/utility_bservice_snapshot_list.go new file mode 100644 index 0000000..1f310f3 --- /dev/null +++ b/decort/utility_bservice_snapshot_list.go @@ -0,0 +1,58 @@ +/* +Copyright (c) 2019-2022 Digital Energy Cloud Solutions LLC. All Rights Reserved. +Author: Stanislav Solovev, , + +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. +*/ + +/* +This file is part of Terraform (by Hashicorp) provider for Digital Energy Cloud Orchestration +Technology platfom. + +Visit https://github.com/rudecs/terraform-provider-decort for full source code package and updates. +*/ + +package decort + +import ( + "encoding/json" + "net/url" + "strconv" + + log "github.com/sirupsen/logrus" + + "github.com/hashicorp/terraform-plugin-sdk/helper/schema" +) + +func utilityBasicServiceSnapshotListCheckPresence(d *schema.ResourceData, m interface{}) (BasicServiceSnapshots, error) { + basicServiceSnapshotList := BasicServiceSnapshots{} + controller := m.(*ControllerCfg) + urlValues := &url.Values{} + + if serviceId, ok := d.GetOk("service_id"); ok { + urlValues.Add("serviceId", strconv.Itoa(serviceId.(int))) + } + + log.Debugf("utilityBasicServiceSnapshotListCheckPresence") + basicServiceSnapshotListRaw, err := controller.decortAPICall("POST", bserviceSnapshotListAPI, urlValues) + if err != nil { + return nil, err + } + + err = json.Unmarshal([]byte(basicServiceSnapshotListRaw), &basicServiceSnapshotList) + if err != nil { + return nil, err + } + + return basicServiceSnapshotList, nil +} diff --git a/decort/utility_extnet.go b/decort/utility_extnet.go new file mode 100644 index 0000000..f7cb0b4 --- /dev/null +++ b/decort/utility_extnet.go @@ -0,0 +1,56 @@ +/* +Copyright (c) 2019-2022 Digital Energy Cloud Solutions LLC. All Rights Reserved. +Author: Stanislav Solovev, , + +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. +*/ + +/* +This file is part of Terraform (by Hashicorp) provider for Digital Energy Cloud Orchestration +Technology platfom. + +Visit https://github.com/rudecs/terraform-provider-decort for full source code package and updates. +*/ + +package decort + +import ( + "encoding/json" + "net/url" + "strconv" + + log "github.com/sirupsen/logrus" + + "github.com/hashicorp/terraform-plugin-sdk/helper/schema" +) + +func utilityExtnetCheckPresence(d *schema.ResourceData, m interface{}) (*ExtnetDetailed, error) { + extnet := &ExtnetDetailed{} + controller := m.(*ControllerCfg) + urlValues := &url.Values{} + + urlValues.Add("net_id", strconv.Itoa(d.Get("net_id").(int))) + + log.Debugf("utilityExtnetCheckPresence") + extnetRaw, err := controller.decortAPICall("POST", extnetGetAPI, urlValues) + if err != nil { + return nil, err + } + + err = json.Unmarshal([]byte(extnetRaw), &extnet) + if err != nil { + return nil, err + } + + return extnet, nil +} diff --git a/decort/utility_extnet_computes_list.go b/decort/utility_extnet_computes_list.go new file mode 100644 index 0000000..2f5c629 --- /dev/null +++ b/decort/utility_extnet_computes_list.go @@ -0,0 +1,56 @@ +/* +Copyright (c) 2019-2022 Digital Energy Cloud Solutions LLC. All Rights Reserved. +Author: Stanislav Solovev, , + +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. +*/ + +/* +This file is part of Terraform (by Hashicorp) provider for Digital Energy Cloud Orchestration +Technology platfom. + +Visit https://github.com/rudecs/terraform-provider-decort for full source code package and updates. +*/ + +package decort + +import ( + "encoding/json" + "net/url" + "strconv" + + log "github.com/sirupsen/logrus" + + "github.com/hashicorp/terraform-plugin-sdk/helper/schema" +) + +func utilityExtnetComputesListCheckPresence(d *schema.ResourceData, m interface{}) (ExtnetComputesList, error) { + extnetComputesList := ExtnetComputesList{} + controller := m.(*ControllerCfg) + urlValues := &url.Values{} + + urlValues.Add("accountId", strconv.Itoa(d.Get("account_id").(int))) + + log.Debugf("utilityExtnetComputesListCheckPresence") + extnetComputesListRaw, err := controller.decortAPICall("POST", extnetListComputesAPI, urlValues) + if err != nil { + return nil, err + } + + err = json.Unmarshal([]byte(extnetComputesListRaw), &extnetComputesList) + if err != nil { + return nil, err + } + + return extnetComputesList, nil +} diff --git a/decort/utility_extnet_default.go b/decort/utility_extnet_default.go new file mode 100644 index 0000000..d07f306 --- /dev/null +++ b/decort/utility_extnet_default.go @@ -0,0 +1,46 @@ +/* +Copyright (c) 2019-2022 Digital Energy Cloud Solutions LLC. All Rights Reserved. +Author: Stanislav Solovev, , + +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. +*/ + +/* +This file is part of Terraform (by Hashicorp) provider for Digital Energy Cloud Orchestration +Technology platfom. + +Visit https://github.com/rudecs/terraform-provider-decort for full source code package and updates. +*/ + +package decort + +import ( + "net/url" + + log "github.com/sirupsen/logrus" + + "github.com/hashicorp/terraform-plugin-sdk/helper/schema" +) + +func utilityExtnetDefaultCheckPresence(d *schema.ResourceData, m interface{}) (string, error) { + controller := m.(*ControllerCfg) + urlValues := &url.Values{} + + log.Debugf("utilityExtnetDefaultCheckPresence") + res, err := controller.decortAPICall("POST", extnetGetDefaultAPI, urlValues) + if err != nil { + return "", err + } + + return res, nil +} diff --git a/decort/utility_extnet_list.go b/decort/utility_extnet_list.go new file mode 100644 index 0000000..a0abe60 --- /dev/null +++ b/decort/utility_extnet_list.go @@ -0,0 +1,64 @@ +/* +Copyright (c) 2019-2022 Digital Energy Cloud Solutions LLC. All Rights Reserved. +Author: Stanislav Solovev, , + +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. +*/ + +/* +This file is part of Terraform (by Hashicorp) provider for Digital Energy Cloud Orchestration +Technology platfom. + +Visit https://github.com/rudecs/terraform-provider-decort for full source code package and updates. +*/ + +package decort + +import ( + "encoding/json" + "net/url" + "strconv" + + log "github.com/sirupsen/logrus" + + "github.com/hashicorp/terraform-plugin-sdk/helper/schema" +) + +func utilityExtnetListCheckPresence(d *schema.ResourceData, m interface{}) (ExtnetList, error) { + extnetList := ExtnetList{} + controller := m.(*ControllerCfg) + urlValues := &url.Values{} + + if accountId, ok := d.GetOk("account_id"); ok { + urlValues.Add("accountId", strconv.Itoa(accountId.(int))) + } + if page, ok := d.GetOk("page"); ok { + urlValues.Add("page", strconv.Itoa(page.(int))) + } + if size, ok := d.GetOk("size"); ok { + urlValues.Add("size", strconv.Itoa(size.(int))) + } + + log.Debugf("utilityExtnetListCheckPresence") + extnetListRaw, err := controller.decortAPICall("POST", extnetListAPI, urlValues) + if err != nil { + return nil, err + } + + err = json.Unmarshal([]byte(extnetListRaw), &extnetList) + if err != nil { + return nil, err + } + + return extnetList, nil +} diff --git a/decort/utility_vins_list.go b/decort/utility_vins_list.go new file mode 100644 index 0000000..7bdf083 --- /dev/null +++ b/decort/utility_vins_list.go @@ -0,0 +1,64 @@ +/* +Copyright (c) 2019-2022 Digital Energy Cloud Solutions LLC. All Rights Reserved. +Author: Stanislav Solovev, , + +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. +*/ + +/* +This file is part of Terraform (by Hashicorp) provider for Digital Energy Cloud Orchestration +Technology platfom. + +Visit https://github.com/rudecs/terraform-provider-decort for full source code package and updates. +*/ + +package decort + +import ( + "encoding/json" + "net/url" + "strconv" + + log "github.com/sirupsen/logrus" + + "github.com/hashicorp/terraform-plugin-sdk/helper/schema" +) + +func utilityVinsListCheckPresence(d *schema.ResourceData, m interface{}) (VinsList, error) { + vinsList := VinsList{} + controller := m.(*ControllerCfg) + urlValues := &url.Values{} + + if includeDeleted, ok := d.GetOk("include_deleted"); ok { + urlValues.Add("includeDeleted", strconv.FormatBool(includeDeleted.(bool))) + } + if page, ok := d.GetOk("page"); ok { + urlValues.Add("page", strconv.Itoa(page.(int))) + } + if size, ok := d.GetOk("size"); ok { + urlValues.Add("size", strconv.Itoa(size.(int))) + } + + log.Debugf("utilityVinsListCheckPresence") + vinsListRaw, err := controller.decortAPICall("POST", vinsListAPI, urlValues) + if err != nil { + return nil, err + } + + err = json.Unmarshal([]byte(vinsListRaw), &vinsList) + if err != nil { + return nil, err + } + + return vinsList, nil +} diff --git a/samples/README.md b/samples/README.md index db5b79e..1e8d2a4 100644 --- a/samples/README.md +++ b/samples/README.md @@ -32,6 +32,14 @@ - account_reserved_units - account_templates_list - account_deleted_list + - bservice_list + - bservice + - bservice_group + - extnet_default + - extnet_list + - extnet + - extnet_computes_list + - vins_list - resources: - image - virtual_image @@ -44,6 +52,8 @@ - sep - sep_config - account + - bservice + - bservice_group ## Как пользоваться примерами 1. Установить terraform diff --git a/samples/data_bservice/main.tf b/samples/data_bservice/main.tf new file mode 100644 index 0000000..1b82faf --- /dev/null +++ b/samples/data_bservice/main.tf @@ -0,0 +1,39 @@ +/* +Пример использования +Получение информации о basic service + +*/ +#Расскомментируйте этот код, +#и внесите необходимые правки в версию и путь, +#чтобы работать с установленным вручную (не через hashicorp provider registry) провайдером +/* +terraform { + required_providers { + decort = { + version = "1.1" + source = "digitalenergy.online/decort/decort" + } + } +} +*/ + +provider "decort" { + authenticator = "oauth2" + #controller_url = + controller_url = "https://ds1.digitalenergy.online" + #oauth2_url = + oauth2_url = "https://sso.digitalenergy.online" + allow_unverified_ssl = true +} + +data "decort_bservice" "b" { + #id сервиса + #обязательный параметр + #тип - число + service_id = 11111 + +} + +output "test" { + value = data.decort_bservice.b +} diff --git a/samples/data_bservice_deleted_list/main.tf b/samples/data_bservice_deleted_list/main.tf new file mode 100644 index 0000000..6a0a7d6 --- /dev/null +++ b/samples/data_bservice_deleted_list/main.tf @@ -0,0 +1,57 @@ +/* +Пример использования +Получение списка удаленных basic service +*/ +#Расскомментируйте этот код, +#и внесите необходимые правки в версию и путь, +#чтобы работать с установленным вручную (не через hashicorp provider registry) провайдером +/* +terraform { + required_providers { + decort = { + version = "1.1" + source = "digitalenergy.online/decort/decort" + } + } +} +*/ + +provider "decort" { + authenticator = "oauth2" + #controller_url = + controller_url = "https://ds1.digitalenergy.online" + #oauth2_url = + oauth2_url = "https://sso.digitalenergy.online" + allow_unverified_ssl = true +} + +data "decort_bservice_deleted_list" "bsdl" { + #id аккаунта для фильтрации данных + #опциональный параметр + #тип - число + #если не задан - выводятся все доступные данные + #account_id = 11111 + + #id ресурсной группы, используется для фильтрации + #опциональный параметр + #тип - число + #если не задан - выводятся все доступные данные + #rg_id = 11111 + + #номер страницы для отображения + #опциональный параметр + #тип - число + #если не задан - выводятся все доступные данные + #page = 2 + + #размер страницы + #опциональный параметр + #тип - число + #если не задан - выводятся все доступные данные + #size = 3 + +} + +output "test" { + value = data.decort_bservice_deleted_list.bsdl +} diff --git a/samples/data_bservice_group/main.tf b/samples/data_bservice_group/main.tf new file mode 100644 index 0000000..d859c3e --- /dev/null +++ b/samples/data_bservice_group/main.tf @@ -0,0 +1,44 @@ +/* +Пример использования +Получение информации о вычислительной группе, принадлежащей basic service + +*/ +#Расскомментируйте этот код, +#и внесите необходимые правки в версию и путь, +#чтобы работать с установленным вручную (не через hashicorp provider registry) провайдером +/* +terraform { + required_providers { + decort = { + version = "1.1" + source = "digitalenergy.online/decort/decort" + } + } +} +*/ + +provider "decort" { + authenticator = "oauth2" + #controller_url = + controller_url = "https://ds1.digitalenergy.online" + #oauth2_url = + oauth2_url = "https://sso.digitalenergy.online" + allow_unverified_ssl = true +} + +data "decort_bservice_group" "bsg" { + #id сервиса + #обязательный параметр + #тип - число + service_id = 11111 + + #id вычислительной группы + #обязательный параметр + #тип - число + compgroup_id = 12121 + +} + +output "test" { + value = data.decort_bservice_group.bsg +} diff --git a/samples/data_bservice_list/main.tf b/samples/data_bservice_list/main.tf new file mode 100644 index 0000000..c87579c --- /dev/null +++ b/samples/data_bservice_list/main.tf @@ -0,0 +1,58 @@ +/* +Пример использования +Получение списка доступных базовых сервисов + +*/ +#Расскомментируйте этот код, +#и внесите необходимые правки в версию и путь, +#чтобы работать с установленным вручную (не через hashicorp provider registry) провайдером +/* +terraform { + required_providers { + decort = { + version = "1.1" + source = "digitalenergy.online/decort/decort" + } + } +} +*/ + +provider "decort" { + authenticator = "oauth2" + #controller_url = + controller_url = "https://ds1.digitalenergy.online" + #oauth2_url = + oauth2_url = "https://sso.digitalenergy.online" + allow_unverified_ssl = true +} + +data "decort_bservice_list" "bsl" { + #id аккаунта для фильтрации данных + #опциональный параметр + #тип - число + #если не задан - выводятся все доступные данные + #account_id = 11111 + + #id ресурсной группы, используется для фильтрации + #опциональный параметр + #тип - число + #если не задан - выводятся все доступные данные + #rg_id = 11111 + + #номер страницы для отображения + #опциональный параметр + #тип - число + #если не задан - выводятся все доступные данные + #page = 2 + + #размер страницы + #опциональный параметр + #тип - число + #если не задан - выводятся все доступные данные + #size = 3 + +} + +output "test" { + value = data.decort_bservice_list.bsl +} diff --git a/samples/data_bservice_snapshot_list/main.tf b/samples/data_bservice_snapshot_list/main.tf new file mode 100644 index 0000000..96cb9c5 --- /dev/null +++ b/samples/data_bservice_snapshot_list/main.tf @@ -0,0 +1,39 @@ +/* +Пример использования +Получение списка снимков состояний basic service + +*/ +#Расскомментируйте этот код, +#и внесите необходимые правки в версию и путь, +#чтобы работать с установленным вручную (не через hashicorp provider registry) провайдером +/* +terraform { + required_providers { + decort = { + version = "1.1" + source = "digitalenergy.online/decort/decort" + } + } +} +*/ + + +provider "decort" { + authenticator = "oauth2" + #controller_url = + controller_url = "https://ds1.digitalenergy.online" + #oauth2_url = + oauth2_url = "https://sso.digitalenergy.online" + allow_unverified_ssl = true +} + +data "decort_bservice_snapshot_list" "bsl" { + #id back service + #обязательный параметр + #тип - число + service_id = 11111 +} + +output "test" { + value = data.decort_bservice_snapshot_list.bsl +} diff --git a/samples/data_extnet/main.tf b/samples/data_extnet/main.tf new file mode 100644 index 0000000..2694c76 --- /dev/null +++ b/samples/data_extnet/main.tf @@ -0,0 +1,38 @@ +/* +Пример использования +Получение информации о сети +*/ +#Расскомментируйте этот код, +#и внесите необходимые правки в версию и путь, +#чтобы работать с установленным вручную (не через hashicorp provider registry) провайдером +/* +terraform { + required_providers { + decort = { + version = "1.1" + source = "digitalenergy.online/decort/decort" + } + } +} +*/ + + +provider "decort" { + authenticator = "oauth2" + #controller_url = + controller_url = "https://ds1.digitalenergy.online" + #oauth2_url = + oauth2_url = "https://sso.digitalenergy.online" + allow_unverified_ssl = true +} + +data "decort_extnet" "e" { + #идентификатор сети + #обязательный параметр + #тип - число + net_id = 1111 +} + +output "test" { + value = data.decort_extnet.e +} diff --git a/samples/data_extnet_computes_list/main.tf b/samples/data_extnet_computes_list/main.tf new file mode 100644 index 0000000..1879d37 --- /dev/null +++ b/samples/data_extnet_computes_list/main.tf @@ -0,0 +1,37 @@ +/* +Пример использования +Получение информации о вычислительных ресурсах, использующих сеть аккаунта +*/ +#Расскомментируйте этот код, +#и внесите необходимые правки в версию и путь, +#чтобы работать с установленным вручную (не через hashicorp provider registry) провайдером +/* +terraform { + required_providers { + decort = { + version = "1.1" + source = "digitalenergy.online/decort/decort" + } + } +} +*/ + +provider "decort" { + authenticator = "oauth2" + #controller_url = + controller_url = "https://ds1.digitalenergy.online" + #oauth2_url = + oauth2_url = "https://sso.digitalenergy.online" + allow_unverified_ssl = true +} + +data "decort_extnet_computes_list" "ecl" { + #идентификатор аккаунта + #обязательный параметр + #тип - число + account_id = 1111 +} + +output "test" { + value = data.decort_extnet_computes_list.ecl +} diff --git a/samples/data_extnet_default/main.tf b/samples/data_extnet_default/main.tf new file mode 100644 index 0000000..cf91c79 --- /dev/null +++ b/samples/data_extnet_default/main.tf @@ -0,0 +1,36 @@ +/* +Пример использования +Получение информации о сети по-умолчанию + +*/ +#Расскомментируйте этот код, +#и внесите необходимые правки в версию и путь, +#чтобы работать с установленным вручную (не через hashicorp provider registry) провайдером +/* +terraform { + required_providers { + decort = { + version = "1.1" + source = "digitalenergy.online/decort/decort" + } + } +} +*/ + + +provider "decort" { + authenticator = "oauth2" + #controller_url = + controller_url = "https://ds1.digitalenergy.online" + #oauth2_url = + oauth2_url = "https://sso.digitalenergy.online" + allow_unverified_ssl = true +} + +data "decort_extnet_default" "ed" { + +} + +output "test" { + value = data.decort_extnet_default.ed +} diff --git a/samples/data_extnet_list/main.tf b/samples/data_extnet_list/main.tf new file mode 100644 index 0000000..355a699 --- /dev/null +++ b/samples/data_extnet_list/main.tf @@ -0,0 +1,48 @@ +/* +Пример использования +Получение списка сетей + +*/ +#Расскомментируйте этот код, +#и внесите необходимые правки в версию и путь, +#чтобы работать с установленным вручную (не через hashicorp provider registry) провайдером +/* +terraform { + required_providers { + decort = { + version = "1.1" + source = "digitalenergy.online/decort/decort" + } + } +} +*/ + +provider "decort" { + authenticator = "oauth2" + #controller_url = + controller_url = "https://ds1.digitalenergy.online" + #oauth2_url = + oauth2_url = "https://sso.digitalenergy.online" + allow_unverified_ssl = true +} + +data "decort_extnet_list" "el" { + #id аккаунта для фильтрации результата + #необязательный параметр + #тип - число + #account_id = 1111111 + + #кол-во страниц для вывода + #опицональный параметр + #тип - число + #page = 1 + + #размер страницы + #опицональный параметр + #тип - число + #size = 1 +} + +output "test" { + value = data.decort_extnet_list.el +} diff --git a/samples/data_vins_list/main.tf b/samples/data_vins_list/main.tf new file mode 100644 index 0000000..0f44b92 --- /dev/null +++ b/samples/data_vins_list/main.tf @@ -0,0 +1,51 @@ +/* +Пример использования +Получение списка vins +*/ +#Расскомментируйте этот код, +#и внесите необходимые правки в версию и путь, +#чтобы работать с установленным вручную (не через hashicorp provider registry) провайдером +/* +terraform { + required_providers { + decort = { + version = "1.1" + source = "digitalenergy.online/decort/decort" + } + } +} +*/ + +provider "decort" { + authenticator = "oauth2" + #controller_url = + controller_url = "https://ds1.digitalenergy.online" + #oauth2_url = + oauth2_url = "https://sso.digitalenergy.online" + allow_unverified_ssl = true +} + +data "decort_vins_list" "vl" { + #включение удаленных vins в результат + #опциональный параметр + #тип - будев тип + #если не задан - выводятся все неудаленные данные + #include_deleted = true + + #номер страницы для отображения + #опциональный параметр + #тип - число + #если не задан - выводятся все доступные данные + #page = 1 + + #размер страницы + #опциональный параметр + #тип - число + #если не задан - выводятся все доступные данные + #size = 1 + +} + +output "test" { + value = data.decort_vins_list.vl +} diff --git a/samples/resource_bservice/main.tf b/samples/resource_bservice/main.tf new file mode 100644 index 0000000..b2b592a --- /dev/null +++ b/samples/resource_bservice/main.tf @@ -0,0 +1,110 @@ +/* +Пример использования +Ресурса cdrom image +Ресурс позволяет: +1. Создавать basic service +2. Редактировать basic service +3. Удалять basic service +4. Создавать снимки состояний basic service +5. Совершать восстановление по снимкам состояний +6. Удалять снимки состояний + +*/ +#Расскомментируйте этот код, +#и внесите необходимые правки в версию и путь, +#чтобы работать с установленным вручную (не через hashicorp provider registry) провайдером +/* +terraform { + required_providers { + decort = { + version = "1.1" + source = "digitalenergy.online/decort/decort" + } + } +} +*/ + +provider "decort" { + authenticator = "oauth2" + #controller_url = + controller_url = "https://ds1.digitalenergy.online" + #oauth2_url = + oauth2_url = "https://sso.digitalenergy.online" + allow_unverified_ssl = true +} + +resource "decort_bservice" "b" { + #имя сервиса + #обязательный параметр + #тип - строка + service_name = "my_test_bservice_sn" + + #id ресурсной группы + #обязательный параметр + #тип - число + rg_id = 11111 + + #доступность сервиса + #необязательный параметр + #тип - булев тип + #используется при редактировании ресурса + #по-умолачанию - false + #enable = true + + #снимок состояния + #необязательный параметр + #тип - объект + #используется при редактировании ресурса + #может быть несколько в ресурсе + /* + snapshots { + #имя снимка состояния + #обязательный параметр + #тип - строка + label = "test_snapshot" + + #восстановление сервиса из снимка состояния + #необязательный параметр + #тип - булев тип + #по-умолчанию - false + #восстановление происходит только при переключении с false на true + rollback = false + } + snapshots { + label = "test_snapshot_1" + } + */ + + #старт сервиса + #необязательный параметр + #тип - булев тип + #используется при редактировании ресурса + #по-умолачанию - false + #start = false + + #восстановление сервиса после удаления + #необязательный параметр + #тип - булев тип + #используется при редактировании ресурса + #по-умолачанию - false + #restore = true + + #мгновенное удаление сервиса без права восстановления + #необязательный параметр + #тип - булев тип + #используется при удалении ресурса + #по-умолачанию - false + #permanently = true + + #id сервиса, позволяет сформировать .tfstate, если сервис есть в платформе + #необязательный параметр + #тип - булев тип + #используется при создании ресурса + #service_id = 11111 + + +} + +output "test" { + value = decort_bservice.b +} diff --git a/samples/resource_bservice_group/main.tf b/samples/resource_bservice_group/main.tf new file mode 100644 index 0000000..70cb5ad --- /dev/null +++ b/samples/resource_bservice_group/main.tf @@ -0,0 +1,150 @@ +/* +Пример использования +Работы с ресурсом basic service group +Ресурс позволяет: +1. Создавать группы +2. Редактировать группы +3. Удалять группы +*/ +#Расскомментируйте этот код, +#и внесите необходимые правки в версию и путь, +#чтобы работать с установленным вручную (не через hashicorp provider registry) провайдером +/* +terraform { + required_providers { + decort = { + version = "1.1" + source = "digitalenergy.online/decort/decort" + } + } +} +*/ + +provider "decort" { + authenticator = "oauth2" + #controller_url = + controller_url = "https://ds1.digitalenergy.online" + #oauth2_url = + oauth2_url = "https://sso.digitalenergy.online" + allow_unverified_ssl = true +} + +resource "decort_bservice_group" "bsg" { + #id back service + #обязательный параметр + #тип - число + service_id = 444444 + + #название группы + #обязательный параметр + #тип - строка + compgroup_name = "tf_group_rename" + + #id группы + #необязательный параметр + #тип - число + #применяется при редактировании группы, либо при создании .tfstate - файла, если группа имеется в плафторме + compgroup_id = 33333 + + #кол-во вычислительных ресурсов + #обязательный параметр + #тип - число + #используется так же для редактирования группы + comp_count = 1 + + #кол-во ядер на выч. ресурс + #обязательный параметр + #тип - число + #используется так же для редактирования группы + cpu = 2 + + #кол-во оперативной памяти на выч. ресурс, в МБ + #обязательный параметр + #тип - число + #используется так же для редактирования группы + ram = 256 + + #размер диска для выч. ресурса, в ГБ + #обязательный параметр + #тип - число + #используется так же для редактирования группы + disk = 11 + + #id образа диска + #обязательный параметр + #тип - число + image_id = 2222 + + #драйвер + #обязательный параметр + #тип - число + driver = "kvm_x86" + + #id сетей extnet + #обязательный параметр + #тип - массив чисел + #должен быть использован vins или extnets + extnets = [1111] + + #id сетей vinses + #обязательный параметр + #тип - массив чисел + #должен быть использован vins или extnets + #vinses = [1111, 2222] + + #время таймуата перед стартом + #необязательный параметр + #тип - число + #используется при создании ресурса + #timeout_start = 0 + + #тег группы + #необязательный параметр + #тип - строка + #используется при создании и редактировании ресурса + # role = "tf_test_changed" + + #id групп родителей + #необязательный параметр + #тип - массив чисел + #используется при редактировании ресурса + #parents = [] + + #принудительное обновление параметров выч. мощностей (ram,disk,cpu) и имени группы + #необязательный параметр + #тип - булев тип + #используется при редактировании + #force_update = true + + #старт/стоп вычислительных мощностей + #необязательный параметр + #тип - булев тип + #используется при редактировании + #по-умолчанию - false + #start = false + + #принудительная остановка вычислительных мощностей + #необязательный параметр + #тип - булев тип + #используется при редактировании и остановке группы + #по-умолчанию - false + #force_stop = false + + #удаление вычислительных мощностей + #необязательный параметр + #тип - массив чисел + #используется при редактировании + #remove_computes = [32287] + + #режим увеличения числа выч. мощностей + #необязательный параметр + #тип - число + #используется в связке с comp_count при редактировании группы + #возможные варианты - RELATIVE и ABSOLUTE + #mode = "RELATIVE" + +} + +output "test" { + value = decort_bservice_group.bsg +}