[AWS SDK for Go Migration] ECR (Elastic Container Registry) Service

internal/service/ecr/authorization_token_data_source.go

@@ -5,30 +5,34 @@ package ecr
 
 import (
 	"context"
-	"log"
 	"strings"
 	"time"
 
-	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/service/ecr"
+	"github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/aws/aws-sdk-go-v2/service/ecr"
 	"github.com/hashicorp/terraform-plugin-sdk/v2/diag"
 	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
 	"github.com/hashicorp/terraform-provider-aws/internal/conns"
 	"github.com/hashicorp/terraform-provider-aws/internal/errs/sdkdiag"
 	itypes "github.com/hashicorp/terraform-provider-aws/internal/types"
 )
 
-// @SDKDataSource("aws_ecr_authorization_token")
-func DataSourceAuthorizationToken() *schema.Resource {
+// @SDKDataSource("aws_ecr_authorization_token", name="Authorization Token")
+func dataSourceAuthorizationToken() *schema.Resource {
 	return &schema.Resource{
 		ReadWithoutTimeout: dataSourceAuthorizationTokenRead,
 
 		Schema: map[string]*schema.Schema{
-			"registry_id": {
+			"authorization_token": {
+				Type:      schema.TypeString,
+				Computed:  true,
+				Sensitive: true,
+			},
+			"expires_at": {
 				Type:     schema.TypeString,
-				Optional: true,
+				Computed: true,
 			},
-			"authorization_token": {
+			"password": {
 				Type:      schema.TypeString,
 				Computed:  true,
 				Sensitive: true,
@@ -37,40 +41,32 @@ func DataSourceAuthorizationToken() *schema.Resource {
 				Type:     schema.TypeString,
 				Computed: true,
 			},
-			"expires_at": {
+			"registry_id": {
 				Type:     schema.TypeString,
-				Computed: true,
+				Optional: true,
 			},
 			"user_name": {
 				Type:     schema.TypeString,
 				Computed: true,
 			},
-			"password": {
-				Type:      schema.TypeString,
-				Computed:  true,
-				Sensitive: true,
-			},
 		},
 	}
 }
 
 func dataSourceAuthorizationTokenRead(ctx context.Context, d *schema.ResourceData, meta interface{}) diag.Diagnostics {
 	var diags diag.Diagnostics
-	conn := meta.(*conns.AWSClient).ECRConn(ctx)
-	params := &ecr.GetAuthorizationTokenInput{}
-	if v, ok := d.GetOk("registry_id"); ok {
-		params.RegistryIds = []*string{aws.String(v.(string))}
-	}
-	log.Printf("[DEBUG] Getting ECR authorization token")
-	out, err := conn.GetAuthorizationTokenWithContext(ctx, params)
+	conn := meta.(*conns.AWSClient).ECRClient(ctx)
+
+	out, err := conn.GetAuthorizationToken(ctx, &ecr.GetAuthorizationTokenInput{})
+
 	if err != nil {
-		return sdkdiag.AppendErrorf(diags, "getting ECR authorization token: %s", err)
+		return sdkdiag.AppendErrorf(diags, "reading ECR Authorization Token: %s", err)
 	}
-	log.Printf("[DEBUG] Received ECR AuthorizationData %v", out.AuthorizationData)
+
 	authorizationData := out.AuthorizationData[0]
-	authorizationToken := aws.StringValue(authorizationData.AuthorizationToken)
-	expiresAt := aws.TimeValue(authorizationData.ExpiresAt).Format(time.RFC3339)
-	proxyEndpoint := aws.StringValue(authorizationData.ProxyEndpoint)
+	authorizationToken := aws.ToString(authorizationData.AuthorizationToken)
+	expiresAt := aws.ToTime(authorizationData.ExpiresAt).Format(time.RFC3339)
+	proxyEndpoint := aws.ToString(authorizationData.ProxyEndpoint)
 	authBytes, err := itypes.Base64Decode(authorizationToken)
 	if err != nil {
 		d.SetId("")
@@ -88,5 +84,6 @@ func dataSourceAuthorizationTokenRead(ctx context.Context, d *schema.ResourceDat
 	d.Set("expires_at", expiresAt)
 	d.Set("user_name", userName)
 	d.Set("password", password)
+
 	return diags
 }

internal/service/ecr/exports_test.go

@@ -5,7 +5,19 @@ package ecr
 
 // Exports for use in tests only.
 var (
-	ResourcePullThroughCacheRule = resourcePullThroughCacheRule
+	ResourceLifecyclePolicy               = resourceLifecyclePolicy
+	ResourcePullThroughCacheRule          = resourcePullThroughCacheRule
+	ResourceRegistryPolicy                = resourceRegistryPolicy
+	ResourceRegistryScanningConfiguration = resourceRegistryScanningConfiguration
+	ResourceReplicationConfiguration      = resourceReplicationConfiguration
+	ResourceRepository                    = resourceRepository
+	ResourceRepositoryPolicy              = resourceRepositoryPolicy
 
+	FindLifecyclePolicyByRepositoryName        = findLifecyclePolicyByRepositoryName
 	FindPullThroughCacheRuleByRepositoryPrefix = findPullThroughCacheRuleByRepositoryPrefix
+	FindRegistryPolicy                         = findRegistryPolicy
+	FindRegistryScanningConfiguration          = findRegistryScanningConfiguration
+	FindReplicationConfiguration               = findReplicationConfiguration
+	FindRepositoryByName                       = findRepositoryByName
+	FindRepositoryPolicyByRepositoryName       = findRepositoryPolicyByRepositoryName
 )

internal/service/ecr/generate.go

@@ -1,7 +1,7 @@
 // Copyright (c) HashiCorp, Inc.
 // SPDX-License-Identifier: MPL-2.0
 
-//go:generate go run ../../generate/tags/main.go -ListTags -ServiceTagsSlice -UpdateTags -CreateTags
+//go:generate go run ../../generate/tags/main.go -ListTags -ServiceTagsSlice -UpdateTags -CreateTags -AWSSDKVersion=2
 //go:generate go run ../../generate/servicepackage/main.go
 // ONLY generate directives and package declaration! Do not add anything else to this file.
 

internal/service/ecr/image_data_source.go

@@ -8,21 +8,23 @@ import (
 	"fmt"
 	"slices"
 
-	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/service/ecr"
-	"github.com/hashicorp/aws-sdk-go-base/v2/awsv1shim/v2/tfawserr"
+	"github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/aws/aws-sdk-go-v2/service/ecr"
+	"github.com/aws/aws-sdk-go-v2/service/ecr/types"
 	"github.com/hashicorp/terraform-plugin-sdk/v2/diag"
 	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/retry"
 	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
 	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/validation"
 	"github.com/hashicorp/terraform-provider-aws/internal/conns"
+	"github.com/hashicorp/terraform-provider-aws/internal/errs"
 	"github.com/hashicorp/terraform-provider-aws/internal/errs/sdkdiag"
 )
 
-// @SDKDataSource("aws_ecr_image")
-func DataSourceImage() *schema.Resource {
+// @SDKDataSource("aws_ecr_image", name="Image")
+func dataSourceImage() *schema.Resource {
 	return &schema.Resource{
 		ReadWithoutTimeout: dataSourceImageRead,
+
 		Schema: map[string]*schema.Schema{
 			"image_digest": {
 				Type:          schema.TypeString,
@@ -76,14 +78,14 @@ func DataSourceImage() *schema.Resource {
 
 func dataSourceImageRead(ctx context.Context, d *schema.ResourceData, meta interface{}) diag.Diagnostics {
 	var diags diag.Diagnostics
-	conn := meta.(*conns.AWSClient).ECRConn(ctx)
+	conn := meta.(*conns.AWSClient).ECRClient(ctx)
 
 	input := &ecr.DescribeImagesInput{
 		RepositoryName: aws.String(d.Get("repository_name").(string)),
 	}
 
 	if v, ok := d.GetOk("image_digest"); ok {
-		input.ImageIds = []*ecr.ImageIdentifier{
+		input.ImageIds = []types.ImageIdentifier{
 			{
 				ImageDigest: aws.String(v.(string)),
 			},
@@ -92,7 +94,7 @@ func dataSourceImageRead(ctx context.Context, d *schema.ResourceData, meta inter
 
 	if v, ok := d.GetOk("image_tag"); ok {
 		if len(input.ImageIds) == 0 {
-			input.ImageIds = []*ecr.ImageIdentifier{
+			input.ImageIds = []types.ImageIdentifier{
 				{
 					ImageTag: aws.String(v.(string)),
 				},
@@ -106,7 +108,7 @@ func dataSourceImageRead(ctx context.Context, d *schema.ResourceData, meta inter
 		input.RegistryId = aws.String(v.(string))
 	}
 
-	imageDetails, err := FindImageDetails(ctx, conn, input)
+	imageDetails, err := findImageDetails(ctx, conn, input)
 
 	if err != nil {
 		return sdkdiag.AppendErrorf(diags, "reading ECR Images: %s", err)
@@ -121,11 +123,11 @@ func dataSourceImageRead(ctx context.Context, d *schema.ResourceData, meta inter
 			return sdkdiag.AppendErrorf(diags, "Your query returned more than one result. Please try a more specific search criteria, or set `most_recent` attribute to true.")
 		}
 
-		slices.SortFunc(imageDetails, func(a, b *ecr.ImageDetail) int {
-			if aws.TimeValue(a.ImagePushedAt).After(aws.TimeValue(b.ImagePushedAt)) {
+		slices.SortFunc(imageDetails, func(a, b types.ImageDetail) int {
+			if aws.ToTime(a.ImagePushedAt).After(aws.ToTime(b.ImagePushedAt)) {
 				return -1
 			}
-			if aws.TimeValue(a.ImagePushedAt).Before(aws.TimeValue(b.ImagePushedAt)) {
+			if aws.ToTime(a.ImagePushedAt).Before(aws.ToTime(b.ImagePushedAt)) {
 				return 1
 			}
 			return 0
@@ -134,56 +136,49 @@ func dataSourceImageRead(ctx context.Context, d *schema.ResourceData, meta inter
 
 	imageDetail := imageDetails[0]
 
-	repositoryName := aws.StringValue(imageDetail.RepositoryName)
+	repositoryName := aws.ToString(imageDetail.RepositoryName)
 	repositoryInput := &ecr.DescribeRepositoriesInput{
-		RepositoryNames: aws.StringSlice([]string{repositoryName}),
+		RepositoryNames: []string{repositoryName},
 		RegistryId:      imageDetail.RegistryId,
 	}
 
-	repository, err := FindRepository(ctx, conn, repositoryInput)
+	repository, err := findRepository(ctx, conn, repositoryInput)
 
 	if err != nil {
 		return sdkdiag.AppendErrorf(diags, "reading ECR Images: %s", err)
 	}
 
-	d.SetId(aws.StringValue(imageDetail.ImageDigest))
+	d.SetId(aws.ToString(imageDetail.ImageDigest))
 	d.Set("image_digest", imageDetail.ImageDigest)
 	d.Set("image_pushed_at", imageDetail.ImagePushedAt.Unix())
 	d.Set("image_size_in_bytes", imageDetail.ImageSizeInBytes)
-	d.Set("image_tags", aws.StringValueSlice(imageDetail.ImageTags))
-	d.Set("image_uri", fmt.Sprintf("%s@%s", aws.StringValue(repository.RepositoryUri), aws.StringValue(imageDetail.ImageDigest)))
+	d.Set("image_tags", imageDetail.ImageTags)
+	d.Set("image_uri", fmt.Sprintf("%s@%s", aws.ToString(repository.RepositoryUri), aws.ToString(imageDetail.ImageDigest)))
 	d.Set("registry_id", imageDetail.RegistryId)
 	d.Set("repository_name", imageDetail.RepositoryName)
 
 	return diags
 }
 
-func FindImageDetails(ctx context.Context, conn *ecr.ECR, input *ecr.DescribeImagesInput) ([]*ecr.ImageDetail, error) {
-	var output []*ecr.ImageDetail
+func findImageDetails(ctx context.Context, conn *ecr.Client, input *ecr.DescribeImagesInput) ([]types.ImageDetail, error) {
+	var output []types.ImageDetail
 
-	err := conn.DescribeImagesPagesWithContext(ctx, input, func(page *ecr.DescribeImagesOutput, lastPage bool) bool {
-		if page == nil {
-			return !lastPage
-		}
+	pages := ecr.NewDescribeImagesPaginator(conn, input)
+	for pages.HasMorePages() {
+		page, err := pages.NextPage(ctx)
 
-		for _, v := range page.ImageDetails {
-			if v != nil {
-				output = append(output, v)
+		if errs.IsA[*types.ImageNotFoundException](err) || errs.IsA[*types.RepositoryNotFoundException](err) {
+			return nil, &retry.NotFoundError{
+				LastError:   err,
+				LastRequest: input,
 			}
 		}
 
-		return !lastPage
-	})
-
-	if tfawserr.ErrCodeEquals(err, ecr.ErrCodeRepositoryNotFoundException) {
-		return nil, &retry.NotFoundError{
-			LastError:   err,
-			LastRequest: input,
+		if err != nil {
+			return nil, err
 		}
-	}
 
-	if err != nil {
-		return nil, err
+		output = append(output, page.ImageDetails...)
 	}
 
 	return output, nil