Skip to content

Commit 753d347

Browse files
authored
Merge pull request #25162 from brittandeyoung/f-aws_service_discovery
New Data Sources: aws_service_discovery_service and aws_service_discovery_http_namespace
2 parents ab2ac9f + 1b4415e commit 753d347

26 files changed

+1395
-655
lines changed

.changelog/25162.txt

+15
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,15 @@
1+
```release-note:new-data-source
2+
aws_service_discovery_service
3+
```
4+
5+
```release-note:new-data-source
6+
aws_service_discovery_http_namespace
7+
```
8+
9+
```release-note:enhancement
10+
resource/aws_service_discovery_http_namespace: Add `http_name` attribute
11+
```
12+
13+
```release-note:enhancement
14+
data-source/aws_service_discovery_dns_namespace: Add `tags` attribute
15+
```

internal/provider/provider.go

+3-1
Original file line numberDiff line numberDiff line change
@@ -855,7 +855,9 @@ func Provider() *schema.Provider {
855855
"aws_servicecatalog_portfolio": servicecatalog.DataSourcePortfolio(),
856856
"aws_servicecatalog_product": servicecatalog.DataSourceProduct(),
857857

858-
"aws_service_discovery_dns_namespace": servicediscovery.DataSourceDNSNamespace(),
858+
"aws_service_discovery_dns_namespace": servicediscovery.DataSourceDNSNamespace(),
859+
"aws_service_discovery_http_namespace": servicediscovery.DataSourceHTTPNamespace(),
860+
"aws_service_discovery_service": servicediscovery.DataSourceService(),
859861

860862
"aws_servicequotas_service": servicequotas.DataSourceService(),
861863
"aws_servicequotas_service_quota": servicequotas.DataSourceServiceQuota(),

internal/service/servicediscovery/dns_namespace_data_source.go

+24-56
Original file line numberDiff line numberDiff line change
@@ -2,14 +2,14 @@ package servicediscovery
22

33
import (
44
"context"
5-
"fmt"
65

76
"github.com/aws/aws-sdk-go/aws"
87
"github.com/aws/aws-sdk-go/service/servicediscovery"
98
"github.com/hashicorp/terraform-plugin-sdk/v2/diag"
109
"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
1110
"github.com/hashicorp/terraform-plugin-sdk/v2/helper/validation"
1211
"github.com/hashicorp/terraform-provider-aws/internal/conns"
12+
tftags "github.com/hashicorp/terraform-provider-aws/internal/tags"
1313
)
1414

1515
func DataSourceDNSNamespace() *schema.Resource {
@@ -33,9 +33,11 @@ func DataSourceDNSNamespace() *schema.Resource {
3333
Type: schema.TypeString,
3434
Required: true,
3535
},
36+
"tags": tftags.TagsSchemaComputed(),
3637
"type": {
3738
Type: schema.TypeString,
3839
Required: true,
40+
// HTTP namespaces are handled via the aws_service_discovery_http_namespace data source.
3941
ValidateFunc: validation.StringInSlice([]string{
4042
servicediscovery.NamespaceTypeDnsPublic,
4143
servicediscovery.NamespaceTypeDnsPrivate,
@@ -47,77 +49,43 @@ func DataSourceDNSNamespace() *schema.Resource {
4749

4850
func dataSourceDNSNamespaceRead(ctx context.Context, d *schema.ResourceData, meta interface{}) diag.Diagnostics {
4951
conn := meta.(*conns.AWSClient).ServiceDiscoveryConn
52+
ignoreTagsConfig := meta.(*conns.AWSClient).IgnoreTagsConfig
5053

5154
name := d.Get("name").(string)
55+
nsType := d.Get("type").(string)
56+
nsSummary, err := findNamespaceByNameAndType(ctx, conn, name, nsType)
5257

53-
input := &servicediscovery.ListNamespacesInput{}
54-
55-
var filters []*servicediscovery.NamespaceFilter
56-
57-
filter := &servicediscovery.NamespaceFilter{
58-
Condition: aws.String(servicediscovery.FilterConditionEq),
59-
Name: aws.String(servicediscovery.NamespaceFilterNameType),
60-
Values: []*string{aws.String(d.Get("type").(string))},
58+
if err != nil {
59+
return diag.Errorf("reading Service Discovery %s Namespace (%s): %s", name, nsType, err)
6160
}
6261

63-
filters = append(filters, filter)
64-
65-
input.Filters = filters
62+
namespaceID := aws.StringValue(nsSummary.Id)
6663

67-
namespaceIds := make([]string, 0)
68-
69-
err := conn.ListNamespacesPagesWithContext(ctx, input, func(page *servicediscovery.ListNamespacesOutput, lastPage bool) bool {
70-
if page == nil {
71-
return !lastPage
72-
}
73-
74-
for _, namespace := range page.Namespaces {
75-
if namespace == nil {
76-
continue
77-
}
78-
79-
if name == aws.StringValue(namespace.Name) {
80-
namespaceIds = append(namespaceIds, aws.StringValue(namespace.Id))
81-
}
82-
}
83-
return !lastPage
84-
})
64+
ns, err := FindNamespaceByID(ctx, conn, namespaceID)
8565

8666
if err != nil {
87-
return diag.FromErr(fmt.Errorf("error listing Service Discovery DNS Namespaces: %w", err))
67+
return diag.Errorf("reading Service Discovery %s Namespace (%s): %s", nsType, namespaceID, err)
8868
}
8969

90-
if len(namespaceIds) == 0 {
91-
return diag.Errorf("no matching Service Discovery DNS Namespace found")
70+
d.SetId(namespaceID)
71+
arn := aws.StringValue(ns.Arn)
72+
d.Set("arn", arn)
73+
d.Set("description", ns.Description)
74+
if ns.Properties != nil && ns.Properties.DnsProperties != nil {
75+
d.Set("hosted_zone", ns.Properties.DnsProperties.HostedZoneId)
76+
} else {
77+
d.Set("hosted_zone", nil)
9278
}
79+
d.Set("name", ns.Name)
9380

94-
if len(namespaceIds) != 1 {
95-
return diag.FromErr(fmt.Errorf("search returned %d Service Discovery DNS Namespaces, please revise so only one is returned", len(namespaceIds)))
96-
}
97-
98-
d.SetId(namespaceIds[0])
99-
100-
req := &servicediscovery.GetNamespaceInput{
101-
Id: aws.String(d.Id()),
102-
}
103-
104-
output, err := conn.GetNamespaceWithContext(ctx, req)
81+
tags, err := ListTags(conn, arn)
10582

10683
if err != nil {
107-
return diag.FromErr(fmt.Errorf("error reading Service Discovery DNS Namespace (%s): %w", d.Id(), err))
84+
return diag.Errorf("listing tags for Service Discovery %s Namespace (%s): %s", nsType, arn, err)
10885
}
10986

110-
if output == nil || output.Namespace == nil {
111-
return diag.FromErr(fmt.Errorf("error reading Service Discovery DNS Namespace (%s): empty output", d.Id()))
112-
}
113-
114-
namespace := output.Namespace
115-
116-
d.Set("name", namespace.Name)
117-
d.Set("description", namespace.Description)
118-
d.Set("arn", namespace.Arn)
119-
if namespace.Properties != nil && namespace.Properties.DnsProperties != nil {
120-
d.Set("hosted_zone", namespace.Properties.DnsProperties.HostedZoneId)
87+
if err := d.Set("tags", tags.IgnoreAWS().IgnoreConfig(ignoreTagsConfig).Map()); err != nil {
88+
return diag.Errorf("setting tags: %s", err)
12189
}
12290

12391
return nil

internal/service/servicediscovery/dns_namespace_data_source_test.go

+10-4
Original file line numberDiff line numberDiff line change
@@ -28,9 +28,10 @@ func TestAccServiceDiscoveryDNSNamespaceDataSource_private(t *testing.T) {
2828
Config: testAccDNSNamespaceDataSourceConfig_private(rName),
2929
Check: resource.ComposeAggregateTestCheckFunc(
3030
resource.TestCheckResourceAttrPair(dataSourceName, "arn", resourceName, "arn"),
31-
resource.TestCheckResourceAttrPair(dataSourceName, "name", resourceName, "name"),
3231
resource.TestCheckResourceAttrPair(dataSourceName, "description", resourceName, "description"),
3332
resource.TestCheckResourceAttrPair(dataSourceName, "hosted_zone", resourceName, "hosted_zone"),
33+
resource.TestCheckResourceAttrPair(dataSourceName, "name", resourceName, "name"),
34+
resource.TestCheckResourceAttrPair(dataSourceName, "tags.%", resourceName, "tags.%"),
3435
),
3536
},
3637
},
@@ -55,9 +56,10 @@ func TestAccServiceDiscoveryDNSNamespaceDataSource_public(t *testing.T) {
5556
Config: testAccDNSNamespaceDataSourceConfig_public(rName),
5657
Check: resource.ComposeAggregateTestCheckFunc(
5758
resource.TestCheckResourceAttrPair(dataSourceName, "arn", resourceName, "arn"),
58-
resource.TestCheckResourceAttrPair(dataSourceName, "name", resourceName, "name"),
5959
resource.TestCheckResourceAttrPair(dataSourceName, "description", resourceName, "description"),
6060
resource.TestCheckResourceAttrPair(dataSourceName, "hosted_zone", resourceName, "hosted_zone"),
61+
resource.TestCheckResourceAttrPair(dataSourceName, "name", resourceName, "name"),
62+
resource.TestCheckResourceAttrPair(dataSourceName, "tags.%", resourceName, "tags.%"),
6163
),
6264
},
6365
},
@@ -68,10 +70,14 @@ func testAccDNSNamespaceDataSourceConfig_private(rName string) string {
6870
return fmt.Sprintf(`
6971
resource "aws_vpc" "test" {
7072
cidr_block = "10.0.0.0/16"
73+
74+
tags = {
75+
Name = %[1]q
76+
}
7177
}
7278
7379
resource "aws_service_discovery_private_dns_namespace" "test" {
74-
name = "%[1]s.tf"
80+
name = "%[1]s.test"
7581
vpc = aws_vpc.test.id
7682
}
7783
@@ -85,7 +91,7 @@ data "aws_service_discovery_dns_namespace" "test" {
8591
func testAccDNSNamespaceDataSourceConfig_public(rName string) string {
8692
return fmt.Sprintf(`
8793
resource "aws_service_discovery_public_dns_namespace" "test" {
88-
name = "%[1]s.tf"
94+
name = "%[1]s.test"
8995
}
9096
9197
data "aws_service_discovery_dns_namespace" "test" {

internal/service/servicediscovery/find.go

+137-6
Original file line numberDiff line numberDiff line change
@@ -1,20 +1,22 @@
11
package servicediscovery
22

33
import (
4+
"context"
5+
46
"github.com/aws/aws-sdk-go/aws"
57
"github.com/aws/aws-sdk-go/service/servicediscovery"
68
"github.com/hashicorp/aws-sdk-go-base/v2/awsv1shim/v2/tfawserr"
79
"github.com/hashicorp/terraform-plugin-sdk/v2/helper/resource"
810
"github.com/hashicorp/terraform-provider-aws/internal/tfresource"
911
)
1012

11-
func FindInstanceByServiceIDAndInstanceID(conn *servicediscovery.ServiceDiscovery, serviceID, instanceID string) (*servicediscovery.Instance, error) {
13+
func FindInstanceByServiceIDAndInstanceID(ctx context.Context, conn *servicediscovery.ServiceDiscovery, serviceID, instanceID string) (*servicediscovery.Instance, error) {
1214
input := &servicediscovery.GetInstanceInput{
1315
InstanceId: aws.String(instanceID),
1416
ServiceId: aws.String(serviceID),
1517
}
1618

17-
output, err := conn.GetInstance(input)
19+
output, err := conn.GetInstanceWithContext(ctx, input)
1820

1921
if tfawserr.ErrCodeEquals(err, servicediscovery.ErrCodeInstanceNotFound) {
2022
return nil, &resource.NotFoundError{
@@ -34,12 +36,89 @@ func FindInstanceByServiceIDAndInstanceID(conn *servicediscovery.ServiceDiscover
3436
return output.Instance, nil
3537
}
3638

37-
func FindOperationByID(conn *servicediscovery.ServiceDiscovery, id string) (*servicediscovery.Operation, error) {
39+
func findNamespaces(ctx context.Context, conn *servicediscovery.ServiceDiscovery, input *servicediscovery.ListNamespacesInput) ([]*servicediscovery.NamespaceSummary, error) {
40+
var output []*servicediscovery.NamespaceSummary
41+
42+
err := conn.ListNamespacesPagesWithContext(ctx, input, func(page *servicediscovery.ListNamespacesOutput, lastPage bool) bool {
43+
if page == nil {
44+
return !lastPage
45+
}
46+
47+
for _, v := range page.Namespaces {
48+
if v != nil {
49+
output = append(output, v)
50+
}
51+
}
52+
53+
return !lastPage
54+
})
55+
56+
if err != nil {
57+
return nil, err
58+
}
59+
60+
return output, nil
61+
}
62+
63+
func findNamespacesByType(ctx context.Context, conn *servicediscovery.ServiceDiscovery, nsType string) ([]*servicediscovery.NamespaceSummary, error) {
64+
input := &servicediscovery.ListNamespacesInput{
65+
Filters: []*servicediscovery.NamespaceFilter{{
66+
Condition: aws.String(servicediscovery.FilterConditionEq),
67+
Name: aws.String(servicediscovery.NamespaceFilterNameType),
68+
Values: aws.StringSlice([]string{nsType}),
69+
}},
70+
}
71+
72+
return findNamespaces(ctx, conn, input)
73+
}
74+
75+
func findNamespaceByNameAndType(ctx context.Context, conn *servicediscovery.ServiceDiscovery, name, nsType string) (*servicediscovery.NamespaceSummary, error) {
76+
output, err := findNamespacesByType(ctx, conn, nsType)
77+
78+
if err != nil {
79+
return nil, err
80+
}
81+
82+
for _, v := range output {
83+
if aws.StringValue(v.Name) == name {
84+
return v, nil
85+
}
86+
}
87+
88+
return nil, &resource.NotFoundError{}
89+
}
90+
91+
func FindNamespaceByID(ctx context.Context, conn *servicediscovery.ServiceDiscovery, id string) (*servicediscovery.Namespace, error) {
92+
input := &servicediscovery.GetNamespaceInput{
93+
Id: aws.String(id),
94+
}
95+
96+
output, err := conn.GetNamespaceWithContext(ctx, input)
97+
98+
if tfawserr.ErrCodeEquals(err, servicediscovery.ErrCodeNamespaceNotFound) {
99+
return nil, &resource.NotFoundError{
100+
LastError: err,
101+
LastRequest: input,
102+
}
103+
}
104+
105+
if err != nil {
106+
return nil, err
107+
}
108+
109+
if output == nil || output.Namespace == nil {
110+
return nil, tfresource.NewEmptyResultError(input)
111+
}
112+
113+
return output.Namespace, nil
114+
}
115+
116+
func FindOperationByID(ctx context.Context, conn *servicediscovery.ServiceDiscovery, id string) (*servicediscovery.Operation, error) {
38117
input := &servicediscovery.GetOperationInput{
39118
OperationId: aws.String(id),
40119
}
41120

42-
output, err := conn.GetOperation(input)
121+
output, err := conn.GetOperationWithContext(ctx, input)
43122

44123
if tfawserr.ErrCodeEquals(err, servicediscovery.ErrCodeOperationNotFound) {
45124
return nil, &resource.NotFoundError{
@@ -59,12 +138,64 @@ func FindOperationByID(conn *servicediscovery.ServiceDiscovery, id string) (*ser
59138
return output.Operation, nil
60139
}
61140

62-
func FindServiceByID(conn *servicediscovery.ServiceDiscovery, id string) (*servicediscovery.Service, error) {
141+
func findServices(ctx context.Context, conn *servicediscovery.ServiceDiscovery, input *servicediscovery.ListServicesInput) ([]*servicediscovery.ServiceSummary, error) {
142+
var output []*servicediscovery.ServiceSummary
143+
144+
err := conn.ListServicesPagesWithContext(ctx, input, func(page *servicediscovery.ListServicesOutput, lastPage bool) bool {
145+
if page == nil {
146+
return !lastPage
147+
}
148+
149+
for _, v := range page.Services {
150+
if v != nil {
151+
output = append(output, v)
152+
}
153+
}
154+
155+
return !lastPage
156+
})
157+
158+
if err != nil {
159+
return nil, err
160+
}
161+
162+
return output, nil
163+
}
164+
165+
func findServicesByNamespaceID(ctx context.Context, conn *servicediscovery.ServiceDiscovery, namespaceID string) ([]*servicediscovery.ServiceSummary, error) {
166+
input := &servicediscovery.ListServicesInput{
167+
Filters: []*servicediscovery.ServiceFilter{{
168+
Condition: aws.String(servicediscovery.FilterConditionEq),
169+
Name: aws.String(servicediscovery.ServiceFilterNameNamespaceId),
170+
Values: aws.StringSlice([]string{namespaceID}),
171+
}},
172+
}
173+
174+
return findServices(ctx, conn, input)
175+
}
176+
177+
func findServiceByNameAndNamespaceID(ctx context.Context, conn *servicediscovery.ServiceDiscovery, name, namespaceID string) (*servicediscovery.ServiceSummary, error) {
178+
output, err := findServicesByNamespaceID(ctx, conn, namespaceID)
179+
180+
if err != nil {
181+
return nil, err
182+
}
183+
184+
for _, v := range output {
185+
if aws.StringValue(v.Name) == name {
186+
return v, nil
187+
}
188+
}
189+
190+
return nil, &resource.NotFoundError{}
191+
}
192+
193+
func FindServiceByID(ctx context.Context, conn *servicediscovery.ServiceDiscovery, id string) (*servicediscovery.Service, error) {
63194
input := &servicediscovery.GetServiceInput{
64195
Id: aws.String(id),
65196
}
66197

67-
output, err := conn.GetService(input)
198+
output, err := conn.GetServiceWithContext(ctx, input)
68199

69200
if tfawserr.ErrCodeEquals(err, servicediscovery.ErrCodeServiceNotFound) {
70201
return nil, &resource.NotFoundError{

0 commit comments

Comments
 (0)