New Resource: azurerm_log_analytics_query_pack

internal/provider/services.go

@@ -129,6 +129,7 @@ func SupportedTypedServices() []sdk.TypedServiceRegistration {
 		keyvault.Registration{},
 		loadbalancer.Registration{},
 		loadtest.Registration{},
+		loganalytics.Registration{},
 		monitor.Registration{},
 		mssql.Registration{},
 		policy.Registration{},

internal/services/loganalytics/client/client.go

@@ -3,6 +3,7 @@ package client
 import (
 	"github.com/Azure/azure-sdk-for-go/services/operationalinsights/mgmt/2020-08-01/operationalinsights"
 	"github.com/Azure/azure-sdk-for-go/services/preview/operationsmanagement/mgmt/2015-11-01-preview/operationsmanagement"
+	queryPacks "github.com/hashicorp/go-azure-sdk/resource-manager/operationalinsights/2019-09-01/operationalinsights"
 	"github.com/hashicorp/terraform-provider-azurerm/internal/common"
 )
 
@@ -12,6 +13,7 @@ type Client struct {
 	DataSourcesClient          *operationalinsights.DataSourcesClient
 	LinkedServicesClient       *operationalinsights.LinkedServicesClient
 	LinkedStorageAccountClient *operationalinsights.LinkedStorageAccountsClient
+	QueryPacksClient           *queryPacks.OperationalInsightsClient
 	SavedSearchesClient        *operationalinsights.SavedSearchesClient
 	SharedKeysClient           *operationalinsights.SharedKeysClient
 	SolutionsClient            *operationsmanagement.SolutionsClient
@@ -50,12 +52,16 @@ func NewClient(o *common.ClientOptions) *Client {
 	LinkedStorageAccountClient := operationalinsights.NewLinkedStorageAccountsClientWithBaseURI(o.ResourceManagerEndpoint, o.SubscriptionId)
 	o.ConfigureClient(&LinkedStorageAccountClient.Client, o.ResourceManagerAuthorizer)
 
+	QueryPacksClient := queryPacks.NewOperationalInsightsClientWithBaseURI(o.ResourceManagerEndpoint)
+	o.ConfigureClient(&QueryPacksClient.Client, o.ResourceManagerAuthorizer)
+
 	return &Client{
 		ClusterClient:              &ClusterClient,
 		DataExportClient:           &DataExportClient,
 		DataSourcesClient:          &DataSourcesClient,
 		LinkedServicesClient:       &LinkedServicesClient,
 		LinkedStorageAccountClient: &LinkedStorageAccountClient,
+		QueryPacksClient:           &QueryPacksClient,
 		SavedSearchesClient:        &SavedSearchesClient,
 		SharedKeysClient:           &SharedKeysClient,
 		SolutionsClient:            &SolutionsClient,

internal/services/loganalytics/log_analytics_query_pack_resource.go

@@ -0,0 +1,205 @@
+package loganalytics
+
+import (
+	"context"
+	"fmt"
+	"net/http"
+	"time"
+
+	"github.com/hashicorp/go-azure-helpers/lang/response"
+	"github.com/hashicorp/go-azure-helpers/resourcemanager/commonschema"
+	"github.com/hashicorp/go-azure-helpers/resourcemanager/location"
+	queryPacks "github.com/hashicorp/go-azure-sdk/resource-manager/operationalinsights/2019-09-01/operationalinsights"
+	"github.com/hashicorp/terraform-provider-azurerm/internal/sdk"
+	"github.com/hashicorp/terraform-provider-azurerm/internal/tf/pluginsdk"
+	"github.com/hashicorp/terraform-provider-azurerm/internal/tf/validation"
+	"github.com/hashicorp/terraform-provider-azurerm/utils"
+)
+
+type LogAnalyticsQueryPackModel struct {
+	Name              string            `tfschema:"name"`
+	ResourceGroupName string            `tfschema:"resource_group_name"`
+	Location          string            `tfschema:"location"`
+	Tags              map[string]string `tfschema:"tags"`
+}
+
+type LogAnalyticsQueryPackResource struct{}
+
+var _ sdk.ResourceWithUpdate = LogAnalyticsQueryPackResource{}
+
+func (r LogAnalyticsQueryPackResource) ResourceType() string {
+	return "azurerm_log_analytics_query_pack"
+}
+
+func (r LogAnalyticsQueryPackResource) ModelObject() interface{} {
+	return &LogAnalyticsQueryPackModel{}
+}
+
+func (r LogAnalyticsQueryPackResource) IDValidationFunc() pluginsdk.SchemaValidateFunc {
+	return queryPacks.ValidateQueryPackID
+}
+
+func (r LogAnalyticsQueryPackResource) Arguments() map[string]*pluginsdk.Schema {
+	return map[string]*pluginsdk.Schema{
+		"name": {
+			Type:         pluginsdk.TypeString,
+			Required:     true,
+			ForceNew:     true,
+			ValidateFunc: validation.StringIsNotEmpty,
+		},
+
+		"resource_group_name": commonschema.ResourceGroupName(),
+
+		"location": commonschema.Location(),
+
+		"tags": commonschema.Tags(),
+	}
+}
+
+func (r LogAnalyticsQueryPackResource) Attributes() map[string]*pluginsdk.Schema {
+	return map[string]*pluginsdk.Schema{}
+}
+
+func (r LogAnalyticsQueryPackResource) Create() sdk.ResourceFunc {
+	return sdk.ResourceFunc{
+		Timeout: 30 * time.Minute,
+		Func: func(ctx context.Context, metadata sdk.ResourceMetaData) error {
+			var model LogAnalyticsQueryPackModel
+			if err := metadata.Decode(&model); err != nil {
+				return fmt.Errorf("decoding: %+v", err)
+			}
+
+			client := metadata.Client.LogAnalytics.QueryPacksClient
+			subscriptionId := metadata.Client.Account.SubscriptionId
+
+			id := queryPacks.NewQueryPackID(subscriptionId, model.ResourceGroupName, model.Name)
+
+			existing, err := client.QueryPacksGet(ctx, id)
+			if err != nil && !response.WasNotFound(existing.HttpResponse) {
+				return fmt.Errorf("checking for existing %s: %+v", id, err)
+			}
+
+			if !response.WasNotFound(existing.HttpResponse) {
+				return metadata.ResourceRequiresImport(r.ResourceType(), id)
+			}
+
+			properties := &queryPacks.LogAnalyticsQueryPack{
+				Location:   location.Normalize(model.Location),
+				Properties: queryPacks.LogAnalyticsQueryPackProperties{},
+				Tags:       &model.Tags,
+			}
+
+			if resp, err := client.QueryPacksCreateOrUpdate(ctx, id, *properties); err != nil {
+				// update check logic once the issue https://github.com/Azure/azure-rest-api-specs/issues/19603 is fixed
+				if !response.WasStatusCode(resp.HttpResponse, http.StatusCreated) {
+					return fmt.Errorf("creating %s: %+v", id, err)
+				}
+			}
+
+			metadata.SetID(id)
+			return nil
+		},
+	}
+}
+
+func (r LogAnalyticsQueryPackResource) Update() sdk.ResourceFunc {
+	return sdk.ResourceFunc{
+		Timeout: 30 * time.Minute,
+		Func: func(ctx context.Context, metadata sdk.ResourceMetaData) error {
+			client := metadata.Client.LogAnalytics.QueryPacksClient
+
+			id, err := queryPacks.ParseQueryPackID(metadata.ResourceData.Id())
+			if err != nil {
+				return err
+			}
+
+			var model LogAnalyticsQueryPackModel
+			if err := metadata.Decode(&model); err != nil {
+				return fmt.Errorf("decoding: %+v", err)
+			}
+
+			resp, err := client.QueryPacksGet(ctx, *id)
+			if err != nil {
+				return fmt.Errorf("retrieving %s: %+v", *id, err)
+			}
+
+			properties := resp.Model
+			if properties == nil {
+				return fmt.Errorf("retrieving %s: properties was nil", id)
+			}
+
+			if metadata.ResourceData.HasChange("tags") {
+				properties.Tags = &model.Tags
+			}
+
+			if resp, err := client.QueryPacksCreateOrUpdate(ctx, *id, *properties); err != nil {
+				// update check logic once the issue https://github.com/Azure/azure-rest-api-specs/issues/19603 is fixed
+				if !response.WasStatusCode(resp.HttpResponse, http.StatusCreated) {
+					return fmt.Errorf("updating %s: %+v", *id, err)
+				}
+			}
+
+			return nil
+		},
+	}
+}
+
+func (r LogAnalyticsQueryPackResource) Read() sdk.ResourceFunc {
+	return sdk.ResourceFunc{
+		Timeout: 5 * time.Minute,
+		Func: func(ctx context.Context, metadata sdk.ResourceMetaData) error {
+			client := metadata.Client.LogAnalytics.QueryPacksClient
+
+			id, err := queryPacks.ParseQueryPackID(metadata.ResourceData.Id())
+			if err != nil {
+				return err
+			}
+
+			resp, err := client.QueryPacksGet(ctx, *id)
+			if err != nil {
+				if response.WasNotFound(resp.HttpResponse) {
+					return metadata.MarkAsGone(id)
+				}
+
+				return fmt.Errorf("retrieving %s: %+v", *id, err)
+			}
+
+			model := resp.Model
+			if model == nil {
+				return fmt.Errorf("retrieving %s: model was nil", id)
+			}
+
+			state := LogAnalyticsQueryPackModel{
+				Name:              id.QueryPackName,
+				ResourceGroupName: id.ResourceGroupName,
+				Location:          location.NormalizeNilable(utils.String(model.Location)),
+			}
+
+			if model.Tags != nil {
+				state.Tags = *model.Tags
+			}
+
+			return metadata.Encode(&state)
+		},
+	}
+}
+
+func (r LogAnalyticsQueryPackResource) Delete() sdk.ResourceFunc {
+	return sdk.ResourceFunc{
+		Timeout: 30 * time.Minute,
+		Func: func(ctx context.Context, metadata sdk.ResourceMetaData) error {
+			client := metadata.Client.LogAnalytics.QueryPacksClient
+
+			id, err := queryPacks.ParseQueryPackID(metadata.ResourceData.Id())
+			if err != nil {
+				return err
+			}
+
+			if _, err := client.QueryPacksDelete(ctx, *id); err != nil {
+				return fmt.Errorf("deleting %s: %+v", id, err)
+			}
+
+			return nil
+		},
+	}
+}

internal/services/loganalytics/log_analytics_query_pack_resource_test.go

@@ -0,0 +1,138 @@
+package loganalytics_test
+
+import (
+	"context"
+	"fmt"
+	"testing"
+
+	"github.com/hashicorp/go-azure-helpers/lang/response"
+	queryPacks "github.com/hashicorp/go-azure-sdk/resource-manager/operationalinsights/2019-09-01/operationalinsights"
+	"github.com/hashicorp/terraform-provider-azurerm/internal/acceptance"
+	"github.com/hashicorp/terraform-provider-azurerm/internal/acceptance/check"
+	"github.com/hashicorp/terraform-provider-azurerm/internal/clients"
+	"github.com/hashicorp/terraform-provider-azurerm/internal/tf/pluginsdk"
+	"github.com/hashicorp/terraform-provider-azurerm/utils"
+)
+
+type LogAnalyticsQueryPackResource struct{}
+
+func (r LogAnalyticsQueryPackResource) Exists(ctx context.Context, client *clients.Client, state *pluginsdk.InstanceState) (*bool, error) {
+	id, err := queryPacks.ParseQueryPackID(state.ID)
+	if err != nil {
+		return nil, err
+	}
+
+	resp, err := client.LogAnalytics.QueryPacksClient.QueryPacksGet(ctx, *id)
+	if err != nil {
+		if response.WasNotFound(resp.HttpResponse) {
+			return utils.Bool(false), nil
+		}
+		return nil, fmt.Errorf("retrieving %s: %+v", *id, err)
+	}
+	return utils.Bool(true), nil
+}
+
+func TestAccLogAnalyticsQueryPack_basic(t *testing.T) {
+	data := acceptance.BuildTestData(t, "azurerm_log_analytics_query_pack", "test")
+	r := LogAnalyticsQueryPackResource{}
+
+	data.ResourceTest(t, r, []acceptance.TestStep{
+		{
+			Config: r.basic(data),
+			Check: acceptance.ComposeTestCheckFunc(
+				check.That(data.ResourceName).ExistsInAzure(r),
+			),
+		},
+		data.ImportStep(),
+	})
+}
+
+func TestAccLogAnalyticsQueryPack_requiresImport(t *testing.T) {
+	data := acceptance.BuildTestData(t, "azurerm_log_analytics_query_pack", "test")
+	r := LogAnalyticsQueryPackResource{}
+
+	data.ResourceTest(t, r, []acceptance.TestStep{
+		{
+			Config: r.basic(data),
+			Check: acceptance.ComposeTestCheckFunc(
+				check.That(data.ResourceName).ExistsInAzure(r),
+			),
+		},
+		data.RequiresImportErrorStep(r.requiresImport),
+	})
+}
+
+func TestAccLogAnalyticsQueryPack_update(t *testing.T) {
+	data := acceptance.BuildTestData(t, "azurerm_log_analytics_query_pack", "test")
+	r := LogAnalyticsQueryPackResource{}
+
+	data.ResourceTest(t, r, []acceptance.TestStep{
+		{
+			Config: r.update(data, "Test1"),
+			Check: acceptance.ComposeTestCheckFunc(
+				check.That(data.ResourceName).ExistsInAzure(r),
+			),
+		},
+		data.ImportStep(),
+		{
+			Config: r.update(data, "Test2"),
+			Check: acceptance.ComposeTestCheckFunc(
+				check.That(data.ResourceName).ExistsInAzure(r),
+			),
+		},
+		data.ImportStep(),
+	})
+}
+
+func (r LogAnalyticsQueryPackResource) basic(data acceptance.TestData) string {
+	return fmt.Sprintf(`
+%[1]s
+
+resource "azurerm_log_analytics_query_pack" "test" {
+  name                = "acctestlaqp-%[2]d"
+  resource_group_name = azurerm_resource_group.test.name
+  location            = azurerm_resource_group.test.location
+}
+`, r.template(data), data.RandomInteger)
+}
+
+func (r LogAnalyticsQueryPackResource) update(data acceptance.TestData, tag string) string {
+	return fmt.Sprintf(`
+%[1]s
+
+resource "azurerm_log_analytics_query_pack" "test" {
+  name                = "acctestlaqp-%[2]d"
+  resource_group_name = azurerm_resource_group.test.name
+  location            = azurerm_resource_group.test.location
+
+  tags = {
+    ENV = "%[3]s"
+  }
+}
+`, r.template(data), data.RandomInteger, tag)
+}
+
+func (r LogAnalyticsQueryPackResource) requiresImport(data acceptance.TestData) string {
+	return fmt.Sprintf(`
+%s
+
+resource "azurerm_log_analytics_query_pack" "import" {
+  name                = azurerm_log_analytics_query_pack.test.name
+  resource_group_name = azurerm_log_analytics_query_pack.test.resource_group_name
+  location            = azurerm_log_analytics_query_pack.test.location
+}
+`, r.basic(data))
+}
+
+func (r LogAnalyticsQueryPackResource) template(data acceptance.TestData) string {
+	return fmt.Sprintf(`
+provider "azurerm" {
+  features {}
+}
+
+resource "azurerm_resource_group" "test" {
+  name     = "acctestRG-LA-%[1]d"
+  location = "%[2]s"
+}
+`, data.RandomInteger, data.Locations.Primary)
+}