New Resource: aws_amplify_domain_association

.changelog/11938.txt

@@ -0,0 +1,3 @@
+```release-note:new-resource
+aws_amplify_domain_association
+```

aws/internal/service/amplify/finder/finder.go

@@ -93,6 +93,35 @@ func BranchByAppIDAndBranchName(conn *amplify.Amplify, appID, branchName string)
 	return output.Branch, nil
 }
 
+func DomainAssociationByAppIDAndDomainName(conn *amplify.Amplify, appID, domainName string) (*amplify.DomainAssociation, error) {
+	input := &amplify.GetDomainAssociationInput{
+		AppId:      aws.String(appID),
+		DomainName: aws.String(domainName),
+	}
+
+	output, err := conn.GetDomainAssociation(input)
+
+	if tfawserr.ErrCodeEquals(err, amplify.ErrCodeNotFoundException) {
+		return nil, &resource.NotFoundError{
+			LastError:   err,
+			LastRequest: input,
+		}
+	}
+
+	if err != nil {
+		return nil, err
+	}
+
+	if output == nil || output.DomainAssociation == nil {
+		return nil, &resource.NotFoundError{
+			Message:     "Empty result",
+			LastRequest: input,
+		}
+	}
+
+	return output.DomainAssociation, nil
+}
+
 func WebhookByID(conn *amplify.Amplify, id string) (*amplify.Webhook, error) {
 	input := &amplify.GetWebhookInput{
 		WebhookId: aws.String(id),

aws/internal/service/amplify/id.go

@@ -42,3 +42,22 @@ func BranchParseResourceID(id string) (string, string, error) {
 
 	return "", "", fmt.Errorf("unexpected format for ID (%[1]s), expected APPID%[2]sBRANCHNAME", id, branchResourceIDSeparator)
 }
+
+const domainAssociationResourceIDSeparator = "/"
+
+func DomainAssociationCreateResourceID(appID, domainName string) string {
+	parts := []string{appID, domainName}
+	id := strings.Join(parts, domainAssociationResourceIDSeparator)
+
+	return id
+}
+
+func DomainAssociationParseResourceID(id string) (string, string, error) {
+	parts := strings.Split(id, domainAssociationResourceIDSeparator)
+
+	if len(parts) == 2 && parts[0] != "" && parts[1] != "" {
+		return parts[0], parts[1], nil
+	}
+
+	return "", "", fmt.Errorf("unexpected format for ID (%[1]s), expected APPID%[2]sDOMAINNAME", id, domainAssociationResourceIDSeparator)
+}

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

@@ -0,0 +1,25 @@
+package waiter
+
+import (
+	"github.com/aws/aws-sdk-go/aws"
+	"github.com/aws/aws-sdk-go/service/amplify"
+	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/resource"
+	"github.com/terraform-providers/terraform-provider-aws/aws/internal/service/amplify/finder"
+	"github.com/terraform-providers/terraform-provider-aws/aws/internal/tfresource"
+)
+
+func DomainAssociationStatus(conn *amplify.Amplify, appID, domainName string) resource.StateRefreshFunc {
+	return func() (interface{}, string, error) {
+		domainAssociation, err := finder.DomainAssociationByAppIDAndDomainName(conn, appID, domainName)
+
+		if tfresource.NotFound(err) {
+			return nil, "", nil
+		}
+
+		if err != nil {
+			return nil, "", err
+		}
+
+		return domainAssociation, aws.StringValue(domainAssociation.DomainStatus), nil
+	}
+}

aws/internal/service/amplify/waiter/waiter.go

@@ -0,0 +1,58 @@
+package waiter
+
+import (
+	"errors"
+	"time"
+
+	"github.com/aws/aws-sdk-go/aws"
+	"github.com/aws/aws-sdk-go/service/amplify"
+	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/resource"
+	"github.com/terraform-providers/terraform-provider-aws/aws/internal/tfresource"
+)
+
+const (
+	DomainAssociationCreatedTimeout  = 5 * time.Minute
+	DomainAssociationVerifiedTimeout = 15 * time.Minute
+)
+
+func DomainAssociationCreated(conn *amplify.Amplify, appID, domainName string) (*amplify.DomainAssociation, error) {
+	stateConf := &resource.StateChangeConf{
+		Pending: []string{amplify.DomainStatusCreating, amplify.DomainStatusInProgress, amplify.DomainStatusRequestingCertificate},
+		Target:  []string{amplify.DomainStatusPendingVerification, amplify.DomainStatusPendingDeployment, amplify.DomainStatusAvailable},
+		Refresh: DomainAssociationStatus(conn, appID, domainName),
+		Timeout: DomainAssociationCreatedTimeout,
+	}
+
+	outputRaw, err := stateConf.WaitForState()
+
+	if v, ok := outputRaw.(*amplify.DomainAssociation); ok {
+		if v != nil && aws.StringValue(v.DomainStatus) == amplify.DomainStatusFailed {
+			tfresource.SetLastError(err, errors.New(aws.StringValue(v.StatusReason)))
+		}
+
+		return v, err
+	}
+
+	return nil, err
+}
+
+func DomainAssociationVerified(conn *amplify.Amplify, appID, domainName string) (*amplify.DomainAssociation, error) {
+	stateConf := &resource.StateChangeConf{
+		Pending: []string{amplify.DomainStatusUpdating, amplify.DomainStatusInProgress, amplify.DomainStatusPendingVerification},
+		Target:  []string{amplify.DomainStatusPendingDeployment, amplify.DomainStatusAvailable},
+		Refresh: DomainAssociationStatus(conn, appID, domainName),
+		Timeout: DomainAssociationVerifiedTimeout,
+	}
+
+	outputRaw, err := stateConf.WaitForState()
+
+	if v, ok := outputRaw.(*amplify.DomainAssociation); ok {
+		if v != nil && aws.StringValue(v.DomainStatus) == amplify.DomainStatusFailed {
+			tfresource.SetLastError(err, errors.New(aws.StringValue(v.StatusReason)))
+		}
+
+		return v, err
+	}
+
+	return nil, err
+}

aws/internal/tfresource/errors.go

@@ -23,3 +23,15 @@ func TimedOut(err error) bool {
 	timeoutErr, ok := err.(*resource.TimeoutError) // nolint:errorlint
 	return ok && timeoutErr.LastError == nil
 }
+
+// SetLastError sets the LastError field on the error if supported.
+func SetLastError(err, lastErr error) {
+	var te *resource.TimeoutError
+	var use *resource.UnexpectedStateError
+
+	if ok := errors.As(err, &te); ok && te.LastError == nil {
+		te.LastError = lastErr
+	} else if ok := errors.As(err, &use); ok && use.LastError == nil {
+		use.LastError = lastErr
+	}
+}

aws/provider.go

@@ -456,6 +456,7 @@ func Provider() *schema.Provider {
 			"aws_amplify_app":                                         resourceAwsAmplifyApp(),
 			"aws_amplify_backend_environment":                         resourceAwsAmplifyBackendEnvironment(),
 			"aws_amplify_branch":                                      resourceAwsAmplifyBranch(),
+			"aws_amplify_domain_association":                          resourceAwsAmplifyDomainAssociation(),
 			"aws_amplify_webhook":                                     resourceAwsAmplifyWebhook(),
 			"aws_api_gateway_account":                                 resourceAwsApiGatewayAccount(),
 			"aws_api_gateway_api_key":                                 resourceAwsApiGatewayApiKey(),