From 500476bef54049c4a6ccaba20c762d5638feacc5 Mon Sep 17 00:00:00 2001 From: saf3dfsa Date: Wed, 22 Jan 2025 10:16:59 +0800 Subject: [PATCH] refactor(aom): refactor alarm rule --- docs/resources/aom_alarm_rule.md | 10 +- ...esource_huaweicloud_aom_alarm_rule_test.go | 22 +- .../resource_huaweicloud_aom_alarm_rule.go | 390 ++++++++---------- 3 files changed, 177 insertions(+), 245 deletions(-) diff --git a/docs/resources/aom_alarm_rule.md b/docs/resources/aom_alarm_rule.md index 3ed9e75781..38e9af39cc 100644 --- a/docs/resources/aom_alarm_rule.md +++ b/docs/resources/aom_alarm_rule.md @@ -110,18 +110,10 @@ In addition to all arguments above, the following attributes are exported: * `state_reason` - Indicates the reason of alarm status. -## Timeouts - -This resource provides the following timeouts configuration options: - -* `create` - Default is 5 minutes. -* `update` - Default is 5 minutes. -* `delete` - Default is 5 minutes. - ## Import AOM alarm rules can be imported using the `id`, e.g. ```bash -$ terraform import huaweicloud_aom_alarm_rule.alarm_rule 966746116613832710 +$ terraform import huaweicloud_aom_alarm_rule.alarm_rule ``` diff --git a/huaweicloud/services/acceptance/aom/resource_huaweicloud_aom_alarm_rule_test.go b/huaweicloud/services/acceptance/aom/resource_huaweicloud_aom_alarm_rule_test.go index f1f0654299..55fe5c9092 100644 --- a/huaweicloud/services/acceptance/aom/resource_huaweicloud_aom_alarm_rule_test.go +++ b/huaweicloud/services/acceptance/aom/resource_huaweicloud_aom_alarm_rule_test.go @@ -7,33 +7,23 @@ import ( "github.com/hashicorp/terraform-plugin-sdk/v2/helper/resource" "github.com/hashicorp/terraform-plugin-sdk/v2/terraform" - aom "github.com/huaweicloud/huaweicloud-sdk-go-v3/services/aom/v2/model" - "github.com/huaweicloud/terraform-provider-huaweicloud/huaweicloud/config" "github.com/huaweicloud/terraform-provider-huaweicloud/huaweicloud/services/acceptance" "github.com/huaweicloud/terraform-provider-huaweicloud/huaweicloud/services/acceptance/common" + "github.com/huaweicloud/terraform-provider-huaweicloud/huaweicloud/services/aom" ) func getAlarmRuleResourceFunc(conf *config.Config, state *terraform.ResourceState) (interface{}, error) { - c, err := conf.HcAomV2Client(acceptance.HW_REGION_NAME) + client, err := conf.NewServiceClient("aom", acceptance.HW_REGION_NAME) if err != nil { return nil, fmt.Errorf("error creating AOM client: %s", err) } - response, err := c.ShowAlarmRule(&aom.ShowAlarmRuleRequest{AlarmRuleId: state.Primary.ID}) - if err != nil { - return nil, fmt.Errorf("error retrieving AOM alarm rule: %s", state.Primary.ID) - } - allRules := *response.Thresholds - if len(allRules) != 1 { - return nil, fmt.Errorf("error retrieving AOM alarm rule %s", state.Primary.ID) - } - rule := allRules[0] - return rule, nil + return aom.GetV2AlarmRule(client, state.Primary.ID) } func TestAccAOMAlarmRule_basic(t *testing.T) { - var ar aom.QueryAlarmResult + var ar interface{} rName := acceptance.RandomAccResourceNameWithDash() resourceName := "huaweicloud_aom_alarm_rule.test" @@ -73,7 +63,7 @@ func TestAccAOMAlarmRule_basic(t *testing.T) { Config: testAOMAlarmRule_update(rName), Check: resource.ComposeTestCheckFunc( resource.TestCheckResourceAttr(resourceName, "name", rName), - resource.TestCheckResourceAttr(resourceName, "description", "test rule update"), + resource.TestCheckResourceAttr(resourceName, "description", ""), resource.TestCheckResourceAttr(resourceName, "alarm_enabled", "true"), resource.TestCheckResourceAttr(resourceName, "alarm_level", "3"), resource.TestCheckResourceAttr(resourceName, "comparison_operator", ">="), @@ -140,7 +130,7 @@ resource "huaweicloud_aom_alarm_rule" "test" { name = "%s" alarm_level = 3 alarm_action_enabled = false - description = "test rule update" + description = "" namespace = "PAAS.NODE" metric_name = "cupUsage" diff --git a/huaweicloud/services/aom/resource_huaweicloud_aom_alarm_rule.go b/huaweicloud/services/aom/resource_huaweicloud_aom_alarm_rule.go index 91768e6d04..a7d2623bd5 100644 --- a/huaweicloud/services/aom/resource_huaweicloud_aom_alarm_rule.go +++ b/huaweicloud/services/aom/resource_huaweicloud_aom_alarm_rule.go @@ -2,16 +2,19 @@ package aom import ( "context" - "log" + "encoding/json" + "fmt" + "io" + "net/http" "strconv" - "time" + "strings" "github.com/hashicorp/go-multierror" "github.com/hashicorp/terraform-plugin-sdk/v2/diag" "github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema" "github.com/hashicorp/terraform-plugin-sdk/v2/helper/validation" - aom "github.com/huaweicloud/huaweicloud-sdk-go-v3/services/aom/v2/model" + "github.com/chnsz/golangsdk" "github.com/huaweicloud/terraform-provider-huaweicloud/huaweicloud/common" "github.com/huaweicloud/terraform-provider-huaweicloud/huaweicloud/config" @@ -32,12 +35,6 @@ func ResourceAlarmRule() *schema.Resource { StateContext: schema.ImportStatePassthroughContext, }, - Timeouts: &schema.ResourceTimeout{ - Create: schema.DefaultTimeout(5 * time.Minute), - Update: schema.DefaultTimeout(5 * time.Minute), - Delete: schema.DefaultTimeout(5 * time.Minute), - }, - Schema: map[string]*schema.Schema{ "region": { Type: schema.TypeString, @@ -164,275 +161,214 @@ func ResourceAlarmRule() *schema.Resource { } } -func buildActionOpts(rawActions []interface{}) *[]string { - if len(rawActions) == 0 { - return nil +// flattenAlarmRuleCreateResponse returns the api response body for creating alarm rule, +// json parse `alarm_rule_id` into float64 in default, which make a loss of precision, +// parse it into json.Number to avoid this situation. +func flattenAlarmRuleCreateResponse(resp *http.Response) (interface{}, error) { + var respBody interface{} + defer resp.Body.Close() + // Don't decode JSON when there is no content + if resp.StatusCode == http.StatusNoContent { + _, err := io.Copy(io.Discard, resp.Body) + return resp, err } - actions := make([]string, len(rawActions)) - for i, raw := range rawActions { - actions[i] = raw.(string) - } - return &actions -} -func buildDimensionsOpts(rawDimensions []interface{}) []aom.Dimension { - if len(rawDimensions) == 0 { - return nil + decoder := json.NewDecoder(resp.Body) + decoder.UseNumber() + if err := decoder.Decode(&respBody); err != nil { + return nil, err } - dimensions := make([]aom.Dimension, len(rawDimensions)) - for i, rawdimension := range rawDimensions { - dimension := rawdimension.(map[string]interface{}) - dimensions[i] = aom.Dimension{ - Name: dimension["name"].(string), - Value: dimension["value"].(string), - } - } - return dimensions -} -func buildAlarmLevelOpts(alarmLevel int) *aom.UpdateAlarmRuleParamAlarmLevel { - var alarmLevelToReq aom.UpdateAlarmRuleParamAlarmLevel - switch alarmLevel { - case 1: - alarmLevelToReq = aom.GetUpdateAlarmRuleParamAlarmLevelEnum().E_1 - case 2: - alarmLevelToReq = aom.GetUpdateAlarmRuleParamAlarmLevelEnum().E_2 - case 3: - alarmLevelToReq = aom.GetUpdateAlarmRuleParamAlarmLevelEnum().E_3 - case 4: - alarmLevelToReq = aom.GetUpdateAlarmRuleParamAlarmLevelEnum().E_4 - default: - log.Printf("[WARN] alarm level invalid: %d", alarmLevel) - return nil - } - - return &alarmLevelToReq + return respBody, nil } -func buildStatisticOpts(statistic string) *aom.UpdateAlarmRuleParamStatistic { - var statisticToReq aom.UpdateAlarmRuleParamStatistic - switch statistic { - case "maximum": - statisticToReq = aom.GetUpdateAlarmRuleParamStatisticEnum().MAXIMUM - case "minimum": - statisticToReq = aom.GetUpdateAlarmRuleParamStatisticEnum().MINIMUM - case "average": - statisticToReq = aom.GetUpdateAlarmRuleParamStatisticEnum().AVERAGE - case "sum": - statisticToReq = aom.GetUpdateAlarmRuleParamStatisticEnum().SUM - case "sampleCount": - statisticToReq = aom.GetUpdateAlarmRuleParamStatisticEnum().SAMPLE_COUNT - default: - log.Printf("[WARN] statistic invalid: %s", statistic) - return nil +func resourceAlarmRuleCreate(ctx context.Context, d *schema.ResourceData, meta interface{}) diag.Diagnostics { + cfg := meta.(*config.Config) + client, err := cfg.NewServiceClient("aom", cfg.GetRegion(d)) + if err != nil { + return diag.Errorf("error creating AOM client: %s", err) } - return &statisticToReq -} - -func buildAlarmLevelCreateOpts(alarmLevel int) aom.AlarmRuleParamAlarmLevel { - alarmLevelToReq := new(aom.AlarmRuleParamAlarmLevel) - if err := alarmLevelToReq.UnmarshalJSON([]byte(strconv.Itoa(alarmLevel))); err != nil { - log.Printf("[WARN] failed to parse alarm_level %d: %s", alarmLevel, err) + createHttpUrl := "v2/{project_id}/alarm-rules" + createPath := client.Endpoint + createHttpUrl + createPath = strings.ReplaceAll(createPath, "{project_id}", client.ProjectID) + createOpt := golangsdk.RequestOpts{ + KeepResponseBody: true, + MoreHeaders: map[string]string{ + "Content-Type": "application/json", + }, + JSONBody: utils.RemoveNil(buildV2AlarmRuleBodyParams(d)), } - return *alarmLevelToReq -} -func buildStatisticCreateOpts(statistic string) aom.AlarmRuleParamStatistic { - statisticToReq := new(aom.AlarmRuleParamStatistic) - if err := statisticToReq.UnmarshalJSON([]byte(statistic)); err != nil { - log.Printf("[WARN] failed to parse statistic %s: %s", statistic, err) + createResp, err := client.Request("POST", createPath, &createOpt) + if err != nil { + return diag.Errorf("error creating the alarm rule: %s", err) } - return *statisticToReq -} -func buildPeriodCreateOpts(period int) aom.AlarmRuleParamPeriod { - periodToReq := new(aom.AlarmRuleParamPeriod) - if err := periodToReq.UnmarshalJSON([]byte(strconv.Itoa(period))); err != nil { - log.Printf("[WARN] failed to parse period %d: %s", period, err) + createRespBody, err := flattenAlarmRuleCreateResponse(createResp) + if err != nil { + return diag.Errorf("error flattening the response: %s", err) } - return *periodToReq -} -func buildComparisonOperatorCreateOpts(comparisonOperator string) aom.AlarmRuleParamComparisonOperator { - comparisonOperatorToReq := new(aom.AlarmRuleParamComparisonOperator) - if err := comparisonOperatorToReq.UnmarshalJSON([]byte(comparisonOperator)); err != nil { - log.Printf("[WARN] failed to parse comparison_operator %s: %s", comparisonOperator, err) + alarmRuleId, ok := utils.PathSearch("alarm_rule_id", createRespBody, json.Number("")).(json.Number) + if !ok { + return diag.Errorf("error asserting alarm rule ID value to json.Number") } - return *comparisonOperatorToReq -} - -func resourceAlarmRuleCreate(ctx context.Context, d *schema.ResourceData, meta interface{}) diag.Diagnostics { - cfg := meta.(*config.Config) - client, err := cfg.HcAomV2Client(cfg.GetRegion(d)) - if err != nil { - return diag.Errorf("error creating AOM client: %s", err) + if alarmRuleId.String() == "" { + return diag.Errorf("unable to find alarm rule ID from API response") } - createOpts := aom.AlarmRuleParam{ - AlarmRuleName: d.Get("name").(string), - AlarmDescription: utils.String(d.Get("description").(string)), - AlarmLevel: buildAlarmLevelCreateOpts(d.Get("alarm_level").(int)), - IsTurnOn: utils.Bool(true), - AlarmActions: buildActionOpts(d.Get("alarm_actions").([]interface{})), - ActionEnabled: utils.Bool(d.Get("alarm_action_enabled").(bool)), - OkActions: buildActionOpts(d.Get("ok_actions").([]interface{})), - InsufficientDataActions: buildActionOpts(d.Get("insufficient_data_actions").([]interface{})), - - Namespace: d.Get("namespace").(string), - MetricName: d.Get("metric_name").(string), - Dimensions: buildDimensionsOpts(d.Get("dimensions").([]interface{})), - - Unit: d.Get("unit").(string), - Threshold: d.Get("threshold").(string), - Statistic: buildStatisticCreateOpts(d.Get("statistic").(string)), - Period: buildPeriodCreateOpts(d.Get("period").(int)), - EvaluationPeriods: int32(d.Get("evaluation_periods").(int)), - ComparisonOperator: buildComparisonOperatorCreateOpts(d.Get("comparison_operator").(string)), - } + d.SetId(alarmRuleId.String()) - log.Printf("[DEBUG] Create %s Options: %#v", createOpts.AlarmRuleName, createOpts) + return resourceAlarmRuleRead(ctx, d, meta) +} - createReq := aom.AddAlarmRuleRequest{ - Body: &createOpts, - } - response, err := client.AddAlarmRule(&createReq) - if err != nil { - return diag.Errorf("error creating AOM alarm rule %s: %s", createOpts.AlarmRuleName, err) +func buildV2AlarmRuleBodyParams(d *schema.ResourceData) map[string]interface{} { + bodyParams := map[string]interface{}{ + "alarm_rule_name": d.Get("name"), + "alarm_description": d.Get("description"), + "alarm_level": utils.ValueIgnoreEmpty(d.Get("alarm_level")), + "is_turn_on": true, + "action_enabled": utils.ValueIgnoreEmpty(d.Get("alarm_action_enabled")), + "alarm_actions": utils.ValueIgnoreEmpty(d.Get("alarm_actions")), + "ok_actions": utils.ValueIgnoreEmpty(d.Get("ok_actions")), + "insufficient_data_actions": utils.ValueIgnoreEmpty(d.Get("insufficient_data_actions")), + "namespace": d.Get("namespace"), + "metric_name": d.Get("metric_name"), + "dimensions": buildDimensionsOpts(d.Get("dimensions").([]interface{})), + "unit": d.Get("unit"), + "threshold": d.Get("threshold"), + "statistic": d.Get("statistic"), + "period": d.Get("period"), + "evaluation_periods": d.Get("evaluation_periods"), + "comparison_operator": d.Get("comparison_operator"), } - d.SetId(strconv.FormatInt(*response.AlarmRuleId, 10)) + return bodyParams +} - return resourceAlarmRuleRead(ctx, d, meta) +func buildDimensionsOpts(rawDimensions []interface{}) interface{} { + if len(rawDimensions) == 0 { + return nil + } + dimensions := make([]interface{}, len(rawDimensions)) + for i, rawdimension := range rawDimensions { + dimension := rawdimension.(map[string]interface{}) + dimensions[i] = map[string]interface{}{ + "name": dimension["name"].(string), + "value": dimension["value"].(string), + } + } + return dimensions } func resourceAlarmRuleRead(_ context.Context, d *schema.ResourceData, meta interface{}) diag.Diagnostics { cfg := meta.(*config.Config) - client, err := cfg.HcAomV2Client(cfg.GetRegion(d)) + client, err := cfg.NewServiceClient("aom", cfg.GetRegion(d)) if err != nil { return diag.Errorf("error creating AOM client: %s", err) } - response, err := client.ShowAlarmRule(&aom.ShowAlarmRuleRequest{AlarmRuleId: d.Id()}) + rule, err := GetV2AlarmRule(client, d.Id()) if err != nil { - return common.CheckDeletedDiag(d, err, "error retrieving AOM alarm rule") + return common.CheckDeletedDiag(d, err, "error getting the alarm rule") } - allRules := *response.Thresholds - if len(allRules) != 1 { - return diag.Errorf("error retrieving AOM alarm rule %s", d.Id()) - } - rule := allRules[0] - log.Printf("[DEBUG] Retrieved AOM alarm rule %s: %#v", d.Id(), rule) - - alarmLevel, _ := strconv.Atoi(*rule.AlarmLevel) + alarmLevel, _ := strconv.Atoi(utils.PathSearch("alarm_level", rule, "0").(string)) mErr := multierror.Append(nil, d.Set("region", cfg.GetRegion(d)), - d.Set("name", rule.AlarmRuleName), - d.Set("description", rule.AlarmDescription), + d.Set("name", utils.PathSearch("alarm_rule_name", rule, nil)), + d.Set("description", utils.PathSearch("alarm_description", rule, nil)), d.Set("alarm_level", alarmLevel), - d.Set("metric_name", rule.MetricName), - d.Set("alarm_actions", rule.AlarmActions), - d.Set("ok_actions", rule.OkActions), - d.Set("alarm_enabled", rule.IdTurnOn), - d.Set("alarm_action_enabled", rule.ActionEnabled), - d.Set("comparison_operator", rule.ComparisonOperator), - d.Set("evaluation_periods", rule.EvaluationPeriods), - d.Set("insufficient_data_actions", rule.InsufficientDataActions), - d.Set("namespace", rule.Namespace), - d.Set("period", rule.Period), - d.Set("state_value", rule.StateValue), - d.Set("state_reason", rule.StateReason), - d.Set("statistic", rule.Statistic), - d.Set("threshold", rule.Threshold), - d.Set("unit", rule.Unit), + d.Set("metric_name", utils.PathSearch("metric_name", rule, nil)), + d.Set("alarm_actions", utils.PathSearch("alarm_actions", rule, nil)), + d.Set("ok_actions", utils.PathSearch("ok_actions", rule, nil)), + d.Set("alarm_enabled", utils.PathSearch("id_turn_on", rule, nil)), + d.Set("alarm_action_enabled", utils.PathSearch("alarm_enabled", rule, nil)), + d.Set("comparison_operator", utils.PathSearch("comparison_operator", rule, nil)), + d.Set("evaluation_periods", utils.PathSearch("evaluation_periods", rule, nil)), + d.Set("insufficient_data_actions", utils.PathSearch("insufficient_data_actions", rule, nil)), + d.Set("namespace", utils.PathSearch("namespace", rule, nil)), + d.Set("period", utils.PathSearch("period", rule, nil)), + d.Set("state_value", utils.PathSearch("state_value", rule, nil)), + d.Set("state_reason", utils.PathSearch("state_reason", rule, nil)), + d.Set("statistic", utils.PathSearch("statistic", rule, nil)), + d.Set("threshold", utils.PathSearch("threshold", rule, nil)), + d.Set("unit", utils.PathSearch("unit", rule, nil)), + d.Set("dimensions", flattenV2AlarmRuleDimensions( + utils.PathSearch("dimensions", rule, make([]interface{}, 0)).([]interface{}))), ) - var dimensions []map[string]interface{} - for _, pairObject := range *rule.Dimensions { - dimension := make(map[string]interface{}) - dimension["name"] = pairObject.Name - dimension["value"] = pairObject.Value + return diag.FromErr(mErr.ErrorOrNil()) +} - dimensions = append(dimensions, dimension) +func GetV2AlarmRule(client *golangsdk.ServiceClient, id string) (interface{}, error) { + getHttpUrl := "v2/{project_id}/alarm-rules/{alarm_rule_id}" + getPath := client.Endpoint + getHttpUrl + getPath = strings.ReplaceAll(getPath, "{project_id}", client.ProjectID) + getPath = strings.ReplaceAll(getPath, "{alarm_rule_id}", id) + getOpt := golangsdk.RequestOpts{ + KeepResponseBody: true, + MoreHeaders: map[string]string{ + "Content-Type": "application/json", + }, } - mErr = multierror.Append(mErr, d.Set("dimensions", dimensions)) - if err := mErr.ErrorOrNil(); err != nil { - return diag.Errorf("error setting AOM alarm rule fields: %s", err) + getResp, err := client.Request("GET", getPath, &getOpt) + if err != nil { + return nil, fmt.Errorf("error getting the alarm rule: %s", err) } - - return nil -} - -func buildAlarmLevelUpdateOpts(alarmLevel int) aom.UpdateAlarmRuleParamAlarmLevel { - alarmLevelToReq := new(aom.UpdateAlarmRuleParamAlarmLevel) - if err := alarmLevelToReq.UnmarshalJSON([]byte(strconv.Itoa(alarmLevel))); err != nil { - log.Printf("[WARN] failed to parse alarm_level %d: %s", alarmLevel, err) + getRespBody, err := utils.FlattenResponse(getResp) + if err != nil { + return nil, fmt.Errorf("error flattening the response: %s", err) } - return *alarmLevelToReq -} -func buildPeriodUpdateOpts(period int) aom.UpdateAlarmRuleParamPeriod { - periodToReq := new(aom.UpdateAlarmRuleParamPeriod) - if err := periodToReq.UnmarshalJSON([]byte(strconv.Itoa(period))); err != nil { - log.Printf("[WARN] failed to parse period %d: %s", period, err) + rule := utils.PathSearch("thresholds|[0]", getRespBody, nil) + if rule == nil { + return nil, golangsdk.ErrDefault404{} } - return *periodToReq -} -func buildComparisonOperatorUpdateOpts(comparisonOperator string) aom.UpdateAlarmRuleParamComparisonOperator { - comparisonOperatorToReq := new(aom.UpdateAlarmRuleParamComparisonOperator) - if err := comparisonOperatorToReq.UnmarshalJSON([]byte(comparisonOperator)); err != nil { - log.Printf("[WARN] failed to parse comparison_operator %s: %s", comparisonOperator, err) - } - return *comparisonOperatorToReq + return rule, nil } -func buildStatisticUpdateOpts(statistic string) aom.UpdateAlarmRuleParamStatistic { - statisticToReq := new(aom.UpdateAlarmRuleParamStatistic) - if err := statisticToReq.UnmarshalJSON([]byte(statistic)); err != nil { - log.Printf("[WARN] failed to parse statistic %s: %s", statistic, err) +func flattenV2AlarmRuleDimensions(paramsList []interface{}) interface{} { + if len(paramsList) == 0 { + return nil + } + rst := make([]map[string]interface{}, 0, len(paramsList)) + for _, params := range paramsList { + m := map[string]interface{}{ + "name": utils.PathSearch("name", params, nil), + "value": utils.PathSearch("value", params, nil), + } + rst = append(rst, m) } - return *statisticToReq + + return rst } func resourceAlarmRuleUpdate(ctx context.Context, d *schema.ResourceData, meta interface{}) diag.Diagnostics { cfg := meta.(*config.Config) - client, err := cfg.HcAomV2Client(cfg.GetRegion(d)) + client, err := cfg.NewServiceClient("aom", cfg.GetRegion(d)) if err != nil { return diag.Errorf("error creating AOM client: %s", err) } - // all parameters should be set when updating due to the API issue - updateOpts := aom.UpdateAlarmRuleParam{ - AlarmRuleName: d.Get("name").(string), - AlarmLevel: buildAlarmLevelUpdateOpts(d.Get("alarm_level").(int)), - AlarmDescription: utils.String(d.Get("description").(string)), - IsTurnOn: utils.Bool(d.Get("alarm_enabled").(bool)), - AlarmActions: buildActionOpts(d.Get("alarm_actions").([]interface{})), - OkActions: buildActionOpts(d.Get("ok_actions").([]interface{})), - InsufficientDataActions: buildActionOpts(d.Get("insufficient_data_actions").([]interface{})), - Namespace: d.Get("namespace").(string), - MetricName: d.Get("metric_name").(string), - Dimensions: buildDimensionsOpts(d.Get("dimensions").([]interface{})), - Period: buildPeriodUpdateOpts(d.Get("period").(int)), - Unit: d.Get("unit").(string), - ComparisonOperator: buildComparisonOperatorUpdateOpts(d.Get("comparison_operator").(string)), - Statistic: buildStatisticUpdateOpts(d.Get("statistic").(string)), - Threshold: d.Get("threshold").(string), - EvaluationPeriods: int32(d.Get("evaluation_periods").(int)), - } - - log.Printf("[DEBUG] Update %s Options: %#v", updateOpts.AlarmRuleName, updateOpts) - reqOpts := aom.UpdateAlarmRuleRequest{ - Body: &updateOpts, + updateHttpUrl := "v2/{project_id}/alarm-rules" + updatePath := client.Endpoint + updateHttpUrl + updatePath = strings.ReplaceAll(updatePath, "{project_id}", client.ProjectID) + updateOpt := golangsdk.RequestOpts{ + KeepResponseBody: true, + MoreHeaders: map[string]string{ + "Content-Type": "application/json", + }, + JSONBody: utils.RemoveNil(buildV2AlarmRuleBodyParams(d)), } - _, err = client.UpdateAlarmRule(&reqOpts) + _, err = client.Request("PUT", updatePath, &updateOpt) if err != nil { - return diag.Errorf("error updating AOM alarm rule %s: %s", updateOpts.AlarmRuleName, err) + return diag.Errorf("error updating the alarm rule: %s", err) } return resourceAlarmRuleRead(ctx, d, meta) @@ -440,14 +376,28 @@ func resourceAlarmRuleUpdate(ctx context.Context, d *schema.ResourceData, meta i func resourceAlarmRuleDelete(_ context.Context, d *schema.ResourceData, meta interface{}) diag.Diagnostics { cfg := meta.(*config.Config) - client, err := cfg.HcAomV2Client(cfg.GetRegion(d)) + client, err := cfg.NewServiceClient("aom", cfg.GetRegion(d)) if err != nil { return diag.Errorf("error creating AOM client: %s", err) } - _, err = client.DeleteAlarmRule(&aom.DeleteAlarmRuleRequest{AlarmRuleId: d.Id()}) + deleteHttpUrl := "v2/{project_id}/alarm-rules/{alarm_rule_id}" + deletePath := client.Endpoint + deleteHttpUrl + deletePath = strings.ReplaceAll(deletePath, "{project_id}", client.ProjectID) + deletePath = strings.ReplaceAll(deletePath, "{alarm_rule_id}", d.Id()) + + deleteOpt := golangsdk.RequestOpts{ + KeepResponseBody: true, + MoreHeaders: map[string]string{ + "Content-Type": "application/json", + }, + } + + _, err = client.Request("DELETE", deletePath, &deleteOpt) if err != nil { - return diag.Errorf("error deleting AOM alarm rule %s: %s", d.Id(), err) + return common.CheckDeletedDiag(d, common.ConvertExpected400ErrInto404Err(err, "error_code", "AOM.02005112"), + "error deleting the alarm rule") } + return nil }