Support for deletion of tags and tag namespaces

Author: varmax2511

oci/crud_helpers.go

@@ -16,6 +16,7 @@ import (
 	"github.com/hashicorp/terraform/helper/resource"
 	"github.com/hashicorp/terraform/helper/schema"
 	oci_common "github.com/oracle/oci-go-sdk/common"
+	oci_identity "github.com/oracle/oci-go-sdk/identity"
 	oci_load_balancer "github.com/oracle/oci-go-sdk/loadbalancer"
 
 	"github.com/terraform-providers/terraform-provider-oci/httpreplay"
@@ -215,6 +216,44 @@ func LoadBalancerWaitForWorkRequest(client *oci_load_balancer.LoadBalancerClient
 	return nil
 }
 
+func IdentityWaitForWorkRequest(client *oci_identity.IdentityClient, d *schema.ResourceData, wr *oci_identity.WorkRequest, retryPolicy *oci_common.RetryPolicy, timeout time.Duration) error {
+	stateConf := &resource.StateChangeConf{
+		Pending: []string{
+			string(oci_identity.WorkRequestStatusInProgress),
+			string(oci_identity.WorkRequestStatusAccepted),
+			string(oci_identity.WorkRequestStatusCanceling),
+		},
+		Target: []string{
+			string(oci_identity.WorkRequestStatusSucceeded),
+			string(oci_identity.WorkRequestStatusFailed),
+			string(oci_identity.WorkRequestStatusCanceled),
+		},
+		Refresh: func() (interface{}, string, error) {
+			getWorkRequestRequest := oci_identity.GetWorkRequestRequest{}
+			getWorkRequestRequest.WorkRequestId = wr.Id
+			getWorkRequestRequest.RequestMetadata.RetryPolicy = retryPolicy
+			workRequestResponse, err := client.GetWorkRequest(context.Background(), getWorkRequestRequest)
+			wr = &workRequestResponse.WorkRequest
+			return wr, string(wr.Status), err
+		},
+		Timeout: timeout,
+	}
+
+	// Should not wait when in replay mode
+	if httpreplay.ShouldRetryImmediately() {
+		stateConf.PollInterval = 1
+	}
+
+	if _, e := stateConf.WaitForState(); e != nil {
+		return e
+	}
+
+	if wr.Status == oci_identity.WorkRequestStatusFailed || wr.Status == oci_identity.WorkRequestStatusCanceled {
+		return fmt.Errorf("WorkRequest FAILED: %+v", wr.Errors)
+	}
+	return nil
+}
+
 func CreateDBSystemResource(d *schema.ResourceData, sync ResourceCreator) error {
 	if e := sync.Create(); e != nil {
 		return e

oci/identity_cost_tracking_tag_test.go

@@ -53,6 +53,7 @@ func TestIdentityCostTrackingTagResource_basic(t *testing.T) {
 					resource.TestCheckResourceAttrSet(datasourceName, "tags.0.is_cost_tracking"),
 					resource.TestCheckResourceAttrSet(datasourceName, "tags.0.is_retired"),
 					resource.TestCheckResourceAttrSet(datasourceName, "tags.0.name"),
+					resource.TestCheckResourceAttrSet(datasourceName, "tags.0.state"),
 					resource.TestCheckResourceAttrSet(datasourceName, "tags.0.tag_namespace_id"),
 					resource.TestCheckResourceAttrSet(datasourceName, "tags.0.tag_namespace_name"),
 					resource.TestCheckResourceAttrSet(datasourceName, "tags.0.time_created"),

oci/identity_cost_tracking_tags_data_source.go

@@ -62,6 +62,10 @@ func IdentityCostTrackingTagsDataSource() *schema.Resource {
 							Type:     schema.TypeString,
 							Computed: true,
 						},
+						"state": {
+							Type:     schema.TypeString,
+							Computed: true,
+						},
 						"tag_namespace_id": {
 							Type:     schema.TypeString,
 							Computed: true,
@@ -180,6 +184,8 @@ func (s *IdentityCostTrackingTagsDataSourceCrud) SetData() error {
 			costTrackingTag["name"] = *r.Name
 		}
 
+		costTrackingTag["state"] = r.LifecycleState
+
 		if r.TagNamespaceId != nil {
 			costTrackingTag["tag_namespace_id"] = *r.TagNamespaceId
 		}

oci/identity_tag_namespace_resource.go

@@ -62,6 +62,10 @@ func IdentityTagNamespaceResource() *schema.Resource {
 			},
 
 			// Computed
+			"state": {
+				Type:     schema.TypeString,
+				Computed: true,
+			},
 			"time_created": {
 				Type:     schema.TypeString,
 				Computed: true,
@@ -95,7 +99,19 @@ func updateIdentityTagNamespace(d *schema.ResourceData, m interface{}) error {
 }
 
 func deleteIdentityTagNamespace(d *schema.ResourceData, m interface{}) error {
-	return nil
+	// Only empty tag namespaces can be deleted, to execute our tests we don't want to delete namespaces as we create
+	// namespaces with tags and deleting a tag is a sequential and time consuming operation allowed one per tenancy
+	importIfExists, _ := strconv.ParseBool(getEnvSettingWithDefault("tags_import_if_exists", "false"))
+	if importIfExists {
+		return nil
+	}
+
+	sync := &IdentityTagNamespaceResourceCrud{}
+	sync.D = d
+	sync.Client = m.(*OracleClients).identityClient
+	sync.DisableNotFoundRetries = true
+
+	return DeleteResource(d, sync)
 }
 
 type IdentityTagNamespaceResourceCrud struct {
@@ -109,6 +125,28 @@ func (s *IdentityTagNamespaceResourceCrud) ID() string {
 	return *s.Res.Id
 }
 
+func (s *IdentityTagNamespaceResourceCrud) CreatedPending() []string {
+	return []string{}
+}
+
+func (s *IdentityTagNamespaceResourceCrud) CreatedTarget() []string {
+	return []string{
+		string(oci_identity.TagNamespaceLifecycleStateActive),
+	}
+}
+
+func (s *IdentityTagNamespaceResourceCrud) DeletedPending() []string {
+	return []string{
+		string(oci_identity.TagNamespaceLifecycleStateDeleting),
+	}
+}
+
+func (s *IdentityTagNamespaceResourceCrud) DeletedTarget() []string {
+	return []string{
+		string(oci_identity.TagNamespaceLifecycleStateDeleted),
+	}
+}
+
 func (s *IdentityTagNamespaceResourceCrud) Create() error {
 	request := oci_identity.CreateTagNamespaceRequest{}
 
@@ -250,6 +288,18 @@ func (s *IdentityTagNamespaceResourceCrud) Update() error {
 	return nil
 }
 
+func (s *IdentityTagNamespaceResourceCrud) Delete() error {
+	request := oci_identity.DeleteTagNamespaceRequest{}
+
+	tmp := s.D.Id()
+	request.TagNamespaceId = &tmp
+
+	request.RequestMetadata.RetryPolicy = getRetryPolicy(s.DisableNotFoundRetries, "identity")
+
+	_, err := s.Client.DeleteTagNamespace(context.Background(), request)
+	return err
+}
+
 func (s *IdentityTagNamespaceResourceCrud) SetData() error {
 	if s.Res.CompartmentId != nil {
 		s.D.Set("compartment_id", *s.Res.CompartmentId)
@@ -273,6 +323,8 @@ func (s *IdentityTagNamespaceResourceCrud) SetData() error {
 		s.D.Set("name", *s.Res.Name)
 	}
 
+	s.D.Set("state", s.Res.LifecycleState)
+
 	if s.Res.TimeCreated != nil {
 		s.D.Set("time_created", s.Res.TimeCreated.String())
 	}

oci/identity_tag_namespace_test.go

@@ -3,11 +3,18 @@
 package provider
 
 import (
+	"context"
 	"fmt"
+	"strconv"
 	"testing"
+	"time"
+
+	"github.com/oracle/oci-go-sdk/common"
 
 	"github.com/hashicorp/terraform/helper/resource"
+	"github.com/hashicorp/terraform/helper/schema"
 	"github.com/hashicorp/terraform/terraform"
+	oci_identity "github.com/oracle/oci-go-sdk/identity"
 
 	"github.com/terraform-providers/terraform-provider-oci/httpreplay"
 )
@@ -19,6 +26,7 @@ var (
 	tagNamespaceDataSourceRepresentation = map[string]interface{}{
 		"compartment_id":          Representation{repType: Required, create: `${var.compartment_id}`},
 		"include_subcompartments": Representation{repType: Optional, create: `false`},
+		"state":                   Representation{repType: Optional, create: `AVAILABLE`},
 		"filter":                  RepresentationGroup{Required, tagNamespaceDataSourceFilterRepresentation}}
 	tagNamespaceDataSourceFilterRepresentation = map[string]interface{}{
 		"name":   Representation{repType: Required, create: `id`},
@@ -59,6 +67,7 @@ func TestIdentityTagNamespaceResource_basic(t *testing.T) {
 		Providers: map[string]terraform.ResourceProvider{
 			"oci": provider,
 		},
+		//CheckDestroy: testAccCheckIdentityTagNamespaceDestroy,
 		Steps: []resource.TestStep{
 			// verify create
 			{
@@ -160,6 +169,7 @@ func TestIdentityTagNamespaceResource_basic(t *testing.T) {
 				Check: resource.ComposeAggregateTestCheckFunc(
 					resource.TestCheckResourceAttr(datasourceName, "compartment_id", compartmentId),
 					resource.TestCheckResourceAttr(datasourceName, "include_subcompartments", "false"),
+					resource.TestCheckResourceAttr(datasourceName, "state", "AVAILABLE"),
 
 					resource.TestCheckResourceAttr(datasourceName, "tag_namespaces.#", "1"),
 					resource.TestCheckResourceAttr(datasourceName, "tag_namespaces.0.compartment_id", compartmentId),
@@ -169,6 +179,7 @@ func TestIdentityTagNamespaceResource_basic(t *testing.T) {
 					resource.TestCheckResourceAttrSet(datasourceName, "tag_namespaces.0.id"),
 					resource.TestCheckResourceAttrSet(datasourceName, "tag_namespaces.0.is_retired"),
 					resource.TestCheckResourceAttr(datasourceName, "tag_namespaces.0.name", "BillingTags"),
+					resource.TestCheckResourceAttrSet(datasourceName, "tag_namespaces.0.state"),
 					resource.TestCheckResourceAttrSet(datasourceName, "tag_namespaces.0.time_created"),
 				),
 			},
@@ -183,3 +194,137 @@ func TestIdentityTagNamespaceResource_basic(t *testing.T) {
 		},
 	})
 }
+
+func testAccCheckIdentityTagNamespaceDestroy(s *terraform.State) error {
+	noResourceFound := true
+	client := testAccProvider.Meta().(*OracleClients).identityClient
+	for _, rs := range s.RootModule().Resources {
+		if rs.Type == "oci_identity_tag_namespace" {
+			noResourceFound = false
+			request := oci_identity.GetTagNamespaceRequest{}
+
+			tmp := rs.Primary.ID
+			request.TagNamespaceId = &tmp
+
+			request.RequestMetadata.RetryPolicy = getRetryPolicy(true, "identity")
+
+			response, err := client.GetTagNamespace(context.Background(), request)
+
+			if err == nil {
+				deletedLifecycleStates := map[string]bool{
+					string(oci_identity.TagNamespaceLifecycleStateDeleted): true,
+				}
+				if _, ok := deletedLifecycleStates[string(response.LifecycleState)]; !ok {
+					//resource lifecycle state is not in expected deleted lifecycle states.
+					return fmt.Errorf("resource lifecycle state: %s is not in expected deleted lifecycle states", response.LifecycleState)
+				}
+				//resource lifecycle state is in expected deleted lifecycle states. continue with next one.
+				continue
+			}
+
+			//Verify that exception is for '404 not found'.
+			if failure, isServiceError := common.IsServiceError(err); !isServiceError || failure.GetHTTPStatusCode() != 404 {
+				return err
+			}
+		}
+	}
+	if noResourceFound {
+		return fmt.Errorf("at least one resource was expected from the state file, but could not be found")
+	}
+
+	return nil
+}
+
+func init() {
+	if DependencyGraph == nil {
+		initDependencyGraph()
+	}
+	if !inSweeperExcludeList("IdentityTagNamespace") {
+		resource.AddTestSweepers("IdentityTagNamespace", &resource.Sweeper{
+			Name:         "IdentityTagNamespace",
+			Dependencies: DependencyGraph["tagNamespace"],
+			F:            sweepIdentityTagNamespaceResource,
+		})
+	}
+}
+
+func sweepIdentityTagNamespaceResource(compartment string) error {
+	// prevent tag deletion when testing, as its a time consuming and sequential operation permitted one per tenancy.
+	importIfExists, _ := strconv.ParseBool(getEnvSettingWithDefault("tags_import_if_exists", "false"))
+	if importIfExists {
+		return nil
+	}
+
+	identityClient := GetTestClients(&schema.ResourceData{}).identityClient
+	tagNamespaceIds, err := getTagNamespaceIds(compartment)
+	if err != nil {
+		return err
+	}
+
+	// clean all tags in namespaces
+	err = sweepIdentityTagResource(compartment)
+	if err != nil {
+		return err
+	}
+
+	for _, tagNamespaceId := range tagNamespaceIds {
+		if ok := SweeperDefaultResourceId[tagNamespaceId]; !ok {
+			deleteTagNamespaceRequest := oci_identity.DeleteTagNamespaceRequest{}
+
+			deleteTagNamespaceRequest.TagNamespaceId = &tagNamespaceId
+
+			deleteTagNamespaceRequest.RequestMetadata.RetryPolicy = getRetryPolicy(true, "identity")
+			_, error := identityClient.DeleteTagNamespace(context.Background(), deleteTagNamespaceRequest)
+			if error != nil {
+				fmt.Printf("Error deleting TagNamespace %s %s, It is possible that the resource is already deleted. Please verify manually \n", tagNamespaceId, error)
+				continue
+			}
+			waitTillCondition(testAccProvider, &tagNamespaceId, tagNamespaceSweepWaitCondition, time.Duration(3*time.Minute),
+				tagNamespaceSweepResponseFetchOperation, "identity", true)
+		}
+	}
+	return nil
+}
+
+func getTagNamespaceIds(compartment string) ([]string, error) {
+	ids := getResourceIdsToSweep(compartment, "TagNamespaceId")
+	if ids != nil {
+		return ids, nil
+	}
+	var resourceIds []string
+	compartmentId := compartment
+	identityClient := GetTestClients(&schema.ResourceData{}).identityClient
+
+	listTagNamespacesRequest := oci_identity.ListTagNamespacesRequest{}
+	listTagNamespacesRequest.CompartmentId = &compartmentId
+	listTagNamespacesRequest.LifecycleState = oci_identity.TagNamespaceLifecycleStateActive
+	listTagNamespacesResponse, err := identityClient.ListTagNamespaces(context.Background(), listTagNamespacesRequest)
+
+	if err != nil {
+		return resourceIds, fmt.Errorf("Error getting TagNamespace list for compartment id : %s , %s \n", compartmentId, err)
+	}
+	for _, tagNamespace := range listTagNamespacesResponse.Items {
+		id := *tagNamespace.Id
+		resourceIds = append(resourceIds, id)
+		addResourceIdToSweeperResourceIdMap(compartmentId, "TagNamespaceId", id)
+	}
+	return resourceIds, nil
+}
+
+func tagNamespaceSweepWaitCondition(response common.OCIOperationResponse) bool {
+	// Only stop if the resource is available beyond 3 mins. As there could be an issue for the sweeper to delete the resource and manual intervention required.
+	if tagNamespaceResponse, ok := response.Response.(oci_identity.GetTagNamespaceResponse); ok {
+		return tagNamespaceResponse.LifecycleState != oci_identity.TagNamespaceLifecycleStateDeleted
+	}
+	return false
+}
+
+func tagNamespaceSweepResponseFetchOperation(client *OracleClients, resourceId *string, retryPolicy *common.RetryPolicy) error {
+	_, err := client.identityClient.GetTagNamespace(context.Background(), oci_identity.GetTagNamespaceRequest{
+		TagNamespaceId: resourceId,
+		RequestMetadata: common.RequestMetadata{
+			RetryPolicy: retryPolicy,
+		},
+	})
+	return err
+}

oci/identity_tag_namespaces_data_source.go

@@ -22,6 +22,10 @@ func IdentityTagNamespacesDataSource() *schema.Resource {
 				Type:     schema.TypeBool,
 				Optional: true,
 			},
+			"state": {
+				Type:     schema.TypeString,
+				Optional: true,
+			},
 			"tag_namespaces": {
 				Type:     schema.TypeList,
 				Computed: true,
@@ -62,6 +66,10 @@ func (s *IdentityTagNamespacesDataSourceCrud) Get() error {
 		request.IncludeSubcompartments = &tmp
 	}
 
+	if state, ok := s.D.GetOkExists("state"); ok {
+		request.LifecycleState = oci_identity.TagNamespaceLifecycleStateEnum(state.(string))
+	}
+
 	request.RequestMetadata.RetryPolicy = getRetryPolicy(false, "identity")
 
 	response, err := s.Client.ListTagNamespaces(context.Background(), request)
@@ -120,6 +128,8 @@ func (s *IdentityTagNamespacesDataSourceCrud) SetData() error {
 			tagNamespace["name"] = *r.Name
 		}
 
+		tagNamespace["state"] = r.LifecycleState
+
 		if r.TimeCreated != nil {
 			tagNamespace["time_created"] = r.TimeCreated.String()
 		}