Merge pull request #20613 from hashicorp/tmp-pr20312

EventBridge Rule and Target: Allow `event_bridge_name` to be an ARN

.changelog/20312.txt

@@ -0,0 +1,7 @@
+```release-note:bug
+aws/resource_aws_cloudwatch_event_rule: Correctly handle ARN in `event_bus_name` argument
+```
+
+```release-note:bug
+aws/resource_aws_cloudwatch_event_target: Correctly handle ARN in `event_bus_name` argument
+```

aws/internal/service/cloudwatchevents/enum.go

@@ -0,0 +1,5 @@
+package cloudwatchevents
+
+const (
+ DefaultEventBusName = "default"
+)

aws/internal/service/cloudwatchevents/finder/finder.go

@@ -39,25 +39,46 @@ func ConnectionByName(conn *events.CloudWatchEvents, name string) (*events.Descr
  return output, nil
 }
 
-func Rule(conn *events.CloudWatchEvents, eventBusName, ruleName string) (*events.DescribeRuleOutput, error) {
+func RuleByEventBusAndRuleNames(conn *events.CloudWatchEvents, eventBusName, ruleName string) (*events.DescribeRuleOutput, error) {
  input := events.DescribeRuleInput{
  Name: aws.String(ruleName),
  }
+
  if eventBusName != "" {
  input.EventBusName = aws.String(eventBusName)
  }
 
- return conn.DescribeRule(&input)
+ output, err := conn.DescribeRule(&input)
 
+ if tfawserr.ErrCodeEquals(err, events.ErrCodeResourceNotFoundException) {
+ return nil, &resource.NotFoundError{
+ LastError: err,
+ LastRequest: input,
+ }
+ }
+
+ if err != nil {
+ return nil, err
+ }
+
+ if output == nil {
+ return nil, &resource.NotFoundError{
+ Message: "Empty result",
+ LastRequest: input,
+ }
+ }
+
+ return output, nil
 }
 
-func RuleByID(conn *events.CloudWatchEvents, ruleID string) (*events.DescribeRuleOutput, error) {
- busName, ruleName, err := tfevents.RuleParseID(ruleID)
+func RuleByResourceID(conn *events.CloudWatchEvents, id string) (*events.DescribeRuleOutput, error) {
+ eventBusName, ruleName, err := tfevents.RuleParseResourceID(id)
+
  if err != nil {
  return nil, err
  }
 
- return Rule(conn, busName, ruleName)
+ return RuleByEventBusAndRuleNames(conn, eventBusName, ruleName)
 }
 
 func Target(conn *events.CloudWatchEvents, busName, ruleName, targetId string) (*events.Target, error) {

aws/internal/service/cloudwatchevents/id.go

@@ -7,77 +7,95 @@ import (
 )
 
 var (
+ eventBusARNPattern = regexp.MustCompile(`^arn:aws[\w-]*:events:[a-z]{2}-[a-z]+-[\w-]+:[0-9]{12}:event-bus\/[\.\-_A-Za-z0-9]+$`)
  partnerEventBusPattern = regexp.MustCompile(`^aws\.partner(/[\.\-_A-Za-z0-9]+){2,}$`)
 )
 
-const DefaultEventBusName = "default"
+const permissionResourceIDSeparator = "/"
 
-const PermissionIDSeparator = "/"
-
-func PermissionCreateID(eventBusName, statementID string) string {
+func PermissionCreateResourceID(eventBusName, statementID string) string {
  if eventBusName == "" || eventBusName == DefaultEventBusName {
  return statementID
  }
- return eventBusName + PermissionIDSeparator + statementID
+
+ parts := []string{eventBusName, statementID}
+ id := strings.Join(parts, permissionResourceIDSeparator)
+
+ return id
 }
 
-func PermissionParseID(id string) (string, string, error) {
- parts := strings.Split(id, PermissionIDSeparator)
+func PermissionParseResourceID(id string) (string, string, error) {
+ parts := strings.Split(id, permissionResourceIDSeparator)
+
  if len(parts) == 1 && parts[0] != "" {
  return DefaultEventBusName, parts[0], nil
  }
  if len(parts) == 2 && parts[0] != "" && parts[1] != "" {
  return parts[0], parts[1], nil
  }
 
- return "", "", fmt.Errorf("unexpected format for ID (%q), expected <event-bus-name>"+PermissionIDSeparator+"<statement-id> or <statement-id>", id)
+ return "", "", fmt.Errorf("unexpected format for ID (%[1]s), expected EVENTBUSNAME%[2]sSTATEMENTID or STATEMENTID", id, permissionResourceIDSeparator)
 }
 
-const ruleIDSeparator = "/"
+const ruleResourceIDSeparator = "/"
 
-func RuleCreateID(eventBusName, ruleName string) string {
+func RuleCreateResourceID(eventBusName, ruleName string) string {
  if eventBusName == "" || eventBusName == DefaultEventBusName {
  return ruleName
  }
- return eventBusName + ruleIDSeparator + ruleName
+
+ parts := []string{eventBusName, ruleName}
+ id := strings.Join(parts, ruleResourceIDSeparator)
+
+ return id
 }
 
-func RuleParseID(id string) (string, string, error) {
- parts := strings.Split(id, ruleIDSeparator)
+func RuleParseResourceID(id string) (string, string, error) {
+ parts := strings.Split(id, ruleResourceIDSeparator)
+
  if len(parts) == 1 && parts[0] != "" {
  return DefaultEventBusName, parts[0], nil
  }
  if len(parts) == 2 && parts[0] != "" && parts[1] != "" {
  return parts[0], parts[1], nil
  }
  if len(parts) > 2 {
- i := strings.LastIndex(id, ruleIDSeparator)
- busName := id[:i]
- statementID := id[i+1:]
- if partnerEventBusPattern.MatchString(busName) && statementID != "" {
- return busName, statementID, nil
+ i := strings.LastIndex(id, ruleResourceIDSeparator)
+ eventBusName := id[:i]
+ ruleName := id[i+1:]
+ if eventBusARNPattern.MatchString(eventBusName) && ruleName != "" {
+ return eventBusName, ruleName, nil
+ }
+ if partnerEventBusPattern.MatchString(eventBusName) && ruleName != "" {
+ return eventBusName, ruleName, nil
  }
  }
 
- return "", "", fmt.Errorf("unexpected format for ID (%q), expected <event-bus-name>"+ruleIDSeparator+"<rule-name> or <rule-name>", id)
+ return "", "", fmt.Errorf("unexpected format for ID (%[1]s), expected EVENTBUSNAME%[2]sRULENAME or RULENAME", id, ruleResourceIDSeparator)
 }
 
-// Terraform state IDs for Targets are not parseable, since the separator used ("-") is also a valid
-// character in both the rule name and the target id.
+// Terraform resource IDs for Targets are not parseable as the separator used ("-") is also a valid character in both the rule name and the target ID.
 
-const targetIDSeparator = "-"
+const targetResourceIDSeparator = "-"
 const targetImportIDSeparator = "/"
 
-func TargetCreateID(eventBusName, ruleName, targetID string) string {
- id := ruleName + targetIDSeparator + targetID
- if eventBusName != "" && eventBusName != DefaultEventBusName {
- id = eventBusName + targetIDSeparator + id
+func TargetCreateResourceID(eventBusName, ruleName, targetID string) string {
+ var parts []string
+
+ if eventBusName == "" || eventBusName == DefaultEventBusName {
+ parts = []string{ruleName, targetID}
+ } else {
+ parts = []string{eventBusName, ruleName, targetID}
  }
+
+ id := strings.Join(parts, targetResourceIDSeparator)
+
  return id
 }
 
 func TargetParseImportID(id string) (string, string, string, error) {
  parts := strings.Split(id, targetImportIDSeparator)
+
  if len(parts) == 2 && parts[0] != "" && parts[1] != "" {
  return DefaultEventBusName, parts[0], parts[1], nil
  }
@@ -88,12 +106,15 @@ func TargetParseImportID(id string) (string, string, string, error) {
  iTarget := strings.LastIndex(id, targetImportIDSeparator)
  targetID := id[iTarget+1:]
  iRule := strings.LastIndex(id[:iTarget], targetImportIDSeparator)
- busName := id[:iRule]
+ eventBusName := id[:iRule]
  ruleName := id[iRule+1 : iTarget]
- if partnerEventBusPattern.MatchString(busName) && ruleName != "" && targetID != "" {
- return busName, ruleName, targetID, nil
+ if eventBusARNPattern.MatchString(eventBusName) && ruleName != "" && targetID != "" {
+ return eventBusName, ruleName, targetID, nil
+ }
+ if partnerEventBusPattern.MatchString(eventBusName) && ruleName != "" && targetID != "" {
+ return eventBusName, ruleName, targetID, nil
  }
  }
 
- return "", "", "", fmt.Errorf("unexpected format for ID (%q), expected <event-bus-name>"+targetImportIDSeparator+"<rule-name>"+targetImportIDSeparator+"<target-id> or <rule-name>"+targetImportIDSeparator+"<target-id>", id)
+ return "", "", "", fmt.Errorf("unexpected format for ID (%[1]s), expected EVENTBUSNAME%[2]sRULENAME%[2]sTARGETID or RULENAME%[2]sTARGETID", id, targetImportIDSeparator)
 }

aws/internal/service/cloudwatchevents/id_test.go

@@ -6,7 +6,7 @@ import (
  tfevents "github.com/terraform-providers/terraform-provider-aws/aws/internal/service/cloudwatchevents"
 )
 
-func TestPermissionParseID(t *testing.T) {
+func TestPermissionParseResourceID(t *testing.T) {
  testCases := []struct {
  TestName string
  InputID string
@@ -27,13 +27,13 @@ func TestPermissionParseID(t *testing.T) {
  },
  {
  TestName: "two parts",
- InputID: tfevents.PermissionCreateID("TestEventBus", "TestStatement"),
+ InputID: tfevents.PermissionCreateResourceID("TestEventBus", "TestStatement"),
  ExpectedPart0: "TestEventBus",
  ExpectedPart1: "TestStatement",
  },
  {
  TestName: "two parts with default event bus",
- InputID: tfevents.PermissionCreateID(tfevents.DefaultEventBusName, "TestStatement"),
+ InputID: tfevents.PermissionCreateResourceID(tfevents.DefaultEventBusName, "TestStatement"),
  ExpectedPart0: tfevents.DefaultEventBusName,
  ExpectedPart1: "TestStatement",
  },
@@ -66,7 +66,7 @@ func TestPermissionParseID(t *testing.T) {
 
  for _, testCase := range testCases {
  t.Run(testCase.TestName, func(t *testing.T) {
- gotPart0, gotPart1, err := tfevents.PermissionParseID(testCase.InputID)
+ gotPart0, gotPart1, err := tfevents.PermissionParseResourceID(testCase.InputID)
 
  if err == nil && testCase.ExpectedError {
  t.Fatalf("expected error, got no error")
@@ -87,7 +87,7 @@ func TestPermissionParseID(t *testing.T) {
  }
 }
 
-func TestRuleParseID(t *testing.T) {
+func TestRuleParseResourceID(t *testing.T) {
  testCases := []struct {
  TestName string
  InputID string
@@ -108,22 +108,34 @@ func TestRuleParseID(t *testing.T) {
  },
  {
  TestName: "two parts",
- InputID: tfevents.RuleCreateID("TestEventBus", "TestRule"),
+ InputID: tfevents.RuleCreateResourceID("TestEventBus", "TestRule"),
  ExpectedPart0: "TestEventBus",
  ExpectedPart1: "TestRule",
  },
  {
  TestName: "two parts with default event bus",
- InputID: tfevents.RuleCreateID(tfevents.DefaultEventBusName, "TestRule"),
+ InputID: tfevents.RuleCreateResourceID(tfevents.DefaultEventBusName, "TestRule"),
  ExpectedPart0: tfevents.DefaultEventBusName,
  ExpectedPart1: "TestRule",
  },
  {
- TestName: "partner event bus",
+ TestName: "partner event bus 1",
  InputID: "aws.partner/example.com/Test/TestRule",
  ExpectedPart0: "aws.partner/example.com/Test",
  ExpectedPart1: "TestRule",
  },
+ {
+ TestName: "partner event bus 2",
+ InputID: "aws.partner/foo.com/foo/18554d09-58ff-aa42-ba9c-c4c33899006f/test",
+ ExpectedPart0: "aws.partner/foo.com/foo/18554d09-58ff-aa42-ba9c-c4c33899006f",
+ ExpectedPart1: "test",
+ },
+ {
+ TestName: "ARN event bus",
+ InputID: tfevents.RuleCreateResourceID("arn:aws:events:us-east-2:123456789012:event-bus/default", "TestRule"),
+ ExpectedPart0: "arn:aws:events:us-east-2:123456789012:event-bus/default",
+ ExpectedPart1: "TestRule",
+ },
  {
  TestName: "empty both parts",
  InputID: "/",
@@ -163,7 +175,7 @@ func TestRuleParseID(t *testing.T) {
 
  for _, testCase := range testCases {
  t.Run(testCase.TestName, func(t *testing.T) {
- gotPart0, gotPart1, err := tfevents.RuleParseID(testCase.InputID)
+ gotPart0, gotPart1, err := tfevents.RuleParseResourceID(testCase.InputID)
 
  if err == nil && testCase.ExpectedError {
  t.Fatalf("expected error, got no error")
@@ -281,6 +293,13 @@ func TestTargetParseImportID(t *testing.T) {
  ExpectedPart1: "TestRule",
  ExpectedPart2: "TestTarget",
  },
+ {
+ TestName: "ARN event bus",
+ InputID: "arn:aws:events:us-east-2:123456789012:event-bus/default/TestRule/TestTarget",
+ ExpectedPart0: "arn:aws:events:us-east-2:123456789012:event-bus/default",
+ ExpectedPart1: "TestRule",
+ ExpectedPart2: "TestTarget",
+ },
  {
  TestName: "empty partner event rule and target",
  InputID: "aws.partner/example.com/Test//",

aws/internal/service/cloudwatchevents/state.go

@@ -0,0 +1,31 @@
+package cloudwatchevents
+
+import (
+ "fmt"
+
+ events "github.com/aws/aws-sdk-go/service/cloudwatchevents"
+)
+
+// RuleEnabledFromState infers from its state whether or not a rule is enabled.
+func RuleEnabledFromState(state string) (bool, error) {
+ if state == events.RuleStateEnabled {
+ return true, nil
+ }
+
+ if state == events.RuleStateDisabled {
+ return false, nil
+ }
+
+ // We don't just blindly trust AWS as they tend to return
+ // unexpected values in similar cases (different casing etc.)
+ return false, fmt.Errorf("unable to infer enabled from state: %s", state)
+}
+
+// RuleStateFromEnabled returns a rule's state based on whether or not it is enabled.
+func RuleStateFromEnabled(enabled bool) string {
+ if enabled {
+ return events.RuleStateEnabled
+ }
+
+ return events.RuleStateDisabled
+}