Add capabilities support to Queue resource

examples/queue/main.tf

@@ -32,6 +32,10 @@ resource "oci_queue_queue" "test_queue1" {
   timeout_in_seconds               = var.queue_timeout_in_seconds
   visibility_in_seconds            = var.queue_visibility_in_seconds
   channel_consumption_limit        = var.queue_channel_consumption_limit
+  capabilities {
+    type                              = var.queue_capabilities_type
+    is_primary_consumer_group_enabled = var.queue_capabilities_is_primary_consumer_group_enabled
+  }
 }
 
 # Purging the queue immediately after create if required. Queue is purged if purge trigger is set to any integer value. We are using the purge trigger and purge type optional parameter.

examples/queue/variables.tf

@@ -56,4 +56,12 @@ variable "purge_type" {
 
 variable "purge_trigger" {
   default = 1
+}
+
+variable "queue_capabilities_type" {
+  default = "CONSUMER_GROUPS"
+}
+
+variable "queue_capabilities_is_primary_consumer_group_enabled" {
+  default = false
 }

internal/integrationtest/queue_queue_test.go

@@ -50,6 +50,11 @@ var (
 		"values": acctest.Representation{RepType: acctest.Required, Create: []string{`${oci_queue_queue.test_queue.id}`}},
 	}
 
+	QueueQueueCapabilitiesRepresentation = map[string]interface{}{
+		"type":                              acctest.Representation{RepType: acctest.Required, Create: `CONSUMER_GROUPS`, Update: `CONSUMER_GROUPS`},
+		"is_primary_consumer_group_enabled": acctest.Representation{RepType: acctest.Optional, Create: `false`, Update: `true`},
+	}
+
 	QueueQueueRepresentation = map[string]interface{}{
 		"compartment_id":                   acctest.Representation{RepType: acctest.Required, Create: `${var.compartment_id}`},
 		"display_name":                     acctest.Representation{RepType: acctest.Required, Create: `displayName`, Update: `displayName2`},
@@ -61,6 +66,7 @@ var (
 		"retention_in_seconds":             acctest.Representation{RepType: acctest.Optional, Create: `10`},
 		"timeout_in_seconds":               acctest.Representation{RepType: acctest.Optional, Create: `10`, Update: `11`},
 		"visibility_in_seconds":            acctest.Representation{RepType: acctest.Optional, Create: `10`, Update: `11`},
+		"capabilities":                     acctest.RepresentationGroup{RepType: acctest.Optional, Group: QueueQueueCapabilitiesRepresentation},
 		"lifecycle":                        acctest.RepresentationGroup{RepType: acctest.Optional, Group: ignoreDefinedTagsRepresentation},
 	}
 
@@ -131,6 +137,9 @@ func TestQueueQueueResource_basic(t *testing.T) {
 				resource.TestCheckResourceAttrSet(resourceName, "time_updated"),
 				resource.TestCheckResourceAttr(resourceName, "timeout_in_seconds", "10"),
 				resource.TestCheckResourceAttr(resourceName, "visibility_in_seconds", "10"),
+				resource.TestCheckResourceAttr(resourceName, "capabilities.#", "1"),
+				resource.TestCheckResourceAttr(resourceName, "capabilities.0.type", "CONSUMER_GROUPS"),
+				resource.TestCheckResourceAttr(resourceName, "capabilities.0.is_primary_consumer_group_enabled", "false"),
 
 				func(s *terraform.State) (err error) {
 					resId, err = acctest.FromInstanceState(s, resourceName, "id")
@@ -233,6 +242,9 @@ func TestQueueQueueResource_basic(t *testing.T) {
 				resource.TestCheckResourceAttrSet(resourceName, "time_updated"),
 				resource.TestCheckResourceAttr(resourceName, "timeout_in_seconds", "11"),
 				resource.TestCheckResourceAttr(resourceName, "visibility_in_seconds", "11"),
+				resource.TestCheckResourceAttr(resourceName, "capabilities.#", "1"),
+				resource.TestCheckResourceAttr(resourceName, "capabilities.0.type", "CONSUMER_GROUPS"),
+				resource.TestCheckResourceAttr(resourceName, "capabilities.0.is_primary_consumer_group_enabled", "true"),
 
 				func(s *terraform.State) (err error) {
 					resId2, err = acctest.FromInstanceState(s, resourceName, "id")
@@ -281,6 +293,9 @@ func TestQueueQueueResource_basic(t *testing.T) {
 				resource.TestCheckResourceAttrSet(singularDatasourceName, "time_updated"),
 				resource.TestCheckResourceAttr(singularDatasourceName, "timeout_in_seconds", "11"),
 				resource.TestCheckResourceAttr(singularDatasourceName, "visibility_in_seconds", "11"),
+				resource.TestCheckResourceAttr(singularDatasourceName, "capabilities.#", "1"),
+				resource.TestCheckResourceAttr(singularDatasourceName, "capabilities.0.type", "CONSUMER_GROUPS"),
+				resource.TestCheckResourceAttr(singularDatasourceName, "capabilities.0.is_primary_consumer_group_enabled", "true"),
 			),
 		},
 		// verify resource import

internal/service/queue/queue_queue_data_source.go

@@ -126,5 +126,13 @@ func (s *QueueQueueDataSourceCrud) SetData() error {
 		s.D.Set("visibility_in_seconds", *s.Res.VisibilityInSeconds)
 	}
 
+	if s.Res.Capabilities != nil {
+		capabilities := []interface{}{}
+		for _, item := range s.Res.Capabilities {
+			capabilities = append(capabilities, QueueCapabilityToMap(item))
+		}
+		s.D.Set("capabilities", capabilities)
+	}
+
 	return nil
 }

internal/service/queue/queue_queue_resource.go

@@ -94,6 +94,24 @@ func QueueQueueResource() *schema.Resource {
 				Type:     schema.TypeString,
 				Optional: true,
 			},
+			"capabilities": {
+				Type:     schema.TypeList,
+				Optional: true,
+				Computed: true,
+				Elem: &schema.Resource{
+					Schema: map[string]*schema.Schema{
+						"type": {
+							Type:     schema.TypeString,
+							Required: true,
+						},
+						"is_primary_consumer_group_enabled": {
+							Type:     schema.TypeBool,
+							Optional: true,
+							Computed: true,
+						},
+					},
+				},
+			},
 
 			// Computed
 			"lifecycle_details": {
@@ -282,6 +300,23 @@ func (s *QueueQueueResourceCrud) Create() error {
 		request.VisibilityInSeconds = &tmp
 	}
 
+	if capabilities, ok := s.D.GetOkExists("capabilities"); ok {
+		interfaces := capabilities.([]interface{})
+		tmp := make([]oci_queue.QueueCapability, len(interfaces))
+		for i := range interfaces {
+			stateDataIndex := i
+			fieldKeyFormat := fmt.Sprintf("%s.%d.%%s", "capabilities", stateDataIndex)
+			converted, err := s.mapToQueueCapability(fieldKeyFormat)
+			if err != nil {
+				return err
+			}
+			tmp[i] = converted
+		}
+		if len(tmp) != 0 || s.D.HasChange("capabilities") {
+			request.Capabilities = tmp
+		}
+	}
+
 	request.RequestMetadata.RetryPolicy = tfresource.GetRetryPolicy(s.DisableNotFoundRetries, "queue")
 
 	response, err := s.Client.CreateQueue(context.Background(), request)
@@ -499,6 +534,23 @@ func (s *QueueQueueResourceCrud) Update() error {
 		request.VisibilityInSeconds = &tmp
 	}
 
+	if capabilities, ok := s.D.GetOkExists("capabilities"); ok {
+		interfaces := capabilities.([]interface{})
+		tmp := make([]oci_queue.QueueCapability, len(interfaces))
+		for i := range interfaces {
+			stateDataIndex := i
+			fieldKeyFormat := fmt.Sprintf("%s.%d.%%s", "capabilities", stateDataIndex)
+			converted, err := s.mapToQueueCapability(fieldKeyFormat)
+			if err != nil {
+				return err
+			}
+			tmp[i] = converted
+		}
+		if len(tmp) != 0 || s.D.HasChange("capabilities") {
+			request.Capabilities = tmp
+		}
+	}
+
 	request.RequestMetadata.RetryPolicy = tfresource.GetRetryPolicy(s.DisableNotFoundRetries, "queue")
 
 	response, err := s.Client.UpdateQueue(context.Background(), request)
@@ -591,6 +643,14 @@ func (s *QueueQueueResourceCrud) SetData() error {
 		s.D.Set("visibility_in_seconds", *s.Res.VisibilityInSeconds)
 	}
 
+	if s.Res.Capabilities != nil {
+		capabilities := []interface{}{}
+		for _, item := range s.Res.Capabilities {
+			capabilities = append(capabilities, QueueCapabilityToMap(item))
+		}
+		s.D.Set("capabilities", capabilities)
+	}
+
 	return nil
 }
 
@@ -640,6 +700,36 @@ func (s *QueueQueueResourceCrud) PurgeQueue() error {
 	return s.getQueueFromWorkRequest(workId, tfresource.GetRetryPolicy(s.DisableNotFoundRetries, "queue"), oci_queue.ActionTypeUpdated, s.D.Timeout(schema.TimeoutUpdate))
 }
 
+func (s *QueueQueueResourceCrud) mapToQueueCapability(fieldKeyFormat string) (oci_queue.QueueCapability, error) {
+	result := oci_queue.QueueCapability{}
+
+	if capabilityType, ok := s.D.GetOkExists(fmt.Sprintf(fieldKeyFormat, "type")); ok {
+		tmp := capabilityType.(string)
+		result.Type = &tmp
+	}
+
+	if isPrimaryConsumerGroupEnabled, ok := s.D.GetOkExists(fmt.Sprintf(fieldKeyFormat, "is_primary_consumer_group_enabled")); ok {
+		tmp := isPrimaryConsumerGroupEnabled.(bool)
+		result.IsPrimaryConsumerGroupEnabled = &tmp
+	}
+
+	return result, nil
+}
+
+func QueueCapabilityToMap(obj oci_queue.QueueCapability) map[string]interface{} {
+	result := map[string]interface{}{}
+
+	if obj.Type != nil {
+		result["type"] = string(*obj.Type)
+	}
+
+	if obj.IsPrimaryConsumerGroupEnabled != nil {
+		result["is_primary_consumer_group_enabled"] = bool(*obj.IsPrimaryConsumerGroupEnabled)
+	}
+
+	return result
+}
+
 func QueueSummaryToMap(obj oci_queue.QueueSummary) map[string]interface{} {
 	result := map[string]interface{}{}
 

website/docs/d/queue_queue.html.markdown

@@ -49,4 +49,7 @@ The following attributes are exported:
 * `time_updated` - The time that the queue was updated, expressed in [RFC 3339](https://tools.ietf.org/rfc/rfc3339) timestamp format.  Example: `2018-04-20T00:00:07.405Z` 
 * `timeout_in_seconds` - The default polling timeout of the messages in the queue, in seconds.
 * `visibility_in_seconds` - The default visibility timeout of the messages consumed from the queue, in seconds.
+* `capabilities` - The capabilities configuration for the queue.
+	* `type` - The type of capability. Example: `CONSUMER_GROUPS`
+	* `is_primary_consumer_group_enabled` - Whether the primary consumer group is enabled for this capability.
 

website/docs/r/queue_queue.html.markdown

@@ -35,6 +35,10 @@ resource "oci_queue_queue" "test_queue" {
 	retention_in_seconds = var.queue_retention_in_seconds
 	timeout_in_seconds = var.queue_timeout_in_seconds
 	visibility_in_seconds = var.queue_visibility_in_seconds
+	capabilities {
+		type = "CONSUMER_GROUPS"
+		is_primary_consumer_group_enabled = false
+	}
 }
 ```
 
@@ -54,6 +58,9 @@ The following arguments are supported:
 * `visibility_in_seconds` - (Optional) (Updatable) The default visibility timeout of the messages consumed from the queue, in seconds.
 * `purge_trigger` - (Optional) (Updatable) An optional property when incremented triggers Purge. Could be set to any integer value.
 * `purge_type` - (Optional) (Updatable) An optional value that specifies the purge behavior for the Queue. Could be set to NORMAL, DLQ or BOTH. If unset, the default value is NORMAL
+* `capabilities` - (Optional) (Updatable) The capabilities configuration for the queue.
+	* `type` - (Required) The type of capability. Example: `CONSUMER_GROUPS`
+	* `is_primary_consumer_group_enabled` - (Optional) Whether the primary consumer group is enabled for this capability.
 
 ** IMPORTANT **
 Any change to a property that does not support update will force the destruction and recreation of the resource with the new property values
@@ -79,6 +86,9 @@ The following attributes are exported:
 * `time_updated` - The time that the queue was updated, expressed in [RFC 3339](https://tools.ietf.org/rfc/rfc3339) timestamp format.  Example: `2018-04-20T00:00:07.405Z` 
 * `timeout_in_seconds` - The default polling timeout of the messages in the queue, in seconds.
 * `visibility_in_seconds` - The default visibility timeout of the messages consumed from the queue, in seconds.
+* `capabilities` - The capabilities configuration for the queue.
+	* `type` - The type of capability. Example: `CONSUMER_GROUPS`
+	* `is_primary_consumer_group_enabled` - Whether the primary consumer group is enabled for this capability.
 
 ## Timeouts