SUMO-178423: refactoring and added destination as this is the support for DF /destinations

Author: Naman Goyal

sumologic/provider.go

@@ -92,7 +92,7 @@ func Provider() terraform.ResourceProvider {
 			"sumologic_folder":                                   resourceSumologicFolder(),
 			"sumologic_content":                                  resourceSumologicContent(),
 			"sumologic_scheduled_view":                           resourceSumologicScheduledView(),
-			"sumologic_s3_data_forwarding_destination":           resourceSumologicDataForwarding(),
+			"sumologic_s3_data_forwarding_destination":           resourceSumologicDataForwardingDestination(),
 			"sumologic_partition":                                resourceSumologicPartition(),
 			"sumologic_field_extraction_rule":                    resourceSumologicFieldExtractionRule(),
 			"sumologic_connection":                               resourceSumologicConnection(),

sumologic/resource_sumologic_data_forwarding.go

@@ -6,13 +6,13 @@ import (
 	"log"
 )
 
-func resourceSumologicDataForwarding() *schema.Resource {
+func resourceSumologicDataForwardingDestination() *schema.Resource {
 	return &schema.Resource{
 
-		Create: resourceSumologicDataForwardingCreate,
-		Read:   resourceSumologicDataForwardingRead,
-		Update: resourceSumologicDataForwardingUpdate,
-		Delete: resourceSumologicDataForwardingDelete,
+		Create: resourceSumologicDataForwardingDestinationCreate,
+		Read:   resourceSumologicDataForwardingDestinationRead,
+		Update: resourceSumologicDataForwardingDestinationUpdate,
+		Delete: resourceSumologicDataForwardingDestinationDelete,
 		Importer: &schema.ResourceImporter{
 			State: schema.ImportStatePassthrough,
 		},
@@ -71,76 +71,76 @@ func resourceSumologicDataForwarding() *schema.Resource {
 
 }
 
-func resourceSumologicDataForwardingCreate(d *schema.ResourceData, meta interface{}) error {
+func resourceSumologicDataForwardingDestinationCreate(d *schema.ResourceData, meta interface{}) error {
 	c := meta.(*Client)
 
 	if d.Id() == "" {
-		dataForwarding := resourceToDataForwarding(d)
-		createdDataForwarding, err := c.CreateDataForwarding(dataForwarding)
+		dataForwardingDestination := resourceToDataForwardingDestination(d)
+		createdDataForwardingDestination, err := c.CreateDataForwardingDestination(dataForwardingDestination)
 
 		if err != nil {
 			return err
 		}
 
-		d.SetId(createdDataForwarding.ID)
+		d.SetId(createdDataForwardingDestination.ID)
 
 	}
 
-	return resourceSumologicDataForwardingUpdate(d, meta)
+	return resourceSumologicDataForwardingDestinationUpdate(d, meta)
 }
 
-func resourceSumologicDataForwardingUpdate(d *schema.ResourceData, meta interface{}) error {
+func resourceSumologicDataForwardingDestinationUpdate(d *schema.ResourceData, meta interface{}) error {
 
-	dataForwarding := resourceToDataForwarding(d)
+	dataForwardingDestination := resourceToDataForwardingDestination(d)
 
 	c := meta.(*Client)
-	err := c.UpdateDataForwarding(dataForwarding)
+	err := c.UpdateDataForwardingDestination(dataForwardingDestination)
 
 	if err != nil {
 		return err
 	}
 
-	return resourceSumologicDataForwardingRead(d, meta)
+	return resourceSumologicDataForwardingDestinationRead(d, meta)
 }
 
-func resourceSumologicDataForwardingRead(d *schema.ResourceData, meta interface{}) error {
+func resourceSumologicDataForwardingDestinationRead(d *schema.ResourceData, meta interface{}) error {
 	c := meta.(*Client)
 
 	id := d.Id()
-	dataForwarding, err := c.getDataForwarding(id)
+	dataForwardingDestination, err := c.getDataForwardingDestination(id)
 
 	if err != nil {
 		return err
 	}
 
-	if dataForwarding == nil {
-		log.Printf("[WARN] Data Forwarding not found, removing from state: %v - %v", id, err)
+	if dataForwardingDestination == nil {
+		log.Printf("[WARN] Data Forwarding destination not found, removing from state: %v - %v", id, err)
 		d.SetId("")
 
 		return nil
 	}
 
-	d.Set("destination_name", dataForwarding.DestinationName)
-	d.Set("description", dataForwarding.Description)
-	d.Set("bucket_name", dataForwarding.BucketName)
-	d.Set("S3_region", dataForwarding.S3Region)
-	d.Set("S3_server_side_encryption", dataForwarding.S3ServerSideEncryption)
+	d.Set("destination_name", dataForwardingDestination.DestinationName)
+	d.Set("description", dataForwardingDestination.Description)
+	d.Set("bucket_name", dataForwardingDestination.BucketName)
+	d.Set("S3_region", dataForwardingDestination.S3Region)
+	d.Set("S3_server_side_encryption", dataForwardingDestination.S3ServerSideEncryption)
 
 	return nil
 }
 
-func resourceSumologicDataForwardingDelete(d *schema.ResourceData, meta interface{}) error {
+func resourceSumologicDataForwardingDestinationDelete(d *schema.ResourceData, meta interface{}) error {
 	c := meta.(*Client)
 	id := d.Id()
 
-	return c.DeleteDataForwarding(id)
+	return c.DeleteDataForwardingDestination(id)
 }
 
-func resourceToDataForwarding(d *schema.ResourceData) DataForwarding {
+func resourceToDataForwardingDestination(d *schema.ResourceData) DataForwardingDestination {
 
 	authentication := extractAuthenticationDetails(d.Get("authentication").([]interface{}))
 
-	return DataForwarding{
+	return DataForwardingDestination{
 		ID:                     d.Id(),
 		DestinationName:        d.Get("destination_name").(string),
 		Description:            d.Get("description").(string),

sumologic/resource_sumologic_data_forwarding_test.go

@@ -135,7 +135,7 @@ func testAccCheckDataForwardingExists() resource.TestCheckFunc {
 		client := testAccProvider.Meta().(*Client)
 		for _, r := range s.RootModule().Resources {
 			id := r.Primary.ID
-			if _, err := client.getDataForwarding(id); err != nil {
+			if _, err := client.getDataForwardingDestination(id); err != nil {
 				return fmt.Errorf("Received an error retrieving data forwarding %s", err)
 			}
 		}
@@ -148,7 +148,7 @@ func testAccCheckDataForwardingDestroy() resource.TestCheckFunc {
 		client := testAccProvider.Meta().(*Client)
 		for _, r := range s.RootModule().Resources {
 			id := r.Primary.ID
-			p, err := client.getDataForwarding(id)
+			p, err := client.getDataForwardingDestination(id)
 
 			if err != nil {
 				if strings.Contains(err.Error(), "Data forwarding Destination doesn't exists") {

sumologic/sumologic_data_forwarding.go

@@ -5,7 +5,7 @@ import (
 	"fmt"
 )
 
-func (s *Client) getDataForwarding(id string) (*DataForwarding, error) {
+func (s *Client) getDataForwardingDestination(id string) (*DataForwardingDestination, error) {
 
 	data, _, err := s.Get(fmt.Sprintf("v1/logsDataForwarding/destinations/%s", id))
 	if err != nil {
@@ -15,50 +15,50 @@ func (s *Client) getDataForwarding(id string) (*DataForwarding, error) {
 		return nil, nil
 	}
 
-	var dataForwarding DataForwarding
-	err = json.Unmarshal(data, &dataForwarding)
+	var dataForwardingDestination DataForwardingDestination
+	err = json.Unmarshal(data, &dataForwardingDestination)
 
 	if err != nil {
 		return nil, err
 	}
 
-	return &dataForwarding, nil
+	return &dataForwardingDestination, nil
 
 }
-func (s *Client) CreateDataForwarding(dataForwarding DataForwarding) (*DataForwarding, error) {
-	var createdDataForwarding DataForwarding
+func (s *Client) CreateDataForwardingDestination(dataForwardingDestination DataForwardingDestination) (*DataForwardingDestination, error) {
+	var createdDataForwardingDestination DataForwardingDestination
 
-	responseBody, err := s.Post("v1/logsDataForwarding/destinations", dataForwarding)
+	responseBody, err := s.Post("v1/logsDataForwarding/destinations", dataForwardingDestination)
 
 	if err != nil {
 		return nil, err
 	}
 
-	err = json.Unmarshal(responseBody, &createdDataForwarding)
+	err = json.Unmarshal(responseBody, &createdDataForwardingDestination)
 
 	if err != nil {
 		return nil, err
 	}
 
-	return &createdDataForwarding, nil
+	return &createdDataForwardingDestination, nil
 }
 
-func (s *Client) UpdateDataForwarding(dataForwarding DataForwarding) error {
+func (s *Client) UpdateDataForwardingDestination(dataForwardingDestination DataForwardingDestination) error {
 
-	url := fmt.Sprintf("v1/logsDataForwarding/destinations/%s", dataForwarding.ID)
-	_, err := s.Put(url, dataForwarding)
+	url := fmt.Sprintf("v1/logsDataForwarding/destinations/%s", dataForwardingDestination.ID)
+	_, err := s.Put(url, dataForwardingDestination)
 
 	return err
 }
-func (s *Client) DeleteDataForwarding(id string) error {
+func (s *Client) DeleteDataForwardingDestination(id string) error {
 	url := fmt.Sprintf("v1/logsDataForwarding/destinations/%s", id)
 
 	_, err := s.Delete(url)
 
 	return err
 }
 
-type DataForwarding struct {
+type DataForwardingDestination struct {
 	ID                     string `json:"id,omitempty"`
 	DestinationName        string `json:"destinationName"`
 	Description            string `json:"description,omitempty"`