Skip to content

Commit 4a03a7f

Browse files
rmamilla-sumormamilla-sumo
committed
Merge branch 'master' into feature/SUMO-191578-monitor-configurable-resolution-window-support
2 parents 1c59f9e + e163195 commit 4a03a7f

10 files changed

+744
-308
lines changed

‎CHANGELOG.md‎

Lines changed: 13 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -1,9 +1,19 @@
1-
## 2.19.0
1+
## 2.19.1
22

33
FEATURES:
4-
* Add new optional `resolution_window` field to resource/sumologic_monitor
4+
* Add new optional `resolution_window` field to resource/sumologic_monitor (GH-418)
55

6-
## 2.18.1 (August 25, 2022)
6+
## 2.19.0
7+
FEATURES:
8+
* **New Resource:** sumologic_cse_entity_normalization_configuration (GH-430)
9+
10+
11+
## 2.18.2 (September 1, 2022)
12+
13+
BUG FIXES:
14+
* Fix bug for validation for monitor name and description regex (GH-428)
15+
16+
## 2.18.1 (August 31, 2022)
717

818
BUG FIXES:
919
* Fix compliance period validation for SLOs (GH-424)

‎sumologic/provider.go‎

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -43,6 +43,7 @@ func Provider() terraform.ResourceProvider {
4343
},
4444
},
4545
ResourcesMap: map[string]*schema.Resource{
46+
"sumologic_cse_entity_normalization_configuration": resourceSumologicCSEEntityNormalizationConfiguration(),
4647
"sumologic_cse_inventory_entity_group_configuration": resourceSumologicCSEInventoryEntityGroupConfiguration(),
4748
"sumologic_cse_entity_entity_group_configuration": resourceSumologicCSEEntityEntityGroupConfiguration(),
4849
"sumologic_cse_match_list": resourceSumologicCSEMatchList(),

‎sumologic/resource_sumologic_cse_entity_normalization_configuration.go‎

Lines changed: 164 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,164 @@
1+
package sumologic
2+
3+
import (
4+
"github.com/hashicorp/terraform-plugin-sdk/helper/schema"
5+
"log"
6+
)
7+
8+
func resourceSumologicCSEEntityNormalizationConfiguration() *schema.Resource {
9+
return &schema.Resource{
10+
Create: resourceSumologicCSEEntityNormalizationConfigurationCreate,
11+
Read: resourceSumologicCSEEntityNormalizationConfigurationRead,
12+
Delete: resourceSumologicCSEEntityNormalizationConfigurationDelete,
13+
Update: resourceSumologicCSEEntityNormalizationConfigurationUpdate,
14+
Importer: &schema.ResourceImporter{
15+
State: schema.ImportStatePassthrough,
16+
},
17+
18+
Schema: map[string]*schema.Schema{
19+
"windows_normalization_enabled": {
20+
Type: schema.TypeBool,
21+
Required: true,
22+
},
23+
"fqdn_normalization_enabled": {
24+
Type: schema.TypeBool,
25+
Required: true,
26+
},
27+
"aws_normalization_enabled": {
28+
Type: schema.TypeBool,
29+
Required: true,
30+
},
31+
"default_normalized_domain": {
32+
Type: schema.TypeString,
33+
Optional: true,
34+
},
35+
"normalize_hostnames": {
36+
Type: schema.TypeBool,
37+
Required: true,
38+
},
39+
"normalize_usernames": {
40+
Type: schema.TypeBool,
41+
Required: true,
42+
},
43+
"domain_mappings": {
44+
Type: schema.TypeList,
45+
Required: true,
46+
Elem: &schema.Resource{
47+
Schema: map[string]*schema.Schema{
48+
"normalized_domain": {
49+
Type: schema.TypeString,
50+
Required: true,
51+
},
52+
"raw_domain": {
53+
Type: schema.TypeString,
54+
Required: true,
55+
},
56+
},
57+
},
58+
},
59+
},
60+
}
61+
}
62+
63+
func resourceSumologicCSEEntityNormalizationConfigurationRead(d *schema.ResourceData, meta interface{}) error {
64+
c := meta.(*Client)
65+
66+
var CSEEntityNormalizationConfiguration *CSEEntityNormalizationConfiguration
67+
68+
CSEEntityNormalizationConfiguration, err := c.GetCSEEntityNormalizationConfiguration()
69+
if err != nil {
70+
log.Printf("[WARN] CSE Entity Normalization Configuration not found, err: %v", err)
71+
72+
}
73+
74+
if CSEEntityNormalizationConfiguration == nil {
75+
log.Printf("[WARN] CSE Entity Normalization Configuration not found, removing from state: %v", err)
76+
d.SetId("")
77+
return nil
78+
}
79+
80+
d.Set("windows_normalization_enabled", CSEEntityNormalizationConfiguration.WindowsNormalizationEnabled)
81+
d.Set("fqdn_normalization_enabled", CSEEntityNormalizationConfiguration.FqdnNormalizationEnabled)
82+
d.Set("aws_normalization_enabled", CSEEntityNormalizationConfiguration.AwsNormalizationEnabled)
83+
d.Set("default_normalized_domain", CSEEntityNormalizationConfiguration.DefaultNormalizedDomain)
84+
d.Set("normalized_hostnames", CSEEntityNormalizationConfiguration.NormalizeHostnames)
85+
d.Set("normalized_usernames", CSEEntityNormalizationConfiguration.NormalizeUsernames)
86+
d.Set("domain_mappings", domainMappingsToResource(CSEEntityNormalizationConfiguration.DomainMappings))
87+
88+
return nil
89+
}
90+
91+
func domainMappingsToResource(domainMappings []DomainMapping) []map[string]interface{} {
92+
result := make([]map[string]interface{}, len(domainMappings))
93+
94+
for i, domainMapping := range domainMappings {
95+
result[i] = map[string]interface{}{
96+
"normalized_domain": domainMapping.NormalizedDomain,
97+
"raw_domain": domainMapping.RawDomain,
98+
}
99+
}
100+
101+
return result
102+
}
103+
104+
func resourceSumologicCSEEntityNormalizationConfigurationDelete(d *schema.ResourceData, meta interface{}) error {
105+
CSEEntityNormalizationConfiguration := CSEEntityNormalizationConfiguration{false, false, false, "", false, false, []DomainMapping{}}
106+
107+
c := meta.(*Client)
108+
err := c.UpdateCSEEntityNormalizationConfiguration(CSEEntityNormalizationConfiguration)
109+
if err != nil {
110+
return err
111+
}
112+
113+
return resourceSumologicCSEEntityNormalizationConfigurationRead(d, meta)
114+
}
115+
116+
func resourceSumologicCSEEntityNormalizationConfigurationCreate(d *schema.ResourceData, meta interface{}) error {
117+
//we are not really creating new object in backend, using constant id for terraform resource
118+
d.SetId("cse-entity-normalization-configuration")
119+
return resourceSumologicCSEEntityNormalizationConfigurationUpdate(d, meta)
120+
}
121+
122+
func resourceSumologicCSEEntityNormalizationConfigurationUpdate(d *schema.ResourceData, meta interface{}) error {
123+
CSEEntityNormalizationConfiguration, err := resourceToCSEEntityNormalizationConfiguration(d)
124+
if err != nil {
125+
return err
126+
}
127+
128+
c := meta.(*Client)
129+
if err = c.UpdateCSEEntityNormalizationConfiguration(CSEEntityNormalizationConfiguration); err != nil {
130+
return err
131+
}
132+
133+
return resourceSumologicCSEEntityNormalizationConfigurationRead(d, meta)
134+
}
135+
136+
func resourceToCSEEntityNormalizationConfiguration(d *schema.ResourceData) (CSEEntityNormalizationConfiguration, error) {
137+
id := d.Id()
138+
if id == "" {
139+
return CSEEntityNormalizationConfiguration{}, nil
140+
}
141+
142+
return CSEEntityNormalizationConfiguration{
143+
WindowsNormalizationEnabled: d.Get("windows_normalization_enabled").(bool),
144+
FqdnNormalizationEnabled: d.Get("fqdn_normalization_enabled").(bool),
145+
AwsNormalizationEnabled: d.Get("aws_normalization_enabled").(bool),
146+
DefaultNormalizedDomain: d.Get("default_normalized_domain").(string),
147+
NormalizeHostnames: d.Get("normalize_hostnames").(bool),
148+
NormalizeUsernames: d.Get("normalize_usernames").(bool),
149+
DomainMappings: resourceToDomainMappingArray(d.Get("domain_mappings").([]interface{})),
150+
}, nil
151+
}
152+
153+
func resourceToDomainMappingArray(resourceDomainMappings []interface{}) []DomainMapping {
154+
result := make([]DomainMapping, len(resourceDomainMappings))
155+
156+
for i, resourceDomainMapping := range resourceDomainMappings {
157+
result[i] = DomainMapping{
158+
NormalizedDomain: resourceDomainMapping.(map[string]interface{})["normalized_domain"].(string),
159+
RawDomain: resourceDomainMapping.(map[string]interface{})["raw_domain"].(string),
160+
}
161+
}
162+
163+
return result
164+
}

‎sumologic/resource_sumologic_cse_entity_normalization_configuration_test.go‎

Lines changed: 141 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,141 @@
1+
package sumologic
2+
3+
import (
4+
"fmt"
5+
"testing"
6+
7+
"github.com/hashicorp/terraform-plugin-sdk/helper/resource"
8+
"github.com/hashicorp/terraform-plugin-sdk/terraform"
9+
)
10+
11+
func TestAccSumologicSCEEntityNormalizationConfiguration_create(t *testing.T) {
12+
SkipCseTest(t)
13+
14+
var entityNormalizationConfiguration CSEEntityNormalizationConfiguration
15+
nWindowsNormalizationEnabled := true
16+
nFqdnNormalizationEnabled := true
17+
nAwsNormalizationEnabled := true
18+
nDefaultNormalizedDomain := "test.domain"
19+
nNormalizeHostnames := true
20+
nNormalizeUsernames := true
21+
nNormalizedDomain := "normalized.domain"
22+
nRawDomain := "raw.domain"
23+
24+
resourceName := "sumologic_cse_entity_normalization_configuration.entity_normalization_configuration"
25+
resource.Test(t, resource.TestCase{
26+
PreCheck: func() { testAccPreCheck(t) },
27+
Providers: testAccProviders,
28+
CheckDestroy: testAccCSEEntityNormalizationConfigurationDestroy,
29+
Steps: []resource.TestStep{
30+
{
31+
Config: testCreateCSEEntityNormalizationConfigurationConfig(nWindowsNormalizationEnabled, nFqdnNormalizationEnabled, nAwsNormalizationEnabled, nDefaultNormalizedDomain, nNormalizeHostnames, nNormalizeUsernames, nNormalizedDomain, nRawDomain),
32+
Check: resource.ComposeTestCheckFunc(
33+
testCheckCSEEntityNormalizationConfigurationExists(resourceName, &entityNormalizationConfiguration),
34+
testCheckEntityNormalizationConfigurationValues(&entityNormalizationConfiguration, nWindowsNormalizationEnabled, nFqdnNormalizationEnabled, nAwsNormalizationEnabled, nDefaultNormalizedDomain,
35+
nNormalizeHostnames, nNormalizeUsernames, nNormalizedDomain, nRawDomain),
36+
resource.TestCheckResourceAttrSet(resourceName, "id"),
37+
),
38+
},
39+
},
40+
})
41+
}
42+
43+
func testAccCSEEntityNormalizationConfigurationDestroy(s *terraform.State) error {
44+
client := testAccProvider.Meta().(*Client)
45+
46+
for _, rs := range s.RootModule().Resources {
47+
if rs.Type != "sumologic_cse_entity_normalization_configuration" {
48+
continue
49+
}
50+
51+
if rs.Primary.ID == "" {
52+
return fmt.Errorf("CSE Entity Normalization destruction check: CSE Entity Normalization ID is not set")
53+
}
54+
55+
s, err := client.GetCSEEntityNormalizationConfiguration()
56+
if err != nil {
57+
return fmt.Errorf("Encountered an error: " + err.Error())
58+
}
59+
if s != nil {
60+
if s.NormalizeHostnames != false && s.NormalizeUsernames != false {
61+
return fmt.Errorf("entity normalization Configuration still exists")
62+
}
63+
}
64+
}
65+
return nil
66+
}
67+
68+
func testCreateCSEEntityNormalizationConfigurationConfig(nWindowsNormalizationEnabled bool, nFqdnNormalizationEnabled bool, nAwsNormalizationEnabled bool, nDefaultNormalizedDomain string,
69+
nNormalizeHostnames bool, nNormalizeUsernames bool, nNormalizedDomain string, nRawDomain string) string {
70+
return fmt.Sprintf(`
71+
resource "sumologic_cse_entity_normalization_configuration" "entity_normalization_configuration" {
72+
windows_normalization_enabled = "%t"
73+
fqdn_normalization_enabled = "%t"
74+
aws_normalization_enabled = "%t"
75+
default_normalized_domain = "%s"
76+
normalize_hostnames = "%t"
77+
normalize_usernames = "%t"
78+
domain_mappings{
79+
normalized_domain = "%s"
80+
raw_domain = "%s"
81+
}
82+
}
83+
`, nWindowsNormalizationEnabled, nFqdnNormalizationEnabled, nAwsNormalizationEnabled, nDefaultNormalizedDomain,
84+
nNormalizeHostnames, nNormalizeUsernames, nNormalizedDomain, nRawDomain)
85+
}
86+
87+
func testCheckCSEEntityNormalizationConfigurationExists(n string, insightConfiguration *CSEEntityNormalizationConfiguration) resource.TestCheckFunc {
88+
return func(s *terraform.State) error {
89+
rs, ok := s.RootModule().Resources[n]
90+
if !ok {
91+
return fmt.Errorf("not found: %s", n)
92+
}
93+
94+
if rs.Primary.ID == "" {
95+
return fmt.Errorf("insight Configuration ID is not set")
96+
}
97+
98+
c := testAccProvider.Meta().(*Client)
99+
insightConfigurationResp, err := c.GetCSEEntityNormalizationConfiguration()
100+
if err != nil {
101+
return err
102+
}
103+
104+
*insightConfiguration = *insightConfigurationResp
105+
106+
return nil
107+
}
108+
}
109+
110+
func testCheckEntityNormalizationConfigurationValues(entityNormalizationConfiguration *CSEEntityNormalizationConfiguration, nWindowsNormalizationEnabled bool, nFqdnNormalizationEnabled bool, nAwsNormalizationEnabled bool, nDefaultNormalizedDomain string,
111+
nNormalizeHostnames bool, nNormalizeUsernames bool, nNormalizedDomain string, nRawDomain string) resource.TestCheckFunc {
112+
return func(s *terraform.State) error {
113+
114+
if entityNormalizationConfiguration.WindowsNormalizationEnabled != nWindowsNormalizationEnabled {
115+
return fmt.Errorf("bad windows_normalization_enabled, expected \"%t\", got: %#v", nWindowsNormalizationEnabled, entityNormalizationConfiguration.WindowsNormalizationEnabled)
116+
}
117+
if entityNormalizationConfiguration.FqdnNormalizationEnabled != nFqdnNormalizationEnabled {
118+
return fmt.Errorf("bad fqdn_normalization_enabled, expected \"%t\", got: %#v", nFqdnNormalizationEnabled, entityNormalizationConfiguration.FqdnNormalizationEnabled)
119+
}
120+
if entityNormalizationConfiguration.AwsNormalizationEnabled != nAwsNormalizationEnabled {
121+
return fmt.Errorf("bad aws_normalization_enabled, expected \"%t\", got: %#v", nAwsNormalizationEnabled, entityNormalizationConfiguration.AwsNormalizationEnabled)
122+
}
123+
if entityNormalizationConfiguration.DefaultNormalizedDomain != nDefaultNormalizedDomain {
124+
return fmt.Errorf("bad default_normalized_domain, expected \"%s\", got: %#v", nDefaultNormalizedDomain, entityNormalizationConfiguration.DefaultNormalizedDomain)
125+
}
126+
if entityNormalizationConfiguration.NormalizeHostnames != nNormalizeHostnames {
127+
return fmt.Errorf("bad normalize_hostnames, expected \"%t\", got: %#v", nNormalizeHostnames, entityNormalizationConfiguration.NormalizeHostnames)
128+
}
129+
if entityNormalizationConfiguration.NormalizeUsernames != nNormalizeUsernames {
130+
return fmt.Errorf("bad normalize_usernames, expected \"%t\", got: %#v", nNormalizeUsernames, entityNormalizationConfiguration.NormalizeUsernames)
131+
}
132+
if entityNormalizationConfiguration.DomainMappings[0].NormalizedDomain != nNormalizedDomain {
133+
return fmt.Errorf("bad normalized_domain, expected \"%s\", got: %#v", nNormalizedDomain, entityNormalizationConfiguration.DomainMappings[0].NormalizedDomain)
134+
}
135+
if entityNormalizationConfiguration.DomainMappings[0].RawDomain != nRawDomain {
136+
return fmt.Errorf("bad raw_domain, expected \"%s\", got: %#v", nNormalizedDomain, entityNormalizationConfiguration.DomainMappings[0].RawDomain)
137+
}
138+
139+
return nil
140+
}
141+
}

0 commit comments

Comments
 (0)