Added - support for metering computation

Author: Varun Kohade

internal/integrationtest/metering_computation_schedule_test.go

@@ -0,0 +1,76 @@
+// Copyright (c) 2017, 2021, Oracle and/or its affiliates. All rights reserved.
+// Licensed under the Mozilla Public License v2.0
+
+package integrationtest
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/resource"
+
+	"github.com/terraform-providers/terraform-provider-oci/httpreplay"
+	"github.com/terraform-providers/terraform-provider-oci/internal/acctest"
+
+	"github.com/terraform-providers/terraform-provider-oci/internal/utils"
+)
+
+var (
+	scheduledRunSingularDataSourceRepresentation = map[string]interface{}{
+		"scheduled_run_id": acctest.Representation{RepType: acctest.Required, Create: `${var.scheduled_run_ocid}`},
+	}
+
+	scheduledRunDataSourceRepresentation = map[string]interface{}{
+		"schedule_id": acctest.Representation{RepType: acctest.Required, Create: `${var.schedule_ocid}`},
+	}
+)
+
+// issue-routing-tag: metering_computation/default
+func TestMeteringComputationScheduledRunResource_basic(t *testing.T) {
+	httpreplay.SetScenario("TestMeteringComputationScheduledRunResource_basic")
+	defer httpreplay.SaveScenario()
+
+	config := acctest.ProviderTestConfig()
+
+	scheduledRunId := utils.GetEnvSettingWithBlankDefault("scheduled_run_id")
+	scheduledRunIdVariableStr := fmt.Sprintf("variable \"scheduled_run_ocid\" { default = \"%s\" }\n", scheduledRunId)
+
+	scheduleId := utils.GetEnvSettingWithBlankDefault("schedule_id")
+	scheduleIdVariableStr := fmt.Sprintf("variable \"schedule_ocid\" { default = \"%s\" }\n", scheduleId)
+
+	compartmentId := utils.GetEnvSettingWithBlankDefault("compartment_ocid")
+	compartmentIdVariableStr := fmt.Sprintf("variable \"compartment_id\" { default = \"%s\" }\n", compartmentId)
+
+	datasourceName := "data.oci_metering_computation_scheduled_runs.test_scheduled_runs"
+	singularDatasourceName := "data.oci_metering_computation_scheduled_run.test_scheduled_run"
+
+	acctest.SaveConfigContent("", "", "", t)
+
+	acctest.ResourceTest(t, nil, []resource.TestStep{
+		// verify datasource
+		{
+			Config: config + scheduleIdVariableStr + scheduledRunIdVariableStr +
+				acctest.GenerateDataSourceFromRepresentationMap("oci_metering_computation_scheduled_runs", "test_scheduled_runs", acctest.Required, acctest.Create, scheduledRunDataSourceRepresentation) +
+				compartmentIdVariableStr,
+			Check: acctest.ComposeAggregateTestCheckFuncWrapper(
+				resource.TestCheckResourceAttrSet(datasourceName, "schedule_id"),
+
+				resource.TestCheckResourceAttrSet(datasourceName, "scheduled_run_collection.#"),
+			),
+		},
+		// verify singular datasource
+		{
+			Config: config + scheduleIdVariableStr + scheduledRunIdVariableStr +
+				acctest.GenerateDataSourceFromRepresentationMap("oci_metering_computation_scheduled_run", "test_scheduled_run", acctest.Required, acctest.Create, scheduledRunSingularDataSourceRepresentation) +
+				compartmentIdVariableStr,
+			Check: acctest.ComposeAggregateTestCheckFuncWrapper(
+				resource.TestCheckResourceAttrSet(singularDatasourceName, "scheduled_run_id"),
+
+				resource.TestCheckResourceAttrSet(singularDatasourceName, "id"),
+				resource.TestCheckResourceAttrSet(singularDatasourceName, "state"),
+				resource.TestCheckResourceAttrSet(singularDatasourceName, "time_created"),
+				resource.TestCheckResourceAttrSet(singularDatasourceName, "time_finished"),
+			),
+		},
+	})
+}

internal/integrationtest/metering_computation_scheduled_run_test.go

@@ -925,6 +925,10 @@ func init() {
 	RegisterDatasource("oci_metering_computation_custom_tables", tf_metering_computation.MeteringComputationCustomTablesDataSource())
 	RegisterDatasource("oci_metering_computation_queries", tf_metering_computation.MeteringComputationQueriesDataSource())
 	RegisterDatasource("oci_metering_computation_query", tf_metering_computation.MeteringComputationQueryDataSource())
+	RegisterDatasource("oci_metering_computation_schedule", tf_metering_computation.MeteringComputationScheduleDataSource())
+	RegisterDatasource("oci_metering_computation_scheduled_run", tf_metering_computation.MeteringComputationScheduledRunDataSource())
+	RegisterDatasource("oci_metering_computation_scheduled_runs", tf_metering_computation.MeteringComputationScheduledRunsDataSource())
+	RegisterDatasource("oci_metering_computation_schedules", tf_metering_computation.MeteringComputationSchedulesDataSource())
 	// monitoring service
 	RegisterDatasource("oci_monitoring_alarm", tf_monitoring.MonitoringAlarmDataSource())
 	RegisterDatasource("oci_monitoring_alarm_history_collection", tf_monitoring.MonitoringAlarmHistoryCollectionDataSource())

internal/provider/register_datasource.go

@@ -474,6 +474,7 @@ func init() {
 	// metering_computation service
 	RegisterResource("oci_metering_computation_custom_table", tf_metering_computation.MeteringComputationCustomTableResource())
 	RegisterResource("oci_metering_computation_query", tf_metering_computation.MeteringComputationQueryResource())
+	RegisterResource("oci_metering_computation_schedule", tf_metering_computation.MeteringComputationScheduleResource())
 	RegisterResource("oci_metering_computation_usage", tf_metering_computation.MeteringComputationUsageResource())
 	// monitoring service
 	RegisterResource("oci_monitoring_alarm", tf_monitoring.MonitoringAlarmResource())

internal/provider/register_resource.go

@@ -40,6 +40,7 @@ import (
 	oci_sch "github.com/oracle/oci-go-sdk/v65/sch"
 	oci_stack_monitoring "github.com/oracle/oci-go-sdk/v65/stackmonitoring"
 	oci_streaming "github.com/oracle/oci-go-sdk/v65/streaming"
+	oci_metering_computation "github.com/oracle/oci-go-sdk/v65/usageapi"
 	oci_vault "github.com/oracle/oci-go-sdk/v65/vault"
 	oci_visual_builder "github.com/oracle/oci-go-sdk/v65/visualbuilder"
 	oci_vulnerability_scanning "github.com/oracle/oci-go-sdk/v65/vulnerabilityscanning"
@@ -2656,6 +2657,18 @@ var exportMeteringComputationCustomTableHints = &TerraformResourceHints{
 	requireResourceRefresh: true,
 }
 
+var exportMeteringComputationScheduleHints = &TerraformResourceHints{
+	resourceClass:          "oci_metering_computation_schedule",
+	datasourceClass:        "oci_metering_computation_schedules",
+	datasourceItemsAttr:    "schedule_collection",
+	isDatasourceCollection: true,
+	resourceAbbreviation:   "schedule",
+	requireResourceRefresh: true,
+	discoverableLifecycleStates: []string{
+		string(oci_metering_computation.ScheduleLifecycleStateActive),
+	},
+}
+
 var exportMonitoringAlarmHints = &TerraformResourceHints{
 	resourceClass:          "oci_monitoring_alarm",
 	datasourceClass:        "oci_monitoring_alarms",

internal/resourcediscovery/export_definitions.go

@@ -1012,6 +1012,7 @@ var marketplaceResourceGraph = TerraformResourceGraph{
 var meteringComputationResourceGraph = TerraformResourceGraph{
 	"oci_identity_tenancy": {
 		{TerraformResourceHints: exportMeteringComputationQueryHints},
+		{TerraformResourceHints: exportMeteringComputationScheduleHints},
 	},
 }
 

internal/resourcediscovery/export_graphs.go

@@ -399,21 +399,3 @@ func (s *MeteringComputationCustomTableResourceCrud) mapToTag(fieldKeyFormat str
 
 	return result, nil
 }
-
-func TagToMap(obj oci_metering_computation.Tag) map[string]interface{} {
-	result := map[string]interface{}{}
-
-	if obj.Key != nil {
-		result["key"] = string(*obj.Key)
-	}
-
-	if obj.Namespace != nil {
-		result["namespace"] = string(*obj.Namespace)
-	}
-
-	if obj.Value != nil {
-		result["value"] = string(*obj.Value)
-	}
-
-	return result
-}

internal/service/metering_computation/metering_computation_custom_table_resource.go

@@ -0,0 +1,119 @@
+// Copyright (c) 2017, 2021, Oracle and/or its affiliates. All rights reserved.
+// Licensed under the Mozilla Public License v2.0
+
+package metering_computation
+
+import (
+	"context"
+	"time"
+
+	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
+	oci_metering_computation "github.com/oracle/oci-go-sdk/v65/usageapi"
+
+	"github.com/terraform-providers/terraform-provider-oci/internal/client"
+	"github.com/terraform-providers/terraform-provider-oci/internal/tfresource"
+)
+
+func MeteringComputationScheduleDataSource() *schema.Resource {
+	fieldMap := make(map[string]*schema.Schema)
+	fieldMap["schedule_id"] = &schema.Schema{
+		Type:     schema.TypeString,
+		Required: true,
+	}
+	return tfresource.GetSingularDataSourceItemSchema(MeteringComputationScheduleResource(), fieldMap, readSingularMeteringComputationSchedule)
+}
+
+func readSingularMeteringComputationSchedule(d *schema.ResourceData, m interface{}) error {
+	sync := &MeteringComputationScheduleDataSourceCrud{}
+	sync.D = d
+	sync.Client = m.(*client.OracleClients).UsageapiClient()
+
+	return tfresource.ReadResource(sync)
+}
+
+type MeteringComputationScheduleDataSourceCrud struct {
+	D      *schema.ResourceData
+	Client *oci_metering_computation.UsageapiClient
+	Res    *oci_metering_computation.GetScheduleResponse
+}
+
+func (s *MeteringComputationScheduleDataSourceCrud) VoidState() {
+	s.D.SetId("")
+}
+
+func (s *MeteringComputationScheduleDataSourceCrud) Get() error {
+	request := oci_metering_computation.GetScheduleRequest{}
+
+	if scheduleId, ok := s.D.GetOkExists("schedule_id"); ok {
+		tmp := scheduleId.(string)
+		request.ScheduleId = &tmp
+	}
+
+	request.RequestMetadata.RetryPolicy = tfresource.GetRetryPolicy(false, "metering_computation")
+
+	response, err := s.Client.GetSchedule(context.Background(), request)
+	if err != nil {
+		return err
+	}
+
+	s.Res = &response
+	return nil
+}
+
+func (s *MeteringComputationScheduleDataSourceCrud) SetData() error {
+	if s.Res == nil {
+		return nil
+	}
+
+	s.D.SetId(*s.Res.Id)
+
+	if s.Res.CompartmentId != nil {
+		s.D.Set("compartment_id", *s.Res.CompartmentId)
+	}
+
+	if s.Res.DefinedTags != nil {
+		s.D.Set("defined_tags", tfresource.DefinedTagsToMap(s.Res.DefinedTags))
+	}
+
+	s.D.Set("freeform_tags", s.Res.FreeformTags)
+
+	if s.Res.Name != nil {
+		s.D.Set("name", *s.Res.Name)
+	}
+
+	if s.Res.QueryProperties != nil {
+		s.D.Set("query_properties", []interface{}{QueryPropertiesToMap(s.Res.QueryProperties)})
+	} else {
+		s.D.Set("query_properties", nil)
+	}
+
+	if s.Res.ResultLocation != nil {
+		resultLocationArray := []interface{}{}
+		if resultLocationMap := ResultLocationToMap(&s.Res.ResultLocation); resultLocationMap != nil {
+			resultLocationArray = append(resultLocationArray, resultLocationMap)
+		}
+		s.D.Set("result_location", resultLocationArray)
+	} else {
+		s.D.Set("result_location", nil)
+	}
+
+	if s.Res.ScheduleRecurrences != nil {
+		s.D.Set("schedule_recurrences", *s.Res.ScheduleRecurrences)
+	}
+
+	s.D.Set("state", s.Res.LifecycleState)
+
+	if s.Res.SystemTags != nil {
+		s.D.Set("system_tags", tfresource.SystemTagsToMap(s.Res.SystemTags))
+	}
+
+	if s.Res.TimeCreated != nil {
+		s.D.Set("time_created", s.Res.TimeCreated.String())
+	}
+
+	if s.Res.TimeScheduled != nil {
+		s.D.Set("time_scheduled", s.Res.TimeScheduled.Format(time.RFC3339Nano))
+	}
+
+	return nil
+}