r/synthetics_canary - new resource

.changelog/13140.txt

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

aws/internal/service/synthetics/finder/finder.go

@@ -0,0 +1,20 @@
+package finder
+
+import (
+	"github.com/aws/aws-sdk-go/aws"
+	"github.com/aws/aws-sdk-go/service/synthetics"
+)
+
+// CanaryByName returns the Canary corresponding to the specified Name.
+func CanaryByName(conn *synthetics.Synthetics, name string) (*synthetics.GetCanaryOutput, error) {
+	input := &synthetics.GetCanaryInput{
+		Name: aws.String(name),
+	}
+
+	output, err := conn.GetCanary(input)
+	if err != nil {
+		return nil, err
+	}
+
+	return output, nil
+}

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

@@ -0,0 +1,26 @@
+package waiter
+
+import (
+	"fmt"
+
+	"github.com/aws/aws-sdk-go/aws"
+	"github.com/aws/aws-sdk-go/service/synthetics"
+	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/resource"
+	"github.com/terraform-providers/terraform-provider-aws/aws/internal/service/synthetics/finder"
+)
+
+func CanaryStatus(conn *synthetics.Synthetics, name string) resource.StateRefreshFunc {
+	return func() (interface{}, string, error) {
+		output, err := finder.CanaryByName(conn, name)
+
+		if err != nil {
+			return nil, synthetics.CanaryStateError, err
+		}
+
+		if aws.StringValue(output.Canary.Status.State) == synthetics.CanaryStateError {
+			return output, synthetics.CanaryStateError, fmt.Errorf("%s: %s", aws.StringValue(output.Canary.Status.StateReasonCode), aws.StringValue(output.Canary.Status.StateReason))
+		}
+
+		return output, aws.StringValue(output.Canary.Status.State), nil
+	}
+}

aws/internal/service/synthetics/waiter/waiter.go

@@ -0,0 +1,90 @@
+package waiter
+
+import (
+	"time"
+
+	"github.com/aws/aws-sdk-go/service/synthetics"
+	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/resource"
+)
+
+const (
+	// Maximum amount of time to wait for a Canary to return Ready
+	CanaryCreatedTimeout = 5 * time.Minute
+	CanaryRunningTimeout = 5 * time.Minute
+	CanaryStoppedTimeout = 5 * time.Minute
+	CanaryDeletedTimeout = 5 * time.Minute
+)
+
+// CanaryReady waits for a Canary to return Ready
+func CanaryReady(conn *synthetics.Synthetics, name string) (*synthetics.GetCanaryOutput, error) {
+	stateConf := &resource.StateChangeConf{
+		Pending: []string{synthetics.CanaryStateCreating, synthetics.CanaryStateUpdating},
+		Target:  []string{synthetics.CanaryStateReady},
+		Refresh: CanaryStatus(conn, name),
+		Timeout: CanaryCreatedTimeout,
+	}
+
+	outputRaw, err := stateConf.WaitForState()
+
+	if v, ok := outputRaw.(*synthetics.GetCanaryOutput); ok {
+		return v, err
+	}
+
+	return nil, err
+}
+
+// CanaryReady waits for a Canary to return Stopped
+func CanaryStopped(conn *synthetics.Synthetics, name string) (*synthetics.GetCanaryOutput, error) {
+	stateConf := &resource.StateChangeConf{
+		Pending: []string{synthetics.CanaryStateStopping, synthetics.CanaryStateUpdating,
+			synthetics.CanaryStateRunning, synthetics.CanaryStateReady, synthetics.CanaryStateStarting},
+		Target:  []string{synthetics.CanaryStateStopped},
+		Refresh: CanaryStatus(conn, name),
+		Timeout: CanaryStoppedTimeout,
+	}
+
+	outputRaw, err := stateConf.WaitForState()
+
+	if v, ok := outputRaw.(*synthetics.GetCanaryOutput); ok {
+		return v, err
+	}
+
+	return nil, err
+}
+
+// CanaryReady waits for a Canary to return Running
+func CanaryRunning(conn *synthetics.Synthetics, name string) (*synthetics.GetCanaryOutput, error) {
+	stateConf := &resource.StateChangeConf{
+		Pending: []string{synthetics.CanaryStateStarting, synthetics.CanaryStateUpdating,
+			synthetics.CanaryStateStarting, synthetics.CanaryStateReady},
+		Target:  []string{synthetics.CanaryStateRunning},
+		Refresh: CanaryStatus(conn, name),
+		Timeout: CanaryRunningTimeout,
+	}
+
+	outputRaw, err := stateConf.WaitForState()
+
+	if v, ok := outputRaw.(*synthetics.GetCanaryOutput); ok {
+		return v, err
+	}
+
+	return nil, err
+}
+
+// CanaryReady waits for a Canary to return Ready
+func CanaryDeleted(conn *synthetics.Synthetics, name string) (*synthetics.GetCanaryOutput, error) {
+	stateConf := &resource.StateChangeConf{
+		Pending: []string{synthetics.CanaryStateDeleting, synthetics.CanaryStateStopped},
+		Target:  []string{},
+		Refresh: CanaryStatus(conn, name),
+		Timeout: CanaryDeletedTimeout,
+	}
+
+	outputRaw, err := stateConf.WaitForState()
+
+	if v, ok := outputRaw.(*synthetics.GetCanaryOutput); ok {
+		return v, err
+	}
+
+	return nil, err
+}

aws/provider.go

@@ -994,6 +994,7 @@ func Provider() *schema.Provider {
 			"aws_default_subnet":                                      resourceAwsDefaultSubnet(),
 			"aws_subnet":                                              resourceAwsSubnet(),
 			"aws_swf_domain":                                          resourceAwsSwfDomain(),
+			"aws_synthetics_canary":                                   resourceAwsSyntheticsCanary(),
 			"aws_transfer_server":                                     resourceAwsTransferServer(),
 			"aws_transfer_ssh_key":                                    resourceAwsTransferSshKey(),
 			"aws_transfer_user":                                       resourceAwsTransferUser(),