Merge pull request #762 from SumoLogic/erikatsumo-datasource-partition

ErikAtSumo · web-flow · commit 0f9fd538dea8 · 2025-05-20T10:01:38.000-04:00
New data sources for partition
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -1,6 +1,10 @@
 ## X.Y.Z (Unreleased)
 * Add new change notes here
 
+FEATURES:
+* **New Data Source:** sumologic_partition
+* **New Data Source:** sumologic_partitions
+
 ENHANCEMENTS:
 * Add support for searchable time for dashboard field time_source
 
diff --git a/sumologic/data_source_sumologic_partition.go b/sumologic/data_source_sumologic_partition.go
@@ -0,0 +1,104 @@
+package sumologic
+
+import (
+	"fmt"
+
+	"github.com/hashicorp/terraform-plugin-sdk/helper/schema"
+)
+
+func dataSourceSumologicPartition() *schema.Resource {
+	return &schema.Resource{
+		Read:   dataSourceSumologicPartitionRead,
+		Schema: dataSourcePartitionSchema(),
+	}
+}
+
+func dataSourcePartitionSchema() map[string]*schema.Schema {
+	return map[string]*schema.Schema{
+		"id": {
+			Type:     schema.TypeString,
+			Required: true,
+		},
+		"name": {
+			Type:     schema.TypeString,
+			Computed: true,
+		},
+		"routing_expression": {
+			Type:     schema.TypeString,
+			Computed: true,
+		},
+		"analytics_tier": {
+			Type:     schema.TypeString,
+			Computed: true,
+		},
+		"retention_period": {
+			Type:     schema.TypeInt,
+			Computed: true,
+		},
+		"is_compliant": {
+			Type:     schema.TypeBool,
+			Computed: true,
+		},
+		"total_bytes": {
+			Type:     schema.TypeInt,
+			Computed: true,
+		},
+		"data_forwarding_id": {
+			Type:     schema.TypeString,
+			Computed: true,
+		},
+		"is_active": {
+			Type:     schema.TypeBool,
+			Computed: true,
+		},
+		"index_type": {
+			Type:     schema.TypeString,
+			Computed: true,
+		},
+		"reduce_retention_period_immediately": {
+			Type:     schema.TypeBool,
+			Computed: true,
+		},
+		"is_included_in_default_search": {
+			Type:     schema.TypeBool,
+			Computed: true,
+		},
+	}
+}
+
+func dataSourceSumologicPartitionRead(d *schema.ResourceData, meta interface{}) error {
+	c := meta.(*Client)
+
+	var err error
+	var spartition *Partition
+
+	rid, ok := d.GetOk("id")
+
+	if !ok {
+		return fmt.Errorf("please specify the partition id")
+	}
+
+	id := rid.(string)
+	spartition, err = c.GetPartition(id)
+	if err != nil {
+		return fmt.Errorf("error retrieving partition with id %v: %v", id, err)
+	}
+	if spartition == nil {
+		return fmt.Errorf("partition with id %v not found", id)
+	}
+
+	d.SetId(spartition.ID)
+	d.Set("routing_expression", spartition.RoutingExpression)
+	d.Set("name", spartition.Name)
+	d.Set("analytics_tier", spartition.AnalyticsTier)
+	d.Set("retention_period", spartition.RetentionPeriod)
+	d.Set("is_compliant", spartition.IsCompliant)
+	d.Set("data_forwarding_id", spartition.DataForwardingId)
+	d.Set("is_active", spartition.IsActive)
+	d.Set("total_bytes", spartition.TotalBytes)
+	d.Set("index_type", spartition.IndexType)
+	d.Set("reduce_retention_period_immediately", spartition.ReduceRetentionPeriodImmediately)
+	d.Set("is_included_in_default_search", spartition.IsIncludedInDefaultSearch)
+
+	return nil
+}
diff --git a/sumologic/data_source_sumologic_partition_test.go b/sumologic/data_source_sumologic_partition_test.go
@@ -0,0 +1,45 @@
+package sumologic
+
+import (
+	"testing"
+
+	"github.com/hashicorp/terraform-plugin-sdk/helper/resource"
+)
+
+func TestAccDataSourcePartition_basic(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck:  func() { testAccPreCheck(t) },
+		Providers: testAccProviders,
+		Steps: []resource.TestStep{
+			{
+				Config: testDataSourceSumologicPartitionConfig,
+				Check: resource.ComposeTestCheckFunc(
+					testAccDataSourcePartitionCheck("data.sumologic_partition.test"),
+				),
+			},
+		},
+	})
+}
+
+func testAccDataSourcePartitionCheck(name string) resource.TestCheckFunc {
+	return resource.ComposeTestCheckFunc(
+		resource.TestCheckResourceAttr(name, "id", "00000000000AD88D"),
+		resource.TestCheckResourceAttr(name, "name", "apache"),
+		resource.TestCheckResourceAttr(name, "routing_expression", "_sourcecategory=*/Apache"),
+		resource.TestCheckResourceAttr(name, "analytics_tier", "continuous"),
+		resource.TestCheckResourceAttr(name, "retention_period", "365"),
+		resource.TestCheckResourceAttr(name, "is_compliant", "false"),
+		resource.TestCheckResourceAttr(name, "is_active", "true"),
+		resource.TestCheckResourceAttr(name, "total_bytes", "0"),
+		resource.TestCheckResourceAttr(name, "data_forwarding_id", ""),
+		resource.TestCheckResourceAttr(name, "index_type", "Partition"),
+		resource.TestCheckResourceAttr(name, "reduce_retention_period_immediately", "false"),
+		resource.TestCheckResourceAttr(name, "is_included_in_default_search", "true"),
+	)
+}
+
+var testDataSourceSumologicPartitionConfig = `
+	data "sumologic_partition" "test" {
+		id = "00000000000AD88D"
+	}
+`
diff --git a/sumologic/data_source_sumologic_partitions.go b/sumologic/data_source_sumologic_partitions.go
@@ -0,0 +1,76 @@
+package sumologic
+
+import (
+	"crypto/sha256"
+	"encoding/hex"
+	"fmt"
+	"sort"
+	"strings"
+
+	"github.com/hashicorp/terraform-plugin-sdk/helper/schema"
+)
+
+func dataSourceSumologicPartitions() *schema.Resource {
+	return &schema.Resource{
+		Read: dataSourceSumologicPartitionsRead,
+
+		Schema: map[string]*schema.Schema{
+			"partitions": {
+				Type:     schema.TypeList,
+				Computed: true,
+				Elem: &schema.Resource{
+					Schema: dataSourcePartitionSchema(),
+					Read:   dataSourceSumologicPartitionRead,
+				},
+			},
+		},
+	}
+}
+
+func dataSourceSumologicPartitionsRead(d *schema.ResourceData, meta interface{}) error {
+	c := meta.(*Client)
+
+	spartitions, err := c.ListPartitions()
+	if err != nil {
+		return fmt.Errorf("error retrieving partitions: %v", err)
+	}
+
+	partitions := make([]map[string]interface{}, 0, len(spartitions))
+
+	for _, spartition := range spartitions {
+		partition := map[string]interface{}{
+			"id":                            spartition.ID,
+			"name":                          spartition.Name,
+			"routing_expression":            spartition.RoutingExpression,
+			"analytics_tier":                spartition.AnalyticsTier,
+			"retention_period":              spartition.RetentionPeriod,
+			"is_compliant":                  spartition.IsCompliant,
+			"total_bytes":                   spartition.TotalBytes,
+			"data_forwarding_id":            spartition.DataForwardingId,
+			"is_active":                     spartition.IsActive,
+			"index_type":                    spartition.IndexType,
+			"is_included_in_default_search": spartition.IsIncludedInDefaultSearch,
+		}
+
+		partitions = append(partitions, partition)
+	}
+
+	d.Set("partitions", partitions)
+	d.SetId(generatePartitionsId(spartitions))
+
+	return nil
+}
+
+func generatePartitionsId(partitions []Partition) string {
+	// Collect a sorted list of partition IDs
+	ids := []string{"partition_ids"}
+	for _, partition := range partitions {
+		ids = append(ids, partition.ID)
+	}
+	sort.Strings(ids)
+
+	// Join all IDs and create a hash
+	idString := strings.Join(ids, "|")
+	hash := sha256.Sum256([]byte(idString))
+	return hex.EncodeToString(hash[:])
+}
diff --git a/sumologic/data_source_sumologic_partitions_test.go b/sumologic/data_source_sumologic_partitions_test.go
@@ -0,0 +1,26 @@
+package sumologic
+
+import (
+	"testing"
+
+	"github.com/hashicorp/terraform-plugin-sdk/helper/resource"
+)
+
+func TestAccDataSourcePartitions_basic(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck:  func() { testAccPreCheck(t) },
+		Providers: testAccProviders,
+		Steps: []resource.TestStep{
+			{
+				Config: testDataSourceSumologicPartitionsConfig,
+				Check: resource.ComposeTestCheckFunc(
+					checkResourceAttrGreaterThanZero("data.sumologic_partitions.test", "partitions.#"),
+				),
+			},
+		},
+	})
+}
+
+var testDataSourceSumologicPartitionsConfig = `
+	data "sumologic_partitions" "test" {}
+`
diff --git a/sumologic/provider.go b/sumologic/provider.go
@@ -134,6 +134,8 @@ func Provider() terraform.ResourceProvider {
 			"sumologic_personal_folder":                dataSourceSumologicPersonalFolder(),
 			"sumologic_folder":                         dataSourceSumologicFolder(),
 			"sumologic_my_user_id":                     dataSourceSumologicMyUserId(),
+			"sumologic_partition":                      dataSourceSumologicPartition(),
+			"sumologic_partitions":                     dataSourceSumologicPartitions(),
 			"sumologic_role":                           dataSourceSumologicRole(),
 			"sumologic_role_v2":                        dataSourceSumologicRoleV2(),
 			"sumologic_user":                           dataSourceSumologicUser(),
diff --git a/sumologic/resource_sumologic_cse_rule_tuning_expression_test.go b/sumologic/resource_sumologic_cse_rule_tuning_expression_test.go
@@ -17,7 +17,7 @@ func TestAccSumologicSCERuleTuningExpression_create(t *testing.T) {
 	var ruleTuningExpression CSERuleTuningExpression
 	nName := acctest.RandomWithPrefix("New Rule Tuning Name")
 	nDescription := "New Rule Tuning Description"
-	nExpression := "expression"
+	nExpression := "accountId = 1234"
 	nEnabled := true
 	nExclude := true
 	nIsGlobal := false
diff --git a/sumologic/sumologic_partition.go b/sumologic/sumologic_partition.go
@@ -63,6 +63,47 @@ func (s *Client) UpdatePartition(spartition Partition) error {
 	return err
 }
 
+func (s *Client) ListPartitions() ([]Partition, error) {
+	var listPartitionResp ListPartitionResp
+
+	data, err := s.Get("v1/partitions")
+	if err != nil {
+		return nil, err
+	}
+
+	err = json.Unmarshal(data, &listPartitionResp)
+	if err != nil {
+		return nil, err
+	}
+
+	spartitions := listPartitionResp.Data
+
+	for listPartitionResp.Next != "" {
+		data, err = s.Get("v1/partitions?token=" + listPartitionResp.Next)
+		if err != nil {
+			return nil, err
+		}
+
+		listPartitionResp.Reset()
+
+		err = json.Unmarshal(data, &listPartitionResp)
+		if err != nil {
+			return nil, err
+		}
+
+		spartitions = append(spartitions, listPartitionResp.Data...)
+	}
+
+	var activePartitions []Partition
+	for _, partition := range spartitions {
+		if partition.IsActive {
+			activePartitions = append(activePartitions, partition)
+		}
+	}
+
+	return activePartitions, nil
+}
+
 type Partition struct {
 	ID                               string  `json:"id,omitempty"`
 	Name                             string  `json:"name"`
@@ -77,3 +118,13 @@ type Partition struct {
 	ReduceRetentionPeriodImmediately bool    `json:"reduceRetentionPeriodImmediately,omitempty"`
 	IsIncludedInDefaultSearch        *bool   `json:"isIncludedInDefaultSearch,omitempty"`
 }
+
+type ListPartitionResp struct {
+	Data []Partition `json:"data"`
+	Next string      `json:"next"`
+}
+
+func (s *ListPartitionResp) Reset() {
+	s.Data = nil
+	s.Next = ""
+}
diff --git a/website/docs/d/partition.html.markdown b/website/docs/d/partition.html.markdown
@@ -0,0 +1,39 @@
+---
+layout: "sumologic"
+page_title: "SumoLogic: sumologic_partition"
+description: |-
+  Provides a way to retrieve Sumo Logic partition details (id, name, etc) for a partition managed outside of terraform.
+---
+
+# sumologic_partition
+
+Provides a way to retrieve a [Sumologic Partition][1]'s details (id, name, etc) for a partition
+managed by another terraform stack.
+
+
+## Example Usage
+
+```hcl
+data "sumologic_partition" "this" {
+  id = "1234567890"
+}
+```
+
+A partition can be looked up by `id`.
+
+## Attributes reference
+
+The following attributes are exported:
+
+- `name` - The name of the partition.
+- `routing_expression` - The query that defines the data to be included in the partition.
+- `analytics_tier` - The Data Tier where the data in the partition will reside. Possible values are: `continuous`, `frequent`, `infrequent`
+- `retention_period` - The number of days to retain data in the partition.
+- `is_compliant` - Whether the partition is used for compliance or audit purposes.
+- `is_included_in_default_search` - Whether the partition is included in the default search scope.
+- `total_bytes` - The size of the data in the partition in bytes.
+- `is_active` - Whether the partition is currently active or decommissioned.
+- `index_type` - The type of partition index. Possible values are: `DefaultIndex`, `AuditIndex`or `Partition`
+- `data_forwarding_id` - The ID of the data forwarding configuration to be used by the partition.
+
+[1]: https://help.sumologic.com/docs/manage/partitions/data-tiers/
diff --git a/website/docs/d/partitions.html.markdown b/website/docs/d/partitions.html.markdown
diff --git a/website/docs/r/partition.html.markdown b/website/docs/r/partition.html.markdown
