Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Jump to bottom

new resource azurerm_monitor_action_rule_action_group, azurerm_monitor_action_rule_suppression #6563

Merged
merged 5 commits into from Jun 4, 2020
Merged

new resource azurerm_monitor_action_rule_action_group, azurerm_monitor_action_rule_suppression #6563

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
5 commits
Select commit Hold shift + click to select a range
b0a57ce
new resource `azurerm_monitor_action_rule`
njuCZ May 12, 2020
6442ab9
update
njuCZ May 12, 2020
a71857b
split into different resources
njuCZ May 25, 2020
eb88851
update deps
njuCZ May 25, 2020
30421ea
refactor based on KT's suggestion
njuCZ Jun 3, 2020
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Jump to
Jump to file
Failed to load files.
Diff view
Diff view
302 changes: 302 additions & 0 deletions azurerm/internal/services/monitor/action_rule.go
View file
Open in desktop
@@ -0,0 +1,302 @@
package monitor

import (
"fmt"

"github.com/Azure/azure-sdk-for-go/services/preview/alertsmanagement/mgmt/2019-05-05/alertsmanagement"
"github.com/hashicorp/terraform-plugin-sdk/helper/schema"
"github.com/hashicorp/terraform-plugin-sdk/helper/validation"
"github.com/terraform-providers/terraform-provider-azurerm/azurerm/internal/clients"
"github.com/terraform-providers/terraform-provider-azurerm/azurerm/internal/services/monitor/parse"
"github.com/terraform-providers/terraform-provider-azurerm/azurerm/internal/timeouts"
"github.com/terraform-providers/terraform-provider-azurerm/azurerm/utils"
)

const (
scheduleDateLayout = "01/02/2006"
scheduleTimeLayout = "15:04:05"
scheduleDateTimeLayout = scheduleDateLayout + " " + scheduleTimeLayout
)

var weekDays = []string{
"Sunday",
"Monday",
"Tuesday",
"Wednesday",
"Thursday",
"Friday",
"Saturday",
}

var weekDayMap = map[string]int{
"Sunday": 0,
"Monday": 1,
"Tuesday": 2,
"Wednesday": 3,
"Thursday": 4,
"Friday": 5,
"Saturday": 6,
}

func schemaActionRuleConditions() *schema.Schema {
return &schema.Schema{
Type: schema.TypeList,
Optional: true,
MaxItems: 1,
Elem: &schema.Resource{
Schema: map[string]*schema.Schema{
"alert_context": schemaActionRuleCondition(
[]string{
string(alertsmanagement.Equals),
string(alertsmanagement.NotEquals),
string(alertsmanagement.Contains),
string(alertsmanagement.DoesNotContain),
},
nil,
),

"alert_rule_id": schemaActionRuleCondition(
[]string{
string(alertsmanagement.Equals),
string(alertsmanagement.NotEquals),
string(alertsmanagement.Contains),
string(alertsmanagement.DoesNotContain),
}, nil,
),

"description": schemaActionRuleCondition(
[]string{
string(alertsmanagement.Equals),
string(alertsmanagement.NotEquals),
string(alertsmanagement.Contains),
string(alertsmanagement.DoesNotContain),
},
nil,
),

"monitor": schemaActionRuleCondition(
[]string{
string(alertsmanagement.Equals),
string(alertsmanagement.NotEquals),
},
[]string{
string(alertsmanagement.Fired),
string(alertsmanagement.Resolved),
},
),

"monitor_service": schemaActionRuleCondition(
[]string{
string(alertsmanagement.Equals),
string(alertsmanagement.NotEquals),
},
// the supported type list is not consistent with the swagger and sdk
// https://github.com/Azure/azure-rest-api-specs/issues/9076
// directly use string constant
[]string{
"ActivityLog Administrative",
"ActivityLog Autoscale",
"ActivityLog Policy",
"ActivityLog Recommendation",
"ActivityLog Security",
"Application Insights",
"Azure Backup",
"Data Box Edge",
"Data Box Gateway",
"Health Platform",
"Log Analytics",
"Platform",
"Resource Health",
},
),

"severity": schemaActionRuleCondition(
[]string{
string(alertsmanagement.Equals),
string(alertsmanagement.NotEquals),
},
[]string{
string(alertsmanagement.Sev0),
string(alertsmanagement.Sev1),
string(alertsmanagement.Sev2),
string(alertsmanagement.Sev3),
string(alertsmanagement.Sev4),
},
),

"target_resource_type": schemaActionRuleCondition(
[]string{
string(alertsmanagement.Equals),
string(alertsmanagement.NotEquals),
},
nil,
),
},
},
}
}

func schemaActionRuleCondition(operatorValidateItems, valuesValidateItems []string) *schema.Schema {
operatorValidateFunc := validation.StringIsNotEmpty
valuesValidateFunc := validation.StringIsNotEmpty
if len(operatorValidateItems) > 0 {
operatorValidateFunc = validation.StringInSlice(operatorValidateItems, false)
}
if len(valuesValidateItems) > 0 {
valuesValidateFunc = validation.StringInSlice(valuesValidateItems, false)
}

return &schema.Schema{
Type: schema.TypeList,
Optional: true,
MaxItems: 1,
Elem: &schema.Resource{
Schema: map[string]*schema.Schema{
"operator": {
Type: schema.TypeString,
Required: true,
ValidateFunc: operatorValidateFunc,
},

"values": {
Type: schema.TypeSet,
Required: true,
Elem: &schema.Schema{
Type: schema.TypeString,
ValidateFunc: valuesValidateFunc,
},
},
},
},
}
}

func expandArmActionRuleCondition(input []interface{}) *alertsmanagement.Condition {
if len(input) == 0 {
return nil
}

v := input[0].(map[string]interface{})
return &alertsmanagement.Condition{
Operator: alertsmanagement.Operator(v["operator"].(string)),
Values: utils.ExpandStringSlice(v["values"].(*schema.Set).List()),
}
}

func expandArmActionRuleScope(input []interface{}) *alertsmanagement.Scope {
if len(input) == 0 {
return nil
}

v := input[0].(map[string]interface{})
return &alertsmanagement.Scope{
ScopeType: alertsmanagement.ScopeType(v["type"].(string)),
Values: utils.ExpandStringSlice(v["resource_ids"].(*schema.Set).List()),
}
}

func expandArmActionRuleConditions(input []interface{}) *alertsmanagement.Conditions {
if len(input) == 0 {
return nil
}
v := input[0].(map[string]interface{})

return &alertsmanagement.Conditions{
AlertContext: expandArmActionRuleCondition(v["alert_context"].([]interface{})),
AlertRuleID: expandArmActionRuleCondition(v["alert_rule_id"].([]interface{})),
Description: expandArmActionRuleCondition(v["description"].([]interface{})),
MonitorCondition: expandArmActionRuleCondition(v["monitor"].([]interface{})),
MonitorService: expandArmActionRuleCondition(v["monitor_service"].([]interface{})),
Severity: expandArmActionRuleCondition(v["severity"].([]interface{})),
TargetResourceType: expandArmActionRuleCondition(v["target_resource_type"].([]interface{})),
}
}

func flattenArmActionRuleCondition(input *alertsmanagement.Condition) []interface{} {
if input == nil {
return make([]interface{}, 0)
}

var operator string
if input.Operator != "" {
operator = string(input.Operator)
}
return []interface{}{
map[string]interface{}{
"operator": operator,
"values": utils.FlattenStringSlice(input.Values),
},
}
}

func flattenArmActionRuleScope(input *alertsmanagement.Scope) []interface{} {
if input == nil {
return make([]interface{}, 0)
}

var scopeType alertsmanagement.ScopeType
if input.ScopeType != "" {
scopeType = input.ScopeType
}
return []interface{}{
map[string]interface{}{
"type": scopeType,
"resource_ids": utils.FlattenStringSlice(input.Values),
},
}
}

func flattenArmActionRuleConditions(input *alertsmanagement.Conditions) []interface{} {
if input == nil {
return make([]interface{}, 0)
}
return []interface{}{
map[string]interface{}{
"alert_context": flattenArmActionRuleCondition(input.AlertContext),
"alert_rule_id": flattenArmActionRuleCondition(input.AlertRuleID),
"description": flattenArmActionRuleCondition(input.Description),
"monitor": flattenArmActionRuleCondition(input.MonitorCondition),
"monitor_service": flattenArmActionRuleCondition(input.MonitorService),
"severity": flattenArmActionRuleCondition(input.Severity),
"target_resource_type": flattenArmActionRuleCondition(input.TargetResourceType),
},
}
}

func importMonitorActionRule(actionRuleType alertsmanagement.Type) func(d *schema.ResourceData, meta interface{}) (data []*schema.ResourceData, err error) {
return func(d *schema.ResourceData, meta interface{}) (data []*schema.ResourceData, err error) {
id, err := parse.ActionRuleID(d.Id())
if err != nil {
return nil, err
}

client := meta.(*clients.Client).Monitor.ActionRulesClient
ctx, cancel := timeouts.ForRead(meta.(*clients.Client).StopContext, d)
defer cancel()

actionRule, err := client.GetByName(ctx, id.ResourceGroup, id.Name)
if err != nil {
return nil, fmt.Errorf("retrieving Monitor Action Rule %q (Resource Group %q): %+v", id.Name, id.ResourceGroup, err)
}

if actionRule.Properties == nil {
return nil, fmt.Errorf("retrieving Monitor Action Rule %q (Resource Group %q): `properties` was nil", id.Name, id.ResourceGroup)
}

var t alertsmanagement.Type
switch actionRule.Properties.(type) {
case alertsmanagement.Suppression:
t = alertsmanagement.TypeSuppression
case alertsmanagement.ActionGroup:
t = alertsmanagement.TypeActionGroup
case alertsmanagement.Diagnostics:
t = alertsmanagement.TypeDiagnostics
}

if t != actionRuleType {
return nil, fmt.Errorf("Monitor Action Rule has mismatched kind, expected: %q, got %q", actionRuleType, t)
}

return []*schema.ResourceData{d}, nil
}
}
8 changes: 8 additions & 0 deletions azurerm/internal/services/monitor/client/client.go
View file
Open in desktop
@@ -1,6 +1,7 @@
package client

import (
"github.com/Azure/azure-sdk-for-go/services/preview/alertsmanagement/mgmt/2019-05-05/alertsmanagement"
"github.com/Azure/azure-sdk-for-go/services/preview/monitor/mgmt/2019-06-01/insights"
"github.com/terraform-providers/terraform-provider-azurerm/azurerm/internal/common"
)
Expand All @@ -9,6 +10,9 @@ type Client struct {
// Autoscale Settings
AutoscaleSettingsClient *insights.AutoscaleSettingsClient

// alerts management
ActionRulesClient *alertsmanagement.ActionRulesClient

// Monitor
ActionGroupsClient *insights.ActionGroupsClient
ActivityLogAlertsClient *insights.ActivityLogAlertsClient
Expand All @@ -24,6 +28,9 @@ func NewClient(o *common.ClientOptions) *Client {
AutoscaleSettingsClient := insights.NewAutoscaleSettingsClientWithBaseURI(o.ResourceManagerEndpoint, o.SubscriptionId)
o.ConfigureClient(&AutoscaleSettingsClient.Client, o.ResourceManagerAuthorizer)

ActionRulesClient := alertsmanagement.NewActionRulesClientWithBaseURI(o.ResourceManagerEndpoint, o.SubscriptionId)
o.ConfigureClient(&ActionRulesClient.Client, o.ResourceManagerAuthorizer)

ActionGroupsClient := insights.NewActionGroupsClientWithBaseURI(o.ResourceManagerEndpoint, o.SubscriptionId)
o.ConfigureClient(&ActionGroupsClient.Client, o.ResourceManagerAuthorizer)

Expand All @@ -50,6 +57,7 @@ func NewClient(o *common.ClientOptions) *Client {

return &Client{
AutoscaleSettingsClient: &AutoscaleSettingsClient,
ActionRulesClient: &ActionRulesClient,
ActionGroupsClient: &ActionGroupsClient,
ActivityLogAlertsClient: &ActivityLogAlertsClient,
AlertRulesClient: &AlertRulesClient,
Expand Down