diff --git a/alicloud/data_source_alicloud_ess_scaling_rules.go b/alicloud/data_source_alicloud_ess_scaling_rules.go new file mode 100644 index 000000000000..89a99ccf6bb9 --- /dev/null +++ b/alicloud/data_source_alicloud_ess_scaling_rules.go @@ -0,0 +1,294 @@ +package alicloud + +import ( + "encoding/json" + "fmt" + "github.com/PaesslerAG/jsonpath" + util "github.com/alibabacloud-go/tea-utils/service" + "regexp" + + "github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests" + "github.com/aliyun/terraform-provider-alicloud/alicloud/connectivity" + "github.com/hashicorp/terraform-plugin-sdk/helper/schema" + "github.com/hashicorp/terraform-plugin-sdk/helper/validation" +) + +func dataSourceAliCloudEssScalingRules() *schema.Resource { + return &schema.Resource{ + Read: dataSourceAliCloudEssScalingRulesRead, + Schema: map[string]*schema.Schema{ + "scaling_group_id": { + Type: schema.TypeString, + Optional: true, + ForceNew: true, + }, + "name_regex": { + Type: schema.TypeString, + Optional: true, + ValidateFunc: validation.ValidateRegexp, + ForceNew: true, + }, + "ids": { + Type: schema.TypeList, + Optional: true, + Elem: &schema.Schema{Type: schema.TypeString}, + Computed: true, + ForceNew: true, + }, + "type": { + Type: schema.TypeString, + Optional: true, + ForceNew: true, + }, + "output_file": { + Type: schema.TypeString, + Optional: true, + ForceNew: true, + }, + "names": { + Type: schema.TypeList, + Computed: true, + Elem: &schema.Schema{Type: schema.TypeString}, + }, + "rules": { + Type: schema.TypeList, + Computed: true, + Elem: &schema.Resource{ + Schema: map[string]*schema.Schema{ + "id": { + Type: schema.TypeString, + Computed: true, + }, + "scaling_group_id": { + Type: schema.TypeString, + Computed: true, + }, + "name": { + Type: schema.TypeString, + Computed: true, + }, + "type": { + Type: schema.TypeString, + Computed: true, + }, + "cooldown": { + Type: schema.TypeInt, + Computed: true, + }, + "predictive_scaling_mode": { + Type: schema.TypeString, + Computed: true, + }, + "initial_max_size": { + Type: schema.TypeInt, + Computed: true, + }, + "predictive_value_behavior": { + Type: schema.TypeString, + Computed: true, + }, + "predictive_value_buffer": { + Type: schema.TypeInt, + Computed: true, + }, + "predictive_task_buffer_time": { + Type: schema.TypeInt, + Computed: true, + }, + "target_value": { + Type: schema.TypeFloat, + Computed: true, + }, + "metric_name": { + Type: schema.TypeString, + Computed: true, + }, + "adjustment_type": { + Type: schema.TypeString, + Computed: true, + }, + "adjustment_value": { + Type: schema.TypeInt, + Computed: true, + }, + "min_adjustment_magnitude": { + Type: schema.TypeInt, + Computed: true, + }, + "scaling_rule_ari": { + Type: schema.TypeString, + Computed: true, + }, + }, + }, + }, + }, + } +} + +func dataSourceAliCloudEssScalingRulesRead(d *schema.ResourceData, meta interface{}) error { + client := meta.(*connectivity.AliyunClient) + var response map[string]interface{} + conn, err := client.NewEssClient() + if err != nil { + return WrapError(err) + } + request := map[string]interface{}{ + "PageSize": requests.NewInteger(PageSizeLarge), + "PageNumber": requests.NewInteger(1), + "RegionId": client.RegionId, + } + + if scalingGroupId, ok := d.GetOk("scaling_group_id"); ok && scalingGroupId.(string) != "" { + request["ScalingGroupId"] = scalingGroupId.(string) + } + + if ruleType, ok := d.GetOk("type"); ok && ruleType.(string) != "" { + request["ScalingRuleType"] = ruleType.(string) + } + + var allScalingRules []interface{} + + for { + runtime := util.RuntimeOptions{} + runtime.SetAutoretry(true) + response, err = conn.DoRequest(StringPointer("DescribeScalingRules"), nil, StringPointer("POST"), StringPointer("2014-08-28"), StringPointer("AK"), nil, request, &runtime) + if err != nil { + return WrapErrorf(err, DataDefaultErrorMsg, "alicloud_ess_scaling_rules", "DescribeScalingRules", AlibabaCloudSdkGoERROR) + } + addDebug("DescribeScalingRules", response, request, request) + w, errInfo := jsonpath.Get("$.TotalCount", response) + if errInfo != nil { + return WrapErrorf(err, FailedGetAttributeMsg, "$.TotalCount", response) + } + i, errConvert := w.(json.Number).Int64() + if errConvert != nil { + return WrapErrorf(err, "Convert resource %s attribute failed!!! Response: %v.", "TotalCount", response) + } + if int(i) < 1 { + break + } + v, err := jsonpath.Get("$.ScalingRules.ScalingRule", response) + if err != nil { + return WrapErrorf(err, FailedGetAttributeMsg, "$.ScalingRules.ScalingRule", response) + } + if len(v.([]interface{})) < 1 { + break + } + allScalingRules = append(allScalingRules, v.([]interface{})...) + + if len(v.([]interface{})) < PageSizeLarge { + break + } + + if page, err := getNextpageNumber(requests.Integer(fmt.Sprint(request["PageNumber"]))); err != nil { + return err + } else { + request["PageNumber"] = page + } + } + + var filteredScalingRulesTemp []interface{} + + nameRegex, okNameRegex := d.GetOk("name_regex") + idsMap := make(map[string]string) + ids, okIds := d.GetOk("ids") + if okIds { + for _, i := range ids.([]interface{}) { + if i == nil { + continue + } + idsMap[i.(string)] = i.(string) + } + } + + if okNameRegex || okIds { + for _, rule := range allScalingRules { + var object map[string]interface{} + object = rule.(map[string]interface{}) + if okNameRegex && nameRegex != "" { + r, err := regexp.Compile(nameRegex.(string)) + if err != nil { + return WrapError(err) + } + if r != nil && !r.MatchString(object["ScalingRuleName"].(string)) { + continue + } + } + if okIds && len(idsMap) > 0 { + if _, ok := idsMap[object["ScalingRuleId"].(string)]; !ok { + continue + } + } + filteredScalingRulesTemp = append(filteredScalingRulesTemp, rule) + } + } else { + filteredScalingRulesTemp = allScalingRules + } + return scalingRulesDescriptionAttribute(d, filteredScalingRulesTemp, meta) +} + +func scalingRulesDescriptionAttribute(d *schema.ResourceData, scalingRules []interface{}, meta interface{}) error { + var ids []string + var names []string + var s = make([]map[string]interface{}, 0) + for _, scalingRule := range scalingRules { + var object map[string]interface{} + object = scalingRule.(map[string]interface{}) + mapping := map[string]interface{}{ + "id": object["ScalingRuleId"], + "scaling_group_id": object["ScalingGroupId"], + "name": object["ScalingRuleName"], + "type": object["ScalingRuleType"], + "adjustment_type": object["AdjustmentType"], + "adjustment_value": object["AdjustmentValue"], + "scaling_rule_ari": object["ScalingRuleAri"], + } + if object["MetricName"] != nil { + mapping["metric_name"] = object["MetricName"] + } + if object["TargetValue"] != nil { + mapping["target_value"] = object["TargetValue"] + } + if object["PredictiveTaskBufferTime"] != nil { + mapping["predictive_task_buffer_time"] = object["PredictiveTaskBufferTime"] + } + if object["PredictiveValueBuffer"] != nil { + mapping["predictive_value_buffer"] = object["PredictiveValueBuffer"] + } + if object["PredictiveValueBehavior"] != nil { + mapping["predictive_value_behavior"] = object["PredictiveValueBehavior"] + } + if object["InitialMaxSize"] != nil { + mapping["initial_max_size"] = object["InitialMaxSize"] + } + if object["PredictiveScalingMode"] != nil { + mapping["predictive_scaling_mode"] = object["PredictiveScalingMode"] + } + if object["Cooldown"] != nil { + mapping["cooldown"] = object["Cooldown"] + } + if object["MinAdjustmentMagnitude"] != nil { + mapping["min_adjustment_magnitude"] = object["MinAdjustmentMagnitude"] + } + ids = append(ids, object["ScalingRuleId"].(string)) + names = append(names, object["ScalingRuleName"].(string)) + s = append(s, mapping) + } + d.SetId(dataResourceIdHash(ids)) + if err := d.Set("rules", s); err != nil { + return WrapError(err) + } + + if err := d.Set("ids", ids); err != nil { + return WrapError(err) + } + + if err := d.Set("names", names); err != nil { + return WrapError(err) + } + if output, ok := d.GetOk("output_file"); ok && output.(string) != "" { + writeToFile(output.(string), s) + } + return nil +} diff --git a/alicloud/data_source_alicloud_ess_scaling_rules_test.go b/alicloud/data_source_alicloud_ess_scaling_rules_test.go new file mode 100644 index 000000000000..7616a09b975b --- /dev/null +++ b/alicloud/data_source_alicloud_ess_scaling_rules_test.go @@ -0,0 +1,370 @@ +package alicloud + +import ( + "fmt" + "strings" + "testing" +) + +func TestAccAliCloudEssScalingrulesDataSource(t *testing.T) { + + idsConf := dataSourceTestAccConfig{ + existConfig: testAccCheckAliCloudEssScalingrulesDataSourceConfig(map[string]string{ + "ids": `["${alicloud_ess_scaling_rule.default.id}"]`, + }), + fakeConfig: testAccCheckAliCloudEssScalingrulesDataSourceConfig(map[string]string{ + "ids": `["${alicloud_ess_scaling_rule.default.id}_fake"]`, + }), + } + + scalingGroupIdConf := dataSourceTestAccConfig{ + existConfig: testAccCheckAliCloudEssScalingrulesDataSourceConfig(map[string]string{ + "scaling_group_id": `"${alicloud_ess_scaling_rule.default.scaling_group_id}"`, + }), + fakeConfig: testAccCheckAliCloudEssScalingrulesDataSourceConfig(map[string]string{ + "scaling_group_id": `"${alicloud_ess_scaling_rule.default.scaling_group_id}_fake"`, + }), + } + + typeConf := dataSourceTestAccConfig{ + existConfig: testAccCheckAliCloudEssScalingrulesDataSourceConfig(map[string]string{ + "scaling_group_id": `"${alicloud_ess_scaling_rule.default.scaling_group_id}"`, + "type": `"SimpleScalingRule"`, + }), + fakeConfig: testAccCheckAliCloudEssScalingrulesDataSourceConfig(map[string]string{ + "scaling_group_id": `"${alicloud_ess_scaling_rule.default.scaling_group_id}_fake"`, + "type": `"TargetTrackingScalingRule"`, + }), + } + + nameRegexConf := dataSourceTestAccConfig{ + existConfig: testAccCheckAliCloudEssScalingrulesDataSourceConfig(map[string]string{ + "name_regex": `"${alicloud_ess_scaling_rule.default.scaling_rule_name}"`, + }), + fakeConfig: testAccCheckAliCloudEssScalingrulesDataSourceConfig(map[string]string{ + "name_regex": `"${alicloud_ess_scaling_rule.default.scaling_rule_name}_fake"`, + }), + } + + allConf := dataSourceTestAccConfig{ + existConfig: testAccCheckAliCloudEssScalingrulesDataSourceConfig(map[string]string{ + "ids": `["${alicloud_ess_scaling_rule.default.id}"]`, + "scaling_group_id": `"${alicloud_ess_scaling_rule.default.scaling_group_id}"`, + "type": `"SimpleScalingRule"`, + "name_regex": `"${alicloud_ess_scaling_rule.default.scaling_rule_name}"`, + }), + fakeConfig: testAccCheckAliCloudEssScalingrulesDataSourceConfig(map[string]string{ + "ids": `["${alicloud_ess_scaling_rule.default.id}"]`, + "scaling_group_id": `"${alicloud_ess_scaling_rule.default.scaling_group_id}_fake"`, + "type": `"SimpleScalingRule"`, + "name_regex": `"${alicloud_ess_scaling_rule.default.scaling_rule_name}"`, + }), + } + + var existEssRecordsMapFunc = func(rand int) map[string]string { + return map[string]string{ + "rules.#": "1", + "ids.#": "1", + "names.#": "1", + "rules.0.id": CHECKSET, + "rules.0.scaling_group_id": CHECKSET, + "rules.0.name": CHECKSET, + "rules.0.type": CHECKSET, + "rules.0.cooldown": "30", + "rules.0.adjustment_type": "PercentChangeInCapacity", + "rules.0.adjustment_value": "1", + "rules.0.min_adjustment_magnitude": "1", + "rules.0.scaling_rule_ari": CHECKSET, + } + } + + var fakeEssRecordsMapFunc = func(rand int) map[string]string { + return map[string]string{ + "rules.#": "0", + "ids.#": "0", + "names.#": "0", + } + } + + var EssScalingrulesRecordsCheckInfo = dataSourceAttr{ + resourceId: "data.alicloud_ess_scaling_rules.default", + existMapFunc: existEssRecordsMapFunc, + fakeMapFunc: fakeEssRecordsMapFunc, + } + + EssScalingrulesRecordsCheckInfo.dataSourceTestCheck(t, -1, idsConf, scalingGroupIdConf, typeConf, nameRegexConf, allConf) +} + +func TestAccAliCloudEssScalingrulesDataSourcePredictiveRule(t *testing.T) { + + idsConf := dataSourceTestAccConfig{ + existConfig: testAccCheckAliCloudEssScalingrulesDataSourcePredictiveRuleConfig(map[string]string{ + "ids": `["${alicloud_ess_scaling_rule.default.id}"]`, + }), + fakeConfig: testAccCheckAliCloudEssScalingrulesDataSourcePredictiveRuleConfig(map[string]string{ + "ids": `["${alicloud_ess_scaling_rule.default.id}_fake"]`, + }), + } + + scalingGroupIdConf := dataSourceTestAccConfig{ + existConfig: testAccCheckAliCloudEssScalingrulesDataSourcePredictiveRuleConfig(map[string]string{ + "scaling_group_id": `"${alicloud_ess_scaling_rule.default.scaling_group_id}"`, + }), + fakeConfig: testAccCheckAliCloudEssScalingrulesDataSourcePredictiveRuleConfig(map[string]string{ + "scaling_group_id": `"${alicloud_ess_scaling_rule.default.scaling_group_id}_fake"`, + }), + } + typeConf := dataSourceTestAccConfig{ + existConfig: testAccCheckAliCloudEssScalingrulesDataSourcePredictiveRuleConfig(map[string]string{ + "scaling_group_id": `"${alicloud_ess_scaling_rule.default.scaling_group_id}"`, + "type": `"PredictiveScalingRule"`, + }), + fakeConfig: testAccCheckAliCloudEssScalingrulesDataSourcePredictiveRuleConfig(map[string]string{ + "scaling_group_id": `"${alicloud_ess_scaling_rule.default.scaling_group_id}_fake"`, + "type": `"TargetTrackingScalingRule"`, + }), + } + nameRegexConf := dataSourceTestAccConfig{ + existConfig: testAccCheckAliCloudEssScalingrulesDataSourcePredictiveRuleConfig(map[string]string{ + "name_regex": `"${alicloud_ess_scaling_rule.default.scaling_rule_name}"`, + }), + fakeConfig: testAccCheckAliCloudEssScalingrulesDataSourcePredictiveRuleConfig(map[string]string{ + "name_regex": `"${alicloud_ess_scaling_rule.default.scaling_rule_name}_fake"`, + }), + } + + allConf := dataSourceTestAccConfig{ + existConfig: testAccCheckAliCloudEssScalingrulesDataSourcePredictiveRuleConfig(map[string]string{ + "ids": `["${alicloud_ess_scaling_rule.default.id}"]`, + "scaling_group_id": `"${alicloud_ess_scaling_rule.default.scaling_group_id}"`, + "type": `"PredictiveScalingRule"`, + "name_regex": `"${alicloud_ess_scaling_rule.default.scaling_rule_name}"`, + }), + fakeConfig: testAccCheckAliCloudEssScalingrulesDataSourcePredictiveRuleConfig(map[string]string{ + "ids": `["${alicloud_ess_scaling_rule.default.id}"]`, + "scaling_group_id": `"${alicloud_ess_scaling_rule.default.scaling_group_id}_fake"`, + "type": `"SimpleScalingRule"`, + "name_regex": `"${alicloud_ess_scaling_rule.default.scaling_rule_name}"`, + }), + } + + var existEssRecordsMapFunc = func(rand int) map[string]string { + return map[string]string{ + "rules.#": "1", + "ids.#": "1", + "names.#": "1", + "rules.0.id": CHECKSET, + "rules.0.scaling_group_id": CHECKSET, + "rules.0.name": CHECKSET, + "rules.0.type": CHECKSET, + "rules.0.predictive_task_buffer_time": "0", + "rules.0.target_value": "20.1", + "rules.0.predictive_value_behavior": "MaxOverridePredictiveValue", + "rules.0.predictive_scaling_mode": "PredictAndScale", + "rules.0.metric_name": "CpuUtilization", + "rules.0.predictive_value_buffer": "0", + "rules.0.initial_max_size": "1", + "rules.0.scaling_rule_ari": CHECKSET, + } + } + + var fakeEssRecordsMapFunc = func(rand int) map[string]string { + return map[string]string{ + "rules.#": "0", + "ids.#": "0", + "names.#": "0", + } + } + + var EssScalingrulesRecordsCheckInfo = dataSourceAttr{ + resourceId: "data.alicloud_ess_scaling_rules.default", + existMapFunc: existEssRecordsMapFunc, + fakeMapFunc: fakeEssRecordsMapFunc, + } + + EssScalingrulesRecordsCheckInfo.dataSourceTestCheck(t, -1, idsConf, scalingGroupIdConf, typeConf, nameRegexConf, allConf) +} + +func testAccCheckAliCloudEssScalingrulesDataSourcePredictiveRuleConfig(attrMap map[string]string) string { + var pairs []string + for k, v := range attrMap { + pairs = append(pairs, k+" = "+v) + } + + config := fmt.Sprintf(` + +variable "name" { + default = "tf-testAccDataSourceEssScalingPredictiveRules" +} + +data "alicloud_zones" "default" { + available_disk_category = "cloud_efficiency" + available_resource_creation = "VSwitch" +} + +data "alicloud_instance_types" "default" { + availability_zone = "${data.alicloud_zones.default.zones.0.id}" + cpu_core_count = 2 + memory_size = 4 +} + +data "alicloud_images" "default" { + name_regex = "^ubuntu_[0-9]+_[0-9]+_x64*" + most_recent = true + owners = "system" +} + +data "alicloud_vpcs" "default" { + +} +data "alicloud_vswitches" "default" { + vpc_id = data.alicloud_vpcs.default.ids.0 + zone_id = data.alicloud_zones.default.zones.0.id +} + +resource "alicloud_vswitch" "vswitch" { + count = length(data.alicloud_vswitches.default.ids) > 0 ? 0 : 1 + vpc_id = data.alicloud_vpcs.default.ids.0 + cidr_block = cidrsubnet(data.alicloud_vpcs.default.vpcs[0].cidr_block, 8, 8) + zone_id = data.alicloud_zones.default.zones.0.id + vswitch_name = var.name +} + +locals { + vswitch_id = length(data.alicloud_vswitches.default.ids) > 0 ? data.alicloud_vswitches.default.ids[0] : concat(alicloud_vswitch.vswitch.*.id, [""])[0] +} + +resource "alicloud_security_group" "default" { + name = "${var.name}" + vpc_id = data.alicloud_vpcs.default.ids.0 +} + +resource "alicloud_security_group_rule" "default" { + type = "ingress" + ip_protocol = "tcp" + nic_type = "intranet" + policy = "accept" + port_range = "22/22" + priority = 1 + security_group_id = "${alicloud_security_group.default.id}" + cidr_ip = "172.16.0.0/24" +} + +resource "alicloud_ess_scaling_group" "default" { + min_size = 0 + max_size = 2 + default_cooldown = 20 + removal_policies = ["OldestInstance", "NewestInstance"] + scaling_group_name = "${var.name}" + vswitch_ids = ["${local.vswitch_id}"] +} + +resource "alicloud_ess_scaling_rule" "default"{ + scaling_group_id = "${alicloud_ess_scaling_group.default.id}" + scaling_rule_name = "${var.name}" + initial_max_size = 1 + predictive_scaling_mode = "PredictAndScale" + predictive_value_behavior = "MaxOverridePredictiveValue" + predictive_value_buffer = 0 + predictive_task_buffer_time = 0 + scaling_rule_type = "PredictiveScalingRule" + metric_name = "CpuUtilization" + target_value = 20.1 +} + +data "alicloud_ess_scaling_rules" "default" { + %s +} +`, strings.Join(pairs, "\n ")) + return config +} + +func testAccCheckAliCloudEssScalingrulesDataSourceConfig(attrMap map[string]string) string { + var pairs []string + for k, v := range attrMap { + pairs = append(pairs, k+" = "+v) + } + + config := fmt.Sprintf(` + +variable "name" { + default = "tf-testAccDataSourceEssScalingRules" +} + +data "alicloud_zones" "default" { + available_disk_category = "cloud_efficiency" + available_resource_creation = "VSwitch" +} + +data "alicloud_instance_types" "default" { + availability_zone = "${data.alicloud_zones.default.zones.0.id}" + cpu_core_count = 2 + memory_size = 4 +} + +data "alicloud_images" "default" { + name_regex = "^ubuntu_[0-9]+_[0-9]+_x64*" + most_recent = true + owners = "system" +} + +data "alicloud_vpcs" "default" { + +} +data "alicloud_vswitches" "default" { + vpc_id = data.alicloud_vpcs.default.ids.0 + zone_id = data.alicloud_zones.default.zones.0.id +} + +resource "alicloud_vswitch" "vswitch" { + count = length(data.alicloud_vswitches.default.ids) > 0 ? 0 : 1 + vpc_id = data.alicloud_vpcs.default.ids.0 + cidr_block = cidrsubnet(data.alicloud_vpcs.default.vpcs[0].cidr_block, 8, 8) + zone_id = data.alicloud_zones.default.zones.0.id + vswitch_name = var.name +} + +locals { + vswitch_id = length(data.alicloud_vswitches.default.ids) > 0 ? data.alicloud_vswitches.default.ids[0] : concat(alicloud_vswitch.vswitch.*.id, [""])[0] +} + +resource "alicloud_security_group" "default" { + name = "${var.name}" + vpc_id = data.alicloud_vpcs.default.ids.0 +} + +resource "alicloud_security_group_rule" "default" { + type = "ingress" + ip_protocol = "tcp" + nic_type = "intranet" + policy = "accept" + port_range = "22/22" + priority = 1 + security_group_id = "${alicloud_security_group.default.id}" + cidr_ip = "172.16.0.0/24" +} + +resource "alicloud_ess_scaling_group" "default" { + min_size = 0 + max_size = 2 + default_cooldown = 20 + removal_policies = ["OldestInstance", "NewestInstance"] + scaling_group_name = "${var.name}" + vswitch_ids = ["${local.vswitch_id}"] +} + +resource "alicloud_ess_scaling_rule" "default"{ + scaling_group_id = "${alicloud_ess_scaling_group.default.id}" + scaling_rule_name = "${var.name}" + adjustment_type = "PercentChangeInCapacity" + adjustment_value = 1 + cooldown = 30 + min_adjustment_magnitude = 1 +} + +data "alicloud_ess_scaling_rules" "default" { + %s +} +`, strings.Join(pairs, "\n ")) + return config +} diff --git a/alicloud/data_source_alicloud_ess_scalingrules.go b/alicloud/data_source_alicloud_ess_scalingrules.go deleted file mode 100644 index 16a5bef02641..000000000000 --- a/alicloud/data_source_alicloud_ess_scalingrules.go +++ /dev/null @@ -1,215 +0,0 @@ -package alicloud - -import ( - "regexp" - - "github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests" - "github.com/aliyun/alibaba-cloud-sdk-go/services/ess" - "github.com/aliyun/terraform-provider-alicloud/alicloud/connectivity" - "github.com/hashicorp/terraform-plugin-sdk/helper/schema" - "github.com/hashicorp/terraform-plugin-sdk/helper/validation" -) - -func dataSourceAlicloudEssScalingRules() *schema.Resource { - return &schema.Resource{ - Read: dataSourceAlicloudEssScalingRulesRead, - Schema: map[string]*schema.Schema{ - "scaling_group_id": { - Type: schema.TypeString, - Optional: true, - ForceNew: true, - }, - "name_regex": { - Type: schema.TypeString, - Optional: true, - ValidateFunc: validation.ValidateRegexp, - ForceNew: true, - }, - "ids": { - Type: schema.TypeList, - Optional: true, - Elem: &schema.Schema{Type: schema.TypeString}, - Computed: true, - ForceNew: true, - }, - "type": { - Type: schema.TypeString, - Optional: true, - ForceNew: true, - }, - "output_file": { - Type: schema.TypeString, - Optional: true, - ForceNew: true, - }, - "names": { - Type: schema.TypeList, - Computed: true, - Elem: &schema.Schema{Type: schema.TypeString}, - }, - "rules": { - Type: schema.TypeList, - Computed: true, - Elem: &schema.Resource{ - Schema: map[string]*schema.Schema{ - "id": { - Type: schema.TypeString, - Computed: true, - }, - "scaling_group_id": { - Type: schema.TypeString, - Computed: true, - }, - "name": { - Type: schema.TypeString, - Computed: true, - }, - "type": { - Type: schema.TypeString, - Computed: true, - }, - "cooldown": { - Type: schema.TypeInt, - Computed: true, - }, - "adjustment_type": { - Type: schema.TypeString, - Computed: true, - }, - "adjustment_value": { - Type: schema.TypeInt, - Computed: true, - }, - "min_adjustment_magnitude": { - Type: schema.TypeInt, - Computed: true, - }, - "scaling_rule_ari": { - Type: schema.TypeString, - Computed: true, - }, - }, - }, - }, - }, - } -} - -func dataSourceAlicloudEssScalingRulesRead(d *schema.ResourceData, meta interface{}) error { - client := meta.(*connectivity.AliyunClient) - request := ess.CreateDescribeScalingRulesRequest() - request.RegionId = client.RegionId - request.PageSize = requests.NewInteger(PageSizeLarge) - request.PageNumber = requests.NewInteger(1) - - if scalingGroupId, ok := d.GetOk("scaling_group_id"); ok && scalingGroupId.(string) != "" { - request.ScalingGroupId = scalingGroupId.(string) - } - - if ruleType, ok := d.GetOk("type"); ok && ruleType.(string) != "" { - request.ScalingRuleType = ruleType.(string) - } - - var allScalingRules []ess.ScalingRule - - for { - raw, err := client.WithEssClient(func(essClient *ess.Client) (interface{}, error) { - return essClient.DescribeScalingRules(request) - }) - if err != nil { - return WrapErrorf(err, DataDefaultErrorMsg, "alicloud_ess_scalingrules", request.GetActionName(), AlibabaCloudSdkGoERROR) - } - addDebug(request.GetActionName(), raw, request.RpcRequest, request) - response, _ := raw.(*ess.DescribeScalingRulesResponse) - if len(response.ScalingRules.ScalingRule) < 1 { - break - } - - allScalingRules = append(allScalingRules, response.ScalingRules.ScalingRule...) - - if len(response.ScalingRules.ScalingRule) < PageSizeLarge { - break - } - - if page, err := getNextpageNumber(request.PageNumber); err != nil { - return err - } else { - request.PageNumber = page - } - } - - var filteredScalingRulesTemp = make([]ess.ScalingRule, 0) - - nameRegex, okNameRegex := d.GetOk("name_regex") - idsMap := make(map[string]string) - ids, okIds := d.GetOk("ids") - if okIds { - for _, i := range ids.([]interface{}) { - if i == nil { - continue - } - idsMap[i.(string)] = i.(string) - } - } - - if okNameRegex || okIds { - for _, rule := range allScalingRules { - if okNameRegex && nameRegex != "" { - r, err := regexp.Compile(nameRegex.(string)) - if err != nil { - return WrapError(err) - } - if r != nil && !r.MatchString(rule.ScalingRuleName) { - continue - } - } - if okIds && len(idsMap) > 0 { - if _, ok := idsMap[rule.ScalingRuleId]; !ok { - continue - } - } - filteredScalingRulesTemp = append(filteredScalingRulesTemp, rule) - } - } else { - filteredScalingRulesTemp = allScalingRules - } - return scalingRulesDescriptionAttribute(d, filteredScalingRulesTemp, meta) -} - -func scalingRulesDescriptionAttribute(d *schema.ResourceData, scalingRules []ess.ScalingRule, meta interface{}) error { - var ids []string - var names []string - var s = make([]map[string]interface{}, 0) - for _, scalingRule := range scalingRules { - mapping := map[string]interface{}{ - "id": scalingRule.ScalingRuleId, - "scaling_group_id": scalingRule.ScalingGroupId, - "name": scalingRule.ScalingRuleName, - "type": scalingRule.ScalingRuleType, - "cooldown": scalingRule.Cooldown, - "adjustment_type": scalingRule.AdjustmentType, - "adjustment_value": scalingRule.AdjustmentValue, - "min_adjustment_magnitude": scalingRule.MinAdjustmentMagnitude, - "scaling_rule_ari": scalingRule.ScalingRuleAri, - } - ids = append(ids, scalingRule.ScalingRuleId) - names = append(names, scalingRule.ScalingRuleName) - s = append(s, mapping) - } - d.SetId(dataResourceIdHash(ids)) - if err := d.Set("rules", s); err != nil { - return WrapError(err) - } - - if err := d.Set("ids", ids); err != nil { - return WrapError(err) - } - - if err := d.Set("names", names); err != nil { - return WrapError(err) - } - if output, ok := d.GetOk("output_file"); ok && output.(string) != "" { - writeToFile(output.(string), s) - } - return nil -} diff --git a/alicloud/data_source_alicloud_ess_scalingrules_test.go b/alicloud/data_source_alicloud_ess_scalingrules_test.go deleted file mode 100644 index 94180a2c7547..000000000000 --- a/alicloud/data_source_alicloud_ess_scalingrules_test.go +++ /dev/null @@ -1,184 +0,0 @@ -package alicloud - -import ( - "fmt" - "strings" - "testing" -) - -func TestAccAlicloudEssScalingrulesDataSource(t *testing.T) { - - idsConf := dataSourceTestAccConfig{ - existConfig: testAccCheckAlicloudEssScalingrulesDataSourceConfig(map[string]string{ - "ids": `["${alicloud_ess_scaling_rule.default.id}"]`, - }), - fakeConfig: testAccCheckAlicloudEssScalingrulesDataSourceConfig(map[string]string{ - "ids": `["${alicloud_ess_scaling_rule.default.id}_fake"]`, - }), - } - - scalingGroupIdConf := dataSourceTestAccConfig{ - existConfig: testAccCheckAlicloudEssScalingrulesDataSourceConfig(map[string]string{ - "scaling_group_id": `"${alicloud_ess_scaling_rule.default.scaling_group_id}"`, - }), - fakeConfig: testAccCheckAlicloudEssScalingrulesDataSourceConfig(map[string]string{ - "scaling_group_id": `"${alicloud_ess_scaling_rule.default.scaling_group_id}_fake"`, - }), - } - - typeConf := dataSourceTestAccConfig{ - existConfig: testAccCheckAlicloudEssScalingrulesDataSourceConfig(map[string]string{ - "scaling_group_id": `"${alicloud_ess_scaling_rule.default.scaling_group_id}"`, - "type": `"SimpleScalingRule"`, - }), - fakeConfig: testAccCheckAlicloudEssScalingrulesDataSourceConfig(map[string]string{ - "scaling_group_id": `"${alicloud_ess_scaling_rule.default.scaling_group_id}_fake"`, - "type": `"TargetTrackingScalingRule"`, - }), - } - - nameRegexConf := dataSourceTestAccConfig{ - existConfig: testAccCheckAlicloudEssScalingrulesDataSourceConfig(map[string]string{ - "name_regex": `"${alicloud_ess_scaling_rule.default.scaling_rule_name}"`, - }), - fakeConfig: testAccCheckAlicloudEssScalingrulesDataSourceConfig(map[string]string{ - "name_regex": `"${alicloud_ess_scaling_rule.default.scaling_rule_name}_fake"`, - }), - } - - allConf := dataSourceTestAccConfig{ - existConfig: testAccCheckAlicloudEssScalingrulesDataSourceConfig(map[string]string{ - "ids": `["${alicloud_ess_scaling_rule.default.id}"]`, - "scaling_group_id": `"${alicloud_ess_scaling_rule.default.scaling_group_id}"`, - "type": `"SimpleScalingRule"`, - "name_regex": `"${alicloud_ess_scaling_rule.default.scaling_rule_name}"`, - }), - fakeConfig: testAccCheckAlicloudEssScalingrulesDataSourceConfig(map[string]string{ - "ids": `["${alicloud_ess_scaling_rule.default.id}"]`, - "scaling_group_id": `"${alicloud_ess_scaling_rule.default.scaling_group_id}_fake"`, - "type": `"SimpleScalingRule"`, - "name_regex": `"${alicloud_ess_scaling_rule.default.scaling_rule_name}"`, - }), - } - - var existEssRecordsMapFunc = func(rand int) map[string]string { - return map[string]string{ - "rules.#": "1", - "ids.#": "1", - "names.#": "1", - "rules.0.id": CHECKSET, - "rules.0.scaling_group_id": CHECKSET, - "rules.0.name": CHECKSET, - "rules.0.type": CHECKSET, - "rules.0.cooldown": CHECKSET, - "rules.0.adjustment_type": "QuantityChangeInCapacity", - "rules.0.adjustment_value": "1", - "rules.0.min_adjustment_magnitude": CHECKSET, - "rules.0.scaling_rule_ari": CHECKSET, - } - } - - var fakeEssRecordsMapFunc = func(rand int) map[string]string { - return map[string]string{ - "rules.#": "0", - "ids.#": "0", - "names.#": "0", - } - } - - var EssScalingrulesRecordsCheckInfo = dataSourceAttr{ - resourceId: "data.alicloud_ess_scaling_rules.default", - existMapFunc: existEssRecordsMapFunc, - fakeMapFunc: fakeEssRecordsMapFunc, - } - - EssScalingrulesRecordsCheckInfo.dataSourceTestCheck(t, -1, idsConf, scalingGroupIdConf, typeConf, nameRegexConf, allConf) -} - -func testAccCheckAlicloudEssScalingrulesDataSourceConfig(attrMap map[string]string) string { - var pairs []string - for k, v := range attrMap { - pairs = append(pairs, k+" = "+v) - } - - config := fmt.Sprintf(` - -variable "name" { - default = "tf-testAccDataSourceEssScalingRules" -} - -data "alicloud_zones" "default" { - available_disk_category = "cloud_efficiency" - available_resource_creation = "VSwitch" -} - -data "alicloud_instance_types" "default" { - availability_zone = "${data.alicloud_zones.default.zones.0.id}" - cpu_core_count = 2 - memory_size = 4 -} - -data "alicloud_images" "default" { - name_regex = "^ubuntu_[0-9]+_[0-9]+_x64*" - most_recent = true - owners = "system" -} - -data "alicloud_vpcs" "default" { - name_regex = "^default-NODELETING$" -} -data "alicloud_vswitches" "default" { - vpc_id = data.alicloud_vpcs.default.ids.0 - zone_id = data.alicloud_zones.default.zones.0.id -} - -resource "alicloud_vswitch" "vswitch" { - count = length(data.alicloud_vswitches.default.ids) > 0 ? 0 : 1 - vpc_id = data.alicloud_vpcs.default.ids.0 - cidr_block = cidrsubnet(data.alicloud_vpcs.default.vpcs[0].cidr_block, 8, 8) - zone_id = data.alicloud_zones.default.zones.0.id - vswitch_name = var.name -} - -locals { - vswitch_id = length(data.alicloud_vswitches.default.ids) > 0 ? data.alicloud_vswitches.default.ids[0] : concat(alicloud_vswitch.vswitch.*.id, [""])[0] -} - -resource "alicloud_security_group" "default" { - name = "${var.name}" - vpc_id = data.alicloud_vpcs.default.ids.0 -} - -resource "alicloud_security_group_rule" "default" { - type = "ingress" - ip_protocol = "tcp" - nic_type = "intranet" - policy = "accept" - port_range = "22/22" - priority = 1 - security_group_id = "${alicloud_security_group.default.id}" - cidr_ip = "172.16.0.0/24" -} - -resource "alicloud_ess_scaling_group" "default" { - min_size = 0 - max_size = 2 - default_cooldown = 20 - removal_policies = ["OldestInstance", "NewestInstance"] - scaling_group_name = "${var.name}" - vswitch_ids = ["${local.vswitch_id}"] -} - -resource "alicloud_ess_scaling_rule" "default"{ - scaling_group_id = "${alicloud_ess_scaling_group.default.id}" - scaling_rule_name = "${var.name}" - adjustment_type = "QuantityChangeInCapacity" - adjustment_value = 1 -} - -data "alicloud_ess_scaling_rules" "default" { - %s -} -`, strings.Join(pairs, "\n ")) - return config -} diff --git a/alicloud/provider.go b/alicloud/provider.go index 452667a73d0d..c0fb1555565a 100644 --- a/alicloud/provider.go +++ b/alicloud/provider.go @@ -327,7 +327,7 @@ func Provider() terraform.ResourceProvider { "alicloud_ess_alarms": dataSourceAlicloudEssAlarms(), "alicloud_ess_notifications": dataSourceAlicloudEssNotifications(), "alicloud_ess_scaling_groups": dataSourceAliCloudEssScalingGroups(), - "alicloud_ess_scaling_rules": dataSourceAlicloudEssScalingRules(), + "alicloud_ess_scaling_rules": dataSourceAliCloudEssScalingRules(), "alicloud_ess_scaling_configurations": dataSourceAlicloudEssScalingConfigurations(), "alicloud_ess_lifecycle_hooks": dataSourceAlicloudEssLifecycleHooks(), "alicloud_ess_scheduled_tasks": dataSourceAlicloudEssScheduledTasks(), diff --git a/website/docs/d/ess_scaling_rules.html.markdown b/website/docs/d/ess_scaling_rules.html.markdown index f15b99e11d90..63389125c035 100644 --- a/website/docs/d/ess_scaling_rules.html.markdown +++ b/website/docs/d/ess_scaling_rules.html.markdown @@ -11,17 +11,65 @@ description: |- This data source provides available scaling rule resources. +-> **NOTE:** Available since v1.39.0 + ## Example Usage -``` +```terraform +variable "name" { + default = "terraform-ex" +} + +resource "random_integer" "default" { + min = 10000 + max = 99999 +} + +locals { + name = "${var.name}-${random_integer.default.result}" +} + +data "alicloud_zones" "default" { + available_disk_category = "cloud_efficiency" + available_resource_creation = "VSwitch" +} + +resource "alicloud_vpc" "default" { + vpc_name = local.name + cidr_block = "172.16.0.0/16" +} + +resource "alicloud_vswitch" "default" { + vpc_id = alicloud_vpc.default.id + cidr_block = "172.16.0.0/24" + zone_id = data.alicloud_zones.default.zones[0].id + vswitch_name = local.name +} + +resource "alicloud_ess_scaling_group" "default" { + min_size = 1 + max_size = 1 + scaling_group_name = local.name + removal_policies = ["OldestInstance", "NewestInstance"] + vswitch_ids = [alicloud_vswitch.default.id] +} + +resource "alicloud_ess_scaling_rule" "default" { + scaling_group_id = alicloud_ess_scaling_group.default.id + scaling_rule_name = local.name + adjustment_type = "PercentChangeInCapacity" + adjustment_value = 1 +} + + data "alicloud_ess_scaling_rules" "scalingrules_ds" { - scaling_group_id = "scaling_group_id" - ids = ["scaling_rule_id1", "scaling_rule_id2"] - name_regex = "scaling_rule_name" + scaling_group_id = alicloud_ess_scaling_group.default.id + ids = [alicloud_ess_scaling_rule.default.id] + name_regex = local.name } output "first_scaling_rule" { - value = "${data.alicloud_ess_scaling_rules.scalingrules_ds.rules.0.id}" + value = data.alicloud_ess_scaling_rules.scalingrules_ds.rules.0.id } ``` @@ -29,11 +77,11 @@ output "first_scaling_rule" { The following arguments are supported: -* `scaling_group_id` - (Optional) Scaling group id the scaling rules belong to. -* `type` - (Optional) Type of scaling rule. -* `name_regex` - (Optional) A regex string to filter resulting scaling rules by name. -* `ids` - (Optional) A list of scaling rule IDs. -* `output_file` - (Optional) File name where to save data source results (after running `terraform plan`). +* `scaling_group_id` - (Optional, ForceNew) Scaling group id the scaling rules belong to. +* `type` - (Optional, ForceNew) Type of scaling rule. +* `name_regex` - (Optional, ForceNew) A regex string to filter resulting scaling rules by name. +* `ids` - (Optional, ForceNew) A list of scaling rule IDs. +* `output_file` - (Optional, ForceNew) File name where to save data source results (after running `terraform plan`). ## Attributes Reference @@ -51,3 +99,10 @@ The following attributes are exported in addition to the arguments listed above: * `adjustment_value` - Adjustment value of the scaling rule. * `min_adjustment_magnitude` - Min adjustment magnitude of scaling rule. * `scaling_rule_ari` - Ari of scaling rule. + * `initial_max_size` - (Available since v1.242.0) The maximum number of ECS instances that can be added to the scaling group. + * `predictive_value_behavior` - (Available since v1.242.0) The action on the predicted maximum value. + * `predictive_scaling_mode` - (Available since v1.242.0) The mode of the predictive scaling rule. + * `predictive_value_buffer` - (Available since v1.242.0) The ratio based on which the predicted value is increased if you set predictive_value_behavior to PredictiveValueOverrideMaxWithBuffer. If the predicted value that is increased by this ratio is greater than the initial maximum capacity, the increased value is used as the maximum value for prediction tasks. + * `predictive_task_buffer_time` - (Available since v1.242.0) The amount of buffer time before the prediction task is executed. By default, all prediction tasks that are automatically created by a predictive scaling rule are executed on the hour. You can set a buffer time to execute prediction tasks and prepare resources in advance. + * `target_value` - (Available since v1.242.0) The target value of the metric. + * `metric_name` - (Available since v1.242.0) The predefined metric of the scaling rule.