Added Support For - Standard Tags

Author: Richard Gullo

examples/identity/availability_domains.tf

@@ -16,7 +16,7 @@ output "ads" {
 
 data "oci_identity_availability_domain" "ad" {
   compartment_id = var.tenancy_ocid
-  ad_number      = 2
+  ad_number      = 1
 }
 
 output "ad" {

examples/identity/group.tf

@@ -35,7 +35,7 @@ output "groups" {
  */
 
 variable "dynamic_group_defined_tags_value" {
-  default = "value"
+  default = "test_value"
 }
 
 variable "dynamic_group_freeform_tags" {

examples/identity/import_standard_tag.tf

@@ -0,0 +1,14 @@
+// Copyright (c) 2017, 2021, Oracle and/or its affiliates. All rights reserved.
+// Licensed under the Mozilla Public License v2.0
+
+variable "test_tag_namespace_name" {
+  default = "Oracle-Standard"
+}
+
+resource "oci_identity_import_standard_tags_management" "test_import_standard_tags_management" {
+  #Required
+  compartment_id              = var.compartment_id
+  standard_tag_namespace_name = var.test_tag_namespace_name
+}
+
+

examples/identity/networksources.tf

@@ -1,6 +1,7 @@
 // Copyright (c) 2017, 2021, Oracle and/or its affiliates. All rights reserved.
 // Licensed under the Mozilla Public License v2.0
 variable "compartment_id" {
+
 }
 
 variable "network_source_defined_tags_value" {

examples/identity/tag_standard_tag_namespace_template.tf

@@ -0,0 +1,10 @@
+// Copyright (c) 2017, 2021, Oracle and/or its affiliates. All rights reserved.
+// Licensed under the Mozilla Public License v2.0
+
+
+data "oci_identity_tag_standard_tag_namespace_template" "test_tag_standard_tag_namespace_template" {
+  #Required
+  compartment_id = var.compartment_id
+  standard_tag_namespace_name = var.test_tag_namespace_name
+}
+

examples/identity/tag_standard_tag_namespace_templates.tf

@@ -0,0 +1,9 @@
+// Copyright (c) 2017, 2021, Oracle and/or its affiliates. All rights reserved.
+// Licensed under the Mozilla Public License v2.0
+
+
+data "oci_identity_tag_standard_tag_namespace_templates" "test_tag_standard_tag_namespace_template" {
+  #Required
+  compartment_id = var.compartment_id
+}
+

examples/identity/user.tf

@@ -7,13 +7,15 @@
 
 resource "oci_identity_user" "user1" {
   name           = "tf-example-user"
+  email          = "[email protected]"
   description    = "user created by terraform"
   compartment_id = var.tenancy_ocid
 }
 
 // Use the "user2" to have non-default values of capabilities without corresponding authentication resources being actually created
 resource "oci_identity_user" "user2" {
   name           = "tf-example-user2"
+  email          = "[email protected]"
   description    = "user2 created by terraform"
   compartment_id = var.tenancy_ocid
 }

oci/export_definitions.go

@@ -1983,6 +1983,11 @@ var exportIdentityTagHints = &TerraformResourceHints{
 	},
 }
 
+var exportIdentityImportStandardTagsManagementHints = &TerraformResourceHints{
+	resourceClass:        "oci_identity_import_standard_tags_management",
+	resourceAbbreviation: "import_standard_tags_management",
+}
+
 var exportIdentityDomainHints = &TerraformResourceHints{
 	resourceClass:        "oci_identity_domain",
 	datasourceClass:      "oci_identity_domains",

oci/identity_import_standard_tags_management_resource.go

@@ -0,0 +1,226 @@
+// 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/v54/common"
+	oci_identity "github.com/oracle/oci-go-sdk/v54/identity"
+)
+
+func init() {
+	RegisterResource("oci_identity_import_standard_tags_management", IdentityImportStandardTagsManagementResource())
+}
+
+func IdentityImportStandardTagsManagementResource() *schema.Resource {
+	return &schema.Resource{
+		Importer: &schema.ResourceImporter{
+			State: schema.ImportStatePassthrough,
+		},
+		Timeouts: DefaultTimeout,
+		Create:   createIdentityImportStandardTagsManagement,
+		Read:     readIdentityImportStandardTagsManagement,
+		Delete:   deleteIdentityImportStandardTagsManagement,
+		Schema: map[string]*schema.Schema{
+			// Required
+			"compartment_id": {
+				Type:     schema.TypeString,
+				Required: true,
+				ForceNew: true,
+			},
+			"standard_tag_namespace_name": {
+				Type:     schema.TypeString,
+				Required: true,
+				ForceNew: true,
+			},
+
+			// Optional
+
+			// Computed
+			"work_request_id": {
+				Type:     schema.TypeString,
+				Computed: true,
+			},
+		},
+	}
+}
+
+func createIdentityImportStandardTagsManagement(d *schema.ResourceData, m interface{}) error {
+	sync := &IdentityImportStandardTagsManagementResourceCrud{}
+	sync.D = d
+	sync.Client = m.(*OracleClients).identityClient()
+
+	return CreateResource(d, sync)
+}
+
+func readIdentityImportStandardTagsManagement(d *schema.ResourceData, m interface{}) error {
+	return nil
+}
+
+func deleteIdentityImportStandardTagsManagement(d *schema.ResourceData, m interface{}) error {
+	return nil
+}
+
+type IdentityImportStandardTagsManagementResourceCrud struct {
+	BaseCrud
+	Client                 *oci_identity.IdentityClient
+	Res                    *oci_identity.ImportStandardTagsResponse
+	DisableNotFoundRetries bool
+}
+
+func (s *IdentityImportStandardTagsManagementResourceCrud) ID() string {
+	return *s.Res.OpcWorkRequestId
+}
+
+func (s *IdentityImportStandardTagsManagementResourceCrud) Create() error {
+	request := oci_identity.ImportStandardTagsRequest{}
+
+	if compartmentId, ok := s.D.GetOkExists("compartment_id"); ok {
+		tmp := compartmentId.(string)
+		request.CompartmentId = &tmp
+	}
+
+	if standardTagNamespaceName, ok := s.D.GetOkExists("standard_tag_namespace_name"); ok {
+		tmp := standardTagNamespaceName.(string)
+		request.StandardTagNamespaceName = &tmp
+	}
+
+	request.RequestMetadata.RetryPolicy = GetRetryPolicy(s.DisableNotFoundRetries, "identity")
+
+	response, err := s.Client.ImportStandardTags(context.Background(), request)
+	if err != nil {
+		return err
+	}
+
+	workId := response.OpcWorkRequestId
+	s.D.SetId(*workId)
+
+	s.Res = &response
+
+	return s.getImportStandardTagsManagementFromWorkRequest(workId, GetRetryPolicy(s.DisableNotFoundRetries, "identity"), oci_identity.WorkRequestResourceActionTypeCreated, s.D.Timeout(schema.TimeoutCreate))
+}
+
+func (s *IdentityImportStandardTagsManagementResourceCrud) getImportStandardTagsManagementFromWorkRequest(workId *string, retryPolicy *oci_common.RetryPolicy,
+	actionTypeEnum oci_identity.WorkRequestResourceActionTypeEnum, timeout time.Duration) error {
+
+	// Wait until it finishes
+	_, err := importStandardTagsManagementWaitForWorkRequest(workId, "identity",
+		actionTypeEnum, timeout, s.DisableNotFoundRetries, s.Client)
+
+	if err != nil {
+		return err
+	}
+
+	s.D.SetId(*workId)
+
+	return nil
+}
+
+func importStandardTagsManagementWorkRequestShouldRetryFunc(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, "identity", startTime) {
+			return true
+		}
+
+		// Only stop if the time Finished is set
+		if workRequestResponse, ok := response.Response.(oci_identity.GetTaggingWorkRequestResponse); ok {
+			return workRequestResponse.TimeFinished == nil
+		}
+		return false
+	}
+}
+
+func importStandardTagsManagementWaitForWorkRequest(wId *string, entityType string, action oci_identity.WorkRequestResourceActionTypeEnum,
+	timeout time.Duration, disableFoundRetries bool, client *oci_identity.IdentityClient) (*string, error) {
+	retryPolicy := GetRetryPolicy(disableFoundRetries, "identity")
+	retryPolicy.ShouldRetryOperation = importStandardTagsManagementWorkRequestShouldRetryFunc(timeout)
+
+	response := oci_identity.GetTaggingWorkRequestResponse{}
+	stateConf := &resource.StateChangeConf{
+		Pending: []string{
+			string(oci_identity.TaggingWorkRequestStatusInProgress),
+			string(oci_identity.TaggingWorkRequestStatusAccepted),
+			string(oci_identity.TaggingWorkRequestStatusCanceling),
+		},
+		Target: []string{
+			string(oci_identity.TaggingWorkRequestStatusSucceeded),
+			string(oci_identity.TaggingWorkRequestStatusFailed),
+			string(oci_identity.TaggingWorkRequestStatusCanceled),
+		},
+		Refresh: func() (interface{}, string, error) {
+			var err error
+			response, err = client.GetTaggingWorkRequest(context.Background(),
+				oci_identity.GetTaggingWorkRequestRequest{
+					WorkRequestId: wId,
+					RequestMetadata: oci_common.RequestMetadata{
+						RetryPolicy: retryPolicy,
+					},
+				})
+			wr := &response.TaggingWorkRequest
+			return wr, string(wr.Status), err
+		},
+		Timeout: timeout,
+	}
+	if _, e := stateConf.WaitForState(); e != nil {
+		return nil, e
+	}
+
+	// The work request response contains an array of resources, but that array will always be empty
+	// Hence, no handling of this array is necessary (unlike in other Terraform managed resources)
+
+	// The workrequest may have failed - so check for failed or canceled work requests
+	if response.Status == oci_identity.TaggingWorkRequestStatusFailed || response.Status == oci_identity.TaggingWorkRequestStatusCanceled {
+		return nil, getErrorFromIdentityImportStandardTagsManagementWorkRequest(client, wId, retryPolicy, entityType, action)
+	}
+
+	return wId, nil
+
+}
+
+func getErrorFromIdentityImportStandardTagsManagementWorkRequest(client *oci_identity.IdentityClient, workId *string, retryPolicy *oci_common.RetryPolicy, entityType string, action oci_identity.WorkRequestResourceActionTypeEnum) error {
+	response, err := client.ListTaggingWorkRequestErrors(context.Background(),
+		oci_identity.ListTaggingWorkRequestErrorsRequest{
+			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 *IdentityImportStandardTagsManagementResourceCrud) SetData() error {
+	if s.Res.OpcWorkRequestId != nil {
+		s.D.Set("work_request_id", *s.Res.OpcWorkRequestId)
+	}
+
+	return nil
+}

oci/identity_import_standard_tags_management_test.go

@@ -0,0 +1,70 @@
+// 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 (
+	importStandardTagsManagementRepresentation = map[string]interface{}{
+		"compartment_id":              Representation{RepType: Required, Create: `${var.compartment_id}`},
+		"standard_tag_namespace_name": Representation{RepType: Required, Create: `${oci_identity_tag_namespace.test_tag_namespace.name}`},
+	}
+
+	standardTagNamespaceRepresentation = map[string]interface{}{
+		"compartment_id": Representation{RepType: Required, Create: `${var.compartment_id}`},
+		"description":    Representation{RepType: Required, Create: `Oracle recommended tags`},
+		"name":           Representation{RepType: Required, Create: `Oracle-Standard`},
+	}
+
+	ImportStandardTagsManagementResourceDependencies = GenerateResourceFromRepresentationMap("oci_identity_tag_namespace", "test_tag_namespace", Required, Create, standardTagNamespaceRepresentation)
+)
+
+// issue-routing-tag: identity/default
+func TestIdentityImportStandardTagsManagementResource_basic(t *testing.T) {
+	httpreplay.SetScenario("TestIdentityImportStandardTagsManagementResource_basic")
+	defer httpreplay.SaveScenario()
+
+	config := testProviderConfig()
+
+	compartmentId := getEnvSettingWithBlankDefault("compartment_ocid")
+	compartmentIdVariableStr := fmt.Sprintf("variable \"compartment_id\" { default = \"%s\" }\n", compartmentId)
+
+	resourceName := "oci_identity_import_standard_tags_management.test_import_standard_tags_management"
+
+	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+ImportStandardTagsManagementResourceDependencies+
+		GenerateResourceFromRepresentationMap("oci_identity_import_standard_tags_management", "test_import_standard_tags_management", Required, Create, importStandardTagsManagementRepresentation), "identity", "importStandardTagsManagement", t)
+
+	ResourceTest(t, nil, []resource.TestStep{
+		// verify Create
+		{
+			Config: config + compartmentIdVariableStr + ImportStandardTagsManagementResourceDependencies +
+				GenerateResourceFromRepresentationMap("oci_identity_import_standard_tags_management", "test_import_standard_tags_management", Required, Create, importStandardTagsManagementRepresentation),
+			Check: ComposeAggregateTestCheckFuncWrapper(
+				resource.TestCheckResourceAttr(resourceName, "compartment_id", compartmentId),
+				resource.TestCheckResourceAttrSet(resourceName, "standard_tag_namespace_name"),
+
+				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
+				},
+			),
+		},
+	})
+}