add resource azurerm_cosmosdb_notebook_workspace

azurerm/internal/services/cosmos/client/client.go

@@ -6,12 +6,13 @@ import (
 )
 
 type Client struct {
-	CassandraClient *documentdb.CassandraResourcesClient
-	DatabaseClient  *documentdb.DatabaseAccountsClient
-	GremlinClient   *documentdb.GremlinResourcesClient
-	MongoDbClient   *documentdb.MongoDBResourcesClient
-	SqlClient       *documentdb.SQLResourcesClient
-	TableClient     *documentdb.TableResourcesClient
+	CassandraClient         *documentdb.CassandraResourcesClient
+	DatabaseClient          *documentdb.DatabaseAccountsClient
+	GremlinClient           *documentdb.GremlinResourcesClient
+	MongoDbClient           *documentdb.MongoDBResourcesClient
+	NotebookWorkspaceClient *documentdb.NotebookWorkspacesClient
+	SqlClient               *documentdb.SQLResourcesClient
+	TableClient             *documentdb.TableResourcesClient
 }
 
 func NewClient(o *common.ClientOptions) *Client {
@@ -27,18 +28,22 @@ func NewClient(o *common.ClientOptions) *Client {
 	mongoDbClient := documentdb.NewMongoDBResourcesClientWithBaseURI(o.ResourceManagerEndpoint, o.SubscriptionId)
 	o.ConfigureClient(&mongoDbClient.Client, o.ResourceManagerAuthorizer)
 
+	notebookWorkspaceClient := documentdb.NewNotebookWorkspacesClientWithBaseURI(o.ResourceManagerEndpoint, o.SubscriptionId)
+	o.ConfigureClient(&notebookWorkspaceClient.Client, o.ResourceManagerAuthorizer)
+
 	sqlClient := documentdb.NewSQLResourcesClientWithBaseURI(o.ResourceManagerEndpoint, o.SubscriptionId)
 	o.ConfigureClient(&sqlClient.Client, o.ResourceManagerAuthorizer)
 
 	tableClient := documentdb.NewTableResourcesClientWithBaseURI(o.ResourceManagerEndpoint, o.SubscriptionId)
 	o.ConfigureClient(&tableClient.Client, o.ResourceManagerAuthorizer)
 
 	return &Client{
-		CassandraClient: &cassandraClient,
-		DatabaseClient:  &databaseClient,
-		GremlinClient:   &gremlinClient,
-		MongoDbClient:   &mongoDbClient,
-		SqlClient:       &sqlClient,
-		TableClient:     &tableClient,
+		CassandraClient:         &cassandraClient,
+		DatabaseClient:          &databaseClient,
+		GremlinClient:           &gremlinClient,
+		MongoDbClient:           &mongoDbClient,
+		NotebookWorkspaceClient: &notebookWorkspaceClient,
+		SqlClient:               &sqlClient,
+		TableClient:             &tableClient,
 	}
 }

azurerm/internal/services/cosmos/cosmosdb_notebook_workspace_resource.go

@@ -0,0 +1,147 @@
+package cosmos
+
+import (
+	"fmt"
+	"log"
+	"time"
+
+	"github.com/Azure/azure-sdk-for-go/services/cosmos-db/mgmt/2021-01-15/documentdb"
+	"github.com/hashicorp/terraform-plugin-sdk/helper/schema"
+	"github.com/hashicorp/terraform-plugin-sdk/helper/validation"
+	"github.com/terraform-providers/terraform-provider-azurerm/azurerm/helpers/azure"
+	"github.com/terraform-providers/terraform-provider-azurerm/azurerm/helpers/tf"
+	"github.com/terraform-providers/terraform-provider-azurerm/azurerm/internal/clients"
+	"github.com/terraform-providers/terraform-provider-azurerm/azurerm/internal/services/cosmos/parse"
+	"github.com/terraform-providers/terraform-provider-azurerm/azurerm/internal/services/cosmos/validate"
+	azSchema "github.com/terraform-providers/terraform-provider-azurerm/azurerm/internal/tf/schema"
+	"github.com/terraform-providers/terraform-provider-azurerm/azurerm/internal/timeouts"
+	"github.com/terraform-providers/terraform-provider-azurerm/azurerm/utils"
+)
+
+func resourceCosmosDbNotebookWorkspace() *schema.Resource {
+	return &schema.Resource{
+		Create: resourceCosmosDbNotebookWorkspaceCreate,
+		Read:   resourceCosmosDbNotebookWorkspaceRead,
+		Delete: resourceCosmosDbNotebookWorkspaceDelete,
+
+		Timeouts: &schema.ResourceTimeout{
+			Create: schema.DefaultTimeout(30 * time.Minute),
+			Read:   schema.DefaultTimeout(5 * time.Minute),
+			Delete: schema.DefaultTimeout(30 * time.Minute),
+		},
+
+		Importer: azSchema.ValidateResourceIDPriorToImport(func(id string) error {
+			_, err := parse.NotebookWorkspaceID(id)
+			return err
+		}),
+
+		Schema: map[string]*schema.Schema{
+			"name": {
+				Type:     schema.TypeString,
+				Required: true,
+				ForceNew: true,
+				ValidateFunc: validation.StringInSlice([]string{
+					"default",
+				}, false),
+			},
+
+			"resource_group_name": azure.SchemaResourceGroupName(),
+
+			"account_name": {
+				Type:         schema.TypeString,
+				Required:     true,
+				ForceNew:     true,
+				ValidateFunc: validate.CosmosAccountName,
+			},
+
+			"notebook_server_endpoint": {
+				Type:     schema.TypeString,
+				Computed: true,
+			},
+		},
+	}
+}
+func resourceCosmosDbNotebookWorkspaceCreate(d *schema.ResourceData, meta interface{}) error {
+	subscriptionId := meta.(*clients.Client).Account.SubscriptionId
+	client := meta.(*clients.Client).Cosmos.NotebookWorkspaceClient
+	ctx, cancel := timeouts.ForCreateUpdate(meta.(*clients.Client).StopContext, d)
+	defer cancel()
+
+	name := d.Get("name").(string)
+	resourceGroup := d.Get("resource_group_name").(string)
+	accountName := d.Get("account_name").(string)
+
+	id := parse.NewNotebookWorkspaceID(subscriptionId, resourceGroup, accountName, name)
+
+	existing, err := client.Get(ctx, id.ResourceGroup, id.DatabaseAccountName)
+	if err != nil {
+		if !utils.ResponseWasNotFound(existing.Response) {
+			return fmt.Errorf("checking for existing CosmosDb NotebookWorkspace %q: %+v", id, err)
+		}
+	}
+	if !utils.ResponseWasNotFound(existing.Response) {
+		return tf.ImportAsExistsError("azurerm_cosmosdb_notebook_workspace", id.ID())
+	}
+
+	notebookCreateUpdateParameters := documentdb.NotebookWorkspaceCreateUpdateParameters{}
+	future, err := client.CreateOrUpdate(ctx, id.ResourceGroup, id.DatabaseAccountName, notebookCreateUpdateParameters)
+	if err != nil {
+		return fmt.Errorf("creating CosmosDb NotebookWorkspace %q: %+v", id, err)
+	}
+
+	if err := future.WaitForCompletionRef(ctx, client.Client); err != nil {
+		return fmt.Errorf("waiting for creation of the CosmosDb NotebookWorkspace %q: %+v", id, err)
+	}
+
+	d.SetId(id.ID())
+	return resourceCosmosDbNotebookWorkspaceRead(d, meta)
+}
+
+func resourceCosmosDbNotebookWorkspaceRead(d *schema.ResourceData, meta interface{}) error {
+	client := meta.(*clients.Client).Cosmos.NotebookWorkspaceClient
+	ctx, cancel := timeouts.ForRead(meta.(*clients.Client).StopContext, d)
+	defer cancel()
+
+	id, err := parse.NotebookWorkspaceID(d.Id())
+	if err != nil {
+		return err
+	}
+
+	resp, err := client.Get(ctx, id.ResourceGroup, id.DatabaseAccountName)
+	if err != nil {
+		if utils.ResponseWasNotFound(resp.Response) {
+			log.Printf("[INFO] CosmosDb NotebookWorkspace %q does not exist - removing from state", d.Id())
+			d.SetId("")
+			return nil
+		}
+		return fmt.Errorf("retrieving CosmosDb NotebookWorkspace %q: %+v", id, err)
+	}
+	d.Set("name", id.Name)
+	d.Set("resource_group_name", id.ResourceGroup)
+	d.Set("account_name", id.DatabaseAccountName)
+	if props := resp.NotebookWorkspaceProperties; props != nil {
+		d.Set("notebook_server_endpoint", props.NotebookServerEndpoint)
+	}
+	return nil
+}
+
+func resourceCosmosDbNotebookWorkspaceDelete(d *schema.ResourceData, meta interface{}) error {
+	client := meta.(*clients.Client).Cosmos.NotebookWorkspaceClient
+	ctx, cancel := timeouts.ForDelete(meta.(*clients.Client).StopContext, d)
+	defer cancel()
+
+	id, err := parse.NotebookWorkspaceID(d.Id())
+	if err != nil {
+		return err
+	}
+
+	future, err := client.Delete(ctx, id.ResourceGroup, id.DatabaseAccountName)
+	if err != nil {
+		return fmt.Errorf("deleting CosmosDb NotebookWorkspace %q: %+v", id, err)
+	}
+
+	if err := future.WaitForCompletionRef(ctx, client.Client); err != nil {
+		return fmt.Errorf("waiting for deletion of the CosmosDb NotebookWorkspace %q: %+v", id, err)
+	}
+	return nil
+}

azurerm/internal/services/cosmos/cosmosdb_notebook_workspace_resource_test.go

@@ -0,0 +1,117 @@
+package cosmos_test
+
+import (
+	"context"
+	"fmt"
+	"testing"
+
+	"github.com/hashicorp/terraform-plugin-sdk/helper/resource"
+	"github.com/hashicorp/terraform-plugin-sdk/terraform"
+	"github.com/terraform-providers/terraform-provider-azurerm/azurerm/internal/acceptance"
+	"github.com/terraform-providers/terraform-provider-azurerm/azurerm/internal/acceptance/check"
+	"github.com/terraform-providers/terraform-provider-azurerm/azurerm/internal/clients"
+	"github.com/terraform-providers/terraform-provider-azurerm/azurerm/internal/services/cosmos/parse"
+	"github.com/terraform-providers/terraform-provider-azurerm/azurerm/utils"
+)
+
+type CosmosDbNotebookWorkspaceResource struct{}
+
+func TestAccCosmosDbNotebookWorkspace_basic(t *testing.T) {
+	data := acceptance.BuildTestData(t, "azurerm_cosmosdb_notebook_workspace", "test")
+	r := CosmosDbNotebookWorkspaceResource{}
+	data.ResourceTest(t, r, []resource.TestStep{
+		{
+			Config: r.basic(data),
+			Check: resource.ComposeTestCheckFunc(
+				check.That(data.ResourceName).ExistsInAzure(r),
+			),
+		},
+		data.ImportStep(),
+	})
+}
+
+func TestAccCosmosDbNotebookWorkspace_requiresImport(t *testing.T) {
+	data := acceptance.BuildTestData(t, "azurerm_cosmosdb_notebook_workspace", "test")
+	r := CosmosDbNotebookWorkspaceResource{}
+	data.ResourceTest(t, r, []resource.TestStep{
+		{
+			Config: r.basic(data),
+			Check: resource.ComposeTestCheckFunc(
+				check.That(data.ResourceName).ExistsInAzure(r),
+			),
+		},
+		data.RequiresImportErrorStep(r.requiresImport),
+	})
+}
+
+func (r CosmosDbNotebookWorkspaceResource) Exists(ctx context.Context, client *clients.Client, state *terraform.InstanceState) (*bool, error) {
+	id, err := parse.NotebookWorkspaceID(state.ID)
+	if err != nil {
+		return nil, err
+	}
+	resp, err := client.Cosmos.NotebookWorkspaceClient.Get(ctx, id.ResourceGroup, id.DatabaseAccountName)
+	if err != nil {
+		if utils.ResponseWasNotFound(resp.Response) {
+			return utils.Bool(false), nil
+		}
+		return nil, fmt.Errorf("retrieving Cosmos NotebookWorkspace %q: %+v", id, err)
+	}
+	return utils.Bool(true), nil
+}
+
+func (r CosmosDbNotebookWorkspaceResource) template(data acceptance.TestData) string {
+	return fmt.Sprintf(`
+provider "azurerm" {
+  features {}
+}
+
+resource "azurerm_resource_group" "test" {
+  name     = "acctest-cosmosdb-%d"
+  location = "%s"
+}
+
+resource "azurerm_cosmosdb_account" "test" {
+  name                = "acctest-ca-%d"
+  location            = azurerm_resource_group.test.location
+  resource_group_name = azurerm_resource_group.test.name
+  offer_type          = "Standard"
+  kind                = "GlobalDocumentDB"
+
+  consistency_policy {
+    consistency_level = "BoundedStaleness"
+  }
+
+  geo_location {
+    location          = azurerm_resource_group.test.location
+    failover_priority = 0
+  }
+}
+
+`, data.RandomInteger, data.Locations.Primary, data.RandomInteger)
+}
+
+func (r CosmosDbNotebookWorkspaceResource) basic(data acceptance.TestData) string {
+	template := r.template(data)
+	return fmt.Sprintf(`
+%s
+
+resource "azurerm_cosmosdb_notebook_workspace" "test" {
+  name                = "default"
+  resource_group_name = azurerm_resource_group.test.name
+  account_name        = azurerm_cosmosdb_account.test.name
+}
+`, template)
+}
+
+func (r CosmosDbNotebookWorkspaceResource) requiresImport(data acceptance.TestData) string {
+	config := r.basic(data)
+	return fmt.Sprintf(`
+%s
+
+resource "azurerm_cosmosdb_notebook_workspace" "import" {
+  name                = "default"
+  resource_group_name = azurerm_resource_group.test.name
+  account_name        = azurerm_cosmosdb_account.test.name
+}
+`, config)
+}

azurerm/internal/services/cosmos/parse/notebook_workspace.go

@@ -0,0 +1,75 @@
+package parse
+
+// NOTE: this file is generated via 'go:generate' - manual changes will be overwritten
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/terraform-providers/terraform-provider-azurerm/azurerm/helpers/azure"
+)
+
+type NotebookWorkspaceId struct {
+	SubscriptionId      string
+	ResourceGroup       string
+	DatabaseAccountName string
+	Name                string
+}
+
+func NewNotebookWorkspaceID(subscriptionId, resourceGroup, databaseAccountName, name string) NotebookWorkspaceId {
+	return NotebookWorkspaceId{
+		SubscriptionId:      subscriptionId,
+		ResourceGroup:       resourceGroup,
+		DatabaseAccountName: databaseAccountName,
+		Name:                name,
+	}
+}
+
+func (id NotebookWorkspaceId) String() string {
+	segments := []string{
+		fmt.Sprintf("Name %q", id.Name),
+		fmt.Sprintf("Database Account Name %q", id.DatabaseAccountName),
+		fmt.Sprintf("Resource Group %q", id.ResourceGroup),
+	}
+	segmentsStr := strings.Join(segments, " / ")
+	return fmt.Sprintf("%s: (%s)", "Notebook Workspace", segmentsStr)
+}
+
+func (id NotebookWorkspaceId) ID() string {
+	fmtString := "/subscriptions/%s/resourceGroups/%s/providers/Microsoft.DocumentDB/databaseAccounts/%s/notebookWorkspaces/%s"
+	return fmt.Sprintf(fmtString, id.SubscriptionId, id.ResourceGroup, id.DatabaseAccountName, id.Name)
+}
+
+// NotebookWorkspaceID parses a NotebookWorkspace ID into an NotebookWorkspaceId struct
+func NotebookWorkspaceID(input string) (*NotebookWorkspaceId, error) {
+	id, err := azure.ParseAzureResourceID(input)
+	if err != nil {
+		return nil, err
+	}
+
+	resourceId := NotebookWorkspaceId{
+		SubscriptionId: id.SubscriptionID,
+		ResourceGroup:  id.ResourceGroup,
+	}
+
+	if resourceId.SubscriptionId == "" {
+		return nil, fmt.Errorf("ID was missing the 'subscriptions' element")
+	}
+
+	if resourceId.ResourceGroup == "" {
+		return nil, fmt.Errorf("ID was missing the 'resourceGroups' element")
+	}
+
+	if resourceId.DatabaseAccountName, err = id.PopSegment("databaseAccounts"); err != nil {
+		return nil, err
+	}
+	if resourceId.Name, err = id.PopSegment("notebookWorkspaces"); err != nil {
+		return nil, err
+	}
+
+	if err := id.ValidateNoEmptySegments(input); err != nil {
+		return nil, err
+	}
+
+	return &resourceId, nil
+}