Migrate Data Safe service console to OCI console

Author: Maxrovr

oci/data_safe_compare_security_assessment_resource.go

@@ -0,0 +1,242 @@
+// Copyright (c) 2017, 2021, Oracle and/or its affiliates. All rights reserved.
+// Licensed under the Mozilla Public License v2.0
+
+package oci
+
+import (
+	"context"
+	"fmt"
+	"strings"
+	"time"
+
+	"github.com/hashicorp/terraform-plugin-sdk/helper/resource"
+	"github.com/hashicorp/terraform-plugin-sdk/helper/schema"
+
+	oci_common "github.com/oracle/oci-go-sdk/v47/common"
+	oci_data_safe "github.com/oracle/oci-go-sdk/v47/datasafe"
+)
+
+func init() {
+	RegisterResource("oci_data_safe_compare_security_assessment", DataSafeCompareSecurityAssessmentResource())
+}
+
+func DataSafeCompareSecurityAssessmentResource() *schema.Resource {
+	return &schema.Resource{
+		Importer: &schema.ResourceImporter{
+			State: schema.ImportStatePassthrough,
+		},
+		Timeouts: DefaultTimeout,
+		Create:   createDataSafeCompareSecurityAssessment,
+		Read:     readDataSafeCompareSecurityAssessment,
+		Delete:   deleteDataSafeCompareSecurityAssessment,
+		Schema: map[string]*schema.Schema{
+			// Required
+			"comparison_security_assessment_id": {
+				Type:     schema.TypeString,
+				Required: true,
+				ForceNew: true,
+			},
+			"security_assessment_id": {
+				Type:     schema.TypeString,
+				Required: true,
+				ForceNew: true,
+			},
+
+			// Optional
+
+			// Computed
+		},
+	}
+}
+
+func createDataSafeCompareSecurityAssessment(d *schema.ResourceData, m interface{}) error {
+	sync := &DataSafeCompareSecurityAssessmentResourceCrud{}
+	sync.D = d
+	sync.Client = m.(*OracleClients).dataSafeClient()
+
+	return CreateResource(d, sync)
+}
+
+func readDataSafeCompareSecurityAssessment(d *schema.ResourceData, m interface{}) error {
+	return nil
+}
+
+func deleteDataSafeCompareSecurityAssessment(d *schema.ResourceData, m interface{}) error {
+	return nil
+}
+
+type DataSafeCompareSecurityAssessmentResourceCrud struct {
+	BaseCrud
+	Client                 *oci_data_safe.DataSafeClient
+	Res                    *oci_data_safe.GetSecurityAssessmentComparisonResponse
+	DisableNotFoundRetries bool
+}
+
+func (s *DataSafeCompareSecurityAssessmentResourceCrud) ID() string {
+	return *s.Res.OpcRequestId
+}
+
+func (s *DataSafeCompareSecurityAssessmentResourceCrud) Get() error {
+	request := oci_data_safe.GetSecurityAssessmentComparisonRequest{}
+
+	if comparisonSecurityAssessmentId, ok := s.D.GetOkExists("comparison_security_assessment_id"); ok {
+		tmp := comparisonSecurityAssessmentId.(string)
+		request.ComparisonSecurityAssessmentId = &tmp
+	}
+
+	if securityAssessmentId, ok := s.D.GetOkExists("security_assessment_id"); ok {
+		tmp := securityAssessmentId.(string)
+		request.SecurityAssessmentId = &tmp
+	}
+
+	request.RequestMetadata.RetryPolicy = getRetryPolicy(false, "data_safe")
+
+	response, err := s.Client.GetSecurityAssessmentComparison(context.Background(), request)
+	if err != nil {
+		return err
+	}
+
+	s.Res = &response
+	return nil
+}
+
+func (s *DataSafeCompareSecurityAssessmentResourceCrud) Create() error {
+	request := oci_data_safe.CompareSecurityAssessmentRequest{}
+
+	if comparisonSecurityAssessmentId, ok := s.D.GetOkExists("comparison_security_assessment_id"); ok {
+		tmp := comparisonSecurityAssessmentId.(string)
+		request.ComparisonSecurityAssessmentId = &tmp
+	}
+
+	if securityAssessmentId, ok := s.D.GetOkExists("security_assessment_id"); ok {
+		tmp := securityAssessmentId.(string)
+		request.SecurityAssessmentId = &tmp
+	}
+
+	request.RequestMetadata.RetryPolicy = getRetryPolicy(s.DisableNotFoundRetries, "data_safe")
+
+	response, err := s.Client.CompareSecurityAssessment(context.Background(), request)
+	if err != nil {
+		return err
+	}
+
+	workId := response.OpcWorkRequestId
+	return s.getCompareSecurityAssessmentFromWorkRequest(workId, getRetryPolicy(s.DisableNotFoundRetries, "data_safe"), oci_data_safe.WorkRequestResourceActionTypeUpdated, s.D.Timeout(schema.TimeoutCreate))
+}
+
+func (s *DataSafeCompareSecurityAssessmentResourceCrud) getCompareSecurityAssessmentFromWorkRequest(workId *string, retryPolicy *oci_common.RetryPolicy,
+	actionTypeEnum oci_data_safe.WorkRequestResourceActionTypeEnum, timeout time.Duration) error {
+
+	// Wait until it finishes
+	compareSecurityAssessmentId, err := compareSecurityAssessmentWaitForWorkRequest(workId, "securityassessment",
+		actionTypeEnum, timeout, s.DisableNotFoundRetries, s.Client)
+
+	if err != nil {
+		return err
+	}
+	s.D.SetId(*compareSecurityAssessmentId)
+
+	return s.Get()
+}
+
+func compareSecurityAssessmentWorkRequestShouldRetryFunc(timeout time.Duration) func(response oci_common.OCIOperationResponse) bool {
+	startTime := time.Now()
+	stopTime := startTime.Add(timeout)
+	return func(response oci_common.OCIOperationResponse) bool {
+
+		// Stop after timeout has elapsed
+		if time.Now().After(stopTime) {
+			return false
+		}
+
+		// Make sure we stop on default rules
+		if shouldRetry(response, false, "data_safe", startTime) {
+			return true
+		}
+
+		// Only stop if the time Finished is set
+		if workRequestResponse, ok := response.Response.(oci_data_safe.GetWorkRequestResponse); ok {
+			return workRequestResponse.TimeFinished == nil
+		}
+		return false
+	}
+}
+
+func compareSecurityAssessmentWaitForWorkRequest(wId *string, entityType string, action oci_data_safe.WorkRequestResourceActionTypeEnum,
+	timeout time.Duration, disableFoundRetries bool, client *oci_data_safe.DataSafeClient) (*string, error) {
+	retryPolicy := getRetryPolicy(disableFoundRetries, "data_safe")
+	retryPolicy.ShouldRetryOperation = compareSecurityAssessmentWorkRequestShouldRetryFunc(timeout)
+
+	response := oci_data_safe.GetWorkRequestResponse{}
+	stateConf := &resource.StateChangeConf{
+		Pending: []string{
+			string(oci_data_safe.WorkRequestStatusInProgress),
+			string(oci_data_safe.WorkRequestStatusAccepted),
+		},
+		Target: []string{
+			string(oci_data_safe.WorkRequestStatusSucceeded),
+			string(oci_data_safe.WorkRequestStatusFailed),
+		},
+		Refresh: func() (interface{}, string, error) {
+			var err error
+			response, err = client.GetWorkRequest(context.Background(),
+				oci_data_safe.GetWorkRequestRequest{
+					WorkRequestId: wId,
+					RequestMetadata: oci_common.RequestMetadata{
+						RetryPolicy: retryPolicy,
+					},
+				})
+			wr := &response.WorkRequest
+			return wr, string(wr.Status), err
+		},
+		Timeout: timeout,
+	}
+	if _, e := stateConf.WaitForState(); e != nil {
+		return nil, e
+	}
+
+	var identifier *string
+	// The work request response contains an array of objects that finished the operation
+	for _, res := range response.Resources {
+		if strings.Contains(strings.ToLower(*res.EntityType), entityType) {
+			if res.ActionType == action {
+				identifier = res.Identifier
+				break
+			}
+		}
+	}
+
+	// The workrequest may have failed, check for errors if identifier is not found or work failed or got cancelled
+	if identifier == nil || response.Status == oci_data_safe.WorkRequestStatusFailed {
+		return nil, getErrorFromDataSafeCompareSecurityAssessmentWorkRequest(client, wId, retryPolicy, entityType, action)
+	}
+
+	return identifier, nil
+}
+
+func getErrorFromDataSafeCompareSecurityAssessmentWorkRequest(client *oci_data_safe.DataSafeClient, workId *string, retryPolicy *oci_common.RetryPolicy, entityType string, action oci_data_safe.WorkRequestResourceActionTypeEnum) error {
+	response, err := client.ListWorkRequestErrors(context.Background(),
+		oci_data_safe.ListWorkRequestErrorsRequest{
+			WorkRequestId: workId,
+			RequestMetadata: oci_common.RequestMetadata{
+				RetryPolicy: retryPolicy,
+			},
+		})
+	if err != nil {
+		return err
+	}
+
+	allErrs := make([]string, 0)
+	for _, wrkErr := range response.Items {
+		allErrs = append(allErrs, *wrkErr.Message)
+	}
+	errorMessage := strings.Join(allErrs, "\n")
+
+	workRequestErr := fmt.Errorf("work request did not succeed, workId: %s, entity: %s, action: %s. Message: %s", *workId, entityType, action, errorMessage)
+
+	return workRequestErr
+}
+
+func (s *DataSafeCompareSecurityAssessmentResourceCrud) SetData() error {
+	return nil
+}

oci/data_safe_compare_security_assessment_test.go

@@ -0,0 +1,67 @@
+// Copyright (c) 2017, 2021, Oracle and/or its affiliates. All rights reserved.
+// Licensed under the Mozilla Public License v2.0
+
+package oci
+
+import (
+	"fmt"
+	"strconv"
+	"testing"
+
+	"github.com/hashicorp/terraform-plugin-sdk/helper/resource"
+	"github.com/hashicorp/terraform-plugin-sdk/terraform"
+
+	"github.com/terraform-providers/terraform-provider-oci/httpreplay"
+)
+
+var (
+	compareSecurityAssessmentRepresentation = map[string]interface{}{
+		"comparison_security_assessment_id": Representation{repType: Required, create: `${oci_data_safe_security_assessment.test_security_assessment1.id}`},
+		"security_assessment_id":            Representation{repType: Required, create: `${oci_data_safe_security_assessment.test_security_assessment2.id}`},
+	}
+
+	CompareSecurityAssessmentResourceDependencies = generateResourceFromRepresentationMap("oci_database_autonomous_database", "test_autonomous_database", Required, Create, autonomousDatabaseRepresentation) +
+		generateResourceFromRepresentationMap("oci_data_safe_target_database", "test_target_database", Required, Create, targetDatabaseRepresentation) +
+		generateResourceFromRepresentationMap("oci_data_safe_security_assessment", "test_security_assessment1", Required, Create, securityAssessmentRepresentation) +
+		generateResourceFromRepresentationMap("oci_data_safe_security_assessment", "test_security_assessment2", Required, Create, securityAssessmentRepresentation)
+)
+
+func TestDataSafeCompareSecurityAssessmentResource_basic(t *testing.T) {
+	httpreplay.SetScenario("TestDataSafeCompareSecurityAssessmentResource_basic")
+	defer httpreplay.SaveScenario()
+
+	config := testProviderConfig()
+
+	compartmentId := getEnvSettingWithBlankDefault("compartment_ocid")
+	compartmentIdVariableStr := fmt.Sprintf("variable \"compartment_id\" { default = \"%s\" }\n", compartmentId)
+
+	resourceName := "oci_data_safe_compare_security_assessment.test_compare_security_assessment"
+
+	var resId string
+	// Save TF content to create resource with only required properties. This has to be exactly the same as the config part in the create step in the test.
+	saveConfigContent(config+compartmentIdVariableStr+CompareSecurityAssessmentResourceDependencies+
+		generateResourceFromRepresentationMap("oci_data_safe_compare_security_assessment", "test_compare_security_assessment", Required, Create, compareSecurityAssessmentRepresentation), "datasafe", "compareSecurityAssessment", t)
+
+	ResourceTest(t, nil, []resource.TestStep{
+		// verify create
+		{
+			Config: config + compartmentIdVariableStr + CompareSecurityAssessmentResourceDependencies +
+				generateResourceFromRepresentationMap("oci_data_safe_compare_security_assessment", "test_compare_security_assessment", Required, Create, compareSecurityAssessmentRepresentation),
+			Check: ComposeAggregateTestCheckFuncWrapper(
+				resource.TestCheckResourceAttrSet(resourceName, "comparison_security_assessment_id"),
+				resource.TestCheckResourceAttrSet(resourceName, "security_assessment_id"),
+				resource.TestCheckResourceAttr(resourceName, "summary.#", "0"),
+
+				func(s *terraform.State) (err error) {
+					resId, err = fromInstanceState(s, resourceName, "id")
+					if isEnableExportCompartment, _ := strconv.ParseBool(getEnvSettingWithDefault("enable_export_compartment", "true")); isEnableExportCompartment {
+						if errExport := testExportCompartmentWithResourceName(&resId, &compartmentId, resourceName); errExport != nil {
+							return errExport
+						}
+					}
+					return err
+				},
+			),
+		},
+	})
+}