Merge pull request #274 from SumoLogic/APP-1056_insights_related_resources

Add support for CSE Insights related resources

Author: pmontiel-git

CHANGELOG.md

@@ -2,7 +2,9 @@
 FEATURES:
 
 * **New Resource:** sumologic_cse_rule_tuning_expression (GH-281)
-
+* **New Resource:** sumologic_cse_insights_resolution (GH-274)
+* **New Resource:** sumologic_cse_insights_status (GH-274)
+* **New Resource:** sumologic_cse_insights_configuration (GH-274)
 
 ## 2.10.0 (September 22, 2021)
 
@@ -15,8 +17,8 @@ FEATURES:
 
 POTENTIALLY BREAKING CHANGES:
 
-* resource/sumologic_policies: Changed all policies to be required. Configurations might need to be updated in 
-case some policies were not specified previously. (GH-279)
+* resource/sumologic_policies: Changed all policies to be required. Configurations might need to be updated in
+  case some policies were not specified previously. (GH-279)
 
 DEPRECATIONS:
 

sumologic/provider.go

@@ -45,6 +45,9 @@ func Provider() terraform.ResourceProvider {
 		ResourcesMap: map[string]*schema.Resource{
 			"sumologic_cse_rule_tuning_expression":         resourceSumologicCSERuleTuningExpression(),
 			"sumologic_cse_network_block":                  resourceSumologicCSENetworkBlock(),
+			"sumologic_cse_insights_configuration":         resourceSumologicCSEInsightsConfiguration(),
+			"sumologic_cse_insights_resolution":            resourceSumologicCSEInsightsResolution(),
+			"sumologic_cse_insights_status":                resourceSumologicCSEInsightsStatus(),
 			"sumologic_collector":                          resourceSumologicCollector(),
 			"sumologic_http_source":                        resourceSumologicHTTPSource(),
 			"sumologic_gcp_source":                         resourceSumologicGCPSource(),

sumologic/resource_sumologic_cse_insights_configuration.go

@@ -0,0 +1,101 @@
+package sumologic
+
+import (
+	"github.com/hashicorp/terraform-plugin-sdk/helper/schema"
+	"log"
+)
+
+func resourceSumologicCSEInsightsConfiguration() *schema.Resource {
+	return &schema.Resource{
+		Create: resourceSumologicCSEInsightsConfigurationCreate,
+		Read:   resourceSumologicCSEInsightsConfigurationRead,
+		Delete: resourceSumologicCSEInsightsConfigurationDelete,
+		Update: resourceSumologicCSEInsightsConfigurationUpdate,
+		Importer: &schema.ResourceImporter{
+			State: schema.ImportStatePassthrough,
+		},
+
+		Schema: map[string]*schema.Schema{
+			"lookback_days": {
+				Type:     schema.TypeFloat,
+				Optional: true,
+				ForceNew: false,
+			},
+			"threshold": {
+				Type:     schema.TypeFloat,
+				Optional: true,
+				ForceNew: false,
+			},
+		},
+	}
+}
+
+func resourceSumologicCSEInsightsConfigurationRead(d *schema.ResourceData, meta interface{}) error {
+	c := meta.(*Client)
+
+	var CSEInsightsConfiguration *CSEInsightsConfiguration
+
+	CSEInsightsConfiguration, err := c.GetCSEInsightsConfiguration()
+	if err != nil {
+		log.Printf("[WARN] CSE Insights Configuration not found, err: %v", err)
+
+	}
+
+	if CSEInsightsConfiguration == nil {
+		log.Printf("[WARN] CSE Insights Configuration not found, removing from state: %v", err)
+		d.SetId("")
+		return nil
+	}
+
+	d.Set("lookback_days", CSEInsightsConfiguration.LookbackDays)
+	d.Set("threshold", CSEInsightsConfiguration.Threshold)
+
+	return nil
+}
+
+func resourceSumologicCSEInsightsConfigurationDelete(d *schema.ResourceData, meta interface{}) error {
+	CSEInsightsConfiguration := CSEInsightsConfiguration{}
+
+	c := meta.(*Client)
+	err := c.UpdateCSEInsightsConfiguration(CSEInsightsConfiguration)
+	if err != nil {
+		return err
+	}
+
+	return resourceSumologicCSEInsightsConfigurationRead(d, meta)
+}
+
+func resourceSumologicCSEInsightsConfigurationCreate(d *schema.ResourceData, meta interface{}) error {
+	//we are not really creating new object in backend, using constant id for terraform resource
+	d.SetId("cse-insights-configuration")
+	return resourceSumologicCSEInsightsConfigurationUpdate(d, meta)
+}
+
+func resourceSumologicCSEInsightsConfigurationUpdate(d *schema.ResourceData, meta interface{}) error {
+	CSEInsightsConfiguration, err := resourceToCSEInsightsConfiguration(d)
+	if err != nil {
+		return err
+	}
+
+	c := meta.(*Client)
+	if err = c.UpdateCSEInsightsConfiguration(CSEInsightsConfiguration); err != nil {
+		return err
+	}
+
+	return resourceSumologicCSEInsightsConfigurationRead(d, meta)
+}
+
+func resourceToCSEInsightsConfiguration(d *schema.ResourceData) (CSEInsightsConfiguration, error) {
+	id := d.Id()
+	if id == "" {
+		return CSEInsightsConfiguration{}, nil
+	}
+
+	lookbackDays := d.Get("lookback_days").(float64)
+	threshold := d.Get("threshold").(float64)
+
+	return CSEInsightsConfiguration{
+		LookbackDays: &lookbackDays,
+		Threshold:    &threshold,
+	}, nil
+}

sumologic/resource_sumologic_cse_insights_configuration_test.go

@@ -0,0 +1,101 @@
+package sumologic
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/hashicorp/terraform-plugin-sdk/helper/resource"
+	"github.com/hashicorp/terraform-plugin-sdk/terraform"
+)
+
+func TestAccSumologicSCEInsightsConfiguration_create(t *testing.T) {
+	var insightConfiguration CSEInsightsConfiguration
+	nLookbackDays := 10.0
+	nThreshold := 13.0
+	resourceName := "sumologic_cse_insights_configuration.insights_configuration"
+	resource.Test(t, resource.TestCase{
+		PreCheck:     func() { testAccPreCheck(t) },
+		Providers:    testAccProviders,
+		CheckDestroy: testAccCSEInsightsConfigurationDestroy,
+		Steps: []resource.TestStep{
+			{
+				Config: testCreateCSEInsightsConfigurationConfig(nLookbackDays, nThreshold),
+				Check: resource.ComposeTestCheckFunc(
+					testCheckCSEInsightsConfigurationExists(resourceName, &insightConfiguration),
+					testCheckInsightsConfigurationValues(&insightConfiguration, nLookbackDays, nThreshold),
+					resource.TestCheckResourceAttrSet(resourceName, "id"),
+				),
+			},
+		},
+	})
+}
+
+func testAccCSEInsightsConfigurationDestroy(s *terraform.State) error {
+	client := testAccProvider.Meta().(*Client)
+
+	for _, rs := range s.RootModule().Resources {
+		if rs.Type != "sumologic_cse_insights_configuration" {
+			continue
+		}
+
+		if rs.Primary.ID == "" {
+			return fmt.Errorf("CSE Insights Status destruction check: CSE Insights Status ID is not set")
+		}
+
+		s, err := client.GetCSEInsightsConfiguration()
+		if err != nil {
+			return fmt.Errorf("Encountered an error: " + err.Error())
+		}
+		if s != nil {
+			if s.Threshold != nil && s.LookbackDays != nil {
+				return fmt.Errorf("insight Configuration still exists")
+			}
+		}
+	}
+	return nil
+}
+
+func testCreateCSEInsightsConfigurationConfig(nLookbackDays float64, nThreshold float64) string {
+	return fmt.Sprintf(`
+resource "sumologic_cse_insights_configuration" "insights_configuration" {
+	lookback_days = "%f"
+	threshold = "%f"
+}
+`, nLookbackDays, nThreshold)
+}
+
+func testCheckCSEInsightsConfigurationExists(n string, insightConfiguration *CSEInsightsConfiguration) resource.TestCheckFunc {
+	return func(s *terraform.State) error {
+		rs, ok := s.RootModule().Resources[n]
+		if !ok {
+			return fmt.Errorf("not found: %s", n)
+		}
+
+		if rs.Primary.ID == "" {
+			return fmt.Errorf("insight Configuration ID is not set")
+		}
+
+		c := testAccProvider.Meta().(*Client)
+		insightConfigurationResp, err := c.GetCSEInsightsConfiguration()
+		if err != nil {
+			return err
+		}
+
+		*insightConfiguration = *insightConfigurationResp
+
+		return nil
+	}
+}
+
+func testCheckInsightsConfigurationValues(insightConfiguration *CSEInsightsConfiguration, nLookbackDays float64, nThreshold float64) resource.TestCheckFunc {
+	return func(s *terraform.State) error {
+		if *insightConfiguration.LookbackDays != nLookbackDays {
+			return fmt.Errorf("bad lookback days, expected \"%f\", got: %#v", nLookbackDays, insightConfiguration.LookbackDays)
+		}
+		if *insightConfiguration.Threshold != nThreshold {
+			return fmt.Errorf("bad threshold, expected \"%f\", got: %#v", nThreshold, insightConfiguration.Threshold)
+		}
+
+		return nil
+	}
+}

sumologic/resource_sumologic_cse_insights_resolution.go

@@ -0,0 +1,157 @@
+package sumologic
+
+import (
+	"github.com/hashicorp/terraform-plugin-sdk/helper/schema"
+	"github.com/hashicorp/terraform-plugin-sdk/helper/validation"
+	"log"
+	"strconv"
+)
+
+const Resolved string = "Resolved"
+const FalsePositive string = "FalsePositive"
+const NoAction string = "NoAction"
+const Duplicate string = "Duplicate"
+
+func resourceSumologicCSEInsightsResolution() *schema.Resource {
+	return &schema.Resource{
+		Create: resourceSumologicCSEInsightsResolutionCreate,
+		Read:   resourceSumologicCSEInsightsResolutionRead,
+		Delete: resourceSumologicCSEInsightsResolutionDelete,
+		Update: resourceSumologicCSEInsightsResolutionUpdate,
+		Importer: &schema.ResourceImporter{
+			State: schema.ImportStatePassthrough,
+		},
+
+		Schema: map[string]*schema.Schema{
+			"description": {
+				Type:     schema.TypeString,
+				Optional: true,
+				ForceNew: false,
+			},
+			"name": {
+				Type:     schema.TypeString,
+				Required: true,
+				ForceNew: false,
+			},
+			"parent": {
+				Type:         schema.TypeString,
+				Optional:     true,
+				ForceNew:     false,
+				ValidateFunc: validation.StringInSlice([]string{Resolved, FalsePositive, NoAction, Duplicate}, false),
+			},
+		},
+	}
+}
+
+func resourceSumologicCSEInsightsResolutionRead(d *schema.ResourceData, meta interface{}) error {
+	c := meta.(*Client)
+
+	var CSEInsightsResolutionGet *CSEInsightsResolutionGet
+	id := d.Id()
+
+	CSEInsightsResolutionGet, err := c.GetCSEInsightsResolution(id)
+	if err != nil {
+		log.Printf("[WARN] CSE Insights Resolution not found when looking by id: %s, err: %v", id, err)
+
+	}
+
+	if CSEInsightsResolutionGet == nil {
+		log.Printf("[WARN] CSE Insights Resolution not found, removing from state: %v - %v", id, err)
+		d.SetId("")
+		return nil
+	}
+
+	d.Set("name", CSEInsightsResolutionGet.Name)
+	d.Set("description", CSEInsightsResolutionGet.Description)
+	d.Set("parent", parentIdToParentName(CSEInsightsResolutionGet.Parent.ID))
+
+	return nil
+}
+
+func parentIdToParentName(parentId int) string {
+
+	parentName := ""
+
+	if parentId > 0 {
+		if parentId == 1 {
+			parentName = Resolved
+		} else if parentId == 2 {
+			parentName = FalsePositive
+		} else if parentId == 3 {
+			parentName = NoAction
+		} else if parentId == 4 {
+			parentName = Duplicate
+		}
+	}
+	return parentName
+}
+
+func parentNameToParentId(parentName string) int {
+
+	parentId := -1
+
+	if parentName == Resolved {
+		parentId = 1
+	} else if parentName == FalsePositive {
+		parentId = 2
+	} else if parentName == NoAction {
+		parentId = 3
+	} else if parentName == Duplicate {
+		parentId = 4
+	}
+
+	return parentId
+}
+
+func resourceSumologicCSEInsightsResolutionDelete(d *schema.ResourceData, meta interface{}) error {
+	c := meta.(*Client)
+
+	id := d.Id()
+	return c.DeleteCSEInsightsResolution(id)
+
+}
+
+func resourceSumologicCSEInsightsResolutionCreate(d *schema.ResourceData, meta interface{}) error {
+	c := meta.(*Client)
+
+	if d.Id() == "" {
+		id, err := c.CreateCSEInsightsResolution(CSEInsightsResolutionPost{
+			Name:        d.Get("name").(string),
+			Description: d.Get("description").(string),
+			ParentId:    parentNameToParentId(d.Get("parent").(string)),
+		})
+
+		if err != nil {
+			return err
+		}
+		d.SetId(strconv.Itoa(id))
+	}
+
+	return resourceSumologicCSEInsightsResolutionUpdate(d, meta)
+}
+
+func resourceSumologicCSEInsightsResolutionUpdate(d *schema.ResourceData, meta interface{}) error {
+	CSEInsightsResolutionPost, err := resourceToCSEInsightsResolution(d)
+	if err != nil {
+		return err
+	}
+
+	c := meta.(*Client)
+	if err = c.UpdateCSEInsightsResolution(CSEInsightsResolutionPost); err != nil {
+		return err
+	}
+
+	return resourceSumologicCSEInsightsResolutionRead(d, meta)
+}
+
+func resourceToCSEInsightsResolution(d *schema.ResourceData) (CSEInsightsResolutionPost, error) {
+	id, err := strconv.Atoi(d.Id())
+	if err != nil {
+		return CSEInsightsResolutionPost{}, err
+	}
+
+	return CSEInsightsResolutionPost{
+		ID:          id,
+		Description: d.Get("description").(string),
+	}, nil
+}