[New Resource] aws_datasync_location_fsx_ontap_file_system

.changelog/32632.txt

@@ -0,0 +1,7 @@
+```release-note:new-resource
+aws_datasync_location_fsx_ontap_file_system
+```
+
+```release-note:new-resource
+aws_datasync_location_azure_blob
+```

internal/service/datasync/agent.go

@@ -208,8 +208,9 @@ func resourceAgentCreate(ctx context.Context, d *schema.ResourceData, meta inter
 	_, err = tfresource.RetryWhenNotFound(ctx, d.Timeout(schema.TimeoutCreate), func() (interface{}, error) {
 		return FindAgentByARN(ctx, conn, d.Id())
 	})
+
 	if err != nil {
-		return sdkdiag.AppendErrorf(diags, "waiting for DataSync Agent (%s) creation: %s", d.Id(), err)
+		return sdkdiag.AppendErrorf(diags, "waiting for DataSync Agent (%s) create: %s", d.Id(), err)
 	}
 
 	return append(diags, resourceAgentRead(ctx, d, meta)...)
@@ -287,3 +288,28 @@ func resourceAgentDelete(ctx context.Context, d *schema.ResourceData, meta inter
 
 	return diags
 }
+
+func FindAgentByARN(ctx context.Context, conn *datasync.DataSync, arn string) (*datasync.DescribeAgentOutput, error) {
+	input := &datasync.DescribeAgentInput{
+		AgentArn: aws.String(arn),
+	}
+
+	output, err := conn.DescribeAgentWithContext(ctx, input)
+
+	if tfawserr.ErrMessageContains(err, datasync.ErrCodeInvalidRequestException, "does not exist") {
+		return nil, &retry.NotFoundError{
+			LastError:   err,
+			LastRequest: input,
+		}
+	}
+
+	if err != nil {
+		return nil, err
+	}
+
+	if output == nil {
+		return nil, tfresource.NewEmptyResultError(input)
+	}
+
+	return output, nil
+}

internal/service/datasync/agent_test.go

@@ -228,11 +228,11 @@ func testAccCheckAgentDestroy(ctx context.Context) resource.TestCheckFunc {
 	}
 }
 
-func testAccCheckAgentExists(ctx context.Context, resourceName string, agent *datasync.DescribeAgentOutput) resource.TestCheckFunc {
+func testAccCheckAgentExists(ctx context.Context, n string, v *datasync.DescribeAgentOutput) resource.TestCheckFunc {
 	return func(s *terraform.State) error {
-		rs, ok := s.RootModule().Resources[resourceName]
+		rs, ok := s.RootModule().Resources[n]
 		if !ok {
-			return fmt.Errorf("Not found: %s", resourceName)
+			return fmt.Errorf("Not found: %s", n)
 		}
 
 		conn := acctest.Provider.Meta().(*conns.AWSClient).DataSyncConn(ctx)
@@ -243,7 +243,7 @@ func testAccCheckAgentExists(ctx context.Context, resourceName string, agent *da
 			return err
 		}
 
-		*agent = *output
+		*v = *output
 
 		return nil
 	}
@@ -260,7 +260,11 @@ func testAccCheckAgentNotRecreated(i, j *datasync.DescribeAgentOutput) resource.
 }
 
 func testAccAgentAgentConfig_base(rName string) string {
-	return acctest.ConfigCompose(acctest.ConfigVPCWithSubnets(rName, 1), fmt.Sprintf(`
+	return acctest.ConfigCompose(
+		acctest.ConfigVPCWithSubnets(rName, 1),
+		// See https://docs.aws.amazon.com/datasync/latest/userguide/agent-requirements.html#ec2-instance-types.
+		acctest.AvailableEC2InstanceTypeForAvailabilityZone("aws_subnet.test[0].availability_zone", "m5.2xlarge", "m5.4xlarge"),
+		fmt.Sprintf(`
 # Reference: https://docs.aws.amazon.com/datasync/latest/userguide/deploy-agents.html
 data "aws_ssm_parameter" "aws_service_datasync_ami" {
   name = "/aws/service/datasync/ami"
@@ -320,11 +324,9 @@ resource "aws_instance" "test" {
 
   ami                         = data.aws_ssm_parameter.aws_service_datasync_ami.value
   associate_public_ip_address = true
-
-  # Default instance type from sync.sh
-  instance_type          = "c5.2xlarge"
-  vpc_security_group_ids = [aws_security_group.test.id]
-  subnet_id              = aws_subnet.test[0].id
+  instance_type               = data.aws_ec2_instance_type_offering.available.instance_type
+  vpc_security_group_ids      = [aws_security_group.test.id]
+  subnet_id                   = aws_subnet.test[0].id
 
   tags = {
     Name = %[1]q

internal/service/datasync/common_fsx_protocol_functions.go

@@ -0,0 +1,89 @@
+// Copyright (c) HashiCorp, Inc.
+// SPDX-License-Identifier: MPL-2.0
+
+package datasync
+
+import (
+	"github.com/aws/aws-sdk-go/service/datasync"
+)
+
+func expandProtocol(l []interface{}) *datasync.FsxProtocol {
+	if len(l) == 0 || l[0] == nil {
+		return nil
+	}
+
+	m := l[0].(map[string]interface{})
+
+	Protocol := &datasync.FsxProtocol{
+		NFS: expandNFS(m["nfs"].([]interface{})),
+		SMB: expandSMB(m["smb"].([]interface{})),
+	}
+
+	return Protocol
+}
+
+func flattenProtocol(protocol *datasync.FsxProtocol) []interface{} {
+	if protocol == nil {
+		return []interface{}{}
+	}
+
+	m := map[string]interface{}{
+		"nfs": flattenNFS(protocol.NFS),
+		"smb": flattenSMB(protocol.SMB),
+	}
+
+	return []interface{}{m}
+}
+
+func expandNFS(l []interface{}) *datasync.FsxProtocolNfs {
+	if len(l) == 0 || l[0] == nil {
+		return nil
+	}
+
+	m := l[0].(map[string]interface{})
+
+	Protocol := &datasync.FsxProtocolNfs{
+		MountOptions: expandNFSMountOptions(m["mount_options"].([]interface{})),
+	}
+
+	return Protocol
+}
+
+func expandSMB(l []interface{}) *datasync.FsxProtocolSmb {
+	if len(l) == 0 || l[0] == nil {
+		return nil
+	}
+
+	m := l[0].(map[string]interface{})
+
+	Protocol := &datasync.FsxProtocolSmb{
+		MountOptions: expandSMBMountOptions(m["mount_options"].([]interface{})),
+	}
+
+	return Protocol
+}
+
+// todo: go another level down?
+func flattenNFS(nfs *datasync.FsxProtocolNfs) []interface{} {
+	if nfs == nil {
+		return []interface{}{}
+	}
+
+	m := map[string]interface{}{
+		"mount_options": flattenNFSMountOptions(nfs.MountOptions),
+	}
+
+	return []interface{}{m}
+}
+
+func flattenSMB(smb *datasync.FsxProtocolSmb) []interface{} {
+	if smb == nil {
+		return []interface{}{}
+	}
+
+	m := map[string]interface{}{
+		"mount_options": flattenSMBMountOptions(smb.MountOptions),
+	}
+
+	return []interface{}{m}
+}