Add individual AWS sources for all content_types supported by polling source (#64)

* Add docs for various AWS sources

* Split polling_source into multiple sources and add to provider

* add deprecation message to sumologic_polling_source resource and its docs

* duplicate sumologic_polling_source to sumologic_generic_polling_source as per the deprecation process to be used for the new resources.

* add to changelog

* Update cloudwatch_source.html.markdown

Author: vsinghal13

CHANGELOG.md

@@ -1,4 +1,17 @@
 ## 2.2.0 (Unreleased)
+DEPRECATIONS:
+
+* resource/sumologic_polling_source: Deprecated in faovur of having individul sources for each content type currently supported. (GH-64)
+
+FEATURES:
+
+* **New Resource:** sumologic_s3_source (GH-64)
+* **New Resource:** sumologic_s3_audit_source (GH-64)
+* **New Resource:** sumologic_cloudwatch_source (GH-64)
+* **New Resource:** sumologic_cloudtrail_source (GH-64)
+* **New Resource:** sumologic_elb_source (GH-64)
+* **New Resource:** sumologic_cloudfront_source (GH-64)
+* **New Resource:** sumologic_metadata_source (GH-61)
 
 ## 2.1.3 (July 30, 2020)
 ENHANCEMENTS:

sumologic/provider.go

@@ -41,6 +41,12 @@ func Provider() terraform.ResourceProvider {
 			"sumologic_collector":                          resourceSumologicCollector(),
 			"sumologic_http_source":                        resourceSumologicHTTPSource(),
 			"sumologic_polling_source":                     resourceSumologicPollingSource(),
+			"sumologic_s3_source":                          resourceSumologicGenericPollingSource(),
+			"sumologic_s3_audit_source":                    resourceSumologicGenericPollingSource(),
+			"sumologic_cloudwatch_source":                  resourceSumologicGenericPollingSource(),
+			"sumologic_cloudtrail_source":                  resourceSumologicGenericPollingSource(),
+			"sumologic_elb_source":                         resourceSumologicGenericPollingSource(),
+			"sumologic_cloudfront_source":                  resourceSumologicGenericPollingSource(),
 			"sumologic_metadata_source":                    resourceSumologicMetadataSource(),
 			"sumologic_cloudsyslog_source":                 resourceSumologicCloudsyslogSource(),
 			"sumologic_role":                               resourceSumologicRole(),

sumologic/resource_sumologic_generic_polling_source.go

@@ -0,0 +1,336 @@
+package sumologic
+
+import (
+	"fmt"
+	"log"
+	"strconv"
+
+	"github.com/hashicorp/terraform-plugin-sdk/helper/schema"
+	"github.com/hashicorp/terraform-plugin-sdk/helper/validation"
+)
+
+func resourceSumologicGenericPollingSource() *schema.Resource {
+	pollingSource := resourceSumologicSource()
+	pollingSource.Create = resourceSumologicGenericPollingSourceCreate
+	pollingSource.Read = resourceSumologicGenericPollingSourceRead
+	pollingSource.Update = resourceSumologicGenericPollingSourceUpdate
+	pollingSource.Importer = &schema.ResourceImporter{
+		State: resourceSumologicSourceImport,
+	}
+
+	pollingSource.Schema["content_type"] = &schema.Schema{
+		Type:         schema.TypeString,
+		Required:     true,
+		ForceNew:     true,
+		ValidateFunc: validation.StringInSlice([]string{"AwsS3Bucket", "AwsElbBucket", "AwsCloudFrontBucket", "AwsCloudTrailBucket", "AwsS3AuditBucket", "AwsCloudWatch"}, false),
+	}
+	pollingSource.Schema["scan_interval"] = &schema.Schema{
+		Type:     schema.TypeInt,
+		Required: true,
+	}
+	pollingSource.Schema["paused"] = &schema.Schema{
+		Type:     schema.TypeBool,
+		Required: true,
+	}
+	pollingSource.Schema["url"] = &schema.Schema{
+		Type:     schema.TypeString,
+		Computed: true,
+	}
+	pollingSource.Schema["authentication"] = &schema.Schema{
+		Type:     schema.TypeList,
+		Required: true,
+		ForceNew: true,
+		MinItems: 1,
+		MaxItems: 1,
+		Elem: &schema.Resource{
+			Schema: map[string]*schema.Schema{
+				"type": {
+					Type:         schema.TypeString,
+					Required:     true,
+					ValidateFunc: validation.StringInSlice([]string{"S3BucketAuthentication", "AWSRoleBasedAuthentication"}, false),
+				},
+				"access_key": {
+					Type:     schema.TypeString,
+					Optional: true,
+				},
+				"secret_key": {
+					Type:     schema.TypeString,
+					Optional: true,
+				},
+				"role_arn": {
+					Type:     schema.TypeString,
+					Optional: true,
+				},
+			},
+		},
+	}
+	pollingSource.Schema["path"] = &schema.Schema{
+		Type:     schema.TypeList,
+		Required: true,
+		ForceNew: true,
+		MinItems: 1,
+		MaxItems: 1,
+		Elem: &schema.Resource{
+			Schema: map[string]*schema.Schema{
+				"type": {
+					Type:         schema.TypeString,
+					Required:     true,
+					ValidateFunc: validation.StringInSlice([]string{"S3BucketPathExpression", "CloudWatchPath"}, false),
+				},
+				"bucket_name": {
+					Type:     schema.TypeString,
+					Optional: true,
+				},
+				"path_expression": {
+					Type:     schema.TypeString,
+					Optional: true,
+				},
+				"limit_to_regions": {
+					Type:     schema.TypeList,
+					Optional: true,
+					Elem: &schema.Schema{
+						Type: schema.TypeString,
+					},
+				},
+				"limit_to_namespaces": {
+					Type:     schema.TypeList,
+					Optional: true,
+					Elem: &schema.Schema{
+						Type: schema.TypeString,
+					},
+				},
+
+				"tag_filters": {
+					Type:     schema.TypeList,
+					Optional: true,
+					Elem: &schema.Resource{
+						Schema: map[string]*schema.Schema{
+							"type": {
+								Type:     schema.TypeString,
+								Optional: true,
+							},
+							"namespace": {
+								Type:     schema.TypeString,
+								Optional: true,
+							},
+							"tags": {
+								Type:     schema.TypeList,
+								Optional: true,
+								Elem: &schema.Schema{
+									Type: schema.TypeString,
+								},
+							},
+						},
+					},
+				},
+			},
+		},
+	}
+
+	return pollingSource
+}
+
+func resourceSumologicGenericPollingSourceCreate(d *schema.ResourceData, meta interface{}) error {
+
+	c := meta.(*Client)
+
+	if d.Id() == "" {
+		source := resourceToGenericPollingSource(d)
+		sourceID, err := c.CreatePollingSource(source, d.Get("collector_id").(int))
+
+		if err != nil {
+			return err
+		}
+
+		id := strconv.Itoa(sourceID)
+
+		d.SetId(id)
+	}
+
+	return resourceSumologicGenericPollingSourceRead(d, meta)
+}
+
+func resourceSumologicGenericPollingSourceUpdate(d *schema.ResourceData, meta interface{}) error {
+	c := meta.(*Client)
+
+	source := resourceToGenericPollingSource(d)
+
+	err := c.UpdatePollingSource(source, d.Get("collector_id").(int))
+
+	if err != nil {
+		return err
+	}
+
+	return resourceSumologicGenericPollingSourceRead(d, meta)
+}
+
+func resourceSumologicGenericPollingSourceRead(d *schema.ResourceData, meta interface{}) error {
+	c := meta.(*Client)
+
+	id, _ := strconv.Atoi(d.Id())
+	source, err := c.GetPollingSource(d.Get("collector_id").(int), id)
+
+	if err != nil {
+		return err
+	}
+
+	if source == nil {
+		log.Printf("[WARN] Polling source not found, removing from state: %v - %v", id, err)
+		d.SetId("")
+
+		return nil
+	}
+
+	pollingResources := source.ThirdPartyRef.Resources
+	path := getPollingThirdPartyPathAttributes(pollingResources)
+
+	if err := d.Set("path", path); err != nil {
+		return err
+	}
+
+	if err := resourceSumologicSourceRead(d, source.Source); err != nil {
+		return fmt.Errorf("%s", err)
+	}
+	d.Set("content_type", source.ContentType)
+	d.Set("scan_interval", source.ScanInterval)
+	d.Set("paused", source.Paused)
+	d.Set("url", source.URL)
+
+	return nil
+}
+
+func resourceToGenericPollingSource(d *schema.ResourceData) PollingSource {
+	source := resourceToSource(d)
+	source.Type = "Polling"
+
+	pollingSource := PollingSource{
+		Source:       source,
+		Paused:       d.Get("paused").(bool),
+		ScanInterval: d.Get("scan_interval").(int),
+		ContentType:  d.Get("content_type").(string),
+		URL:          d.Get("url").(string),
+	}
+
+	pollingResource := PollingResource{
+		ServiceType:    d.Get("content_type").(string),
+		Authentication: getPollingAuthentication(d),
+		Path:           getPollingPathSettings(d),
+	}
+
+	pollingSource.ThirdPartyRef.Resources = append(pollingSource.ThirdPartyRef.Resources, pollingResource)
+
+	return pollingSource
+}
+
+func getPollingThirdPartyPathAttributes(pollingResource []PollingResource) []map[string]interface{} {
+
+	var s []map[string]interface{}
+
+	for _, t := range pollingResource {
+		mapping := map[string]interface{}{
+			"type":                t.Path.Type,
+			"bucket_name":         t.Path.BucketName,
+			"path_expression":     t.Path.PathExpression,
+			"limit_to_regions":    t.Path.LimitToRegions,
+			"limit_to_namespaces": t.Path.LimitToNamespaces,
+			"tag_filters":         flattenPollingTagFilters(t.Path.TagFilters),
+		}
+		s = append(s, mapping)
+	}
+	return s
+}
+
+func flattenPollingTagFilters(v []TagFilter) []map[string]interface{} {
+	var filters []map[string]interface{}
+	for _, d := range v {
+		filter := map[string]interface{}{
+			"type":      d.Type,
+			"namespace": d.Namespace,
+			"tags":      d.Tags,
+		}
+		filters = append(filters, filter)
+	}
+
+	return filters
+}
+
+func getPollingTagFilters(d *schema.ResourceData) []TagFilter {
+	paths := d.Get("path").([]interface{})
+	path := paths[0].(map[string]interface{})
+	rawTagFilterConfig := path["tag_filters"].([]interface{})
+	var filters []TagFilter
+
+	for _, rawConfig := range rawTagFilterConfig {
+		config := rawConfig.(map[string]interface{})
+		filter := TagFilter{}
+		filter.Type = config["type"].(string)
+		filter.Namespace = config["namespace"].(string)
+
+		rawTags := config["tags"].([]interface{})
+		Tags := make([]string, len(rawTags))
+		for i, v := range rawTags {
+			Tags[i] = v.(string)
+		}
+		filter.Tags = Tags
+		filters = append(filters, filter)
+	}
+
+	return filters
+}
+
+func getPollingAuthentication(d *schema.ResourceData) PollingAuthentication {
+	auths := d.Get("authentication").([]interface{})
+	authSettings := PollingAuthentication{}
+
+	if len(auths) > 0 {
+		auth := auths[0].(map[string]interface{})
+		switch authType := auth["type"].(string); authType {
+		case "S3BucketAuthentication":
+			authSettings.Type = "S3BucketAuthentication"
+			authSettings.AwsID = auth["access_key"].(string)
+			authSettings.AwsKey = auth["secret_key"].(string)
+		case "AWSRoleBasedAuthentication":
+			authSettings.Type = "AWSRoleBasedAuthentication"
+			authSettings.RoleARN = auth["role_arn"].(string)
+		default:
+			log.Printf("[ERROR] Unknown authType: %v", authType)
+		}
+	}
+
+	return authSettings
+}
+
+func getPollingPathSettings(d *schema.ResourceData) PollingPath {
+	pathSettings := PollingPath{}
+	paths := d.Get("path").([]interface{})
+
+	if len(paths) > 0 {
+		path := paths[0].(map[string]interface{})
+		switch pathType := path["type"].(string); pathType {
+		case "S3BucketPathExpression":
+			pathSettings.Type = "S3BucketPathExpression"
+			pathSettings.BucketName = path["bucket_name"].(string)
+			pathSettings.PathExpression = path["path_expression"].(string)
+		case "CloudWatchPath":
+			pathSettings.Type = "CloudWatchPath"
+			rawLimitToRegions := path["limit_to_regions"].([]interface{})
+			LimitToRegions := make([]string, len(rawLimitToRegions))
+			for i, v := range rawLimitToRegions {
+				LimitToRegions[i] = v.(string)
+			}
+
+			rawLimitToNamespaces := path["limit_to_namespaces"].([]interface{})
+			LimitToNamespaces := make([]string, len(rawLimitToNamespaces))
+			for i, v := range rawLimitToNamespaces {
+				LimitToNamespaces[i] = v.(string)
+			}
+			pathSettings.LimitToRegions = LimitToRegions
+			pathSettings.LimitToNamespaces = LimitToNamespaces
+			pathSettings.TagFilters = getPollingTagFilters(d)
+		default:
+			log.Printf("[ERROR] Unknown resourceType in path: %v", pathType)
+		}
+	}
+
+	return pathSettings
+}

sumologic/resource_sumologic_polling_source.go

@@ -17,6 +17,8 @@ func resourceSumologicPollingSource() *schema.Resource {
 	pollingSource.Importer = &schema.ResourceImporter{
 		State: resourceSumologicSourceImport,
 	}
+	pollingSource.DeprecationMessage =
+		"We are deprecating the generic sumologic polling source and in turn creating individual sources for each of the content_type currently supported."
 
 	pollingSource.Schema["content_type"] = &schema.Schema{
 		Type:         schema.TypeString,