support FTP & FTPS protocols for the aws_transfer_server resource

.changelog/13371.txt

@@ -0,0 +1,7 @@
+```release-note:enhancement
+resource/aws_transfer_server: Add `protocols` argument
+```
+
+```release-note:enhancement
+data-source/aws_transfer_server: Add `certificate`, `endpoint_type`, `protocols` and `security_policy_name` attributes
+```

aws/data_source_aws_transfer_server.go

@@ -2,75 +2,108 @@ package aws
 
 import (
  "fmt"
- "log"
 
  "github.com/aws/aws-sdk-go/aws"
- "github.com/aws/aws-sdk-go/service/transfer"
  "github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
+ "github.com/terraform-providers/terraform-provider-aws/aws/internal/service/transfer/finder"
 )
 
 func dataSourceAwsTransferServer() *schema.Resource {
  return &schema.Resource{
- Read: dataSourceAwsTransferServerRead,
  Schema: map[string]*schema.Schema{
- "server_id": {
+ "arn": {
  Type: schema.TypeString,
- Required: true,
+ Computed: true,
  },
- "arn": {
+
+ "certificate": {
  Type: schema.TypeString,
  Computed: true,
  },
+
  "endpoint": {
  Type: schema.TypeString,
  Computed: true,
  },
- "invocation_role": {
+
+ "endpoint_type": {
  Type: schema.TypeString,
  Computed: true,
  },
- "url": {
+
+ "identity_provider_type": {
  Type: schema.TypeString,
  Computed: true,
  },
- "identity_provider_type": {
+
+ "invocation_role": {
  Type: schema.TypeString,
  Computed: true,
  },
+
  "logging_role": {
  Type: schema.TypeString,
  Computed: true,
  },
+
+ "protocols": {
+ Type: schema.TypeList,
+ Computed: true,
+ Elem: &schema.Schema{
+ Type: schema.TypeString,
+ },
+ },
+
+ "security_policy_name": {
+ Type: schema.TypeString,
+ Computed: true,
+ },
+
+ "server_id": {
+ Type: schema.TypeString,
+ Required: true,
+ },
+
+ "url": {
+ Type: schema.TypeString,
+ Computed: true,
+ },
  },
+
+ Read: dataSourceAwsTransferServerRead,
  }
 }
 
 func dataSourceAwsTransferServerRead(d *schema.ResourceData, meta interface{}) error {
  conn := meta.(*AWSClient).transferconn
 
  serverID := d.Get("server_id").(string)
- input := &transfer.DescribeServerInput{
- ServerId: aws.String(serverID),
- }
 
- log.Printf("[DEBUG] Describe Transfer Server Option: %#v", input)
+ output, err := finder.ServerByID(conn, serverID)
 
- resp, err := conn.DescribeServer(input)
  if err != nil {
- return fmt.Errorf("error describing Transfer Server (%s): %w", serverID, err)
+ return fmt.Errorf("error reading Transfer Server (%s): %w", serverID, err)
  }
 
- endpoint := meta.(*AWSClient).RegionalHostname(fmt.Sprintf("%s.server.transfer", serverID))
-
- d.SetId(serverID)
- d.Set("arn", resp.Server.Arn)
- d.Set("endpoint", endpoint)
- if resp.Server.IdentityProviderDetails != nil {
- d.Set("invocation_role", resp.Server.IdentityProviderDetails.InvocationRole)
- d.Set("url", resp.Server.IdentityProviderDetails.Url)
+ d.SetId(aws.StringValue(output.ServerId))
+ d.Set("arn", output.Arn)
+ d.Set("certificate", output.Certificate)
+ d.Set("endpoint", meta.(*AWSClient).RegionalHostname(fmt.Sprintf("%s.server.transfer", serverID)))
+ d.Set("endpoint_type", output.EndpointType)
+ d.Set("identity_provider_type", output.IdentityProviderType)
+ if output.IdentityProviderDetails != nil {
+ d.Set("invocation_role", output.IdentityProviderDetails.InvocationRole)
+ } else {
+ d.Set("invocation_role", "")
+ }
+ d.Set("logging_role", output.LoggingRole)
+ d.Set("protocols", aws.StringValueSlice(output.Protocols))
+ d.Set("security_policy_name", output.SecurityPolicyName)
+ if output.IdentityProviderDetails != nil {
+ d.Set("url", output.IdentityProviderDetails.Url)
+ } else {
+ d.Set("url", "")
  }
- d.Set("identity_provider_type", resp.Server.IdentityProviderType)
- d.Set("logging_role", resp.Server.LoggingRole)
 
  return nil
 }

aws/data_source_aws_transfer_server_test.go

@@ -45,9 +45,15 @@ func TestAccDataSourceAwsTransferServer_service_managed(t *testing.T) {
  Config: testAccDataSourceAwsTransferServerConfig_service_managed(rName),
  Check: resource.ComposeTestCheckFunc(
  resource.TestCheckResourceAttrPair(datasourceName, "arn", resourceName, "arn"),
+ resource.TestCheckResourceAttrPair(datasourceName, "certificate", resourceName, "certificate"),
  resource.TestCheckResourceAttrPair(datasourceName, "endpoint", resourceName, "endpoint"),
+ resource.TestCheckResourceAttrPair(datasourceName, "endpoint_type", resourceName, "endpoint_type"),
  resource.TestCheckResourceAttrPair(datasourceName, "identity_provider_type", resourceName, "identity_provider_type"),
+ resource.TestCheckResourceAttrPair(datasourceName, "invocation_role", resourceName, "invocation_role"),
  resource.TestCheckResourceAttrPair(datasourceName, "logging_role", resourceName, "logging_role"),
+ resource.TestCheckResourceAttrPair(datasourceName, "protocols.#", resourceName, "protocols.#"),
+ resource.TestCheckResourceAttrPair(datasourceName, "security_policy_name", resourceName, "security_policy_name"),
+ resource.TestCheckResourceAttrPair(datasourceName, "url", resourceName, "url"),
  ),
  },
  },

aws/internal/service/transfer/finder/finder.go

@@ -0,0 +1,36 @@
+package finder
+
+import (
+ "github.com/aws/aws-sdk-go/aws"
+ "github.com/aws/aws-sdk-go/service/transfer"
+ "github.com/hashicorp/aws-sdk-go-base/tfawserr"
+ "github.com/hashicorp/terraform-plugin-sdk/v2/helper/resource"
+)
+
+func ServerByID(conn *transfer.Transfer, id string) (*transfer.DescribedServer, error) {
+ input := &transfer.DescribeServerInput{
+ ServerId: aws.String(id),
+ }
+
+ output, err := conn.DescribeServer(input)
+
+ if tfawserr.ErrCodeEquals(err, transfer.ErrCodeResourceNotFoundException) {
+ return nil, &resource.NotFoundError{
+ LastError: err,
+ LastRequest: input,
+ }
+ }
+
+ if err != nil {
+ return nil, err
+ }
+
+ if output == nil || output.Server == nil {
+ return nil, &resource.NotFoundError{
+ Message: "Empty result",
+ LastRequest: input,
+ }
+ }
+
+ return output.Server, nil
+}

aws/internal/service/transfer/id.go

@@ -0,0 +1,25 @@
+package transfer
+
+import (
+ "fmt"
+ "strings"
+)
+
+const userResourceIDSeparator = "/"
+
+func UserCreateResourceID(serverID, userName string) string {
+ parts := []string{serverID, userName}
+ id := strings.Join(parts, userResourceIDSeparator)
+
+ return id
+}
+
+func UserParseResourceID(id string) (string, string, error) {
+ parts := strings.Split(id, userResourceIDSeparator)
+
+ if len(parts) == 2 && parts[0] != "" && parts[1] != "" {
+ return parts[0], parts[1], nil
+ }
+
+ return "", "", fmt.Errorf("unexpected format for ID (%[1]s), expected SERVERID%[2]sUSERNAME", id, userResourceIDSeparator)
+}

aws/internal/service/transfer/waiter/status.go

@@ -0,0 +1,25 @@
+package waiter
+
+import (
+ "github.com/aws/aws-sdk-go/aws"
+ "github.com/aws/aws-sdk-go/service/transfer"
+ "github.com/hashicorp/terraform-plugin-sdk/v2/helper/resource"
+ "github.com/terraform-providers/terraform-provider-aws/aws/internal/service/transfer/finder"
+ "github.com/terraform-providers/terraform-provider-aws/aws/internal/tfresource"
+)
+
+func ServerState(conn *transfer.Transfer, id string) resource.StateRefreshFunc {
+ return func() (interface{}, string, error) {
+ output, err := finder.ServerByID(conn, id)
+
+ if tfresource.NotFound(err) {
+ return nil, "", nil
+ }
+
+ if err != nil {
+ return nil, "", err
+ }
+
+ return output, aws.StringValue(output.State), nil
+ }
+}

aws/internal/service/transfer/waiter/waiter.go

@@ -0,0 +1,80 @@
+package waiter
+
+import (
+ "time"
+
+ "github.com/aws/aws-sdk-go/service/transfer"
+ "github.com/hashicorp/terraform-plugin-sdk/v2/helper/resource"
+)
+
+const (
+ ServerDeletedTimeout = 10 * time.Minute
+)
+
+func ServerCreated(conn *transfer.Transfer, id string, timeout time.Duration) (*transfer.DescribedServer, error) {
+ stateConf := &resource.StateChangeConf{
+ Pending: []string{transfer.StateStarting},
+ Target: []string{transfer.StateOnline},
+ Refresh: ServerState(conn, id),
+ Timeout: timeout,
+ }
+
+ outputRaw, err := stateConf.WaitForState()
+
+ if output, ok := outputRaw.(*transfer.DescribedServer); ok {
+ return output, err
+ }
+
+ return nil, err
+}
+
+func ServerDeleted(conn *transfer.Transfer, id string) (*transfer.DescribedServer, error) {
+ stateConf := &resource.StateChangeConf{
+ Pending: transfer.State_Values(),
+ Target: []string{},
+ Refresh: ServerState(conn, id),
+ Timeout: ServerDeletedTimeout,
+ }
+
+ outputRaw, err := stateConf.WaitForState()
+
+ if output, ok := outputRaw.(*transfer.DescribedServer); ok {
+ return output, err
+ }
+
+ return nil, err
+}
+
+func ServerStarted(conn *transfer.Transfer, id string, timeout time.Duration) (*transfer.DescribedServer, error) {
+ stateConf := &resource.StateChangeConf{
+ Pending: []string{transfer.StateStarting, transfer.StateOffline, transfer.StateStopping},
+ Target: []string{transfer.StateOnline},
+ Refresh: ServerState(conn, id),
+ Timeout: timeout,
+ }
+
+ outputRaw, err := stateConf.WaitForState()
+
+ if output, ok := outputRaw.(*transfer.DescribedServer); ok {
+ return output, err
+ }
+
+ return nil, err
+}
+
+func ServerStopped(conn *transfer.Transfer, id string, timeout time.Duration) (*transfer.DescribedServer, error) {
+ stateConf := &resource.StateChangeConf{
+ Pending: []string{transfer.StateStarting, transfer.StateOnline, transfer.StateStopping},
+ Target: []string{transfer.StateOffline},
+ Refresh: ServerState(conn, id),
+ Timeout: timeout,
+ }
+
+ outputRaw, err := stateConf.WaitForState()
+
+ if output, ok := outputRaw.(*transfer.DescribedServer); ok {
+ return output, err
+ }
+
+ return nil, err
+}