new resource "azurerm_data_factory_managed_private_endpoint"

azurerm/internal/services/datafactory/client/client.go

@@ -6,13 +6,14 @@ import (
 )
 
 type Client struct {
-	DatasetClient                *datafactory.DatasetsClient
-	FactoriesClient              *datafactory.FactoriesClient
-	IntegrationRuntimesClient    *datafactory.IntegrationRuntimesClient
-	LinkedServiceClient          *datafactory.LinkedServicesClient
-	ManagedVirtualNetworksClient *datafactory.ManagedVirtualNetworksClient
-	PipelinesClient              *datafactory.PipelinesClient
-	TriggersClient               *datafactory.TriggersClient
+	DatasetClient                 *datafactory.DatasetsClient
+	FactoriesClient               *datafactory.FactoriesClient
+	IntegrationRuntimesClient     *datafactory.IntegrationRuntimesClient
+	LinkedServiceClient           *datafactory.LinkedServicesClient
+	ManagedPrivateEndpointsClient *datafactory.ManagedPrivateEndpointsClient
+	ManagedVirtualNetworksClient  *datafactory.ManagedVirtualNetworksClient
+	PipelinesClient               *datafactory.PipelinesClient
+	TriggersClient                *datafactory.TriggersClient
 }
 
 func NewClient(o *common.ClientOptions) *Client {
@@ -28,6 +29,9 @@ func NewClient(o *common.ClientOptions) *Client {
 	LinkedServiceClient := datafactory.NewLinkedServicesClientWithBaseURI(o.ResourceManagerEndpoint, o.SubscriptionId)
 	o.ConfigureClient(&LinkedServiceClient.Client, o.ResourceManagerAuthorizer)
 
+	ManagedPrivateEndpointsClient := datafactory.NewManagedPrivateEndpointsClientWithBaseURI(o.ResourceManagerEndpoint, o.SubscriptionId)
+	o.ConfigureClient(&ManagedPrivateEndpointsClient.Client, o.ResourceManagerAuthorizer)
+
 	ManagedVirtualNetworksClient := datafactory.NewManagedVirtualNetworksClientWithBaseURI(o.ResourceManagerEndpoint, o.SubscriptionId)
 	o.ConfigureClient(&ManagedVirtualNetworksClient.Client, o.ResourceManagerAuthorizer)
 
@@ -38,12 +42,13 @@ func NewClient(o *common.ClientOptions) *Client {
 	o.ConfigureClient(&TriggersClient.Client, o.ResourceManagerAuthorizer)
 
 	return &Client{
-		DatasetClient:                &DatasetClient,
-		FactoriesClient:              &FactoriesClient,
-		IntegrationRuntimesClient:    &IntegrationRuntimesClient,
-		LinkedServiceClient:          &LinkedServiceClient,
-		ManagedVirtualNetworksClient: &ManagedVirtualNetworksClient,
-		PipelinesClient:              &PipelinesClient,
-		TriggersClient:               &TriggersClient,
+		DatasetClient:                 &DatasetClient,
+		FactoriesClient:               &FactoriesClient,
+		IntegrationRuntimesClient:     &IntegrationRuntimesClient,
+		LinkedServiceClient:           &LinkedServiceClient,
+		ManagedPrivateEndpointsClient: &ManagedPrivateEndpointsClient,
+		ManagedVirtualNetworksClient:  &ManagedVirtualNetworksClient,
+		PipelinesClient:               &PipelinesClient,
+		TriggersClient:                &TriggersClient,
 	}
 }

azurerm/internal/services/datafactory/data_factory_managed_private_endpoint_resource.go

@@ -0,0 +1,181 @@
+package datafactory
+
+import (
+	"context"
+	"fmt"
+	"time"
+
+	"github.com/Azure/azure-sdk-for-go/services/datafactory/mgmt/2018-06-01/datafactory"
+	"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/datafactory/parse"
+	"github.com/terraform-providers/terraform-provider-azurerm/azurerm/internal/services/datafactory/validate"
+	networkValidate "github.com/terraform-providers/terraform-provider-azurerm/azurerm/internal/services/network/validate"
+	"github.com/terraform-providers/terraform-provider-azurerm/azurerm/internal/tf/pluginsdk"
+	"github.com/terraform-providers/terraform-provider-azurerm/azurerm/internal/timeouts"
+	"github.com/terraform-providers/terraform-provider-azurerm/azurerm/utils"
+)
+
+func resourceDataFactoryManagedPrivateEndpoint() *pluginsdk.Resource {
+	return &pluginsdk.Resource{
+		Create: resourceDataFactoryManagedPrivateEndpointCreate,
+		Read:   resourceDataFactoryManagedPrivateEndpointRead,
+		Delete: resourceDataFactoryManagedPrivateEndpointDelete,
+
+		Importer: pluginsdk.ImporterValidatingResourceId(func(id string) error {
+			_, err := parse.ManagedPrivateEndpointID(id)
+			return err
+		}),
+
+		Timeouts: &pluginsdk.ResourceTimeout{
+			Create: pluginsdk.DefaultTimeout(30 * time.Minute),
+			Read:   pluginsdk.DefaultTimeout(5 * time.Minute),
+			Delete: pluginsdk.DefaultTimeout(30 * time.Minute),
+		},
+
+		Schema: map[string]*pluginsdk.Schema{
+			"name": {
+				Type:         pluginsdk.TypeString,
+				Required:     true,
+				ForceNew:     true,
+				ValidateFunc: validate.DataFactoryManagedPrivateEndpointName(),
+			},
+
+			"data_factory_id": {
+				Type:         pluginsdk.TypeString,
+				Required:     true,
+				ForceNew:     true,
+				ValidateFunc: validate.DataFactoryID,
+			},
+
+			"target_resource_id": {
+				Type:         pluginsdk.TypeString,
+				Required:     true,
+				ForceNew:     true,
+				ValidateFunc: azure.ValidateResourceID,
+			},
+
+			"subresource_name": {
+				Type:         pluginsdk.TypeString,
+				Required:     true,
+				ForceNew:     true,
+				ValidateFunc: networkValidate.PrivateLinkSubResourceName,
+			},
+		},
+	}
+}
+
+func resourceDataFactoryManagedPrivateEndpointCreate(d *pluginsdk.ResourceData, meta interface{}) error {
+	client := meta.(*clients.Client).DataFactory.ManagedPrivateEndpointsClient
+	managedVirtualNetworksClient := meta.(*clients.Client).DataFactory.ManagedVirtualNetworksClient
+	subscriptionId := meta.(*clients.Client).Account.SubscriptionId
+	ctx, cancel := timeouts.ForCreate(meta.(*clients.Client).StopContext, d)
+	defer cancel()
+
+	dataFactoryId, err := parse.DataFactoryID(d.Get("data_factory_id").(string))
+	if err != nil {
+		return err
+	}
+
+	managedVirtualNetworkName, err := getManagedVirtualNetworkName(ctx, managedVirtualNetworksClient, dataFactoryId.ResourceGroup, dataFactoryId.FactoryName)
+	if err != nil {
+		return err
+	}
+	if managedVirtualNetworkName == nil {
+		return fmt.Errorf("managed Private endpoints are only available after managed virtual network for %s is enabled", dataFactoryId)
+	}
+
+	id := parse.NewManagedPrivateEndpointID(subscriptionId, dataFactoryId.ResourceGroup, dataFactoryId.FactoryName, *managedVirtualNetworkName, d.Get("name").(string))
+	existing, err := getManagedPrivateEndpoint(ctx, client, id.ResourceGroup, id.FactoryName, *managedVirtualNetworkName, id.Name)
+	if err != nil {
+		return fmt.Errorf("checking for presence of existing %s: %+v", id, err)
+	}
+	if existing != nil {
+		return tf.ImportAsExistsError("azurerm_data_factory_managed_private_endpoint", id.ID())
+	}
+
+	managedPrivateEndpoint := datafactory.ManagedPrivateEndpointResource{
+		Properties: &datafactory.ManagedPrivateEndpoint{
+			PrivateLinkResourceID: utils.String(d.Get("target_resource_id").(string)),
+			GroupID:               utils.String(d.Get("subresource_name").(string)),
+		},
+	}
+
+	if _, err := client.CreateOrUpdate(ctx, id.ResourceGroup, id.FactoryName, id.ManagedVirtualNetworkName, id.Name, managedPrivateEndpoint, ""); err != nil {
+		return fmt.Errorf("creating %s: %+v", id, err)
+	}
+
+	d.SetId(id.ID())
+
+	return resourceDataFactoryManagedPrivateEndpointRead(d, meta)
+}
+
+func resourceDataFactoryManagedPrivateEndpointRead(d *pluginsdk.ResourceData, meta interface{}) error {
+	client := meta.(*clients.Client).DataFactory.ManagedPrivateEndpointsClient
+	subscriptionId := meta.(*clients.Client).Account.SubscriptionId
+	ctx, cancel := timeouts.ForRead(meta.(*clients.Client).StopContext, d)
+	defer cancel()
+
+	id, err := parse.ManagedPrivateEndpointID(d.Id())
+	if err != nil {
+		return err
+	}
+
+	resp, err := client.Get(ctx, id.ResourceGroup, id.FactoryName, id.ManagedVirtualNetworkName, id.Name, "")
+	if err != nil {
+		if utils.ResponseWasNotFound(resp.Response) {
+			d.SetId("")
+			return nil
+		}
+
+		return fmt.Errorf("retrieving %s: %+v", id, err)
+	}
+
+	d.Set("name", id.Name)
+	d.Set("data_factory_id", parse.NewDataFactoryID(subscriptionId, id.ResourceGroup, id.FactoryName).ID())
+
+	if props := resp.Properties; props != nil {
+		d.Set("target_resource_id", props.PrivateLinkResourceID)
+		d.Set("subresource_name", props.GroupID)
+	}
+
+	return nil
+}
+
+func resourceDataFactoryManagedPrivateEndpointDelete(d *pluginsdk.ResourceData, meta interface{}) error {
+	client := meta.(*clients.Client).DataFactory.ManagedPrivateEndpointsClient
+	ctx, cancel := timeouts.ForDelete(meta.(*clients.Client).StopContext, d)
+	defer cancel()
+
+	id, err := parse.ManagedPrivateEndpointID(d.Id())
+	if err != nil {
+		return err
+	}
+
+	if _, err := client.Delete(ctx, id.ResourceGroup, id.FactoryName, id.ManagedVirtualNetworkName, id.Name); err != nil {
+		return fmt.Errorf("deleting %s: %+v", id, err)
+	}
+
+	return nil
+}
+
+// if ManagedPrivateEndpoint not exist, get rest api will return 400 bad request
+// invoke list rets api and then filter by name
+func getManagedPrivateEndpoint(ctx context.Context, client *datafactory.ManagedPrivateEndpointsClient, resourceGroupName, factoryName, managedVirtualNetworkName, name string) (*datafactory.ManagedPrivateEndpointResource, error) {
+	iter, err := client.ListByFactoryComplete(ctx, resourceGroupName, factoryName, managedVirtualNetworkName)
+	if err != nil {
+		return nil, err
+	}
+	for iter.NotDone() {
+		managedPrivateEndpoint := iter.Value()
+		if managedPrivateEndpoint.Name != nil && *managedPrivateEndpoint.Name == name {
+			return &managedPrivateEndpoint, nil
+		}
+
+		if err := iter.NextWithContext(ctx); err != nil {
+			return nil, err
+		}
+	}
+	return nil, nil
+}

azurerm/internal/services/datafactory/data_factory_managed_private_endpoint_resource_test.go

@@ -0,0 +1,126 @@
+package datafactory_test
+
+import (
+	"context"
+	"fmt"
+	"testing"
+
+	"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/datafactory/parse"
+	"github.com/terraform-providers/terraform-provider-azurerm/azurerm/internal/tf/pluginsdk"
+	"github.com/terraform-providers/terraform-provider-azurerm/azurerm/utils"
+)
+
+type ManagedPrivateEndpointResource struct{}
+
+func TestAccDataFactoryManagedPrivateEndpoint_basic(t *testing.T) {
+	data := acceptance.BuildTestData(t, "azurerm_data_factory_managed_private_endpoint", "test")
+	r := ManagedPrivateEndpointResource{}
+
+	data.ResourceTest(t, r, []acceptance.TestStep{
+		{
+			Config: r.basic(data),
+			Check: acceptance.ComposeTestCheckFunc(
+				check.That(data.ResourceName).ExistsInAzure(r),
+			),
+		},
+		data.ImportStep(),
+	})
+}
+
+func TestAccDataFactoryManagedPrivateEndpoint_requiresImport(t *testing.T) {
+	data := acceptance.BuildTestData(t, "azurerm_data_factory_managed_private_endpoint", "test")
+	r := ManagedPrivateEndpointResource{}
+
+	data.ResourceTest(t, r, []acceptance.TestStep{
+		{
+			Config: r.basic(data),
+			Check: acceptance.ComposeTestCheckFunc(
+				check.That(data.ResourceName).ExistsInAzure(r),
+			),
+		},
+		data.RequiresImportErrorStep(r.requiresImport),
+	})
+}
+
+func (r ManagedPrivateEndpointResource) Exists(ctx context.Context, client *clients.Client, state *pluginsdk.InstanceState) (*bool, error) {
+	id, err := parse.ManagedPrivateEndpointID(state.ID)
+	if err != nil {
+		return nil, err
+	}
+
+	iter, err := client.DataFactory.ManagedPrivateEndpointsClient.ListByFactoryComplete(ctx, id.ResourceGroup, id.FactoryName, id.ManagedVirtualNetworkName)
+	if err != nil {
+		return nil, fmt.Errorf("listing %s: %+v", id, err)
+	}
+	for iter.NotDone() {
+		managedPrivateEndpoint := iter.Value()
+		if managedPrivateEndpoint.Name != nil && *managedPrivateEndpoint.Name == id.Name {
+			return utils.Bool(true), nil
+		}
+
+		if err := iter.NextWithContext(ctx); err != nil {
+			return nil, err
+		}
+	}
+	return utils.Bool(false), nil
+}
+
+func (r ManagedPrivateEndpointResource) basic(data acceptance.TestData) string {
+	template := r.template(data)
+	return fmt.Sprintf(`
+	%s
+
+resource "azurerm_data_factory_managed_private_endpoint" "test" {
+  name               = "acctestEndpoint%d"
+  data_factory_id    = azurerm_data_factory.test.id
+  target_resource_id = azurerm_storage_account.test.id
+  subresource_name   = "blob"
+}
+`, template, data.RandomInteger)
+}
+
+func (r ManagedPrivateEndpointResource) requiresImport(data acceptance.TestData) string {
+	config := r.basic(data)
+	return fmt.Sprintf(`
+	%s
+
+resource "azurerm_data_factory_managed_private_endpoint" "import" {
+  name               = azurerm_data_factory_managed_private_endpoint.test.name
+  data_factory_id    = azurerm_data_factory_managed_private_endpoint.test.data_factory_id
+  target_resource_id = azurerm_data_factory_managed_private_endpoint.test.target_resource_id
+  subresource_name   = azurerm_data_factory_managed_private_endpoint.test.subresource_name
+}
+`, config)
+}
+
+func (r ManagedPrivateEndpointResource) template(data acceptance.TestData) string {
+	return fmt.Sprintf(`
+provider "azurerm" {
+  features {}
+}
+
+resource "azurerm_resource_group" "test" {
+  name     = "acctestRG-adf-%d"
+  location = "%s"
+}
+
+resource "azurerm_data_factory" "test" {
+  name                            = "acctestdf%d"
+  location                        = azurerm_resource_group.test.location
+  resource_group_name             = azurerm_resource_group.test.name
+  managed_virtual_network_enabled = true
+}
+
+resource "azurerm_storage_account" "test" {
+  name                     = "acctestacc%s"
+  resource_group_name      = azurerm_resource_group.test.name
+  location                 = azurerm_resource_group.test.location
+  account_kind             = "BlobStorage"
+  account_tier             = "Standard"
+  account_replication_type = "LRS"
+}
+`, data.RandomInteger, data.Locations.Primary, data.RandomInteger, data.RandomString)
+}