From d9ded12545a07449c29c92af44fc3ba96110e20e Mon Sep 17 00:00:00 2001 From: Liangquan Li Date: Fri, 4 Jul 2025 14:45:52 +0800 Subject: [PATCH 1/8] Migrate node-related code to AWS SDK v2 --- bootstrap/eks/internal/userdata/node_test.go | 2 +- pkg/cloud/scope/managednodegroup.go | 30 +++++-------------- pkg/cloud/services/awsnode/cni_test.go | 2 +- test/e2e/suites/managed/aws_node_env.go | 4 +-- test/e2e/suites/managed/cluster.go | 3 +- test/e2e/suites/managed/machine_deployment.go | 4 +-- test/e2e/suites/managed/machine_pool.go | 3 +- 7 files changed, 16 insertions(+), 32 deletions(-) diff --git a/bootstrap/eks/internal/userdata/node_test.go b/bootstrap/eks/internal/userdata/node_test.go index 0b1e6af894..a5e314c115 100644 --- a/bootstrap/eks/internal/userdata/node_test.go +++ b/bootstrap/eks/internal/userdata/node_test.go @@ -19,7 +19,7 @@ package userdata import ( "testing" - "github.com/aws/aws-sdk-go/aws" + "github.com/aws/aws-sdk-go-v2/aws" . "github.com/onsi/gomega" "github.com/onsi/gomega/format" "k8s.io/utils/ptr" diff --git a/pkg/cloud/scope/managednodegroup.go b/pkg/cloud/scope/managednodegroup.go index c23bb1d8ad..2ce1890438 100644 --- a/pkg/cloud/scope/managednodegroup.go +++ b/pkg/cloud/scope/managednodegroup.go @@ -22,7 +22,6 @@ import ( "time" awsv2 "github.com/aws/aws-sdk-go-v2/aws" - awsclient "github.com/aws/aws-sdk-go/aws/client" "github.com/pkg/errors" corev1 "k8s.io/api/core/v1" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" @@ -54,7 +53,7 @@ type ManagedMachinePoolScopeParams struct { MachinePool *expclusterv1.MachinePool ControllerName string Endpoints []ServiceEndpoint - Session awsclient.ConfigProvider + Session awsv2.Config MaxWaitActiveUpdateDelete time.Duration EnableIAM bool @@ -88,10 +87,6 @@ func NewManagedMachinePoolScope(params ManagedMachinePoolScopeParams) (*ManagedM ControlPlane: params.ControlPlane, controllerName: params.ControllerName, } - session, serviceLimiters, err := sessionForClusterWithRegion(params.Client, managedScope, params.ControlPlane.Spec.Region, params.Endpoints, params.Logger) - if err != nil { - return nil, errors.Errorf("failed to create aws session: %v", err) - } sessionv2, serviceLimitersv2, err := sessionForClusterWithRegionV2(params.Client, managedScope, params.ControlPlane.Spec.Region, params.Endpoints, params.Logger) if err != nil { @@ -119,10 +114,8 @@ func NewManagedMachinePoolScope(params ManagedMachinePoolScopeParams) (*ManagedM MachinePool: params.MachinePool, MaxWaitActiveUpdateDelete: params.MaxWaitActiveUpdateDelete, EC2Scope: params.InfraCluster, - session: session, - sessionV2: *sessionv2, - serviceLimiters: serviceLimiters, - serviceLimitersV2: serviceLimitersv2, + session: *sessionv2, + serviceLimiters: serviceLimitersv2, controllerName: params.ControllerName, enableIAM: params.EnableIAM, allowAdditionalRoles: params.AllowAdditionalRoles, @@ -143,11 +136,9 @@ type ManagedMachinePoolScope struct { EC2Scope EC2Scope MaxWaitActiveUpdateDelete time.Duration - session awsclient.ConfigProvider - sessionV2 awsv2.Config - serviceLimiters throttle.ServiceLimiters - serviceLimitersV2 throttle.ServiceLimiters - controllerName string + session awsv2.Config + serviceLimiters throttle.ServiceLimiters + controllerName string enableIAM bool allowAdditionalRoles bool @@ -311,16 +302,11 @@ func (s *ManagedMachinePoolScope) ClusterObj() cloud.ClusterObject { return s.Cluster } -// Session returns the AWS SDK session. Used for creating clients. -func (s *ManagedMachinePoolScope) Session() awsclient.ConfigProvider { +// Session returns the AWS SDK V2 config. Used for creating clients. +func (s *ManagedMachinePoolScope) Session() awsv2.Config { return s.session } -// SessionV2 returns the AWS SDK V2 config. Used for creating clients. -func (s *ManagedMachinePoolScope) SessionV2() awsv2.Config { - return s.sessionV2 -} - // ControllerName returns the name of the controller that // created the ManagedMachinePool. func (s *ManagedMachinePoolScope) ControllerName() string { diff --git a/pkg/cloud/services/awsnode/cni_test.go b/pkg/cloud/services/awsnode/cni_test.go index 67c78d806b..ff08781e6b 100644 --- a/pkg/cloud/services/awsnode/cni_test.go +++ b/pkg/cloud/services/awsnode/cni_test.go @@ -21,7 +21,7 @@ import ( "testing" "github.com/aws/amazon-vpc-cni-k8s/pkg/apis/crd/v1alpha1" - "github.com/aws/aws-sdk-go/aws" + "github.com/aws/aws-sdk-go-v2/aws" "github.com/golang/mock/gomock" . "github.com/onsi/gomega" v1 "k8s.io/api/apps/v1" diff --git a/test/e2e/suites/managed/aws_node_env.go b/test/e2e/suites/managed/aws_node_env.go index 90685dba7d..09b71b1892 100644 --- a/test/e2e/suites/managed/aws_node_env.go +++ b/test/e2e/suites/managed/aws_node_env.go @@ -24,7 +24,7 @@ import ( "errors" "fmt" - "github.com/aws/aws-sdk-go/aws/client" + "github.com/aws/aws-sdk-go-v2/aws" . "github.com/onsi/ginkgo/v2" . "github.com/onsi/gomega" appsv1 "k8s.io/api/apps/v1" @@ -39,7 +39,7 @@ import ( type UpdateAwsNodeVersionSpecInput struct { E2EConfig *clusterctl.E2EConfig BootstrapClusterProxy framework.ClusterProxy - AWSSession client.ConfigProvider + AWSSession aws.Config Namespace *corev1.Namespace ClusterName string } diff --git a/test/e2e/suites/managed/cluster.go b/test/e2e/suites/managed/cluster.go index e0d70706bd..7994be269c 100644 --- a/test/e2e/suites/managed/cluster.go +++ b/test/e2e/suites/managed/cluster.go @@ -26,7 +26,6 @@ import ( "time" "github.com/aws/aws-sdk-go-v2/aws" - "github.com/aws/aws-sdk-go/aws/client" "github.com/onsi/ginkgo/v2" . "github.com/onsi/gomega" corev1 "k8s.io/api/core/v1" @@ -44,7 +43,7 @@ type ManagedClusterSpecInput struct { E2EConfig *clusterctl.E2EConfig ConfigClusterFn DefaultConfigClusterFn BootstrapClusterProxy framework.ClusterProxy - AWSSession client.ConfigProvider + AWSSession aws.Config AWSSessionV2 *aws.Config Namespace *corev1.Namespace ClusterName string diff --git a/test/e2e/suites/managed/machine_deployment.go b/test/e2e/suites/managed/machine_deployment.go index 79d26d3355..bc7f0f06a3 100644 --- a/test/e2e/suites/managed/machine_deployment.go +++ b/test/e2e/suites/managed/machine_deployment.go @@ -23,7 +23,7 @@ import ( "context" "fmt" - "github.com/aws/aws-sdk-go/aws/client" + "github.com/aws/aws-sdk-go-v2/aws" . "github.com/onsi/ginkgo/v2" . "github.com/onsi/gomega" corev1 "k8s.io/api/core/v1" @@ -40,7 +40,7 @@ type MachineDeploymentSpecInput struct { E2EConfig *clusterctl.E2EConfig ConfigClusterFn DefaultConfigClusterFn BootstrapClusterProxy framework.ClusterProxy - AWSSession client.ConfigProvider + AWSSession aws.Config Namespace *corev1.Namespace Replicas int64 ClusterName string diff --git a/test/e2e/suites/managed/machine_pool.go b/test/e2e/suites/managed/machine_pool.go index 8078aaa48d..bbad25b6f5 100644 --- a/test/e2e/suites/managed/machine_pool.go +++ b/test/e2e/suites/managed/machine_pool.go @@ -26,7 +26,6 @@ import ( "strings" "github.com/aws/aws-sdk-go-v2/aws" - "github.com/aws/aws-sdk-go/aws/client" "github.com/onsi/ginkgo/v2" . "github.com/onsi/gomega" corev1 "k8s.io/api/core/v1" @@ -42,7 +41,7 @@ type MachinePoolSpecInput struct { E2EConfig *clusterctl.E2EConfig ConfigClusterFn DefaultConfigClusterFn BootstrapClusterProxy framework.ClusterProxy - AWSSession client.ConfigProvider + AWSSession aws.Config AWSSessionV2 *aws.Config Namespace *corev1.Namespace ClusterName string From 35e6953b68d0bb9295843225d2f397b5d967e941 Mon Sep 17 00:00:00 2001 From: Liangquan Li Date: Fri, 4 Jul 2025 16:58:26 +0800 Subject: [PATCH 2/8] remove Session() awsclient.ConfigProvider --- pkg/cloud/interfaces.go | 4 +- pkg/cloud/scope/clients.go | 58 ++++----- pkg/cloud/scope/cluster.go | 17 +-- pkg/cloud/scope/fargate.go | 17 +-- pkg/cloud/scope/global.go | 18 +-- pkg/cloud/scope/managedcontrolplane.go | 17 ++- pkg/cloud/scope/rosacontrolplane.go | 18 +-- pkg/cloud/scope/rosamachinepool.go | 19 +-- .../gomock_reflect_2588283099/prog.go | 66 +++++++++++ pkg/cloud/services/secretsmanager/secret.go | 23 ++-- pkg/cloud/services/secretsmanager/service.go | 4 +- .../ssm/mock_ssmiface/ssmiface_mock.go | 112 ++++++++++++++++++ test/mocks/capa_clusterscoper_mock.go | 21 +--- 13 files changed, 260 insertions(+), 134 deletions(-) create mode 100644 pkg/cloud/services/mock_services/gomock_reflect_2588283099/prog.go create mode 100644 pkg/cloud/services/ssm/mock_ssmiface/ssmiface_mock.go diff --git a/pkg/cloud/interfaces.go b/pkg/cloud/interfaces.go index 4fd9be6f04..82c671e2c1 100644 --- a/pkg/cloud/interfaces.go +++ b/pkg/cloud/interfaces.go @@ -21,7 +21,6 @@ import ( "time" awsv2 "github.com/aws/aws-sdk-go-v2/aws" - awsclient "github.com/aws/aws-sdk-go/aws/client" "k8s.io/apimachinery/pkg/apis/meta/v1/unstructured" "sigs.k8s.io/controller-runtime/pkg/client" @@ -34,8 +33,7 @@ import ( // Session represents an AWS session. type Session interface { - Session() awsclient.ConfigProvider - SessionV2() awsv2.Config + Session() awsv2.Config ServiceLimiter(service string) *throttle.ServiceLimiter } diff --git a/pkg/cloud/scope/clients.go b/pkg/cloud/scope/clients.go index d00123b966..b5285c29ef 100644 --- a/pkg/cloud/scope/clients.go +++ b/pkg/cloud/scope/clients.go @@ -26,20 +26,17 @@ import ( "github.com/aws/aws-sdk-go-v2/service/iam" rgapi "github.com/aws/aws-sdk-go-v2/service/resourcegroupstaggingapi" "github.com/aws/aws-sdk-go-v2/service/s3" + "github.com/aws/aws-sdk-go-v2/service/secretsmanager" "github.com/aws/aws-sdk-go-v2/service/sqs" "github.com/aws/aws-sdk-go-v2/service/ssm" stsv2 "github.com/aws/aws-sdk-go-v2/service/sts" - "github.com/aws/aws-sdk-go/aws" "github.com/aws/aws-sdk-go/aws/awserr" "github.com/aws/aws-sdk-go/aws/request" - "github.com/aws/aws-sdk-go/service/secretsmanager" - "github.com/aws/aws-sdk-go/service/secretsmanager/secretsmanageriface" "k8s.io/apimachinery/pkg/runtime" "sigs.k8s.io/cluster-api-provider-aws/v2/pkg/cloud" "sigs.k8s.io/cluster-api-provider-aws/v2/pkg/cloud/endpointsv2" awslogs "sigs.k8s.io/cluster-api-provider-aws/v2/pkg/cloud/logs" - awsmetrics "sigs.k8s.io/cluster-api-provider-aws/v2/pkg/cloud/metrics" awsmetricsv2 "sigs.k8s.io/cluster-api-provider-aws/v2/pkg/cloud/metricsv2" stsservice "sigs.k8s.io/cluster-api-provider-aws/v2/pkg/cloud/services/sts" "sigs.k8s.io/cluster-api-provider-aws/v2/pkg/cloud/throttle" @@ -50,7 +47,7 @@ import ( // NewASGClient creates a new ASG API client for a given session. func NewASGClient(scopeUser cloud.ScopeUsage, session cloud.Session, logger logger.Wrapper, target runtime.Object) *autoscaling.Client { - cfg := session.SessionV2() + cfg := session.Session() autoscalingOpts := []func(*autoscaling.Options){ func(o *autoscaling.Options) { @@ -68,7 +65,7 @@ func NewASGClient(scopeUser cloud.ScopeUsage, session cloud.Session, logger logg // NewEC2Client creates a new EC2 API client for a given session. func NewEC2Client(scopeUser cloud.ScopeUsage, session cloud.Session, logger logger.Wrapper, target runtime.Object) *ec2.Client { - cfg := session.SessionV2() + cfg := session.Session() multiSvcEndpointResolver := endpointsv2.NewMultiServiceEndpointResolver() ec2EndpointResolver := &endpointsv2.EC2EndpointResolver{ MultiServiceEndpointResolver: multiSvcEndpointResolver, @@ -92,7 +89,7 @@ func NewEC2Client(scopeUser cloud.ScopeUsage, session cloud.Session, logger logg // NewELBClient creates a new ELB API client for a given session. func NewELBClient(scopeUser cloud.ScopeUsage, session cloud.Session, logger logger.Wrapper, target runtime.Object) *elb.Client { - cfg := session.SessionV2() + cfg := session.Session() multiSvcEndpointResolver := endpointsv2.NewMultiServiceEndpointResolver() endpointResolver := &endpointsv2.ELBEndpointResolver{ MultiServiceEndpointResolver: multiSvcEndpointResolver, @@ -116,7 +113,7 @@ func NewELBClient(scopeUser cloud.ScopeUsage, session cloud.Session, logger logg // NewELBv2Client creates a new ELB v2 API client for a given session. func NewELBv2Client(scopeUser cloud.ScopeUsage, session cloud.Session, logger logger.Wrapper, target runtime.Object) *elbv2.Client { - cfg := session.SessionV2() + cfg := session.Session() multiSvcEndpointResolver := endpointsv2.NewMultiServiceEndpointResolver() endpointResolver := &endpointsv2.ELBV2EndpointResolver{ MultiServiceEndpointResolver: multiSvcEndpointResolver, @@ -140,7 +137,7 @@ func NewELBv2Client(scopeUser cloud.ScopeUsage, session cloud.Session, logger lo // NewEventBridgeClient creates a new EventBridge API client for a given session. func NewEventBridgeClient(scopeUser cloud.ScopeUsage, session cloud.Session, target runtime.Object) *eventbridge.Client { - cfg := session.SessionV2() + cfg := session.Session() multiSvcEndpointResolver := endpointsv2.NewMultiServiceEndpointResolver() endpointResolver := &endpointsv2.EventBridgeEndpointResolver{ MultiServiceEndpointResolver: multiSvcEndpointResolver, @@ -161,7 +158,7 @@ func NewEventBridgeClient(scopeUser cloud.ScopeUsage, session cloud.Session, tar // NewSQSClient creates a new SQS API client for a given session. func NewSQSClient(scopeUser cloud.ScopeUsage, session cloud.Session, target runtime.Object) *sqs.Client { - cfg := session.SessionV2() + cfg := session.Session() multiSvcEndpointResolver := endpointsv2.NewMultiServiceEndpointResolver() endpointResolver := &endpointsv2.SQSEndpointResolver{ MultiServiceEndpointResolver: multiSvcEndpointResolver, @@ -182,7 +179,7 @@ func NewSQSClient(scopeUser cloud.ScopeUsage, session cloud.Session, target runt // NewGlobalSQSClient for creating a new SQS API client that isn't tied to a cluster. func NewGlobalSQSClient(scopeUser cloud.ScopeUsage, session cloud.Session) *sqs.Client { - cfg := session.SessionV2() + cfg := session.Session() multiSvcEndpointResolver := endpointsv2.NewMultiServiceEndpointResolver() endpointResolver := &endpointsv2.SQSEndpointResolver{ MultiServiceEndpointResolver: multiSvcEndpointResolver, @@ -203,7 +200,7 @@ func NewGlobalSQSClient(scopeUser cloud.ScopeUsage, session cloud.Session) *sqs. // NewResourgeTaggingClient creates a new Resource Tagging API client for a given session. func NewResourgeTaggingClient(scopeUser cloud.ScopeUsage, session cloud.Session, logger logger.Wrapper, target runtime.Object) *rgapi.Client { - cfg := session.SessionV2() + cfg := session.Session() multiSvcEndpointResolver := endpointsv2.NewMultiServiceEndpointResolver() endpointResolver := &endpointsv2.RGAPIEndpointResolver{ MultiServiceEndpointResolver: multiSvcEndpointResolver, @@ -222,20 +219,27 @@ func NewResourgeTaggingClient(scopeUser cloud.ScopeUsage, session cloud.Session, } // NewSecretsManagerClient creates a new Secrets API client for a given session.. -func NewSecretsManagerClient(scopeUser cloud.ScopeUsage, session cloud.Session, logger logger.Wrapper, target runtime.Object) secretsmanageriface.SecretsManagerAPI { - secretsClient := secretsmanager.New(session.Session(), aws.NewConfig().WithLogLevel(awslogs.GetAWSLogLevel(logger.GetLogger())).WithLogger(awslogs.NewWrapLogr(logger.GetLogger()))) - secretsClient.Handlers.Build.PushFrontNamed(getUserAgentHandler()) - secretsClient.Handlers.Sign.PushFront(session.ServiceLimiter(secretsClient.ServiceID).LimitRequest) - secretsClient.Handlers.CompleteAttempt.PushFront(awsmetrics.CaptureRequestMetrics(scopeUser.ControllerName())) - secretsClient.Handlers.CompleteAttempt.PushFront(session.ServiceLimiter(secretsClient.ServiceID).ReviewResponse) - secretsClient.Handlers.Complete.PushBack(recordAWSPermissionsIssue(target)) - - return secretsClient +func NewSecretsManagerClient(scopeUser cloud.ScopeUsage, session cloud.Session, logger logger.Wrapper, target runtime.Object) *secretsmanager.Client { + cfg := session.Session() + + secretsOpts := []func(*secretsmanager.Options){ + func(o *secretsmanager.Options) { + o.Logger = logger.GetAWSLogger() + o.ClientLogMode = awslogs.GetAWSLogLevelV2(logger.GetLogger()) + }, + secretsmanager.WithAPIOptions( + awsmetricsv2.WithMiddlewares(scopeUser.ControllerName(), target), + awsmetricsv2.WithCAPAUserAgentMiddleware(), + throttle.WithServiceLimiterMiddleware(session.ServiceLimiter(secretsmanager.ServiceID)), + ), + } + + return secretsmanager.NewFromConfig(cfg, secretsOpts...) } // NewEKSClient creates a new EKS API client for a given session. func NewEKSClient(scopeUser cloud.ScopeUsage, session cloud.Session, logger logger.Wrapper, target runtime.Object) *eks.Client { - cfg := session.SessionV2() + cfg := session.Session() multiSvcEndpointResolver := endpointsv2.NewMultiServiceEndpointResolver() eksEndpointResolver := &endpointsv2.EKSEndpointResolver{ MultiServiceEndpointResolver: multiSvcEndpointResolver, @@ -253,7 +257,7 @@ func NewEKSClient(scopeUser cloud.ScopeUsage, session cloud.Session, logger logg // NewIAMClient creates a new IAM API client for a given session. func NewIAMClient(scopeUser cloud.ScopeUsage, session cloud.Session, logger logger.Wrapper, target runtime.Object) *iam.Client { - cfg := session.SessionV2() + cfg := session.Session() iamOpts := []func(*iam.Options){ func(o *iam.Options) { @@ -271,7 +275,7 @@ func NewIAMClient(scopeUser cloud.ScopeUsage, session cloud.Session, logger logg // NewSTSClient creates a new STS API client for a given session. func NewSTSClient(scopeUser cloud.ScopeUsage, session cloud.Session, logger logger.Wrapper, target runtime.Object) stsservice.STSClient { - cfg := session.SessionV2() + cfg := session.Session() multiSvcEndpointResolver := endpointsv2.NewMultiServiceEndpointResolver() stsEndpointResolver := &endpointsv2.STSEndpointResolver{ MultiServiceEndpointResolver: multiSvcEndpointResolver, @@ -294,7 +298,7 @@ func NewSTSClient(scopeUser cloud.ScopeUsage, session cloud.Session, logger logg // NewSSMClient creates a new Secrets API client for a given session. func NewSSMClient(scopeUser cloud.ScopeUsage, session cloud.Session, logger logger.Wrapper, target runtime.Object) *ssm.Client { - cfg := session.SessionV2() + cfg := session.Session() multiSvcEndpointResolver := endpointsv2.NewMultiServiceEndpointResolver() ssmEndpointResolver := &endpointsv2.SSMEndpointResolver{ MultiServiceEndpointResolver: multiSvcEndpointResolver, @@ -316,7 +320,7 @@ func NewSSMClient(scopeUser cloud.ScopeUsage, session cloud.Session, logger logg // NewS3Client creates a new S3 API client for a given session. func NewS3Client(scopeUser cloud.ScopeUsage, session cloud.Session, logger logger.Wrapper, target runtime.Object) *s3.Client { - cfg := session.SessionV2() + cfg := session.Session() multiSvcEndpointResolver := endpointsv2.NewMultiServiceEndpointResolver() s3EndpointResolver := &endpointsv2.S3EndpointResolver{ MultiServiceEndpointResolver: multiSvcEndpointResolver, @@ -353,7 +357,7 @@ func getUserAgentHandler() request.NamedHandler { // AWSClients contains all the aws clients used by the scopes. type AWSClients struct { ELB *elb.Client - SecretsManager secretsmanageriface.SecretsManagerAPI + SecretsManager *secretsmanager.Client ResourceTagging *rgapi.Client ASG *autoscaling.Client EC2 *ec2.Client diff --git a/pkg/cloud/scope/cluster.go b/pkg/cloud/scope/cluster.go index 5bb9873d9c..04f8942d2d 100644 --- a/pkg/cloud/scope/cluster.go +++ b/pkg/cloud/scope/cluster.go @@ -77,7 +77,7 @@ func NewClusterScope(params ClusterScopeParams) (*ClusterScope, error) { maxWaitActiveUpdateDelete: params.MaxWaitActiveUpdateDelete, } - session, serviceLimiters, err := sessionForClusterWithRegion(params.Client, clusterScope, params.AWSCluster.Spec.Region, params.Endpoints, params.Logger) + _, serviceLimiters, err := sessionForClusterWithRegion(params.Client, clusterScope, params.AWSCluster.Spec.Region, params.Endpoints, params.Logger) if err != nil { return nil, errors.Errorf("failed to create aws session: %v", err) } @@ -93,8 +93,7 @@ func NewClusterScope(params ClusterScopeParams) (*ClusterScope, error) { } clusterScope.patchHelper = helper - clusterScope.session = session - clusterScope.sessionV2 = *sessionv2 + clusterScope.session = *sessionv2 clusterScope.serviceLimiters = serviceLimiters clusterScope.serviceLimitersV2 = serviceLimitersv2 @@ -110,8 +109,7 @@ type ClusterScope struct { Cluster *clusterv1.Cluster AWSCluster *infrav1.AWSCluster - session awsclient.ConfigProvider - sessionV2 awsv2.Config + session awsv2.Config serviceLimiters throttle.ServiceLimiters serviceLimitersV2 throttle.ServiceLimiters controllerName string @@ -361,16 +359,11 @@ func (s *ClusterScope) ClusterObj() cloud.ClusterObject { return s.Cluster } -// Session returns the AWS SDK session. Used for creating clients. -func (s *ClusterScope) Session() awsclient.ConfigProvider { +// Session returns the AWS SDK V2 session. Used for creating clients. +func (s *ClusterScope) Session() awsv2.Config { return s.session } -// SessionV2 returns the AWS SDK V2 session. Used for creating clients. -func (s *ClusterScope) SessionV2() awsv2.Config { - return s.sessionV2 -} - // ServiceLimiter returns the AWS SDK session. Used for creating clients. func (s *ClusterScope) ServiceLimiter(service string) *throttle.ServiceLimiter { if sl, ok := s.serviceLimiters[service]; ok { diff --git a/pkg/cloud/scope/fargate.go b/pkg/cloud/scope/fargate.go index d70a518b7b..1e5d424a5a 100644 --- a/pkg/cloud/scope/fargate.go +++ b/pkg/cloud/scope/fargate.go @@ -70,7 +70,7 @@ func NewFargateProfileScope(params FargateProfileScopeParams) (*FargateProfileSc controllerName: params.ControllerName, } - session, serviceLimiters, err := sessionForClusterWithRegion(params.Client, managedScope, params.ControlPlane.Spec.Region, params.Endpoints, params.Logger) + _, serviceLimiters, err := sessionForClusterWithRegion(params.Client, managedScope, params.ControlPlane.Spec.Region, params.Endpoints, params.Logger) if err != nil { return nil, errors.Errorf("failed to create aws session: %v", err) } @@ -92,8 +92,7 @@ func NewFargateProfileScope(params FargateProfileScopeParams) (*FargateProfileSc ControlPlane: params.ControlPlane, FargateProfile: params.FargateProfile, patchHelper: helper, - session: session, - sessionV2: *sessionv2, + session: *sessionv2, serviceLimiters: serviceLimiters, serviceLimitersV2: serviceLimitersv2, controllerName: params.ControllerName, @@ -111,8 +110,7 @@ type FargateProfileScope struct { ControlPlane *ekscontrolplanev1.AWSManagedControlPlane FargateProfile *expinfrav1.AWSFargateProfile - session awsclient.ConfigProvider - sessionV2 awsv2.Config + session awsv2.Config serviceLimiters throttle.ServiceLimiters serviceLimitersV2 throttle.ServiceLimiters controllerName string @@ -225,16 +223,11 @@ func (s *FargateProfileScope) ClusterObj() cloud.ClusterObject { return s.Cluster } -// Session returns the AWS SDK session. Used for creating clients. -func (s *FargateProfileScope) Session() awsclient.ConfigProvider { +// Session returns the AWS SDK V2 session. Used for creating clients. +func (s *FargateProfileScope) Session() awsv2.Config { return s.session } -// SessionV2 returns the AWS SDK session. Used for creating clients. -func (s *FargateProfileScope) SessionV2() awsv2.Config { - return s.sessionV2 -} - // ControllerName returns the name of the controller that // created the FargateProfile. func (s *FargateProfileScope) ControllerName() string { diff --git a/pkg/cloud/scope/global.go b/pkg/cloud/scope/global.go index 842dfb321d..dc084ab717 100644 --- a/pkg/cloud/scope/global.go +++ b/pkg/cloud/scope/global.go @@ -19,7 +19,6 @@ package scope import ( awsv2 "github.com/aws/aws-sdk-go-v2/aws" - awsclient "github.com/aws/aws-sdk-go/aws/client" "github.com/pkg/errors" "sigs.k8s.io/cluster-api-provider-aws/v2/pkg/cloud/throttle" @@ -33,7 +32,7 @@ func NewGlobalScope(params GlobalScopeParams) (*GlobalScope, error) { if params.ControllerName == "" { return nil, errors.New("controller name required to generate global scope") } - ns, limiters, err := sessionForRegion(params.Region, params.Endpoints) + _, limiters, err := sessionForRegion(params.Region, params.Endpoints) if err != nil { return nil, errors.Wrap(err, "failed to create aws session") } @@ -43,8 +42,7 @@ func NewGlobalScope(params GlobalScopeParams) (*GlobalScope, error) { return nil, errors.Wrap(err, "failed to create aws V2 session") } return &GlobalScope{ - session: ns, - sessionV2: *ns2, + session: *ns2, serviceLimiters: limiters, controllerName: params.ControllerName, }, nil @@ -59,22 +57,16 @@ type GlobalScopeParams struct { // GlobalScope defines the specs for the GlobalScope. type GlobalScope struct { - session awsclient.ConfigProvider - sessionV2 awsv2.Config + session awsv2.Config serviceLimiters throttle.ServiceLimiters controllerName string } -// Session returns the AWS SDK session. Used for creating clients. -func (s *GlobalScope) Session() awsclient.ConfigProvider { +// Session returns the AWS SDK V2 config. Used for creating clients. +func (s *GlobalScope) Session() awsv2.Config { return s.session } -// SessionV2 returns the AWS SDK V2 config. Used for creating clients. -func (s *GlobalScope) SessionV2() awsv2.Config { - return s.sessionV2 -} - // ServiceLimiter returns the AWS SDK session. Used for creating clients. func (s *GlobalScope) ServiceLimiter(service string) *throttle.ServiceLimiter { if sl, ok := s.serviceLimiters[service]; ok { diff --git a/pkg/cloud/scope/managedcontrolplane.go b/pkg/cloud/scope/managedcontrolplane.go index f6335c381f..803a2cfe74 100644 --- a/pkg/cloud/scope/managedcontrolplane.go +++ b/pkg/cloud/scope/managedcontrolplane.go @@ -92,14 +92,13 @@ func NewManagedControlPlaneScope(params ManagedControlPlaneScopeParams) (*Manage ControlPlane: params.ControlPlane, MaxWaitActiveUpdateDelete: params.MaxWaitActiveUpdateDelete, patchHelper: nil, - session: nil, serviceLimiters: nil, controllerName: params.ControllerName, allowAdditionalRoles: params.AllowAdditionalRoles, enableIAM: params.EnableIAM, tagUnmanagedNetworkResources: params.TagUnmanagedNetworkResources, } - session, serviceLimiters, err := sessionForClusterWithRegion(params.Client, managedScope, params.ControlPlane.Spec.Region, params.Endpoints, params.Logger) + _, serviceLimiters, err := sessionForClusterWithRegion(params.Client, managedScope, params.ControlPlane.Spec.Region, params.Endpoints, params.Logger) if err != nil { return nil, errors.Errorf("failed to create aws session: %v", err) } @@ -109,8 +108,7 @@ func NewManagedControlPlaneScope(params ManagedControlPlaneScopeParams) (*Manage return nil, errors.Errorf("failed to create aws V2 session: %v", err) } - managedScope.session = session - managedScope.sessionV2 = *sessionv2 + managedScope.session = *sessionv2 managedScope.serviceLimiters = serviceLimiters managedScope.serviceLimitersV2 = serviceLimitersv2 @@ -133,8 +131,7 @@ type ManagedControlPlaneScope struct { ControlPlane *ekscontrolplanev1.AWSManagedControlPlane MaxWaitActiveUpdateDelete time.Duration - session awsclient.ConfigProvider - sessionV2 awsv2.Config + session awsv2.Config serviceLimiters throttle.ServiceLimiters serviceLimitersV2 throttle.ServiceLimiters controllerName string @@ -334,14 +331,14 @@ func (s *ManagedControlPlaneScope) ClusterObj() cloud.ClusterObject { return s.Cluster } -// Session returns the AWS SDK session. Used for creating clients. -func (s *ManagedControlPlaneScope) Session() awsclient.ConfigProvider { +// Session returns the AWS SDK V2 config. Used for creating clients. +func (s *ManagedControlPlaneScope) Session() awsv2.Config { return s.session } -// SessionV2 returns the AWS SDK config. Used for creating clients. +// SessionV2 returns the AWS SDK V2 config. Used for creating clients. func (s *ManagedControlPlaneScope) SessionV2() awsv2.Config { - return s.sessionV2 + return s.session } // Bastion returns the bastion details. diff --git a/pkg/cloud/scope/rosacontrolplane.go b/pkg/cloud/scope/rosacontrolplane.go index f2d781cdf9..2e20c4c352 100644 --- a/pkg/cloud/scope/rosacontrolplane.go +++ b/pkg/cloud/scope/rosacontrolplane.go @@ -22,7 +22,6 @@ import ( awsv2 "github.com/aws/aws-sdk-go-v2/aws" stsv2 "github.com/aws/aws-sdk-go-v2/service/sts" - awsclient "github.com/aws/aws-sdk-go/aws/client" "github.com/pkg/errors" corev1 "k8s.io/api/core/v1" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" @@ -73,7 +72,7 @@ func NewROSAControlPlaneScope(params ROSAControlPlaneScopeParams) (*ROSAControlP controllerName: params.ControllerName, } - session, serviceLimiters, err := sessionForClusterWithRegion(params.Client, managedScope, params.ControlPlane.Spec.Region, params.Endpoints, params.Logger) + _, serviceLimiters, err := sessionForClusterWithRegion(params.Client, managedScope, params.ControlPlane.Spec.Region, params.Endpoints, params.Logger) if err != nil { return nil, errors.Errorf("failed to create aws session: %v", err) } @@ -89,8 +88,7 @@ func NewROSAControlPlaneScope(params ROSAControlPlaneScopeParams) (*ROSAControlP } managedScope.patchHelper = helper - managedScope.session = session - managedScope.sessionV2 = *sessionv2 + managedScope.session = *sessionv2 managedScope.serviceLimiters = serviceLimiters managedScope.serviceLimitersV2 = serviceLimitersv2 @@ -113,8 +111,7 @@ type ROSAControlPlaneScope struct { Cluster *clusterv1.Cluster ControlPlane *rosacontrolplanev1.ROSAControlPlane - session awsclient.ConfigProvider - sessionV2 awsv2.Config + session awsv2.Config serviceLimiters throttle.ServiceLimiters serviceLimitersV2 throttle.ServiceLimiters controllerName string @@ -131,16 +128,11 @@ func (s *ROSAControlPlaneScope) IdentityRef() *infrav1.AWSIdentityReference { return s.ControlPlane.Spec.IdentityRef } -// Session returns the AWS SDK session. Used for creating clients. -func (s *ROSAControlPlaneScope) Session() awsclient.ConfigProvider { +// Session returns the AWS SDK V2 session. Used for creating clients. +func (s *ROSAControlPlaneScope) Session() awsv2.Config { return s.session } -// SessionV2 returns the AWS SDK V2 Config. Used for creating clients. -func (s *ROSAControlPlaneScope) SessionV2() awsv2.Config { - return s.sessionV2 -} - // ServiceLimiter returns the AWS SDK session. Used for creating clients. func (s *ROSAControlPlaneScope) ServiceLimiter(service string) *throttle.ServiceLimiter { if sl, ok := s.serviceLimiters[service]; ok { diff --git a/pkg/cloud/scope/rosamachinepool.go b/pkg/cloud/scope/rosamachinepool.go index 9155bc450d..8ae0114ba1 100644 --- a/pkg/cloud/scope/rosamachinepool.go +++ b/pkg/cloud/scope/rosamachinepool.go @@ -20,7 +20,6 @@ import ( "context" awsv2 "github.com/aws/aws-sdk-go-v2/aws" - awsclient "github.com/aws/aws-sdk-go/aws/client" "github.com/pkg/errors" "k8s.io/klog/v2" "sigs.k8s.io/controller-runtime/pkg/client" @@ -89,7 +88,7 @@ func NewRosaMachinePoolScope(params RosaMachinePoolScopeParams) (*RosaMachinePoo controllerName: params.ControllerName, } - session, serviceLimiters, err := sessionForClusterWithRegion(params.Client, scope, params.ControlPlane.Spec.Region, params.Endpoints, params.Logger) + _, serviceLimiters, err := sessionForClusterWithRegion(params.Client, scope, params.ControlPlane.Spec.Region, params.Endpoints, params.Logger) if err != nil { return nil, errors.Errorf("failed to create aws session: %v", err) } @@ -99,15 +98,13 @@ func NewRosaMachinePoolScope(params RosaMachinePoolScopeParams) (*RosaMachinePoo return nil, errors.Errorf("failed to create aws V2 session: %v", err) } - scope.session = session - scope.sessionV2 = *sessionv2 + scope.session = *sessionv2 scope.serviceLimiters = serviceLimiters scope.serviceLimitersV2 = serviceLimitersv2 return scope, nil } -var _ cloud.Session = &RosaMachinePoolScope{} var _ cloud.SessionMetadata = &RosaMachinePoolScope{} // RosaMachinePoolScope defines the basic context for an actuator to operate upon. @@ -122,8 +119,7 @@ type RosaMachinePoolScope struct { RosaMachinePool *expinfrav1.ROSAMachinePool MachinePool *expclusterv1.MachinePool - session awsclient.ConfigProvider - sessionV2 awsv2.Config + session awsv2.Config serviceLimiters throttle.ServiceLimiters serviceLimitersV2 throttle.ServiceLimiters @@ -179,16 +175,11 @@ func (s *RosaMachinePoolScope) ServiceLimiter(service string) *throttle.ServiceL return nil } -// Session implements cloud.Session. -func (s *RosaMachinePoolScope) Session() awsclient.ConfigProvider { +// Session implements cloud.Session for AWS SDK V2. +func (s *RosaMachinePoolScope) Session() awsv2.Config { return s.session } -// SessionV2 implements cloud.Session for AWS SDK V2. -func (s *RosaMachinePoolScope) SessionV2() awsv2.Config { - return s.sessionV2 -} - // IdentityRef implements cloud.SessionMetadata. func (s *RosaMachinePoolScope) IdentityRef() *v1beta2.AWSIdentityReference { return s.ControlPlane.Spec.IdentityRef diff --git a/pkg/cloud/services/mock_services/gomock_reflect_2588283099/prog.go b/pkg/cloud/services/mock_services/gomock_reflect_2588283099/prog.go new file mode 100644 index 0000000000..3b5e87d123 --- /dev/null +++ b/pkg/cloud/services/mock_services/gomock_reflect_2588283099/prog.go @@ -0,0 +1,66 @@ + +package main + +import ( + "encoding/gob" + "flag" + "fmt" + "os" + "path" + "reflect" + + "github.com/golang/mock/mockgen/model" + + pkg_ "sigs.k8s.io/cluster-api-provider-aws/v2/pkg/cloud/services" +) + +var output = flag.String("output", "", "The output file name, or empty to use stdout.") + +func main() { + flag.Parse() + + its := []struct{ + sym string + typ reflect.Type + }{ + + { "ELBInterface", reflect.TypeOf((*pkg_.ELBInterface)(nil)).Elem()}, + + } + pkg := &model.Package{ + // NOTE: This behaves contrary to documented behaviour if the + // package name is not the final component of the import path. + // The reflect package doesn't expose the package name, though. + Name: path.Base("sigs.k8s.io/cluster-api-provider-aws/v2/pkg/cloud/services"), + } + + for _, it := range its { + intf, err := model.InterfaceFromInterfaceType(it.typ) + if err != nil { + fmt.Fprintf(os.Stderr, "Reflection: %v\n", err) + os.Exit(1) + } + intf.Name = it.sym + pkg.Interfaces = append(pkg.Interfaces, intf) + } + + outfile := os.Stdout + if len(*output) != 0 { + var err error + outfile, err = os.Create(*output) + if err != nil { + fmt.Fprintf(os.Stderr, "failed to open output file %q", *output) + } + defer func() { + if err := outfile.Close(); err != nil { + fmt.Fprintf(os.Stderr, "failed to close output file %q", *output) + os.Exit(1) + } + }() + } + + if err := gob.NewEncoder(outfile).Encode(pkg); err != nil { + fmt.Fprintf(os.Stderr, "gob encode: %v\n", err) + os.Exit(1) + } +} diff --git a/pkg/cloud/services/secretsmanager/secret.go b/pkg/cloud/services/secretsmanager/secret.go index bc72aa084a..08ff8522a0 100644 --- a/pkg/cloud/services/secretsmanager/secret.go +++ b/pkg/cloud/services/secretsmanager/secret.go @@ -17,17 +17,18 @@ limitations under the License. package secretsmanager import ( + "context" "fmt" "path" - "github.com/aws/aws-sdk-go/aws" - "github.com/aws/aws-sdk-go/service/secretsmanager" + "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/service/secretsmanager" kerrors "k8s.io/apimachinery/pkg/util/errors" "k8s.io/apimachinery/pkg/util/uuid" infrav1 "sigs.k8s.io/cluster-api-provider-aws/v2/api/v1beta2" "sigs.k8s.io/cluster-api-provider-aws/v2/pkg/cloud/awserrors" - "sigs.k8s.io/cluster-api-provider-aws/v2/pkg/cloud/converters" + "sigs.k8s.io/cluster-api-provider-aws/v2/pkg/cloud/convertersv2" "sigs.k8s.io/cluster-api-provider-aws/v2/pkg/cloud/scope" "sigs.k8s.io/cluster-api-provider-aws/v2/pkg/cloud/services/wait" "sigs.k8s.io/cluster-api-provider-aws/v2/pkg/internal/bytes" @@ -43,9 +44,9 @@ const ( var retryableErrors = []string{ // Returned when the secret is scheduled for deletion - secretsmanager.ErrCodeInvalidRequestException, + "InvalidRequestException", // Returned during retries of deletes prior to recreation - secretsmanager.ErrCodeResourceNotFoundException, + "ResourceNotFoundException", } // Create stores data in AWS Secrets Manager for a given machine, chunking at 10kb per secret. The prefix of the secret @@ -86,13 +87,14 @@ func (s *Service) Create(m *scope.MachineScope, data []byte) (string, int32, err // retryableCreateSecret is a function to be passed into a waiter. In a separate function for ease of reading. func (s *Service) retryableCreateSecret(name string, chunk []byte, tags infrav1.Tags) (bool, error) { - _, err := s.SecretsManagerClient.CreateSecret(&secretsmanager.CreateSecretInput{ + _, err := s.SecretsManagerClient.CreateSecret(context.TODO(), &secretsmanager.CreateSecretInput{ Name: aws.String(name), SecretBinary: chunk, - Tags: converters.MapToSecretsManagerTags(tags), + Tags: convertersv2.MapToSecretsManagerTags(tags), }) // If the secret already exists, delete it, return request to retry, as deletes are eventually consistent - if awserrors.IsResourceExists(err) { + smithyErr := awserrors.ParseSmithyError(err) + if smithyErr != nil && smithyErr.ErrorCode() == "ResourceExistsException" { return false, s.forceDeleteSecretEntry(name) } if err != nil { @@ -103,11 +105,12 @@ func (s *Service) retryableCreateSecret(name string, chunk []byte, tags infrav1. // forceDeleteSecretEntry deletes a single secret, ignoring if it is absent. func (s *Service) forceDeleteSecretEntry(name string) error { - _, err := s.SecretsManagerClient.DeleteSecret(&secretsmanager.DeleteSecretInput{ + _, err := s.SecretsManagerClient.DeleteSecret(context.TODO(), &secretsmanager.DeleteSecretInput{ SecretId: aws.String(name), ForceDeleteWithoutRecovery: aws.Bool(true), }) - if awserrors.IsNotFound(err) { + smithyErr := awserrors.ParseSmithyError(err) + if smithyErr != nil && smithyErr.ErrorCode() == "ResourceNotFoundException" { return nil } return err diff --git a/pkg/cloud/services/secretsmanager/service.go b/pkg/cloud/services/secretsmanager/service.go index c9a06510f6..5b025a904d 100644 --- a/pkg/cloud/services/secretsmanager/service.go +++ b/pkg/cloud/services/secretsmanager/service.go @@ -18,7 +18,7 @@ limitations under the License. package secretsmanager import ( - "github.com/aws/aws-sdk-go/service/secretsmanager/secretsmanageriface" + "github.com/aws/aws-sdk-go-v2/service/secretsmanager" "sigs.k8s.io/cluster-api-provider-aws/v2/pkg/cloud" "sigs.k8s.io/cluster-api-provider-aws/v2/pkg/cloud/scope" @@ -29,7 +29,7 @@ import ( // One alternative is to have a large list of functions from the ec2 client. type Service struct { scope cloud.ClusterScoper - SecretsManagerClient secretsmanageriface.SecretsManagerAPI + SecretsManagerClient *secretsmanager.Client } // NewService returns a new service given the api clients. diff --git a/pkg/cloud/services/ssm/mock_ssmiface/ssmiface_mock.go b/pkg/cloud/services/ssm/mock_ssmiface/ssmiface_mock.go new file mode 100644 index 0000000000..e48bb8ade8 --- /dev/null +++ b/pkg/cloud/services/ssm/mock_ssmiface/ssmiface_mock.go @@ -0,0 +1,112 @@ +/* +Copyright The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +// Code generated by MockGen. DO NOT EDIT. +// Source: pkg/cloud/services/ssm/service.go + +// Package mock_ssmiface is a generated GoMock package. +package mock_ssmiface + +import ( + context "context" + reflect "reflect" + + ssm "github.com/aws/aws-sdk-go-v2/service/ssm" + gomock "github.com/golang/mock/gomock" +) + +// MockSSMAPI is a mock of SSMAPI interface. +type MockSSMAPI struct { + ctrl *gomock.Controller + recorder *MockSSMAPIMockRecorder +} + +// MockSSMAPIMockRecorder is the mock recorder for MockSSMAPI. +type MockSSMAPIMockRecorder struct { + mock *MockSSMAPI +} + +// NewMockSSMAPI creates a new mock instance. +func NewMockSSMAPI(ctrl *gomock.Controller) *MockSSMAPI { + mock := &MockSSMAPI{ctrl: ctrl} + mock.recorder = &MockSSMAPIMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockSSMAPI) EXPECT() *MockSSMAPIMockRecorder { + return m.recorder +} + +// DeleteParameter mocks base method. +func (m *MockSSMAPI) DeleteParameter(ctx context.Context, input *ssm.DeleteParameterInput, optFns ...func(*ssm.Options)) (*ssm.DeleteParameterOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, input} + for _, a := range optFns { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteParameter", varargs...) + ret0, _ := ret[0].(*ssm.DeleteParameterOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteParameter indicates an expected call of DeleteParameter. +func (mr *MockSSMAPIMockRecorder) DeleteParameter(ctx, input interface{}, optFns ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, input}, optFns...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteParameter", reflect.TypeOf((*MockSSMAPI)(nil).DeleteParameter), varargs...) +} + +// GetParameter mocks base method. +func (m *MockSSMAPI) GetParameter(ctx context.Context, input *ssm.GetParameterInput, optFns ...func(*ssm.Options)) (*ssm.GetParameterOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, input} + for _, a := range optFns { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetParameter", varargs...) + ret0, _ := ret[0].(*ssm.GetParameterOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetParameter indicates an expected call of GetParameter. +func (mr *MockSSMAPIMockRecorder) GetParameter(ctx, input interface{}, optFns ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, input}, optFns...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetParameter", reflect.TypeOf((*MockSSMAPI)(nil).GetParameter), varargs...) +} + +// PutParameter mocks base method. +func (m *MockSSMAPI) PutParameter(ctx context.Context, input *ssm.PutParameterInput, optFns ...func(*ssm.Options)) (*ssm.PutParameterOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, input} + for _, a := range optFns { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "PutParameter", varargs...) + ret0, _ := ret[0].(*ssm.PutParameterOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// PutParameter indicates an expected call of PutParameter. +func (mr *MockSSMAPIMockRecorder) PutParameter(ctx, input interface{}, optFns ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, input}, optFns...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutParameter", reflect.TypeOf((*MockSSMAPI)(nil).PutParameter), varargs...) +} diff --git a/test/mocks/capa_clusterscoper_mock.go b/test/mocks/capa_clusterscoper_mock.go index 2a45045bf9..ed5b72fc72 100644 --- a/test/mocks/capa_clusterscoper_mock.go +++ b/test/mocks/capa_clusterscoper_mock.go @@ -25,7 +25,6 @@ import ( time "time" aws "github.com/aws/aws-sdk-go-v2/aws" - client "github.com/aws/aws-sdk-go/aws/client" logging "github.com/aws/smithy-go/logging" logr "github.com/go-logr/logr" gomock "github.com/golang/mock/gomock" @@ -364,22 +363,8 @@ func (mr *MockClusterScoperMockRecorder) ServiceLimiter(arg0 interface{}) *gomoc return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ServiceLimiter", reflect.TypeOf((*MockClusterScoper)(nil).ServiceLimiter), arg0) } -// Session mocks base method. -func (m *MockClusterScoper) Session() client.ConfigProvider { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Session") - ret0, _ := ret[0].(client.ConfigProvider) - return ret0 -} - -// Session indicates an expected call of Session. -func (mr *MockClusterScoperMockRecorder) Session() *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Session", reflect.TypeOf((*MockClusterScoper)(nil).Session)) -} - // SessionV2 mocks base method. -func (m *MockClusterScoper) SessionV2() aws.Config { +func (m *MockClusterScoper) Session() aws.Config { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "SessionV2") ret0, _ := ret[0].(aws.Config) @@ -387,9 +372,9 @@ func (m *MockClusterScoper) SessionV2() aws.Config { } // SessionV2 indicates an expected call of SessionV2. -func (mr *MockClusterScoperMockRecorder) SessionV2() *gomock.Call { +func (mr *MockClusterScoperMockRecorder) Session() *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SessionV2", reflect.TypeOf((*MockClusterScoper)(nil).SessionV2)) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SessionV2", reflect.TypeOf((*MockClusterScoper)(nil).Session)) } // SetFailureDomain mocks base method. From 7c0075a7273ff7f83f0b1f6201fdfd266dd7e846 Mon Sep 17 00:00:00 2001 From: Liangquan Li Date: Tue, 29 Jul 2025 21:25:31 +0800 Subject: [PATCH 3/8] fix lint error --- pkg/cloud/services/s3/mock_stsiface/doc.go | 22 + .../mock_secretsmanageriface/doc.go | 2 +- .../secretsmanagerapi_mock.go | 1234 +---------------- .../services/secretsmanager/secret_test.go | 49 +- pkg/cloud/services/secretsmanager/service.go | 12 +- .../ssm/mock_ssmiface/ssmiface_mock.go | 112 -- .../sts/mock_stsiface/stsiface_mock_v1.go | 395 +----- pkg/cloud/services/wait/wait.go | 5 +- test/e2e/shared/aws_helpers.go | 38 +- test/e2e/suites/managed/addon.go | 8 +- test/e2e/suites/managed/addon_helpers.go | 12 +- test/e2e/suites/managed/aws_node_env.go | 4 +- test/e2e/suites/managed/control_plane.go | 6 +- .../suites/managed/control_plane_helpers.go | 6 +- test/e2e/suites/managed/eks_ipv6_test.go | 2 - test/e2e/suites/managed/eks_legacy_test.go | 2 - test/e2e/suites/managed/eks_test.go | 10 +- test/e2e/suites/managed/gc_test.go | 82 +- test/e2e/suites/managed/machine_deployment.go | 4 +- test/e2e/suites/managed/machine_pool.go | 3 +- test/e2e/suites/managed/upgrade_test.go | 3 +- test/e2e/suites/unmanaged/gc_test.go | 80 +- .../unmanaged_classic_elb_upgrade_test.go | 12 +- test/mocks/capa_clusterscoper_mock.go | 14 +- 24 files changed, 218 insertions(+), 1899 deletions(-) create mode 100644 pkg/cloud/services/s3/mock_stsiface/doc.go delete mode 100644 pkg/cloud/services/ssm/mock_ssmiface/ssmiface_mock.go diff --git a/pkg/cloud/services/s3/mock_stsiface/doc.go b/pkg/cloud/services/s3/mock_stsiface/doc.go new file mode 100644 index 0000000000..9cfa86a225 --- /dev/null +++ b/pkg/cloud/services/s3/mock_stsiface/doc.go @@ -0,0 +1,22 @@ +/* +Copyright 2019 The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +// Package mock_stsiface provides a mock implementation for the STSAPI interface. +// Run go generate to regenerate this mock. +// +//go:generate ../../../../../hack/tools/bin/mockgen -destination stsapi_mock.go -package mock_stsiface sigs.k8s.io/cluster-api-provider-aws/v2/pkg/cloud/services/s3 STSAPI +//go:generate /usr/bin/env bash -c "cat ../../../../../hack/boilerplate/boilerplate.generatego.txt stsapi_mock.go > _stsapi_mock.go && mv _stsapi_mock.go stsapi_mock.go" +package mock_stsiface //nolint:stylecheck diff --git a/pkg/cloud/services/secretsmanager/mock_secretsmanageriface/doc.go b/pkg/cloud/services/secretsmanager/mock_secretsmanageriface/doc.go index 88f2878984..750f6d60dd 100644 --- a/pkg/cloud/services/secretsmanager/mock_secretsmanageriface/doc.go +++ b/pkg/cloud/services/secretsmanager/mock_secretsmanageriface/doc.go @@ -17,6 +17,6 @@ limitations under the License. // Package mock_secretsmanageriface provides a mock interface for the SecretsManager API client. // Run go generate to regenerate this mock. // -//go:generate ../../../../../hack/tools/bin/mockgen -destination secretsmanagerapi_mock.go -package mock_secretsmanageriface github.com/aws/aws-sdk-go/service/secretsmanager/secretsmanageriface SecretsManagerAPI +//go:generate ../../../../../hack/tools/bin/mockgen -destination secretsmanagerapi_mock.go -package mock_secretsmanageriface sigs.k8s.io/cluster-api-provider-aws/v2/pkg/cloud/services/secretsmanager SecretsManagerAPI //go:generate /usr/bin/env bash -c "cat ../../../../../hack/boilerplate/boilerplate.generatego.txt secretsmanagerapi_mock.go > _secretsmanagerapi_mock.go && mv _secretsmanagerapi_mock.go secretsmanagerapi_mock.go" package mock_secretsmanageriface //nolint:stylecheck diff --git a/pkg/cloud/services/secretsmanager/mock_secretsmanageriface/secretsmanagerapi_mock.go b/pkg/cloud/services/secretsmanager/mock_secretsmanageriface/secretsmanagerapi_mock.go index 638d716da2..d2e72e44cf 100644 --- a/pkg/cloud/services/secretsmanager/mock_secretsmanageriface/secretsmanagerapi_mock.go +++ b/pkg/cloud/services/secretsmanager/mock_secretsmanageriface/secretsmanagerapi_mock.go @@ -15,7 +15,7 @@ limitations under the License. */ // Code generated by MockGen. DO NOT EDIT. -// Source: github.com/aws/aws-sdk-go/service/secretsmanager/secretsmanageriface (interfaces: SecretsManagerAPI) +// Source: sigs.k8s.io/cluster-api-provider-aws/v2/pkg/cloud/services/secretsmanager (interfaces: SecretsManagerAPI) // Package mock_secretsmanageriface is a generated GoMock package. package mock_secretsmanageriface @@ -24,8 +24,7 @@ import ( context "context" reflect "reflect" - request "github.com/aws/aws-sdk-go/aws/request" - secretsmanager "github.com/aws/aws-sdk-go/service/secretsmanager" + secretsmanager "github.com/aws/aws-sdk-go-v2/service/secretsmanager" gomock "github.com/golang/mock/gomock" ) @@ -52,1251 +51,42 @@ func (m *MockSecretsManagerAPI) EXPECT() *MockSecretsManagerAPIMockRecorder { return m.recorder } -// BatchGetSecretValue mocks base method. -func (m *MockSecretsManagerAPI) BatchGetSecretValue(arg0 *secretsmanager.BatchGetSecretValueInput) (*secretsmanager.BatchGetSecretValueOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "BatchGetSecretValue", arg0) - ret0, _ := ret[0].(*secretsmanager.BatchGetSecretValueOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// BatchGetSecretValue indicates an expected call of BatchGetSecretValue. -func (mr *MockSecretsManagerAPIMockRecorder) BatchGetSecretValue(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchGetSecretValue", reflect.TypeOf((*MockSecretsManagerAPI)(nil).BatchGetSecretValue), arg0) -} - -// BatchGetSecretValuePages mocks base method. -func (m *MockSecretsManagerAPI) BatchGetSecretValuePages(arg0 *secretsmanager.BatchGetSecretValueInput, arg1 func(*secretsmanager.BatchGetSecretValueOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "BatchGetSecretValuePages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// BatchGetSecretValuePages indicates an expected call of BatchGetSecretValuePages. -func (mr *MockSecretsManagerAPIMockRecorder) BatchGetSecretValuePages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchGetSecretValuePages", reflect.TypeOf((*MockSecretsManagerAPI)(nil).BatchGetSecretValuePages), arg0, arg1) -} - -// BatchGetSecretValuePagesWithContext mocks base method. -func (m *MockSecretsManagerAPI) BatchGetSecretValuePagesWithContext(arg0 context.Context, arg1 *secretsmanager.BatchGetSecretValueInput, arg2 func(*secretsmanager.BatchGetSecretValueOutput, bool) bool, arg3 ...request.Option) error { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1, arg2} - for _, a := range arg3 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "BatchGetSecretValuePagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// BatchGetSecretValuePagesWithContext indicates an expected call of BatchGetSecretValuePagesWithContext. -func (mr *MockSecretsManagerAPIMockRecorder) BatchGetSecretValuePagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchGetSecretValuePagesWithContext", reflect.TypeOf((*MockSecretsManagerAPI)(nil).BatchGetSecretValuePagesWithContext), varargs...) -} - -// BatchGetSecretValueRequest mocks base method. -func (m *MockSecretsManagerAPI) BatchGetSecretValueRequest(arg0 *secretsmanager.BatchGetSecretValueInput) (*request.Request, *secretsmanager.BatchGetSecretValueOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "BatchGetSecretValueRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*secretsmanager.BatchGetSecretValueOutput) - return ret0, ret1 -} - -// BatchGetSecretValueRequest indicates an expected call of BatchGetSecretValueRequest. -func (mr *MockSecretsManagerAPIMockRecorder) BatchGetSecretValueRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchGetSecretValueRequest", reflect.TypeOf((*MockSecretsManagerAPI)(nil).BatchGetSecretValueRequest), arg0) -} - -// BatchGetSecretValueWithContext mocks base method. -func (m *MockSecretsManagerAPI) BatchGetSecretValueWithContext(arg0 context.Context, arg1 *secretsmanager.BatchGetSecretValueInput, arg2 ...request.Option) (*secretsmanager.BatchGetSecretValueOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "BatchGetSecretValueWithContext", varargs...) - ret0, _ := ret[0].(*secretsmanager.BatchGetSecretValueOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// BatchGetSecretValueWithContext indicates an expected call of BatchGetSecretValueWithContext. -func (mr *MockSecretsManagerAPIMockRecorder) BatchGetSecretValueWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchGetSecretValueWithContext", reflect.TypeOf((*MockSecretsManagerAPI)(nil).BatchGetSecretValueWithContext), varargs...) -} - -// CancelRotateSecret mocks base method. -func (m *MockSecretsManagerAPI) CancelRotateSecret(arg0 *secretsmanager.CancelRotateSecretInput) (*secretsmanager.CancelRotateSecretOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CancelRotateSecret", arg0) - ret0, _ := ret[0].(*secretsmanager.CancelRotateSecretOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CancelRotateSecret indicates an expected call of CancelRotateSecret. -func (mr *MockSecretsManagerAPIMockRecorder) CancelRotateSecret(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelRotateSecret", reflect.TypeOf((*MockSecretsManagerAPI)(nil).CancelRotateSecret), arg0) -} - -// CancelRotateSecretRequest mocks base method. -func (m *MockSecretsManagerAPI) CancelRotateSecretRequest(arg0 *secretsmanager.CancelRotateSecretInput) (*request.Request, *secretsmanager.CancelRotateSecretOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CancelRotateSecretRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*secretsmanager.CancelRotateSecretOutput) - return ret0, ret1 -} - -// CancelRotateSecretRequest indicates an expected call of CancelRotateSecretRequest. -func (mr *MockSecretsManagerAPIMockRecorder) CancelRotateSecretRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelRotateSecretRequest", reflect.TypeOf((*MockSecretsManagerAPI)(nil).CancelRotateSecretRequest), arg0) -} - -// CancelRotateSecretWithContext mocks base method. -func (m *MockSecretsManagerAPI) CancelRotateSecretWithContext(arg0 context.Context, arg1 *secretsmanager.CancelRotateSecretInput, arg2 ...request.Option) (*secretsmanager.CancelRotateSecretOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "CancelRotateSecretWithContext", varargs...) - ret0, _ := ret[0].(*secretsmanager.CancelRotateSecretOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CancelRotateSecretWithContext indicates an expected call of CancelRotateSecretWithContext. -func (mr *MockSecretsManagerAPIMockRecorder) CancelRotateSecretWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelRotateSecretWithContext", reflect.TypeOf((*MockSecretsManagerAPI)(nil).CancelRotateSecretWithContext), varargs...) -} - // CreateSecret mocks base method. -func (m *MockSecretsManagerAPI) CreateSecret(arg0 *secretsmanager.CreateSecretInput) (*secretsmanager.CreateSecretOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateSecret", arg0) - ret0, _ := ret[0].(*secretsmanager.CreateSecretOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateSecret indicates an expected call of CreateSecret. -func (mr *MockSecretsManagerAPIMockRecorder) CreateSecret(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateSecret", reflect.TypeOf((*MockSecretsManagerAPI)(nil).CreateSecret), arg0) -} - -// CreateSecretRequest mocks base method. -func (m *MockSecretsManagerAPI) CreateSecretRequest(arg0 *secretsmanager.CreateSecretInput) (*request.Request, *secretsmanager.CreateSecretOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateSecretRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*secretsmanager.CreateSecretOutput) - return ret0, ret1 -} - -// CreateSecretRequest indicates an expected call of CreateSecretRequest. -func (mr *MockSecretsManagerAPIMockRecorder) CreateSecretRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateSecretRequest", reflect.TypeOf((*MockSecretsManagerAPI)(nil).CreateSecretRequest), arg0) -} - -// CreateSecretWithContext mocks base method. -func (m *MockSecretsManagerAPI) CreateSecretWithContext(arg0 context.Context, arg1 *secretsmanager.CreateSecretInput, arg2 ...request.Option) (*secretsmanager.CreateSecretOutput, error) { +func (m *MockSecretsManagerAPI) CreateSecret(arg0 context.Context, arg1 *secretsmanager.CreateSecretInput, arg2 ...func(*secretsmanager.Options)) (*secretsmanager.CreateSecretOutput, error) { m.ctrl.T.Helper() varargs := []interface{}{arg0, arg1} for _, a := range arg2 { varargs = append(varargs, a) } - ret := m.ctrl.Call(m, "CreateSecretWithContext", varargs...) + ret := m.ctrl.Call(m, "CreateSecret", varargs...) ret0, _ := ret[0].(*secretsmanager.CreateSecretOutput) ret1, _ := ret[1].(error) return ret0, ret1 } -// CreateSecretWithContext indicates an expected call of CreateSecretWithContext. -func (mr *MockSecretsManagerAPIMockRecorder) CreateSecretWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateSecretWithContext", reflect.TypeOf((*MockSecretsManagerAPI)(nil).CreateSecretWithContext), varargs...) -} - -// DeleteResourcePolicy mocks base method. -func (m *MockSecretsManagerAPI) DeleteResourcePolicy(arg0 *secretsmanager.DeleteResourcePolicyInput) (*secretsmanager.DeleteResourcePolicyOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteResourcePolicy", arg0) - ret0, _ := ret[0].(*secretsmanager.DeleteResourcePolicyOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteResourcePolicy indicates an expected call of DeleteResourcePolicy. -func (mr *MockSecretsManagerAPIMockRecorder) DeleteResourcePolicy(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteResourcePolicy", reflect.TypeOf((*MockSecretsManagerAPI)(nil).DeleteResourcePolicy), arg0) -} - -// DeleteResourcePolicyRequest mocks base method. -func (m *MockSecretsManagerAPI) DeleteResourcePolicyRequest(arg0 *secretsmanager.DeleteResourcePolicyInput) (*request.Request, *secretsmanager.DeleteResourcePolicyOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteResourcePolicyRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*secretsmanager.DeleteResourcePolicyOutput) - return ret0, ret1 -} - -// DeleteResourcePolicyRequest indicates an expected call of DeleteResourcePolicyRequest. -func (mr *MockSecretsManagerAPIMockRecorder) DeleteResourcePolicyRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteResourcePolicyRequest", reflect.TypeOf((*MockSecretsManagerAPI)(nil).DeleteResourcePolicyRequest), arg0) -} - -// DeleteResourcePolicyWithContext mocks base method. -func (m *MockSecretsManagerAPI) DeleteResourcePolicyWithContext(arg0 context.Context, arg1 *secretsmanager.DeleteResourcePolicyInput, arg2 ...request.Option) (*secretsmanager.DeleteResourcePolicyOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DeleteResourcePolicyWithContext", varargs...) - ret0, _ := ret[0].(*secretsmanager.DeleteResourcePolicyOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteResourcePolicyWithContext indicates an expected call of DeleteResourcePolicyWithContext. -func (mr *MockSecretsManagerAPIMockRecorder) DeleteResourcePolicyWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { +// CreateSecret indicates an expected call of CreateSecret. +func (mr *MockSecretsManagerAPIMockRecorder) CreateSecret(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteResourcePolicyWithContext", reflect.TypeOf((*MockSecretsManagerAPI)(nil).DeleteResourcePolicyWithContext), varargs...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateSecret", reflect.TypeOf((*MockSecretsManagerAPI)(nil).CreateSecret), varargs...) } // DeleteSecret mocks base method. -func (m *MockSecretsManagerAPI) DeleteSecret(arg0 *secretsmanager.DeleteSecretInput) (*secretsmanager.DeleteSecretOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteSecret", arg0) - ret0, _ := ret[0].(*secretsmanager.DeleteSecretOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteSecret indicates an expected call of DeleteSecret. -func (mr *MockSecretsManagerAPIMockRecorder) DeleteSecret(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSecret", reflect.TypeOf((*MockSecretsManagerAPI)(nil).DeleteSecret), arg0) -} - -// DeleteSecretRequest mocks base method. -func (m *MockSecretsManagerAPI) DeleteSecretRequest(arg0 *secretsmanager.DeleteSecretInput) (*request.Request, *secretsmanager.DeleteSecretOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteSecretRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*secretsmanager.DeleteSecretOutput) - return ret0, ret1 -} - -// DeleteSecretRequest indicates an expected call of DeleteSecretRequest. -func (mr *MockSecretsManagerAPIMockRecorder) DeleteSecretRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSecretRequest", reflect.TypeOf((*MockSecretsManagerAPI)(nil).DeleteSecretRequest), arg0) -} - -// DeleteSecretWithContext mocks base method. -func (m *MockSecretsManagerAPI) DeleteSecretWithContext(arg0 context.Context, arg1 *secretsmanager.DeleteSecretInput, arg2 ...request.Option) (*secretsmanager.DeleteSecretOutput, error) { +func (m *MockSecretsManagerAPI) DeleteSecret(arg0 context.Context, arg1 *secretsmanager.DeleteSecretInput, arg2 ...func(*secretsmanager.Options)) (*secretsmanager.DeleteSecretOutput, error) { m.ctrl.T.Helper() varargs := []interface{}{arg0, arg1} for _, a := range arg2 { varargs = append(varargs, a) } - ret := m.ctrl.Call(m, "DeleteSecretWithContext", varargs...) + ret := m.ctrl.Call(m, "DeleteSecret", varargs...) ret0, _ := ret[0].(*secretsmanager.DeleteSecretOutput) ret1, _ := ret[1].(error) return ret0, ret1 } -// DeleteSecretWithContext indicates an expected call of DeleteSecretWithContext. -func (mr *MockSecretsManagerAPIMockRecorder) DeleteSecretWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSecretWithContext", reflect.TypeOf((*MockSecretsManagerAPI)(nil).DeleteSecretWithContext), varargs...) -} - -// DescribeSecret mocks base method. -func (m *MockSecretsManagerAPI) DescribeSecret(arg0 *secretsmanager.DescribeSecretInput) (*secretsmanager.DescribeSecretOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeSecret", arg0) - ret0, _ := ret[0].(*secretsmanager.DescribeSecretOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeSecret indicates an expected call of DescribeSecret. -func (mr *MockSecretsManagerAPIMockRecorder) DescribeSecret(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSecret", reflect.TypeOf((*MockSecretsManagerAPI)(nil).DescribeSecret), arg0) -} - -// DescribeSecretRequest mocks base method. -func (m *MockSecretsManagerAPI) DescribeSecretRequest(arg0 *secretsmanager.DescribeSecretInput) (*request.Request, *secretsmanager.DescribeSecretOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeSecretRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*secretsmanager.DescribeSecretOutput) - return ret0, ret1 -} - -// DescribeSecretRequest indicates an expected call of DescribeSecretRequest. -func (mr *MockSecretsManagerAPIMockRecorder) DescribeSecretRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSecretRequest", reflect.TypeOf((*MockSecretsManagerAPI)(nil).DescribeSecretRequest), arg0) -} - -// DescribeSecretWithContext mocks base method. -func (m *MockSecretsManagerAPI) DescribeSecretWithContext(arg0 context.Context, arg1 *secretsmanager.DescribeSecretInput, arg2 ...request.Option) (*secretsmanager.DescribeSecretOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeSecretWithContext", varargs...) - ret0, _ := ret[0].(*secretsmanager.DescribeSecretOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeSecretWithContext indicates an expected call of DescribeSecretWithContext. -func (mr *MockSecretsManagerAPIMockRecorder) DescribeSecretWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSecretWithContext", reflect.TypeOf((*MockSecretsManagerAPI)(nil).DescribeSecretWithContext), varargs...) -} - -// GetRandomPassword mocks base method. -func (m *MockSecretsManagerAPI) GetRandomPassword(arg0 *secretsmanager.GetRandomPasswordInput) (*secretsmanager.GetRandomPasswordOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetRandomPassword", arg0) - ret0, _ := ret[0].(*secretsmanager.GetRandomPasswordOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetRandomPassword indicates an expected call of GetRandomPassword. -func (mr *MockSecretsManagerAPIMockRecorder) GetRandomPassword(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRandomPassword", reflect.TypeOf((*MockSecretsManagerAPI)(nil).GetRandomPassword), arg0) -} - -// GetRandomPasswordRequest mocks base method. -func (m *MockSecretsManagerAPI) GetRandomPasswordRequest(arg0 *secretsmanager.GetRandomPasswordInput) (*request.Request, *secretsmanager.GetRandomPasswordOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetRandomPasswordRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*secretsmanager.GetRandomPasswordOutput) - return ret0, ret1 -} - -// GetRandomPasswordRequest indicates an expected call of GetRandomPasswordRequest. -func (mr *MockSecretsManagerAPIMockRecorder) GetRandomPasswordRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRandomPasswordRequest", reflect.TypeOf((*MockSecretsManagerAPI)(nil).GetRandomPasswordRequest), arg0) -} - -// GetRandomPasswordWithContext mocks base method. -func (m *MockSecretsManagerAPI) GetRandomPasswordWithContext(arg0 context.Context, arg1 *secretsmanager.GetRandomPasswordInput, arg2 ...request.Option) (*secretsmanager.GetRandomPasswordOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "GetRandomPasswordWithContext", varargs...) - ret0, _ := ret[0].(*secretsmanager.GetRandomPasswordOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetRandomPasswordWithContext indicates an expected call of GetRandomPasswordWithContext. -func (mr *MockSecretsManagerAPIMockRecorder) GetRandomPasswordWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRandomPasswordWithContext", reflect.TypeOf((*MockSecretsManagerAPI)(nil).GetRandomPasswordWithContext), varargs...) -} - -// GetResourcePolicy mocks base method. -func (m *MockSecretsManagerAPI) GetResourcePolicy(arg0 *secretsmanager.GetResourcePolicyInput) (*secretsmanager.GetResourcePolicyOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetResourcePolicy", arg0) - ret0, _ := ret[0].(*secretsmanager.GetResourcePolicyOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetResourcePolicy indicates an expected call of GetResourcePolicy. -func (mr *MockSecretsManagerAPIMockRecorder) GetResourcePolicy(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetResourcePolicy", reflect.TypeOf((*MockSecretsManagerAPI)(nil).GetResourcePolicy), arg0) -} - -// GetResourcePolicyRequest mocks base method. -func (m *MockSecretsManagerAPI) GetResourcePolicyRequest(arg0 *secretsmanager.GetResourcePolicyInput) (*request.Request, *secretsmanager.GetResourcePolicyOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetResourcePolicyRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*secretsmanager.GetResourcePolicyOutput) - return ret0, ret1 -} - -// GetResourcePolicyRequest indicates an expected call of GetResourcePolicyRequest. -func (mr *MockSecretsManagerAPIMockRecorder) GetResourcePolicyRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetResourcePolicyRequest", reflect.TypeOf((*MockSecretsManagerAPI)(nil).GetResourcePolicyRequest), arg0) -} - -// GetResourcePolicyWithContext mocks base method. -func (m *MockSecretsManagerAPI) GetResourcePolicyWithContext(arg0 context.Context, arg1 *secretsmanager.GetResourcePolicyInput, arg2 ...request.Option) (*secretsmanager.GetResourcePolicyOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "GetResourcePolicyWithContext", varargs...) - ret0, _ := ret[0].(*secretsmanager.GetResourcePolicyOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetResourcePolicyWithContext indicates an expected call of GetResourcePolicyWithContext. -func (mr *MockSecretsManagerAPIMockRecorder) GetResourcePolicyWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetResourcePolicyWithContext", reflect.TypeOf((*MockSecretsManagerAPI)(nil).GetResourcePolicyWithContext), varargs...) -} - -// GetSecretValue mocks base method. -func (m *MockSecretsManagerAPI) GetSecretValue(arg0 *secretsmanager.GetSecretValueInput) (*secretsmanager.GetSecretValueOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetSecretValue", arg0) - ret0, _ := ret[0].(*secretsmanager.GetSecretValueOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetSecretValue indicates an expected call of GetSecretValue. -func (mr *MockSecretsManagerAPIMockRecorder) GetSecretValue(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSecretValue", reflect.TypeOf((*MockSecretsManagerAPI)(nil).GetSecretValue), arg0) -} - -// GetSecretValueRequest mocks base method. -func (m *MockSecretsManagerAPI) GetSecretValueRequest(arg0 *secretsmanager.GetSecretValueInput) (*request.Request, *secretsmanager.GetSecretValueOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetSecretValueRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*secretsmanager.GetSecretValueOutput) - return ret0, ret1 -} - -// GetSecretValueRequest indicates an expected call of GetSecretValueRequest. -func (mr *MockSecretsManagerAPIMockRecorder) GetSecretValueRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSecretValueRequest", reflect.TypeOf((*MockSecretsManagerAPI)(nil).GetSecretValueRequest), arg0) -} - -// GetSecretValueWithContext mocks base method. -func (m *MockSecretsManagerAPI) GetSecretValueWithContext(arg0 context.Context, arg1 *secretsmanager.GetSecretValueInput, arg2 ...request.Option) (*secretsmanager.GetSecretValueOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "GetSecretValueWithContext", varargs...) - ret0, _ := ret[0].(*secretsmanager.GetSecretValueOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetSecretValueWithContext indicates an expected call of GetSecretValueWithContext. -func (mr *MockSecretsManagerAPIMockRecorder) GetSecretValueWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSecretValueWithContext", reflect.TypeOf((*MockSecretsManagerAPI)(nil).GetSecretValueWithContext), varargs...) -} - -// ListSecretVersionIds mocks base method. -func (m *MockSecretsManagerAPI) ListSecretVersionIds(arg0 *secretsmanager.ListSecretVersionIdsInput) (*secretsmanager.ListSecretVersionIdsOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ListSecretVersionIds", arg0) - ret0, _ := ret[0].(*secretsmanager.ListSecretVersionIdsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ListSecretVersionIds indicates an expected call of ListSecretVersionIds. -func (mr *MockSecretsManagerAPIMockRecorder) ListSecretVersionIds(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListSecretVersionIds", reflect.TypeOf((*MockSecretsManagerAPI)(nil).ListSecretVersionIds), arg0) -} - -// ListSecretVersionIdsPages mocks base method. -func (m *MockSecretsManagerAPI) ListSecretVersionIdsPages(arg0 *secretsmanager.ListSecretVersionIdsInput, arg1 func(*secretsmanager.ListSecretVersionIdsOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ListSecretVersionIdsPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// ListSecretVersionIdsPages indicates an expected call of ListSecretVersionIdsPages. -func (mr *MockSecretsManagerAPIMockRecorder) ListSecretVersionIdsPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListSecretVersionIdsPages", reflect.TypeOf((*MockSecretsManagerAPI)(nil).ListSecretVersionIdsPages), arg0, arg1) -} - -// ListSecretVersionIdsPagesWithContext mocks base method. -func (m *MockSecretsManagerAPI) ListSecretVersionIdsPagesWithContext(arg0 context.Context, arg1 *secretsmanager.ListSecretVersionIdsInput, arg2 func(*secretsmanager.ListSecretVersionIdsOutput, bool) bool, arg3 ...request.Option) error { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1, arg2} - for _, a := range arg3 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "ListSecretVersionIdsPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// ListSecretVersionIdsPagesWithContext indicates an expected call of ListSecretVersionIdsPagesWithContext. -func (mr *MockSecretsManagerAPIMockRecorder) ListSecretVersionIdsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListSecretVersionIdsPagesWithContext", reflect.TypeOf((*MockSecretsManagerAPI)(nil).ListSecretVersionIdsPagesWithContext), varargs...) -} - -// ListSecretVersionIdsRequest mocks base method. -func (m *MockSecretsManagerAPI) ListSecretVersionIdsRequest(arg0 *secretsmanager.ListSecretVersionIdsInput) (*request.Request, *secretsmanager.ListSecretVersionIdsOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ListSecretVersionIdsRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*secretsmanager.ListSecretVersionIdsOutput) - return ret0, ret1 -} - -// ListSecretVersionIdsRequest indicates an expected call of ListSecretVersionIdsRequest. -func (mr *MockSecretsManagerAPIMockRecorder) ListSecretVersionIdsRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListSecretVersionIdsRequest", reflect.TypeOf((*MockSecretsManagerAPI)(nil).ListSecretVersionIdsRequest), arg0) -} - -// ListSecretVersionIdsWithContext mocks base method. -func (m *MockSecretsManagerAPI) ListSecretVersionIdsWithContext(arg0 context.Context, arg1 *secretsmanager.ListSecretVersionIdsInput, arg2 ...request.Option) (*secretsmanager.ListSecretVersionIdsOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "ListSecretVersionIdsWithContext", varargs...) - ret0, _ := ret[0].(*secretsmanager.ListSecretVersionIdsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ListSecretVersionIdsWithContext indicates an expected call of ListSecretVersionIdsWithContext. -func (mr *MockSecretsManagerAPIMockRecorder) ListSecretVersionIdsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListSecretVersionIdsWithContext", reflect.TypeOf((*MockSecretsManagerAPI)(nil).ListSecretVersionIdsWithContext), varargs...) -} - -// ListSecrets mocks base method. -func (m *MockSecretsManagerAPI) ListSecrets(arg0 *secretsmanager.ListSecretsInput) (*secretsmanager.ListSecretsOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ListSecrets", arg0) - ret0, _ := ret[0].(*secretsmanager.ListSecretsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ListSecrets indicates an expected call of ListSecrets. -func (mr *MockSecretsManagerAPIMockRecorder) ListSecrets(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListSecrets", reflect.TypeOf((*MockSecretsManagerAPI)(nil).ListSecrets), arg0) -} - -// ListSecretsPages mocks base method. -func (m *MockSecretsManagerAPI) ListSecretsPages(arg0 *secretsmanager.ListSecretsInput, arg1 func(*secretsmanager.ListSecretsOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ListSecretsPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// ListSecretsPages indicates an expected call of ListSecretsPages. -func (mr *MockSecretsManagerAPIMockRecorder) ListSecretsPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListSecretsPages", reflect.TypeOf((*MockSecretsManagerAPI)(nil).ListSecretsPages), arg0, arg1) -} - -// ListSecretsPagesWithContext mocks base method. -func (m *MockSecretsManagerAPI) ListSecretsPagesWithContext(arg0 context.Context, arg1 *secretsmanager.ListSecretsInput, arg2 func(*secretsmanager.ListSecretsOutput, bool) bool, arg3 ...request.Option) error { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1, arg2} - for _, a := range arg3 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "ListSecretsPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// ListSecretsPagesWithContext indicates an expected call of ListSecretsPagesWithContext. -func (mr *MockSecretsManagerAPIMockRecorder) ListSecretsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListSecretsPagesWithContext", reflect.TypeOf((*MockSecretsManagerAPI)(nil).ListSecretsPagesWithContext), varargs...) -} - -// ListSecretsRequest mocks base method. -func (m *MockSecretsManagerAPI) ListSecretsRequest(arg0 *secretsmanager.ListSecretsInput) (*request.Request, *secretsmanager.ListSecretsOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ListSecretsRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*secretsmanager.ListSecretsOutput) - return ret0, ret1 -} - -// ListSecretsRequest indicates an expected call of ListSecretsRequest. -func (mr *MockSecretsManagerAPIMockRecorder) ListSecretsRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListSecretsRequest", reflect.TypeOf((*MockSecretsManagerAPI)(nil).ListSecretsRequest), arg0) -} - -// ListSecretsWithContext mocks base method. -func (m *MockSecretsManagerAPI) ListSecretsWithContext(arg0 context.Context, arg1 *secretsmanager.ListSecretsInput, arg2 ...request.Option) (*secretsmanager.ListSecretsOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "ListSecretsWithContext", varargs...) - ret0, _ := ret[0].(*secretsmanager.ListSecretsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ListSecretsWithContext indicates an expected call of ListSecretsWithContext. -func (mr *MockSecretsManagerAPIMockRecorder) ListSecretsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListSecretsWithContext", reflect.TypeOf((*MockSecretsManagerAPI)(nil).ListSecretsWithContext), varargs...) -} - -// PutResourcePolicy mocks base method. -func (m *MockSecretsManagerAPI) PutResourcePolicy(arg0 *secretsmanager.PutResourcePolicyInput) (*secretsmanager.PutResourcePolicyOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "PutResourcePolicy", arg0) - ret0, _ := ret[0].(*secretsmanager.PutResourcePolicyOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// PutResourcePolicy indicates an expected call of PutResourcePolicy. -func (mr *MockSecretsManagerAPIMockRecorder) PutResourcePolicy(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutResourcePolicy", reflect.TypeOf((*MockSecretsManagerAPI)(nil).PutResourcePolicy), arg0) -} - -// PutResourcePolicyRequest mocks base method. -func (m *MockSecretsManagerAPI) PutResourcePolicyRequest(arg0 *secretsmanager.PutResourcePolicyInput) (*request.Request, *secretsmanager.PutResourcePolicyOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "PutResourcePolicyRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*secretsmanager.PutResourcePolicyOutput) - return ret0, ret1 -} - -// PutResourcePolicyRequest indicates an expected call of PutResourcePolicyRequest. -func (mr *MockSecretsManagerAPIMockRecorder) PutResourcePolicyRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutResourcePolicyRequest", reflect.TypeOf((*MockSecretsManagerAPI)(nil).PutResourcePolicyRequest), arg0) -} - -// PutResourcePolicyWithContext mocks base method. -func (m *MockSecretsManagerAPI) PutResourcePolicyWithContext(arg0 context.Context, arg1 *secretsmanager.PutResourcePolicyInput, arg2 ...request.Option) (*secretsmanager.PutResourcePolicyOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "PutResourcePolicyWithContext", varargs...) - ret0, _ := ret[0].(*secretsmanager.PutResourcePolicyOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// PutResourcePolicyWithContext indicates an expected call of PutResourcePolicyWithContext. -func (mr *MockSecretsManagerAPIMockRecorder) PutResourcePolicyWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutResourcePolicyWithContext", reflect.TypeOf((*MockSecretsManagerAPI)(nil).PutResourcePolicyWithContext), varargs...) -} - -// PutSecretValue mocks base method. -func (m *MockSecretsManagerAPI) PutSecretValue(arg0 *secretsmanager.PutSecretValueInput) (*secretsmanager.PutSecretValueOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "PutSecretValue", arg0) - ret0, _ := ret[0].(*secretsmanager.PutSecretValueOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// PutSecretValue indicates an expected call of PutSecretValue. -func (mr *MockSecretsManagerAPIMockRecorder) PutSecretValue(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutSecretValue", reflect.TypeOf((*MockSecretsManagerAPI)(nil).PutSecretValue), arg0) -} - -// PutSecretValueRequest mocks base method. -func (m *MockSecretsManagerAPI) PutSecretValueRequest(arg0 *secretsmanager.PutSecretValueInput) (*request.Request, *secretsmanager.PutSecretValueOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "PutSecretValueRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*secretsmanager.PutSecretValueOutput) - return ret0, ret1 -} - -// PutSecretValueRequest indicates an expected call of PutSecretValueRequest. -func (mr *MockSecretsManagerAPIMockRecorder) PutSecretValueRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutSecretValueRequest", reflect.TypeOf((*MockSecretsManagerAPI)(nil).PutSecretValueRequest), arg0) -} - -// PutSecretValueWithContext mocks base method. -func (m *MockSecretsManagerAPI) PutSecretValueWithContext(arg0 context.Context, arg1 *secretsmanager.PutSecretValueInput, arg2 ...request.Option) (*secretsmanager.PutSecretValueOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "PutSecretValueWithContext", varargs...) - ret0, _ := ret[0].(*secretsmanager.PutSecretValueOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// PutSecretValueWithContext indicates an expected call of PutSecretValueWithContext. -func (mr *MockSecretsManagerAPIMockRecorder) PutSecretValueWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutSecretValueWithContext", reflect.TypeOf((*MockSecretsManagerAPI)(nil).PutSecretValueWithContext), varargs...) -} - -// RemoveRegionsFromReplication mocks base method. -func (m *MockSecretsManagerAPI) RemoveRegionsFromReplication(arg0 *secretsmanager.RemoveRegionsFromReplicationInput) (*secretsmanager.RemoveRegionsFromReplicationOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "RemoveRegionsFromReplication", arg0) - ret0, _ := ret[0].(*secretsmanager.RemoveRegionsFromReplicationOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// RemoveRegionsFromReplication indicates an expected call of RemoveRegionsFromReplication. -func (mr *MockSecretsManagerAPIMockRecorder) RemoveRegionsFromReplication(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveRegionsFromReplication", reflect.TypeOf((*MockSecretsManagerAPI)(nil).RemoveRegionsFromReplication), arg0) -} - -// RemoveRegionsFromReplicationRequest mocks base method. -func (m *MockSecretsManagerAPI) RemoveRegionsFromReplicationRequest(arg0 *secretsmanager.RemoveRegionsFromReplicationInput) (*request.Request, *secretsmanager.RemoveRegionsFromReplicationOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "RemoveRegionsFromReplicationRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*secretsmanager.RemoveRegionsFromReplicationOutput) - return ret0, ret1 -} - -// RemoveRegionsFromReplicationRequest indicates an expected call of RemoveRegionsFromReplicationRequest. -func (mr *MockSecretsManagerAPIMockRecorder) RemoveRegionsFromReplicationRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveRegionsFromReplicationRequest", reflect.TypeOf((*MockSecretsManagerAPI)(nil).RemoveRegionsFromReplicationRequest), arg0) -} - -// RemoveRegionsFromReplicationWithContext mocks base method. -func (m *MockSecretsManagerAPI) RemoveRegionsFromReplicationWithContext(arg0 context.Context, arg1 *secretsmanager.RemoveRegionsFromReplicationInput, arg2 ...request.Option) (*secretsmanager.RemoveRegionsFromReplicationOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "RemoveRegionsFromReplicationWithContext", varargs...) - ret0, _ := ret[0].(*secretsmanager.RemoveRegionsFromReplicationOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// RemoveRegionsFromReplicationWithContext indicates an expected call of RemoveRegionsFromReplicationWithContext. -func (mr *MockSecretsManagerAPIMockRecorder) RemoveRegionsFromReplicationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveRegionsFromReplicationWithContext", reflect.TypeOf((*MockSecretsManagerAPI)(nil).RemoveRegionsFromReplicationWithContext), varargs...) -} - -// ReplicateSecretToRegions mocks base method. -func (m *MockSecretsManagerAPI) ReplicateSecretToRegions(arg0 *secretsmanager.ReplicateSecretToRegionsInput) (*secretsmanager.ReplicateSecretToRegionsOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ReplicateSecretToRegions", arg0) - ret0, _ := ret[0].(*secretsmanager.ReplicateSecretToRegionsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ReplicateSecretToRegions indicates an expected call of ReplicateSecretToRegions. -func (mr *MockSecretsManagerAPIMockRecorder) ReplicateSecretToRegions(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReplicateSecretToRegions", reflect.TypeOf((*MockSecretsManagerAPI)(nil).ReplicateSecretToRegions), arg0) -} - -// ReplicateSecretToRegionsRequest mocks base method. -func (m *MockSecretsManagerAPI) ReplicateSecretToRegionsRequest(arg0 *secretsmanager.ReplicateSecretToRegionsInput) (*request.Request, *secretsmanager.ReplicateSecretToRegionsOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ReplicateSecretToRegionsRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*secretsmanager.ReplicateSecretToRegionsOutput) - return ret0, ret1 -} - -// ReplicateSecretToRegionsRequest indicates an expected call of ReplicateSecretToRegionsRequest. -func (mr *MockSecretsManagerAPIMockRecorder) ReplicateSecretToRegionsRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReplicateSecretToRegionsRequest", reflect.TypeOf((*MockSecretsManagerAPI)(nil).ReplicateSecretToRegionsRequest), arg0) -} - -// ReplicateSecretToRegionsWithContext mocks base method. -func (m *MockSecretsManagerAPI) ReplicateSecretToRegionsWithContext(arg0 context.Context, arg1 *secretsmanager.ReplicateSecretToRegionsInput, arg2 ...request.Option) (*secretsmanager.ReplicateSecretToRegionsOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "ReplicateSecretToRegionsWithContext", varargs...) - ret0, _ := ret[0].(*secretsmanager.ReplicateSecretToRegionsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ReplicateSecretToRegionsWithContext indicates an expected call of ReplicateSecretToRegionsWithContext. -func (mr *MockSecretsManagerAPIMockRecorder) ReplicateSecretToRegionsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReplicateSecretToRegionsWithContext", reflect.TypeOf((*MockSecretsManagerAPI)(nil).ReplicateSecretToRegionsWithContext), varargs...) -} - -// RestoreSecret mocks base method. -func (m *MockSecretsManagerAPI) RestoreSecret(arg0 *secretsmanager.RestoreSecretInput) (*secretsmanager.RestoreSecretOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "RestoreSecret", arg0) - ret0, _ := ret[0].(*secretsmanager.RestoreSecretOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// RestoreSecret indicates an expected call of RestoreSecret. -func (mr *MockSecretsManagerAPIMockRecorder) RestoreSecret(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RestoreSecret", reflect.TypeOf((*MockSecretsManagerAPI)(nil).RestoreSecret), arg0) -} - -// RestoreSecretRequest mocks base method. -func (m *MockSecretsManagerAPI) RestoreSecretRequest(arg0 *secretsmanager.RestoreSecretInput) (*request.Request, *secretsmanager.RestoreSecretOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "RestoreSecretRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*secretsmanager.RestoreSecretOutput) - return ret0, ret1 -} - -// RestoreSecretRequest indicates an expected call of RestoreSecretRequest. -func (mr *MockSecretsManagerAPIMockRecorder) RestoreSecretRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RestoreSecretRequest", reflect.TypeOf((*MockSecretsManagerAPI)(nil).RestoreSecretRequest), arg0) -} - -// RestoreSecretWithContext mocks base method. -func (m *MockSecretsManagerAPI) RestoreSecretWithContext(arg0 context.Context, arg1 *secretsmanager.RestoreSecretInput, arg2 ...request.Option) (*secretsmanager.RestoreSecretOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "RestoreSecretWithContext", varargs...) - ret0, _ := ret[0].(*secretsmanager.RestoreSecretOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// RestoreSecretWithContext indicates an expected call of RestoreSecretWithContext. -func (mr *MockSecretsManagerAPIMockRecorder) RestoreSecretWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RestoreSecretWithContext", reflect.TypeOf((*MockSecretsManagerAPI)(nil).RestoreSecretWithContext), varargs...) -} - -// RotateSecret mocks base method. -func (m *MockSecretsManagerAPI) RotateSecret(arg0 *secretsmanager.RotateSecretInput) (*secretsmanager.RotateSecretOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "RotateSecret", arg0) - ret0, _ := ret[0].(*secretsmanager.RotateSecretOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// RotateSecret indicates an expected call of RotateSecret. -func (mr *MockSecretsManagerAPIMockRecorder) RotateSecret(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RotateSecret", reflect.TypeOf((*MockSecretsManagerAPI)(nil).RotateSecret), arg0) -} - -// RotateSecretRequest mocks base method. -func (m *MockSecretsManagerAPI) RotateSecretRequest(arg0 *secretsmanager.RotateSecretInput) (*request.Request, *secretsmanager.RotateSecretOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "RotateSecretRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*secretsmanager.RotateSecretOutput) - return ret0, ret1 -} - -// RotateSecretRequest indicates an expected call of RotateSecretRequest. -func (mr *MockSecretsManagerAPIMockRecorder) RotateSecretRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RotateSecretRequest", reflect.TypeOf((*MockSecretsManagerAPI)(nil).RotateSecretRequest), arg0) -} - -// RotateSecretWithContext mocks base method. -func (m *MockSecretsManagerAPI) RotateSecretWithContext(arg0 context.Context, arg1 *secretsmanager.RotateSecretInput, arg2 ...request.Option) (*secretsmanager.RotateSecretOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "RotateSecretWithContext", varargs...) - ret0, _ := ret[0].(*secretsmanager.RotateSecretOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// RotateSecretWithContext indicates an expected call of RotateSecretWithContext. -func (mr *MockSecretsManagerAPIMockRecorder) RotateSecretWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RotateSecretWithContext", reflect.TypeOf((*MockSecretsManagerAPI)(nil).RotateSecretWithContext), varargs...) -} - -// StopReplicationToReplica mocks base method. -func (m *MockSecretsManagerAPI) StopReplicationToReplica(arg0 *secretsmanager.StopReplicationToReplicaInput) (*secretsmanager.StopReplicationToReplicaOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "StopReplicationToReplica", arg0) - ret0, _ := ret[0].(*secretsmanager.StopReplicationToReplicaOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// StopReplicationToReplica indicates an expected call of StopReplicationToReplica. -func (mr *MockSecretsManagerAPIMockRecorder) StopReplicationToReplica(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StopReplicationToReplica", reflect.TypeOf((*MockSecretsManagerAPI)(nil).StopReplicationToReplica), arg0) -} - -// StopReplicationToReplicaRequest mocks base method. -func (m *MockSecretsManagerAPI) StopReplicationToReplicaRequest(arg0 *secretsmanager.StopReplicationToReplicaInput) (*request.Request, *secretsmanager.StopReplicationToReplicaOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "StopReplicationToReplicaRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*secretsmanager.StopReplicationToReplicaOutput) - return ret0, ret1 -} - -// StopReplicationToReplicaRequest indicates an expected call of StopReplicationToReplicaRequest. -func (mr *MockSecretsManagerAPIMockRecorder) StopReplicationToReplicaRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StopReplicationToReplicaRequest", reflect.TypeOf((*MockSecretsManagerAPI)(nil).StopReplicationToReplicaRequest), arg0) -} - -// StopReplicationToReplicaWithContext mocks base method. -func (m *MockSecretsManagerAPI) StopReplicationToReplicaWithContext(arg0 context.Context, arg1 *secretsmanager.StopReplicationToReplicaInput, arg2 ...request.Option) (*secretsmanager.StopReplicationToReplicaOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "StopReplicationToReplicaWithContext", varargs...) - ret0, _ := ret[0].(*secretsmanager.StopReplicationToReplicaOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// StopReplicationToReplicaWithContext indicates an expected call of StopReplicationToReplicaWithContext. -func (mr *MockSecretsManagerAPIMockRecorder) StopReplicationToReplicaWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StopReplicationToReplicaWithContext", reflect.TypeOf((*MockSecretsManagerAPI)(nil).StopReplicationToReplicaWithContext), varargs...) -} - -// TagResource mocks base method. -func (m *MockSecretsManagerAPI) TagResource(arg0 *secretsmanager.TagResourceInput) (*secretsmanager.TagResourceOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "TagResource", arg0) - ret0, _ := ret[0].(*secretsmanager.TagResourceOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// TagResource indicates an expected call of TagResource. -func (mr *MockSecretsManagerAPIMockRecorder) TagResource(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TagResource", reflect.TypeOf((*MockSecretsManagerAPI)(nil).TagResource), arg0) -} - -// TagResourceRequest mocks base method. -func (m *MockSecretsManagerAPI) TagResourceRequest(arg0 *secretsmanager.TagResourceInput) (*request.Request, *secretsmanager.TagResourceOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "TagResourceRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*secretsmanager.TagResourceOutput) - return ret0, ret1 -} - -// TagResourceRequest indicates an expected call of TagResourceRequest. -func (mr *MockSecretsManagerAPIMockRecorder) TagResourceRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TagResourceRequest", reflect.TypeOf((*MockSecretsManagerAPI)(nil).TagResourceRequest), arg0) -} - -// TagResourceWithContext mocks base method. -func (m *MockSecretsManagerAPI) TagResourceWithContext(arg0 context.Context, arg1 *secretsmanager.TagResourceInput, arg2 ...request.Option) (*secretsmanager.TagResourceOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "TagResourceWithContext", varargs...) - ret0, _ := ret[0].(*secretsmanager.TagResourceOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// TagResourceWithContext indicates an expected call of TagResourceWithContext. -func (mr *MockSecretsManagerAPIMockRecorder) TagResourceWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TagResourceWithContext", reflect.TypeOf((*MockSecretsManagerAPI)(nil).TagResourceWithContext), varargs...) -} - -// UntagResource mocks base method. -func (m *MockSecretsManagerAPI) UntagResource(arg0 *secretsmanager.UntagResourceInput) (*secretsmanager.UntagResourceOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "UntagResource", arg0) - ret0, _ := ret[0].(*secretsmanager.UntagResourceOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// UntagResource indicates an expected call of UntagResource. -func (mr *MockSecretsManagerAPIMockRecorder) UntagResource(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UntagResource", reflect.TypeOf((*MockSecretsManagerAPI)(nil).UntagResource), arg0) -} - -// UntagResourceRequest mocks base method. -func (m *MockSecretsManagerAPI) UntagResourceRequest(arg0 *secretsmanager.UntagResourceInput) (*request.Request, *secretsmanager.UntagResourceOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "UntagResourceRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*secretsmanager.UntagResourceOutput) - return ret0, ret1 -} - -// UntagResourceRequest indicates an expected call of UntagResourceRequest. -func (mr *MockSecretsManagerAPIMockRecorder) UntagResourceRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UntagResourceRequest", reflect.TypeOf((*MockSecretsManagerAPI)(nil).UntagResourceRequest), arg0) -} - -// UntagResourceWithContext mocks base method. -func (m *MockSecretsManagerAPI) UntagResourceWithContext(arg0 context.Context, arg1 *secretsmanager.UntagResourceInput, arg2 ...request.Option) (*secretsmanager.UntagResourceOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "UntagResourceWithContext", varargs...) - ret0, _ := ret[0].(*secretsmanager.UntagResourceOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// UntagResourceWithContext indicates an expected call of UntagResourceWithContext. -func (mr *MockSecretsManagerAPIMockRecorder) UntagResourceWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UntagResourceWithContext", reflect.TypeOf((*MockSecretsManagerAPI)(nil).UntagResourceWithContext), varargs...) -} - -// UpdateSecret mocks base method. -func (m *MockSecretsManagerAPI) UpdateSecret(arg0 *secretsmanager.UpdateSecretInput) (*secretsmanager.UpdateSecretOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "UpdateSecret", arg0) - ret0, _ := ret[0].(*secretsmanager.UpdateSecretOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// UpdateSecret indicates an expected call of UpdateSecret. -func (mr *MockSecretsManagerAPIMockRecorder) UpdateSecret(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateSecret", reflect.TypeOf((*MockSecretsManagerAPI)(nil).UpdateSecret), arg0) -} - -// UpdateSecretRequest mocks base method. -func (m *MockSecretsManagerAPI) UpdateSecretRequest(arg0 *secretsmanager.UpdateSecretInput) (*request.Request, *secretsmanager.UpdateSecretOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "UpdateSecretRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*secretsmanager.UpdateSecretOutput) - return ret0, ret1 -} - -// UpdateSecretRequest indicates an expected call of UpdateSecretRequest. -func (mr *MockSecretsManagerAPIMockRecorder) UpdateSecretRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateSecretRequest", reflect.TypeOf((*MockSecretsManagerAPI)(nil).UpdateSecretRequest), arg0) -} - -// UpdateSecretVersionStage mocks base method. -func (m *MockSecretsManagerAPI) UpdateSecretVersionStage(arg0 *secretsmanager.UpdateSecretVersionStageInput) (*secretsmanager.UpdateSecretVersionStageOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "UpdateSecretVersionStage", arg0) - ret0, _ := ret[0].(*secretsmanager.UpdateSecretVersionStageOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// UpdateSecretVersionStage indicates an expected call of UpdateSecretVersionStage. -func (mr *MockSecretsManagerAPIMockRecorder) UpdateSecretVersionStage(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateSecretVersionStage", reflect.TypeOf((*MockSecretsManagerAPI)(nil).UpdateSecretVersionStage), arg0) -} - -// UpdateSecretVersionStageRequest mocks base method. -func (m *MockSecretsManagerAPI) UpdateSecretVersionStageRequest(arg0 *secretsmanager.UpdateSecretVersionStageInput) (*request.Request, *secretsmanager.UpdateSecretVersionStageOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "UpdateSecretVersionStageRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*secretsmanager.UpdateSecretVersionStageOutput) - return ret0, ret1 -} - -// UpdateSecretVersionStageRequest indicates an expected call of UpdateSecretVersionStageRequest. -func (mr *MockSecretsManagerAPIMockRecorder) UpdateSecretVersionStageRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateSecretVersionStageRequest", reflect.TypeOf((*MockSecretsManagerAPI)(nil).UpdateSecretVersionStageRequest), arg0) -} - -// UpdateSecretVersionStageWithContext mocks base method. -func (m *MockSecretsManagerAPI) UpdateSecretVersionStageWithContext(arg0 context.Context, arg1 *secretsmanager.UpdateSecretVersionStageInput, arg2 ...request.Option) (*secretsmanager.UpdateSecretVersionStageOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "UpdateSecretVersionStageWithContext", varargs...) - ret0, _ := ret[0].(*secretsmanager.UpdateSecretVersionStageOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// UpdateSecretVersionStageWithContext indicates an expected call of UpdateSecretVersionStageWithContext. -func (mr *MockSecretsManagerAPIMockRecorder) UpdateSecretVersionStageWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateSecretVersionStageWithContext", reflect.TypeOf((*MockSecretsManagerAPI)(nil).UpdateSecretVersionStageWithContext), varargs...) -} - -// UpdateSecretWithContext mocks base method. -func (m *MockSecretsManagerAPI) UpdateSecretWithContext(arg0 context.Context, arg1 *secretsmanager.UpdateSecretInput, arg2 ...request.Option) (*secretsmanager.UpdateSecretOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "UpdateSecretWithContext", varargs...) - ret0, _ := ret[0].(*secretsmanager.UpdateSecretOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// UpdateSecretWithContext indicates an expected call of UpdateSecretWithContext. -func (mr *MockSecretsManagerAPIMockRecorder) UpdateSecretWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateSecretWithContext", reflect.TypeOf((*MockSecretsManagerAPI)(nil).UpdateSecretWithContext), varargs...) -} - -// ValidateResourcePolicy mocks base method. -func (m *MockSecretsManagerAPI) ValidateResourcePolicy(arg0 *secretsmanager.ValidateResourcePolicyInput) (*secretsmanager.ValidateResourcePolicyOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ValidateResourcePolicy", arg0) - ret0, _ := ret[0].(*secretsmanager.ValidateResourcePolicyOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ValidateResourcePolicy indicates an expected call of ValidateResourcePolicy. -func (mr *MockSecretsManagerAPIMockRecorder) ValidateResourcePolicy(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ValidateResourcePolicy", reflect.TypeOf((*MockSecretsManagerAPI)(nil).ValidateResourcePolicy), arg0) -} - -// ValidateResourcePolicyRequest mocks base method. -func (m *MockSecretsManagerAPI) ValidateResourcePolicyRequest(arg0 *secretsmanager.ValidateResourcePolicyInput) (*request.Request, *secretsmanager.ValidateResourcePolicyOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ValidateResourcePolicyRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*secretsmanager.ValidateResourcePolicyOutput) - return ret0, ret1 -} - -// ValidateResourcePolicyRequest indicates an expected call of ValidateResourcePolicyRequest. -func (mr *MockSecretsManagerAPIMockRecorder) ValidateResourcePolicyRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ValidateResourcePolicyRequest", reflect.TypeOf((*MockSecretsManagerAPI)(nil).ValidateResourcePolicyRequest), arg0) -} - -// ValidateResourcePolicyWithContext mocks base method. -func (m *MockSecretsManagerAPI) ValidateResourcePolicyWithContext(arg0 context.Context, arg1 *secretsmanager.ValidateResourcePolicyInput, arg2 ...request.Option) (*secretsmanager.ValidateResourcePolicyOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "ValidateResourcePolicyWithContext", varargs...) - ret0, _ := ret[0].(*secretsmanager.ValidateResourcePolicyOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ValidateResourcePolicyWithContext indicates an expected call of ValidateResourcePolicyWithContext. -func (mr *MockSecretsManagerAPIMockRecorder) ValidateResourcePolicyWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { +// DeleteSecret indicates an expected call of DeleteSecret. +func (mr *MockSecretsManagerAPIMockRecorder) DeleteSecret(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ValidateResourcePolicyWithContext", reflect.TypeOf((*MockSecretsManagerAPI)(nil).ValidateResourcePolicyWithContext), varargs...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSecret", reflect.TypeOf((*MockSecretsManagerAPI)(nil).DeleteSecret), varargs...) } diff --git a/pkg/cloud/services/secretsmanager/secret_test.go b/pkg/cloud/services/secretsmanager/secret_test.go index 87cf7e958a..26ee62c780 100644 --- a/pkg/cloud/services/secretsmanager/secret_test.go +++ b/pkg/cloud/services/secretsmanager/secret_test.go @@ -17,12 +17,13 @@ limitations under the License. package secretsmanager import ( + "context" "crypto/rand" "sort" "testing" - "github.com/aws/aws-sdk-go/aws" - "github.com/aws/aws-sdk-go/service/secretsmanager" + "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/service/secretsmanager" "github.com/golang/mock/gomock" . "github.com/onsi/gomega" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" @@ -30,8 +31,8 @@ import ( "sigs.k8s.io/controller-runtime/pkg/client" "sigs.k8s.io/controller-runtime/pkg/client/fake" + "github.com/aws/aws-sdk-go-v2/service/secretsmanager/types" infrav1 "sigs.k8s.io/cluster-api-provider-aws/v2/api/v1beta2" - "sigs.k8s.io/cluster-api-provider-aws/v2/pkg/cloud/awserrors" "sigs.k8s.io/cluster-api-provider-aws/v2/pkg/cloud/scope" "sigs.k8s.io/cluster-api-provider-aws/v2/pkg/cloud/services/secretsmanager/mock_secretsmanageriface" clusterv1 "sigs.k8s.io/cluster-api/api/v1beta1" @@ -48,13 +49,13 @@ func TestServiceCreate(t *testing.T) { return token } - sortTagsByKey := func(tags []*secretsmanager.Tag) { + sortTagsByKey := func(tags []types.Tag) { sort.Slice(tags, func(i, j int) bool { return *(tags[i].Key) < *(tags[j].Key) }) } - expectedTags := []*secretsmanager.Tag{ + expectedTags := []types.Tag{ { Key: aws.String("Name"), Value: aws.String("infra-cluster"), @@ -97,7 +98,7 @@ func TestServiceCreate(t *testing.T) { expectedPrefix: "/awsprefix", wantErr: false, expect: func(g *WithT, m *mock_secretsmanageriface.MockSecretsManagerAPIMockRecorder) { - m.CreateSecret(gomock.Any()).Times(0) + m.CreateSecret(gomock.Any(), gomock.AssignableToTypeOf(&secretsmanager.CreateSecretInput{})).Times(0) }, }, { @@ -107,8 +108,8 @@ func TestServiceCreate(t *testing.T) { expectedPrefix: "prefix", wantErr: false, expect: func(g *WithT, m *mock_secretsmanageriface.MockSecretsManagerAPIMockRecorder) { - m.CreateSecret(gomock.AssignableToTypeOf(&secretsmanager.CreateSecretInput{})).MinTimes(1).Return(&secretsmanager.CreateSecretOutput{}, nil).Do( - func(createSecretInput *secretsmanager.CreateSecretInput) { + m.CreateSecret(gomock.Any(), gomock.AssignableToTypeOf(&secretsmanager.CreateSecretInput{})).MinTimes(1).Return(&secretsmanager.CreateSecretOutput{}, nil).Do( + func(ctx context.Context, createSecretInput *secretsmanager.CreateSecretInput, optFns ...func(*secretsmanager.Options)) { g.Expect(*(createSecretInput.Name)).To(HavePrefix("prefix-")) sortTagsByKey(createSecretInput.Tags) g.Expect(createSecretInput.Tags).To(Equal(expectedTags)) @@ -123,8 +124,8 @@ func TestServiceCreate(t *testing.T) { expectedPrefix: "/prefix", wantErr: true, expect: func(g *WithT, m *mock_secretsmanageriface.MockSecretsManagerAPIMockRecorder) { - m.CreateSecret(gomock.AssignableToTypeOf(&secretsmanager.CreateSecretInput{})).Return(nil, &secretsmanager.InternalServiceError{}).Do( - func(createSecretInput *secretsmanager.CreateSecretInput) { + m.CreateSecret(gomock.Any(), gomock.AssignableToTypeOf(&secretsmanager.CreateSecretInput{})).Return(nil, &types.InternalServiceError{}).Do( + func(ctx context.Context, createSecretInput *secretsmanager.CreateSecretInput, optFns ...func(*secretsmanager.Options)) { g.Expect(*(createSecretInput.Name)).To(HavePrefix("/prefix-")) sortTagsByKey(createSecretInput.Tags) g.Expect(createSecretInput.Tags).To(Equal(expectedTags)) @@ -139,9 +140,9 @@ func TestServiceCreate(t *testing.T) { expectedPrefix: "aws.cluster.x-k8s.io", wantErr: false, expect: func(g *WithT, m *mock_secretsmanageriface.MockSecretsManagerAPIMockRecorder) { - m.CreateSecret(gomock.AssignableToTypeOf(&secretsmanager.CreateSecretInput{})).Return(nil, &secretsmanager.InvalidRequestException{}) - m.CreateSecret(gomock.AssignableToTypeOf(&secretsmanager.CreateSecretInput{})).Return(nil, &secretsmanager.ResourceNotFoundException{}) - m.CreateSecret(gomock.AssignableToTypeOf(&secretsmanager.CreateSecretInput{})).Return(&secretsmanager.CreateSecretOutput{}, nil) + m.CreateSecret(gomock.Any(), gomock.AssignableToTypeOf(&secretsmanager.CreateSecretInput{})).Return(nil, &types.InvalidRequestException{}) + m.CreateSecret(gomock.Any(), gomock.AssignableToTypeOf(&secretsmanager.CreateSecretInput{})).Return(nil, &types.ResourceNotFoundException{}) + m.CreateSecret(gomock.Any(), gomock.AssignableToTypeOf(&secretsmanager.CreateSecretInput{})).Return(&secretsmanager.CreateSecretOutput{}, nil) }, }, { @@ -151,9 +152,9 @@ func TestServiceCreate(t *testing.T) { expectedPrefix: "aws.cluster.x-k8s.io", wantErr: false, expect: func(g *WithT, m *mock_secretsmanageriface.MockSecretsManagerAPIMockRecorder) { - m.CreateSecret(gomock.AssignableToTypeOf(&secretsmanager.CreateSecretInput{})).Return(nil, &secretsmanager.ResourceExistsException{}) - m.DeleteSecret(gomock.AssignableToTypeOf(&secretsmanager.DeleteSecretInput{})).Return(&secretsmanager.DeleteSecretOutput{}, nil) - m.CreateSecret(gomock.AssignableToTypeOf(&secretsmanager.CreateSecretInput{})).Return(&secretsmanager.CreateSecretOutput{}, nil) + m.CreateSecret(gomock.Any(), gomock.AssignableToTypeOf(&secretsmanager.CreateSecretInput{})).Return(nil, &types.ResourceExistsException{}) + m.DeleteSecret(gomock.Any(), gomock.AssignableToTypeOf(&secretsmanager.DeleteSecretInput{})).Return(&secretsmanager.DeleteSecretOutput{}, nil) + m.CreateSecret(gomock.Any(), gomock.AssignableToTypeOf(&secretsmanager.CreateSecretInput{})).Return(&secretsmanager.CreateSecretOutput{}, nil) }, }, } @@ -202,7 +203,7 @@ func TestServiceDelete(t *testing.T) { name: "Should not return error when delete is successful", secretCount: 1, expect: func(m *mock_secretsmanageriface.MockSecretsManagerAPIMockRecorder) { - m.DeleteSecret(gomock.Eq(&secretsmanager.DeleteSecretInput{ + m.DeleteSecret(gomock.Any(), gomock.Eq(&secretsmanager.DeleteSecretInput{ SecretId: aws.String("prefix-0"), ForceDeleteWithoutRecovery: aws.Bool(true), })).Return(&secretsmanager.DeleteSecretOutput{}, nil) @@ -215,22 +216,22 @@ func TestServiceDelete(t *testing.T) { name: "Should return all errors except not found errors", secretCount: 3, expect: func(m *mock_secretsmanageriface.MockSecretsManagerAPIMockRecorder) { - m.DeleteSecret(gomock.Eq(&secretsmanager.DeleteSecretInput{ + m.DeleteSecret(gomock.Any(), gomock.Eq(&secretsmanager.DeleteSecretInput{ SecretId: aws.String("prefix-0"), ForceDeleteWithoutRecovery: aws.Bool(true), - })).Return(nil, awserrors.NewFailedDependency("failed dependency")) - m.DeleteSecret(gomock.Eq(&secretsmanager.DeleteSecretInput{ + })).Return(nil, &types.InternalServiceError{}) + m.DeleteSecret(gomock.Any(), gomock.Eq(&secretsmanager.DeleteSecretInput{ SecretId: aws.String("prefix-1"), ForceDeleteWithoutRecovery: aws.Bool(true), - })).Return(nil, awserrors.NewNotFound("not found")) - m.DeleteSecret(gomock.Eq(&secretsmanager.DeleteSecretInput{ + })).Return(nil, &types.ResourceNotFoundException{}) + m.DeleteSecret(gomock.Any(), gomock.Eq(&secretsmanager.DeleteSecretInput{ SecretId: aws.String("prefix-2"), ForceDeleteWithoutRecovery: aws.Bool(true), - })).Return(nil, awserrors.NewConflict("new conflict")) + })).Return(nil, &types.InvalidRequestException{}) }, check: func(g *WithT, err error) { g.Expect(err).ToNot(BeNil()) - g.Expect((err.Error())).To(Equal("[failed dependency, new conflict]")) + g.Expect((err.Error())).To(Equal("[InternalServiceError: , InvalidRequestException: ]")) }, }, } diff --git a/pkg/cloud/services/secretsmanager/service.go b/pkg/cloud/services/secretsmanager/service.go index 5b025a904d..405e88f197 100644 --- a/pkg/cloud/services/secretsmanager/service.go +++ b/pkg/cloud/services/secretsmanager/service.go @@ -18,6 +18,8 @@ limitations under the License. package secretsmanager import ( + "context" + "github.com/aws/aws-sdk-go-v2/service/secretsmanager" "sigs.k8s.io/cluster-api-provider-aws/v2/pkg/cloud" @@ -29,9 +31,17 @@ import ( // One alternative is to have a large list of functions from the ec2 client. type Service struct { scope cloud.ClusterScoper - SecretsManagerClient *secretsmanager.Client + SecretsManagerClient SecretsManagerAPI +} + +// SecretsManagerAPI is the subset of the AWS Secrets Manager API that is used by CAPA. +type SecretsManagerAPI interface { + CreateSecret(ctx context.Context, params *secretsmanager.CreateSecretInput, optFns ...func(*secretsmanager.Options)) (*secretsmanager.CreateSecretOutput, error) + DeleteSecret(ctx context.Context, params *secretsmanager.DeleteSecretInput, optFns ...func(*secretsmanager.Options)) (*secretsmanager.DeleteSecretOutput, error) } +var _ SecretsManagerAPI = &secretsmanager.Client{} + // NewService returns a new service given the api clients. func NewService(secretsScope cloud.ClusterScoper) *Service { return &Service{ diff --git a/pkg/cloud/services/ssm/mock_ssmiface/ssmiface_mock.go b/pkg/cloud/services/ssm/mock_ssmiface/ssmiface_mock.go deleted file mode 100644 index e48bb8ade8..0000000000 --- a/pkg/cloud/services/ssm/mock_ssmiface/ssmiface_mock.go +++ /dev/null @@ -1,112 +0,0 @@ -/* -Copyright The Kubernetes Authors. - -Licensed under the Apache License, Version 2.0 (the "License"); -you may not use this file except in compliance with the License. -You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - -Unless required by applicable law or agreed to in writing, software -distributed under the License is distributed on an "AS IS" BASIS, -WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -See the License for the specific language governing permissions and -limitations under the License. -*/ - -// Code generated by MockGen. DO NOT EDIT. -// Source: pkg/cloud/services/ssm/service.go - -// Package mock_ssmiface is a generated GoMock package. -package mock_ssmiface - -import ( - context "context" - reflect "reflect" - - ssm "github.com/aws/aws-sdk-go-v2/service/ssm" - gomock "github.com/golang/mock/gomock" -) - -// MockSSMAPI is a mock of SSMAPI interface. -type MockSSMAPI struct { - ctrl *gomock.Controller - recorder *MockSSMAPIMockRecorder -} - -// MockSSMAPIMockRecorder is the mock recorder for MockSSMAPI. -type MockSSMAPIMockRecorder struct { - mock *MockSSMAPI -} - -// NewMockSSMAPI creates a new mock instance. -func NewMockSSMAPI(ctrl *gomock.Controller) *MockSSMAPI { - mock := &MockSSMAPI{ctrl: ctrl} - mock.recorder = &MockSSMAPIMockRecorder{mock} - return mock -} - -// EXPECT returns an object that allows the caller to indicate expected use. -func (m *MockSSMAPI) EXPECT() *MockSSMAPIMockRecorder { - return m.recorder -} - -// DeleteParameter mocks base method. -func (m *MockSSMAPI) DeleteParameter(ctx context.Context, input *ssm.DeleteParameterInput, optFns ...func(*ssm.Options)) (*ssm.DeleteParameterOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{ctx, input} - for _, a := range optFns { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DeleteParameter", varargs...) - ret0, _ := ret[0].(*ssm.DeleteParameterOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteParameter indicates an expected call of DeleteParameter. -func (mr *MockSSMAPIMockRecorder) DeleteParameter(ctx, input interface{}, optFns ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{ctx, input}, optFns...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteParameter", reflect.TypeOf((*MockSSMAPI)(nil).DeleteParameter), varargs...) -} - -// GetParameter mocks base method. -func (m *MockSSMAPI) GetParameter(ctx context.Context, input *ssm.GetParameterInput, optFns ...func(*ssm.Options)) (*ssm.GetParameterOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{ctx, input} - for _, a := range optFns { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "GetParameter", varargs...) - ret0, _ := ret[0].(*ssm.GetParameterOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetParameter indicates an expected call of GetParameter. -func (mr *MockSSMAPIMockRecorder) GetParameter(ctx, input interface{}, optFns ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{ctx, input}, optFns...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetParameter", reflect.TypeOf((*MockSSMAPI)(nil).GetParameter), varargs...) -} - -// PutParameter mocks base method. -func (m *MockSSMAPI) PutParameter(ctx context.Context, input *ssm.PutParameterInput, optFns ...func(*ssm.Options)) (*ssm.PutParameterOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{ctx, input} - for _, a := range optFns { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "PutParameter", varargs...) - ret0, _ := ret[0].(*ssm.PutParameterOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// PutParameter indicates an expected call of PutParameter. -func (mr *MockSSMAPIMockRecorder) PutParameter(ctx, input interface{}, optFns ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{ctx, input}, optFns...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutParameter", reflect.TypeOf((*MockSSMAPI)(nil).PutParameter), varargs...) -} diff --git a/pkg/cloud/services/sts/mock_stsiface/stsiface_mock_v1.go b/pkg/cloud/services/sts/mock_stsiface/stsiface_mock_v1.go index 047c9491fc..93b56832b9 100644 --- a/pkg/cloud/services/sts/mock_stsiface/stsiface_mock_v1.go +++ b/pkg/cloud/services/sts/mock_stsiface/stsiface_mock_v1.go @@ -15,7 +15,7 @@ limitations under the License. */ // Code generated by MockGen. DO NOT EDIT. -// Source: github.com/aws/aws-sdk-go/service/sts/stsiface (interfaces: STSAPI) +// Source: sigs.k8s.io/cluster-api-provider-aws/v2/pkg/cloud/services/s3 (interfaces: STSAPI) // Package mock_stsiface is a generated GoMock package. package mock_stsiface @@ -24,8 +24,7 @@ import ( context "context" reflect "reflect" - request "github.com/aws/aws-sdk-go/aws/request" - sts "github.com/aws/aws-sdk-go/service/sts" + sts "github.com/aws/aws-sdk-go-v2/service/sts" gomock "github.com/golang/mock/gomock" ) @@ -52,402 +51,22 @@ func (m *MockSTSAPI) EXPECT() *MockSTSAPIMockRecorder { return m.recorder } -// AssumeRole mocks base method. -func (m *MockSTSAPI) AssumeRole(arg0 *sts.AssumeRoleInput) (*sts.AssumeRoleOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "AssumeRole", arg0) - ret0, _ := ret[0].(*sts.AssumeRoleOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// AssumeRole indicates an expected call of AssumeRole. -func (mr *MockSTSAPIMockRecorder) AssumeRole(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssumeRole", reflect.TypeOf((*MockSTSAPI)(nil).AssumeRole), arg0) -} - -// AssumeRoleRequest mocks base method. -func (m *MockSTSAPI) AssumeRoleRequest(arg0 *sts.AssumeRoleInput) (*request.Request, *sts.AssumeRoleOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "AssumeRoleRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*sts.AssumeRoleOutput) - return ret0, ret1 -} - -// AssumeRoleRequest indicates an expected call of AssumeRoleRequest. -func (mr *MockSTSAPIMockRecorder) AssumeRoleRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssumeRoleRequest", reflect.TypeOf((*MockSTSAPI)(nil).AssumeRoleRequest), arg0) -} - -// AssumeRoleWithContext mocks base method. -func (m *MockSTSAPI) AssumeRoleWithContext(arg0 context.Context, arg1 *sts.AssumeRoleInput, arg2 ...request.Option) (*sts.AssumeRoleOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "AssumeRoleWithContext", varargs...) - ret0, _ := ret[0].(*sts.AssumeRoleOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// AssumeRoleWithContext indicates an expected call of AssumeRoleWithContext. -func (mr *MockSTSAPIMockRecorder) AssumeRoleWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssumeRoleWithContext", reflect.TypeOf((*MockSTSAPI)(nil).AssumeRoleWithContext), varargs...) -} - -// AssumeRoleWithSAML mocks base method. -func (m *MockSTSAPI) AssumeRoleWithSAML(arg0 *sts.AssumeRoleWithSAMLInput) (*sts.AssumeRoleWithSAMLOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "AssumeRoleWithSAML", arg0) - ret0, _ := ret[0].(*sts.AssumeRoleWithSAMLOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// AssumeRoleWithSAML indicates an expected call of AssumeRoleWithSAML. -func (mr *MockSTSAPIMockRecorder) AssumeRoleWithSAML(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssumeRoleWithSAML", reflect.TypeOf((*MockSTSAPI)(nil).AssumeRoleWithSAML), arg0) -} - -// AssumeRoleWithSAMLRequest mocks base method. -func (m *MockSTSAPI) AssumeRoleWithSAMLRequest(arg0 *sts.AssumeRoleWithSAMLInput) (*request.Request, *sts.AssumeRoleWithSAMLOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "AssumeRoleWithSAMLRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*sts.AssumeRoleWithSAMLOutput) - return ret0, ret1 -} - -// AssumeRoleWithSAMLRequest indicates an expected call of AssumeRoleWithSAMLRequest. -func (mr *MockSTSAPIMockRecorder) AssumeRoleWithSAMLRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssumeRoleWithSAMLRequest", reflect.TypeOf((*MockSTSAPI)(nil).AssumeRoleWithSAMLRequest), arg0) -} - -// AssumeRoleWithSAMLWithContext mocks base method. -func (m *MockSTSAPI) AssumeRoleWithSAMLWithContext(arg0 context.Context, arg1 *sts.AssumeRoleWithSAMLInput, arg2 ...request.Option) (*sts.AssumeRoleWithSAMLOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "AssumeRoleWithSAMLWithContext", varargs...) - ret0, _ := ret[0].(*sts.AssumeRoleWithSAMLOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// AssumeRoleWithSAMLWithContext indicates an expected call of AssumeRoleWithSAMLWithContext. -func (mr *MockSTSAPIMockRecorder) AssumeRoleWithSAMLWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssumeRoleWithSAMLWithContext", reflect.TypeOf((*MockSTSAPI)(nil).AssumeRoleWithSAMLWithContext), varargs...) -} - -// AssumeRoleWithWebIdentity mocks base method. -func (m *MockSTSAPI) AssumeRoleWithWebIdentity(arg0 *sts.AssumeRoleWithWebIdentityInput) (*sts.AssumeRoleWithWebIdentityOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "AssumeRoleWithWebIdentity", arg0) - ret0, _ := ret[0].(*sts.AssumeRoleWithWebIdentityOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// AssumeRoleWithWebIdentity indicates an expected call of AssumeRoleWithWebIdentity. -func (mr *MockSTSAPIMockRecorder) AssumeRoleWithWebIdentity(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssumeRoleWithWebIdentity", reflect.TypeOf((*MockSTSAPI)(nil).AssumeRoleWithWebIdentity), arg0) -} - -// AssumeRoleWithWebIdentityRequest mocks base method. -func (m *MockSTSAPI) AssumeRoleWithWebIdentityRequest(arg0 *sts.AssumeRoleWithWebIdentityInput) (*request.Request, *sts.AssumeRoleWithWebIdentityOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "AssumeRoleWithWebIdentityRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*sts.AssumeRoleWithWebIdentityOutput) - return ret0, ret1 -} - -// AssumeRoleWithWebIdentityRequest indicates an expected call of AssumeRoleWithWebIdentityRequest. -func (mr *MockSTSAPIMockRecorder) AssumeRoleWithWebIdentityRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssumeRoleWithWebIdentityRequest", reflect.TypeOf((*MockSTSAPI)(nil).AssumeRoleWithWebIdentityRequest), arg0) -} - -// AssumeRoleWithWebIdentityWithContext mocks base method. -func (m *MockSTSAPI) AssumeRoleWithWebIdentityWithContext(arg0 context.Context, arg1 *sts.AssumeRoleWithWebIdentityInput, arg2 ...request.Option) (*sts.AssumeRoleWithWebIdentityOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "AssumeRoleWithWebIdentityWithContext", varargs...) - ret0, _ := ret[0].(*sts.AssumeRoleWithWebIdentityOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// AssumeRoleWithWebIdentityWithContext indicates an expected call of AssumeRoleWithWebIdentityWithContext. -func (mr *MockSTSAPIMockRecorder) AssumeRoleWithWebIdentityWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssumeRoleWithWebIdentityWithContext", reflect.TypeOf((*MockSTSAPI)(nil).AssumeRoleWithWebIdentityWithContext), varargs...) -} - -// DecodeAuthorizationMessage mocks base method. -func (m *MockSTSAPI) DecodeAuthorizationMessage(arg0 *sts.DecodeAuthorizationMessageInput) (*sts.DecodeAuthorizationMessageOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DecodeAuthorizationMessage", arg0) - ret0, _ := ret[0].(*sts.DecodeAuthorizationMessageOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DecodeAuthorizationMessage indicates an expected call of DecodeAuthorizationMessage. -func (mr *MockSTSAPIMockRecorder) DecodeAuthorizationMessage(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DecodeAuthorizationMessage", reflect.TypeOf((*MockSTSAPI)(nil).DecodeAuthorizationMessage), arg0) -} - -// DecodeAuthorizationMessageRequest mocks base method. -func (m *MockSTSAPI) DecodeAuthorizationMessageRequest(arg0 *sts.DecodeAuthorizationMessageInput) (*request.Request, *sts.DecodeAuthorizationMessageOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DecodeAuthorizationMessageRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*sts.DecodeAuthorizationMessageOutput) - return ret0, ret1 -} - -// DecodeAuthorizationMessageRequest indicates an expected call of DecodeAuthorizationMessageRequest. -func (mr *MockSTSAPIMockRecorder) DecodeAuthorizationMessageRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DecodeAuthorizationMessageRequest", reflect.TypeOf((*MockSTSAPI)(nil).DecodeAuthorizationMessageRequest), arg0) -} - -// DecodeAuthorizationMessageWithContext mocks base method. -func (m *MockSTSAPI) DecodeAuthorizationMessageWithContext(arg0 context.Context, arg1 *sts.DecodeAuthorizationMessageInput, arg2 ...request.Option) (*sts.DecodeAuthorizationMessageOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DecodeAuthorizationMessageWithContext", varargs...) - ret0, _ := ret[0].(*sts.DecodeAuthorizationMessageOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DecodeAuthorizationMessageWithContext indicates an expected call of DecodeAuthorizationMessageWithContext. -func (mr *MockSTSAPIMockRecorder) DecodeAuthorizationMessageWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DecodeAuthorizationMessageWithContext", reflect.TypeOf((*MockSTSAPI)(nil).DecodeAuthorizationMessageWithContext), varargs...) -} - -// GetAccessKeyInfo mocks base method. -func (m *MockSTSAPI) GetAccessKeyInfo(arg0 *sts.GetAccessKeyInfoInput) (*sts.GetAccessKeyInfoOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetAccessKeyInfo", arg0) - ret0, _ := ret[0].(*sts.GetAccessKeyInfoOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetAccessKeyInfo indicates an expected call of GetAccessKeyInfo. -func (mr *MockSTSAPIMockRecorder) GetAccessKeyInfo(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAccessKeyInfo", reflect.TypeOf((*MockSTSAPI)(nil).GetAccessKeyInfo), arg0) -} - -// GetAccessKeyInfoRequest mocks base method. -func (m *MockSTSAPI) GetAccessKeyInfoRequest(arg0 *sts.GetAccessKeyInfoInput) (*request.Request, *sts.GetAccessKeyInfoOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetAccessKeyInfoRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*sts.GetAccessKeyInfoOutput) - return ret0, ret1 -} - -// GetAccessKeyInfoRequest indicates an expected call of GetAccessKeyInfoRequest. -func (mr *MockSTSAPIMockRecorder) GetAccessKeyInfoRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAccessKeyInfoRequest", reflect.TypeOf((*MockSTSAPI)(nil).GetAccessKeyInfoRequest), arg0) -} - -// GetAccessKeyInfoWithContext mocks base method. -func (m *MockSTSAPI) GetAccessKeyInfoWithContext(arg0 context.Context, arg1 *sts.GetAccessKeyInfoInput, arg2 ...request.Option) (*sts.GetAccessKeyInfoOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "GetAccessKeyInfoWithContext", varargs...) - ret0, _ := ret[0].(*sts.GetAccessKeyInfoOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetAccessKeyInfoWithContext indicates an expected call of GetAccessKeyInfoWithContext. -func (mr *MockSTSAPIMockRecorder) GetAccessKeyInfoWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAccessKeyInfoWithContext", reflect.TypeOf((*MockSTSAPI)(nil).GetAccessKeyInfoWithContext), varargs...) -} - // GetCallerIdentity mocks base method. -func (m *MockSTSAPI) GetCallerIdentity(arg0 *sts.GetCallerIdentityInput) (*sts.GetCallerIdentityOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetCallerIdentity", arg0) - ret0, _ := ret[0].(*sts.GetCallerIdentityOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetCallerIdentity indicates an expected call of GetCallerIdentity. -func (mr *MockSTSAPIMockRecorder) GetCallerIdentity(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCallerIdentity", reflect.TypeOf((*MockSTSAPI)(nil).GetCallerIdentity), arg0) -} - -// GetCallerIdentityRequest mocks base method. -func (m *MockSTSAPI) GetCallerIdentityRequest(arg0 *sts.GetCallerIdentityInput) (*request.Request, *sts.GetCallerIdentityOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetCallerIdentityRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*sts.GetCallerIdentityOutput) - return ret0, ret1 -} - -// GetCallerIdentityRequest indicates an expected call of GetCallerIdentityRequest. -func (mr *MockSTSAPIMockRecorder) GetCallerIdentityRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCallerIdentityRequest", reflect.TypeOf((*MockSTSAPI)(nil).GetCallerIdentityRequest), arg0) -} - -// GetCallerIdentityWithContext mocks base method. -func (m *MockSTSAPI) GetCallerIdentityWithContext(arg0 context.Context, arg1 *sts.GetCallerIdentityInput, arg2 ...request.Option) (*sts.GetCallerIdentityOutput, error) { +func (m *MockSTSAPI) GetCallerIdentity(arg0 context.Context, arg1 *sts.GetCallerIdentityInput, arg2 ...func(*sts.Options)) (*sts.GetCallerIdentityOutput, error) { m.ctrl.T.Helper() varargs := []interface{}{arg0, arg1} for _, a := range arg2 { varargs = append(varargs, a) } - ret := m.ctrl.Call(m, "GetCallerIdentityWithContext", varargs...) + ret := m.ctrl.Call(m, "GetCallerIdentity", varargs...) ret0, _ := ret[0].(*sts.GetCallerIdentityOutput) ret1, _ := ret[1].(error) return ret0, ret1 } -// GetCallerIdentityWithContext indicates an expected call of GetCallerIdentityWithContext. -func (mr *MockSTSAPIMockRecorder) GetCallerIdentityWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCallerIdentityWithContext", reflect.TypeOf((*MockSTSAPI)(nil).GetCallerIdentityWithContext), varargs...) -} - -// GetFederationToken mocks base method. -func (m *MockSTSAPI) GetFederationToken(arg0 *sts.GetFederationTokenInput) (*sts.GetFederationTokenOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetFederationToken", arg0) - ret0, _ := ret[0].(*sts.GetFederationTokenOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetFederationToken indicates an expected call of GetFederationToken. -func (mr *MockSTSAPIMockRecorder) GetFederationToken(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetFederationToken", reflect.TypeOf((*MockSTSAPI)(nil).GetFederationToken), arg0) -} - -// GetFederationTokenRequest mocks base method. -func (m *MockSTSAPI) GetFederationTokenRequest(arg0 *sts.GetFederationTokenInput) (*request.Request, *sts.GetFederationTokenOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetFederationTokenRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*sts.GetFederationTokenOutput) - return ret0, ret1 -} - -// GetFederationTokenRequest indicates an expected call of GetFederationTokenRequest. -func (mr *MockSTSAPIMockRecorder) GetFederationTokenRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetFederationTokenRequest", reflect.TypeOf((*MockSTSAPI)(nil).GetFederationTokenRequest), arg0) -} - -// GetFederationTokenWithContext mocks base method. -func (m *MockSTSAPI) GetFederationTokenWithContext(arg0 context.Context, arg1 *sts.GetFederationTokenInput, arg2 ...request.Option) (*sts.GetFederationTokenOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "GetFederationTokenWithContext", varargs...) - ret0, _ := ret[0].(*sts.GetFederationTokenOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetFederationTokenWithContext indicates an expected call of GetFederationTokenWithContext. -func (mr *MockSTSAPIMockRecorder) GetFederationTokenWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetFederationTokenWithContext", reflect.TypeOf((*MockSTSAPI)(nil).GetFederationTokenWithContext), varargs...) -} - -// GetSessionToken mocks base method. -func (m *MockSTSAPI) GetSessionToken(arg0 *sts.GetSessionTokenInput) (*sts.GetSessionTokenOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetSessionToken", arg0) - ret0, _ := ret[0].(*sts.GetSessionTokenOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetSessionToken indicates an expected call of GetSessionToken. -func (mr *MockSTSAPIMockRecorder) GetSessionToken(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSessionToken", reflect.TypeOf((*MockSTSAPI)(nil).GetSessionToken), arg0) -} - -// GetSessionTokenRequest mocks base method. -func (m *MockSTSAPI) GetSessionTokenRequest(arg0 *sts.GetSessionTokenInput) (*request.Request, *sts.GetSessionTokenOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetSessionTokenRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*sts.GetSessionTokenOutput) - return ret0, ret1 -} - -// GetSessionTokenRequest indicates an expected call of GetSessionTokenRequest. -func (mr *MockSTSAPIMockRecorder) GetSessionTokenRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSessionTokenRequest", reflect.TypeOf((*MockSTSAPI)(nil).GetSessionTokenRequest), arg0) -} - -// GetSessionTokenWithContext mocks base method. -func (m *MockSTSAPI) GetSessionTokenWithContext(arg0 context.Context, arg1 *sts.GetSessionTokenInput, arg2 ...request.Option) (*sts.GetSessionTokenOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "GetSessionTokenWithContext", varargs...) - ret0, _ := ret[0].(*sts.GetSessionTokenOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetSessionTokenWithContext indicates an expected call of GetSessionTokenWithContext. -func (mr *MockSTSAPIMockRecorder) GetSessionTokenWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { +// GetCallerIdentity indicates an expected call of GetCallerIdentity. +func (mr *MockSTSAPIMockRecorder) GetCallerIdentity(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSessionTokenWithContext", reflect.TypeOf((*MockSTSAPI)(nil).GetSessionTokenWithContext), varargs...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCallerIdentity", reflect.TypeOf((*MockSTSAPI)(nil).GetCallerIdentity), varargs...) } diff --git a/pkg/cloud/services/wait/wait.go b/pkg/cloud/services/wait/wait.go index b725fa6b14..aa97bd9487 100644 --- a/pkg/cloud/services/wait/wait.go +++ b/pkg/cloud/services/wait/wait.go @@ -68,11 +68,12 @@ func WaitForWithRetryable(backoff wait.Backoff, condition wait.ConditionFunc, re // If the returned error isn't empty, check if the error is a retryable one, // or return immediately. - code, ok := awserrors.Code(errors.Cause(err)) - if !ok { + smithyErr := awserrors.ParseSmithyError(err) + if smithyErr == nil { return false, err } + code := smithyErr.ErrorCode() for _, r := range retryableErrors { if code == r { // We should retry. diff --git a/test/e2e/shared/aws_helpers.go b/test/e2e/shared/aws_helpers.go index a338741f75..cb8cbfbaed 100644 --- a/test/e2e/shared/aws_helpers.go +++ b/test/e2e/shared/aws_helpers.go @@ -37,11 +37,11 @@ import ( ) type WaitForLoadBalancerToExistForServiceInput struct { - AWSSession *aws.Config - ServiceName string - ServiceNamespace string - ClusterName string - Type infrav1.LoadBalancerType + AWSSessionV2 *aws.Config + ServiceName string + ServiceNamespace string + ClusterName string + Type infrav1.LoadBalancerType } func WaitForLoadBalancerToExistForService(ctx context.Context, input WaitForLoadBalancerToExistForServiceInput, intervals ...interface{}) { @@ -65,11 +65,11 @@ func WaitForLoadBalancerToExistForService(ctx context.Context, input WaitForLoad } type GetLoadBalancerARNsInput struct { - AWSSession *aws.Config - ServiceName string - ServiceNamespace string - ClusterName string - Type infrav1.LoadBalancerType + AWSSessionV2 *aws.Config + ServiceName string + ServiceNamespace string + ClusterName string + Type infrav1.LoadBalancerType } func GetLoadBalancerARNs(ctx context.Context, input GetLoadBalancerARNsInput) ([]string, error) { @@ -81,8 +81,8 @@ func GetLoadBalancerARNs(ctx context.Context, input GetLoadBalancerARNsInput) ([ serviceTag: {string(infrav1.ResourceLifecycleOwned)}, } descInput := &DescribeResourcesByTagsInput{ - AWSSession: input.AWSSession, - Tags: tags, + AWSSessionV2: input.AWSSessionV2, + Tags: tags, } descOutput, err := DescribeResourcesByTags(ctx, *descInput) @@ -123,8 +123,8 @@ func GetLoadBalancerARNs(ctx context.Context, input GetLoadBalancerARNsInput) ([ } type DescribeResourcesByTagsInput struct { - AWSSession *aws.Config - Tags map[string][]string + AWSSessionV2 *aws.Config + Tags map[string][]string } type DescribeResourcesByTagsOutput struct { @@ -147,7 +147,7 @@ func DescribeResourcesByTags(ctx context.Context, input DescribeResourcesByTagsI }) } - rgSvc := rgapi.NewFromConfig(*input.AWSSession) + rgSvc := rgapi.NewFromConfig(*input.AWSSessionV2) awsOutput, err := rgSvc.GetResources(ctx, &awsInput) if err != nil { return nil, fmt.Errorf("getting resources by tags: %w", err) @@ -164,15 +164,15 @@ func DescribeResourcesByTags(ctx context.Context, input DescribeResourcesByTagsI } type CheckClassicElbHealthCheckInput struct { - AWSSession *aws.Config - LoadBalancerName string - ExpectedTarget string + AWSSessionV2 *aws.Config + LoadBalancerName string + ExpectedTarget string } func CheckClassicElbHealthCheck(ctx context.Context, input CheckClassicElbHealthCheckInput, intervals ...interface{}) { Byf("Checking the health check for the classic load balancer %s", input.LoadBalancerName) - elbSvc := elb.NewFromConfig(*input.AWSSession) + elbSvc := elb.NewFromConfig(*input.AWSSessionV2) Eventually(func() error { out, err := elbSvc.DescribeLoadBalancers(ctx, &elb.DescribeLoadBalancersInput{ diff --git a/test/e2e/suites/managed/addon.go b/test/e2e/suites/managed/addon.go index 52de46b52c..5ecab3c2f3 100644 --- a/test/e2e/suites/managed/addon.go +++ b/test/e2e/suites/managed/addon.go @@ -38,7 +38,7 @@ import ( type CheckAddonExistsSpecInput struct { E2EConfig *clusterctl.E2EConfig BootstrapClusterProxy framework.ClusterProxy - AWSSession *awsv2.Config + AWSSessionV2 *awsv2.Config Namespace *corev1.Namespace ClusterName string AddonName string @@ -51,7 +51,7 @@ func CheckAddonExistsSpec(ctx context.Context, inputGetter func() CheckAddonExis input := inputGetter() Expect(input.E2EConfig).ToNot(BeNil(), "Invalid argument. input.E2EConfig can't be nil") Expect(input.BootstrapClusterProxy).ToNot(BeNil(), "Invalid argument. input.BootstrapClusterProxy can't be nil") - Expect(input.AWSSession).ToNot(BeNil(), "Invalid argument. input.AWSSession can't be nil") + Expect(input.AWSSessionV2).ToNot(BeNil(), "Invalid argument. input.AWSSessionV2 can't be nil") Expect(input.Namespace).NotTo(BeNil(), "Invalid argument. input.Namespace can't be nil") Expect(input.ClusterName).ShouldNot(BeEmpty(), "Invalid argument. input.ClusterName can't be empty") Expect(input.AddonName).ShouldNot(BeEmpty(), "Invalid argument. input.AddonName can't be empty") @@ -69,7 +69,7 @@ func CheckAddonExistsSpec(ctx context.Context, inputGetter func() CheckAddonExis By(fmt.Sprintf("Checking EKS addon %s is installed on cluster %s and is active", input.AddonName, input.ClusterName)) waitForEKSAddonToHaveStatus(ctx, waitForEKSAddonToHaveStatusInput{ ControlPlane: controlPlane, - AWSSession: input.AWSSession, + AWSSessionV2: input.AWSSessionV2, AddonName: input.AddonName, AddonVersion: input.AddonVersion, AddonStatus: []string{string(ekstypes.AddonStatusActive), string(ekstypes.AddonStatusDegraded)}, @@ -79,7 +79,7 @@ func CheckAddonExistsSpec(ctx context.Context, inputGetter func() CheckAddonExis By(fmt.Sprintf("Checking EKS addon %s has the correct configuration", input.AddonName)) checkEKSAddonConfiguration(ctx, checkEKSAddonConfigurationInput{ ControlPlane: controlPlane, - AWSSession: input.AWSSession, + AWSSessionV2: input.AWSSessionV2, AddonName: input.AddonName, AddonVersion: input.AddonVersion, AddonConfiguration: input.AddonConfiguration, diff --git a/test/e2e/suites/managed/addon_helpers.go b/test/e2e/suites/managed/addon_helpers.go index 7643275277..96442d7a1e 100644 --- a/test/e2e/suites/managed/addon_helpers.go +++ b/test/e2e/suites/managed/addon_helpers.go @@ -32,7 +32,7 @@ import ( type waitForEKSAddonToHaveStatusInput struct { ControlPlane *ekscontrolplanev1.AWSManagedControlPlane - AWSSession *aws.Config + AWSSessionV2 *aws.Config AddonName string AddonVersion string AddonStatus []string @@ -40,7 +40,7 @@ type waitForEKSAddonToHaveStatusInput struct { func waitForEKSAddonToHaveStatus(ctx context.Context, input waitForEKSAddonToHaveStatusInput, intervals ...interface{}) { Expect(input.ControlPlane).ToNot(BeNil(), "Invalid argument. input.ControlPlane can't be nil") - Expect(input.AWSSession).ToNot(BeNil(), "Invalid argument. input.AWSSession can't be nil") + Expect(input.AWSSessionV2).ToNot(BeNil(), "Invalid argument. input.AWSSessionV2 can't be nil") Expect(input.AddonName).ShouldNot(BeEmpty(), "Invalid argument. input.AddonName can't be empty") Expect(input.AddonVersion).ShouldNot(BeEmpty(), "Invalid argument. input.AddonVersion can't be empty") Expect(input.AddonStatus).ShouldNot(BeEmpty(), "Invalid argument. input.AddonStatus can't be empty") @@ -48,7 +48,7 @@ func waitForEKSAddonToHaveStatus(ctx context.Context, input waitForEKSAddonToHav ginkgo.By(fmt.Sprintf("Ensuring EKS addon %s has status in %q for EKS cluster %s", input.AddonName, input.AddonStatus, input.ControlPlane.Spec.EKSClusterName)) Eventually(func() (bool, error) { - installedAddon, err := getEKSClusterAddon(ctx, input.ControlPlane.Spec.EKSClusterName, input.AddonName, input.AWSSession) + installedAddon, err := getEKSClusterAddon(ctx, input.ControlPlane.Spec.EKSClusterName, input.AddonName, input.AWSSessionV2) if err != nil { return false, err } @@ -71,7 +71,7 @@ func waitForEKSAddonToHaveStatus(ctx context.Context, input waitForEKSAddonToHav type checkEKSAddonConfigurationInput struct { ControlPlane *ekscontrolplanev1.AWSManagedControlPlane - AWSSession *aws.Config + AWSSessionV2 *aws.Config AddonName string AddonVersion string AddonConfiguration string @@ -79,7 +79,7 @@ type checkEKSAddonConfigurationInput struct { func checkEKSAddonConfiguration(ctx context.Context, input checkEKSAddonConfigurationInput, intervals ...interface{}) { Expect(input.ControlPlane).ToNot(BeNil(), "Invalid argument. input.ControlPlane can't be nil") - Expect(input.AWSSession).ToNot(BeNil(), "Invalid argument. input.AWSSession can't be nil") + Expect(input.AWSSessionV2).ToNot(BeNil(), "Invalid argument. input.AWSSessionV2 can't be nil") Expect(input.AddonName).ShouldNot(BeEmpty(), "Invalid argument. input.AddonName can't be empty") Expect(input.AddonVersion).ShouldNot(BeEmpty(), "Invalid argument. input.AddonVersion can't be empty") Expect(input.AddonConfiguration).ShouldNot(BeEmpty(), "Invalid argument. input.AddonConfiguration can't be empty") @@ -87,7 +87,7 @@ func checkEKSAddonConfiguration(ctx context.Context, input checkEKSAddonConfigur ginkgo.By(fmt.Sprintf("Ensuring EKS addon %s has config in %q for EKS cluster %s", input.AddonName, input.AddonConfiguration, input.ControlPlane.Spec.EKSClusterName)) Eventually(func() (bool, error) { - installedAddon, err := getEKSClusterAddon(ctx, input.ControlPlane.Spec.EKSClusterName, input.AddonName, input.AWSSession) + installedAddon, err := getEKSClusterAddon(ctx, input.ControlPlane.Spec.EKSClusterName, input.AddonName, input.AWSSessionV2) if err != nil { return false, err } diff --git a/test/e2e/suites/managed/aws_node_env.go b/test/e2e/suites/managed/aws_node_env.go index 09b71b1892..f4554649ac 100644 --- a/test/e2e/suites/managed/aws_node_env.go +++ b/test/e2e/suites/managed/aws_node_env.go @@ -39,7 +39,7 @@ import ( type UpdateAwsNodeVersionSpecInput struct { E2EConfig *clusterctl.E2EConfig BootstrapClusterProxy framework.ClusterProxy - AWSSession aws.Config + AWSSessionV2 *aws.Config Namespace *corev1.Namespace ClusterName string } @@ -49,7 +49,7 @@ func CheckAwsNodeEnvVarsSet(ctx context.Context, inputGetter func() UpdateAwsNod input := inputGetter() Expect(input.E2EConfig).ToNot(BeNil(), "Invalid argument. input.E2EConfig can't be nil") Expect(input.BootstrapClusterProxy).ToNot(BeNil(), "Invalid argument. input.BootstrapClusterProxy can't be nil") - Expect(input.AWSSession).ToNot(BeNil(), "Invalid argument. input.AWSSession can't be nil") + Expect(input.AWSSessionV2).ToNot(BeNil(), "Invalid argument. input.AWSSessionV2 can't be nil") Expect(input.Namespace).NotTo(BeNil(), "Invalid argument. input.Namespace can't be nil") Expect(input.ClusterName).ShouldNot(BeEmpty(), "Invalid argument. input.ClusterName can't be empty") diff --git a/test/e2e/suites/managed/control_plane.go b/test/e2e/suites/managed/control_plane.go index 1b820a7b11..d2d4369843 100644 --- a/test/e2e/suites/managed/control_plane.go +++ b/test/e2e/suites/managed/control_plane.go @@ -38,7 +38,7 @@ import ( // UpgradeControlPlaneVersionSpecInput is the input type for UpgradeControlPlaneVersionSpec. type UpgradeControlPlaneVersionSpecInput struct { E2EConfig *clusterctl.E2EConfig - AWSSession *aws.Config + AWSSessionV2 *aws.Config BootstrapClusterProxy framework.ClusterProxy ClusterName string Namespace *corev1.Namespace @@ -49,7 +49,7 @@ type UpgradeControlPlaneVersionSpecInput struct { func UpgradeControlPlaneVersionSpec(ctx context.Context, inputGetter func() UpgradeControlPlaneVersionSpecInput) { input := inputGetter() Expect(input.E2EConfig).ToNot(BeNil(), "Invalid argument. input.E2EConfig can't be nil") - Expect(input.AWSSession).ToNot(BeNil(), "Invalid argument. input.AWSSession can't be nil") + Expect(input.AWSSessionV2).ToNot(BeNil(), "Invalid argument. input.AWSSessionV2 can't be nil") Expect(input.BootstrapClusterProxy).ToNot(BeNil(), "Invalid argument. input.BootstrapClusterProxy can't be nil") Expect(input.ClusterName).ToNot(BeNil(), "Invalid argument. input.ClusterName can't be nil") Expect(input.Namespace).ToNot(BeNil(), "Invalid argument. input.Namespace can't be nil") @@ -72,7 +72,7 @@ func UpgradeControlPlaneVersionSpec(ctx context.Context, inputGetter func() Upgr ginkgo.By("Waiting for EKS control-plane to be upgraded to new version") waitForControlPlaneToBeUpgraded(ctx, waitForControlPlaneToBeUpgradedInput{ ControlPlane: controlPlane, - AWSSession: input.AWSSession, + AWSSessionV2: input.AWSSessionV2, UpgradeVersion: input.UpgradeVersion, }, input.E2EConfig.GetIntervals("", "wait-control-plane-upgrade")...) } diff --git a/test/e2e/suites/managed/control_plane_helpers.go b/test/e2e/suites/managed/control_plane_helpers.go index 0178236d32..d96c098074 100644 --- a/test/e2e/suites/managed/control_plane_helpers.go +++ b/test/e2e/suites/managed/control_plane_helpers.go @@ -40,13 +40,13 @@ import ( type waitForControlPlaneToBeUpgradedInput struct { ControlPlane *ekscontrolplanev1.AWSManagedControlPlane - AWSSession *aws.Config + AWSSessionV2 *aws.Config UpgradeVersion string } func waitForControlPlaneToBeUpgraded(ctx context.Context, input waitForControlPlaneToBeUpgradedInput, intervals ...interface{}) { Expect(input.ControlPlane).ToNot(BeNil(), "Invalid argument. input.ControlPlane can't be nil") - Expect(input.AWSSession).ToNot(BeNil(), "Invalid argument. input.AWSSession can't be nil") + Expect(input.AWSSessionV2).ToNot(BeNil(), "Invalid argument. input.AWSSessionV2 can't be nil") Expect(input.UpgradeVersion).ToNot(BeNil(), "Invalid argument. input.UpgradeVersion can't be nil") By(fmt.Sprintf("Ensuring EKS control-plane has been upgraded to kubernetes version %s", input.UpgradeVersion)) @@ -55,7 +55,7 @@ func waitForControlPlaneToBeUpgraded(ctx context.Context, input waitForControlPl expectedVersion := fmt.Sprintf("%d.%d", v.Major(), v.Minor()) Eventually(func() (bool, error) { - cluster, err := getEKSCluster(ctx, input.ControlPlane.Spec.EKSClusterName, input.AWSSession) + cluster, err := getEKSCluster(ctx, input.ControlPlane.Spec.EKSClusterName, input.AWSSessionV2) if err != nil { return false, err } diff --git a/test/e2e/suites/managed/eks_ipv6_test.go b/test/e2e/suites/managed/eks_ipv6_test.go index ced329bb25..b0212b34e5 100644 --- a/test/e2e/suites/managed/eks_ipv6_test.go +++ b/test/e2e/suites/managed/eks_ipv6_test.go @@ -66,7 +66,6 @@ var _ = ginkgo.Describe("[managed] [general] [ipv6] EKS cluster tests", func() { E2EConfig: e2eCtx.E2EConfig, ConfigClusterFn: defaultConfigCluster, BootstrapClusterProxy: e2eCtx.Environment.BootstrapClusterProxy, - AWSSession: e2eCtx.BootstrapUserAWSSession, AWSSessionV2: e2eCtx.BootstrapUserAWSSessionV2, Namespace: namespace, ClusterName: clusterName, @@ -82,7 +81,6 @@ var _ = ginkgo.Describe("[managed] [general] [ipv6] EKS cluster tests", func() { E2EConfig: e2eCtx.E2EConfig, ConfigClusterFn: defaultConfigCluster, BootstrapClusterProxy: e2eCtx.Environment.BootstrapClusterProxy, - AWSSession: e2eCtx.BootstrapUserAWSSession, AWSSessionV2: e2eCtx.BootstrapUserAWSSessionV2, Namespace: namespace, ClusterName: clusterName, diff --git a/test/e2e/suites/managed/eks_legacy_test.go b/test/e2e/suites/managed/eks_legacy_test.go index b749b77e5f..52ca56e079 100644 --- a/test/e2e/suites/managed/eks_legacy_test.go +++ b/test/e2e/suites/managed/eks_legacy_test.go @@ -66,7 +66,6 @@ var _ = ginkgo.Describe("[managed] [legacy] EKS cluster tests - single kind", fu E2EConfig: e2eCtx.E2EConfig, ConfigClusterFn: defaultConfigCluster, BootstrapClusterProxy: e2eCtx.Environment.BootstrapClusterProxy, - AWSSession: e2eCtx.BootstrapUserAWSSession, AWSSessionV2: e2eCtx.BootstrapUserAWSSessionV2, Namespace: namespace, ClusterName: clusterName, @@ -82,7 +81,6 @@ var _ = ginkgo.Describe("[managed] [legacy] EKS cluster tests - single kind", fu E2EConfig: e2eCtx.E2EConfig, ConfigClusterFn: defaultConfigCluster, BootstrapClusterProxy: e2eCtx.Environment.BootstrapClusterProxy, - AWSSession: e2eCtx.BootstrapUserAWSSession, AWSSessionV2: e2eCtx.BootstrapUserAWSSessionV2, Namespace: namespace, ClusterName: clusterName, diff --git a/test/e2e/suites/managed/eks_test.go b/test/e2e/suites/managed/eks_test.go index 3ee6a575c0..206aba4dc7 100644 --- a/test/e2e/suites/managed/eks_test.go +++ b/test/e2e/suites/managed/eks_test.go @@ -64,7 +64,6 @@ var _ = ginkgo.Describe("[managed] [general] EKS cluster tests", func() { E2EConfig: e2eCtx.E2EConfig, ConfigClusterFn: defaultConfigCluster, BootstrapClusterProxy: e2eCtx.Environment.BootstrapClusterProxy, - AWSSession: e2eCtx.BootstrapUserAWSSession, AWSSessionV2: e2eCtx.BootstrapUserAWSSessionV2, Namespace: namespace, ClusterName: clusterName, @@ -79,7 +78,7 @@ var _ = ginkgo.Describe("[managed] [general] EKS cluster tests", func() { return UpdateAwsNodeVersionSpecInput{ E2EConfig: e2eCtx.E2EConfig, BootstrapClusterProxy: e2eCtx.Environment.BootstrapClusterProxy, - AWSSession: e2eCtx.BootstrapUserAWSSession, + AWSSessionV2: e2eCtx.BootstrapUserAWSSessionV2, Namespace: namespace, ClusterName: clusterName, } @@ -90,7 +89,7 @@ var _ = ginkgo.Describe("[managed] [general] EKS cluster tests", func() { return CheckAddonExistsSpecInput{ E2EConfig: e2eCtx.E2EConfig, BootstrapClusterProxy: e2eCtx.Environment.BootstrapClusterProxy, - AWSSession: e2eCtx.BootstrapUserAWSSessionV2, + AWSSessionV2: e2eCtx.BootstrapUserAWSSessionV2, Namespace: namespace, ClusterName: clusterName, AddonName: cniAddonName, @@ -104,7 +103,7 @@ var _ = ginkgo.Describe("[managed] [general] EKS cluster tests", func() { E2EConfig: e2eCtx.E2EConfig, ConfigClusterFn: defaultConfigCluster, BootstrapClusterProxy: e2eCtx.Environment.BootstrapClusterProxy, - AWSSession: e2eCtx.BootstrapUserAWSSession, + AWSSessionV2: e2eCtx.BootstrapUserAWSSessionV2, Namespace: namespace, ClusterName: clusterName, Replicas: 1, @@ -118,7 +117,6 @@ var _ = ginkgo.Describe("[managed] [general] EKS cluster tests", func() { E2EConfig: e2eCtx.E2EConfig, ConfigClusterFn: defaultConfigCluster, BootstrapClusterProxy: e2eCtx.Environment.BootstrapClusterProxy, - AWSSession: e2eCtx.BootstrapUserAWSSession, AWSSessionV2: e2eCtx.BootstrapUserAWSSessionV2, Namespace: namespace, ClusterName: clusterName, @@ -135,7 +133,6 @@ var _ = ginkgo.Describe("[managed] [general] EKS cluster tests", func() { E2EConfig: e2eCtx.E2EConfig, ConfigClusterFn: defaultConfigCluster, BootstrapClusterProxy: e2eCtx.Environment.BootstrapClusterProxy, - AWSSession: e2eCtx.BootstrapUserAWSSession, AWSSessionV2: e2eCtx.BootstrapUserAWSSessionV2, Namespace: namespace, ClusterName: clusterName, @@ -153,7 +150,6 @@ var _ = ginkgo.Describe("[managed] [general] EKS cluster tests", func() { E2EConfig: e2eCtx.E2EConfig, ConfigClusterFn: defaultConfigCluster, BootstrapClusterProxy: e2eCtx.Environment.BootstrapClusterProxy, - AWSSession: e2eCtx.BootstrapUserAWSSession, AWSSessionV2: e2eCtx.BootstrapUserAWSSessionV2, Namespace: namespace, ClusterName: clusterName, diff --git a/test/e2e/suites/managed/gc_test.go b/test/e2e/suites/managed/gc_test.go index 51a34e99d2..9a1e3052fb 100644 --- a/test/e2e/suites/managed/gc_test.go +++ b/test/e2e/suites/managed/gc_test.go @@ -63,7 +63,6 @@ var _ = ginkgo.Describe("[managed] [gc] EKS Cluster external resource GC tests", E2EConfig: e2eCtx.E2EConfig, ConfigClusterFn: defaultConfigCluster, BootstrapClusterProxy: e2eCtx.Environment.BootstrapClusterProxy, - AWSSession: e2eCtx.BootstrapUserAWSSession, AWSSessionV2: e2eCtx.BootstrapUserAWSSessionV2, Namespace: namespace, ClusterName: clusterName, @@ -112,18 +111,18 @@ var _ = ginkgo.Describe("[managed] [gc] EKS Cluster external resource GC tests", ginkgo.By("Checking we have the load balancers in AWS") shared.WaitForLoadBalancerToExistForService(ctx, shared.WaitForLoadBalancerToExistForServiceInput{ - AWSSession: e2eCtx.BootstrapUserAWSSessionV2, - ServiceName: "podinfo-nlb", - ServiceNamespace: "default", - ClusterName: cp.Spec.EKSClusterName, - Type: infrav1.LoadBalancerTypeNLB, + AWSSessionV2: e2eCtx.BootstrapUserAWSSessionV2, + ServiceName: "podinfo-nlb", + ServiceNamespace: "default", + ClusterName: cp.Spec.EKSClusterName, + Type: infrav1.LoadBalancerTypeNLB, }, e2eCtx.E2EConfig.GetIntervals("", "wait-loadbalancer-ready")...) shared.WaitForLoadBalancerToExistForService(ctx, shared.WaitForLoadBalancerToExistForServiceInput{ - AWSSession: e2eCtx.BootstrapUserAWSSessionV2, - ServiceName: "podinfo-elb", - ServiceNamespace: "default", - ClusterName: cp.Spec.EKSClusterName, - Type: infrav1.LoadBalancerTypeELB, + AWSSessionV2: e2eCtx.BootstrapUserAWSSessionV2, + ServiceName: "podinfo-elb", + ServiceNamespace: "default", + ClusterName: cp.Spec.EKSClusterName, + Type: infrav1.LoadBalancerTypeELB, }, e2eCtx.E2EConfig.GetIntervals("", "wait-loadbalancer-ready")...) ginkgo.By(fmt.Sprintf("Deleting workload/tenant cluster %s", clusterName)) @@ -140,20 +139,20 @@ var _ = ginkgo.Describe("[managed] [gc] EKS Cluster external resource GC tests", ginkgo.By("Getting counts of service load balancers") arns, err := shared.GetLoadBalancerARNs(ctx, shared.GetLoadBalancerARNsInput{ - AWSSession: e2eCtx.BootstrapUserAWSSessionV2, - ServiceName: "podinfo-nlb", - ServiceNamespace: "default", - ClusterName: cp.Spec.EKSClusterName, - Type: infrav1.LoadBalancerTypeNLB, + AWSSessionV2: e2eCtx.BootstrapUserAWSSessionV2, + ServiceName: "podinfo-nlb", + ServiceNamespace: "default", + ClusterName: cp.Spec.EKSClusterName, + Type: infrav1.LoadBalancerTypeNLB, }) Expect(err).NotTo(HaveOccurred()) Expect(arns).To(BeEmpty(), "there are %d service load balancers (nlb) still", len(arns)) arns, err = shared.GetLoadBalancerARNs(ctx, shared.GetLoadBalancerARNsInput{ - AWSSession: e2eCtx.BootstrapUserAWSSessionV2, - ServiceName: "podinfo-elb", - ServiceNamespace: "default", - ClusterName: cp.Spec.EKSClusterName, - Type: infrav1.LoadBalancerTypeELB, + AWSSessionV2: e2eCtx.BootstrapUserAWSSessionV2, + ServiceName: "podinfo-elb", + ServiceNamespace: "default", + ClusterName: cp.Spec.EKSClusterName, + Type: infrav1.LoadBalancerTypeELB, }) Expect(err).NotTo(HaveOccurred()) Expect(arns).To(BeEmpty(), "there are %d service load balancers (elb) still", len(arns)) @@ -187,7 +186,6 @@ var _ = ginkgo.Describe("[managed] [gc] EKS Cluster external resource GC tests", E2EConfig: e2eCtx.E2EConfig, ConfigClusterFn: defaultConfigCluster, BootstrapClusterProxy: e2eCtx.Environment.BootstrapClusterProxy, - AWSSession: e2eCtx.BootstrapUserAWSSession, AWSSessionV2: e2eCtx.BootstrapUserAWSSessionV2, Namespace: namespace, ClusterName: clusterName, @@ -236,18 +234,18 @@ var _ = ginkgo.Describe("[managed] [gc] EKS Cluster external resource GC tests", ginkgo.By("Checking we have the load balancers in AWS") shared.WaitForLoadBalancerToExistForService(ctx, shared.WaitForLoadBalancerToExistForServiceInput{ - AWSSession: e2eCtx.BootstrapUserAWSSessionV2, - ServiceName: "podinfo-nlb", - ServiceNamespace: "default", - ClusterName: cp.Spec.EKSClusterName, - Type: infrav1.LoadBalancerTypeNLB, + AWSSessionV2: e2eCtx.BootstrapUserAWSSessionV2, + ServiceName: "podinfo-nlb", + ServiceNamespace: "default", + ClusterName: cp.Spec.EKSClusterName, + Type: infrav1.LoadBalancerTypeNLB, }, e2eCtx.E2EConfig.GetIntervals("", "wait-loadbalancer-ready")...) shared.WaitForLoadBalancerToExistForService(ctx, shared.WaitForLoadBalancerToExistForServiceInput{ - AWSSession: e2eCtx.BootstrapUserAWSSessionV2, - ServiceName: "podinfo-elb", - ServiceNamespace: "default", - ClusterName: cp.Spec.EKSClusterName, - Type: infrav1.LoadBalancerTypeELB, + AWSSessionV2: e2eCtx.BootstrapUserAWSSessionV2, + ServiceName: "podinfo-elb", + ServiceNamespace: "default", + ClusterName: cp.Spec.EKSClusterName, + Type: infrav1.LoadBalancerTypeELB, }, e2eCtx.E2EConfig.GetIntervals("", "wait-loadbalancer-ready")...) ginkgo.By(fmt.Sprintf("Deleting workload/tenant cluster %s", clusterName)) @@ -264,20 +262,20 @@ var _ = ginkgo.Describe("[managed] [gc] EKS Cluster external resource GC tests", ginkgo.By("Getting counts of service load balancers") arns, err := shared.GetLoadBalancerARNs(ctx, shared.GetLoadBalancerARNsInput{ - AWSSession: e2eCtx.BootstrapUserAWSSessionV2, - ServiceName: "podinfo-nlb", - ServiceNamespace: "default", - ClusterName: cp.Spec.EKSClusterName, - Type: infrav1.LoadBalancerTypeNLB, + AWSSessionV2: e2eCtx.BootstrapUserAWSSessionV2, + ServiceName: "podinfo-nlb", + ServiceNamespace: "default", + ClusterName: cp.Spec.EKSClusterName, + Type: infrav1.LoadBalancerTypeNLB, }) Expect(err).NotTo(HaveOccurred()) Expect(arns).To(BeEmpty(), "there are %d service load balancers (nlb) still", len(arns)) arns, err = shared.GetLoadBalancerARNs(ctx, shared.GetLoadBalancerARNsInput{ - AWSSession: e2eCtx.BootstrapUserAWSSessionV2, - ServiceName: "podinfo-elb", - ServiceNamespace: "default", - ClusterName: cp.Spec.EKSClusterName, - Type: infrav1.LoadBalancerTypeELB, + AWSSessionV2: e2eCtx.BootstrapUserAWSSessionV2, + ServiceName: "podinfo-elb", + ServiceNamespace: "default", + ClusterName: cp.Spec.EKSClusterName, + Type: infrav1.LoadBalancerTypeELB, }) Expect(err).NotTo(HaveOccurred()) Expect(arns).To(BeEmpty(), "there are %d service load balancers (elb) still", len(arns)) diff --git a/test/e2e/suites/managed/machine_deployment.go b/test/e2e/suites/managed/machine_deployment.go index bc7f0f06a3..bd576f70bc 100644 --- a/test/e2e/suites/managed/machine_deployment.go +++ b/test/e2e/suites/managed/machine_deployment.go @@ -40,7 +40,7 @@ type MachineDeploymentSpecInput struct { E2EConfig *clusterctl.E2EConfig ConfigClusterFn DefaultConfigClusterFn BootstrapClusterProxy framework.ClusterProxy - AWSSession aws.Config + AWSSessionV2 *aws.Config Namespace *corev1.Namespace Replicas int64 ClusterName string @@ -53,7 +53,7 @@ func MachineDeploymentSpec(ctx context.Context, inputGetter func() MachineDeploy Expect(input.E2EConfig).ToNot(BeNil(), "Invalid argument. input.E2EConfig can't be nil") Expect(input.ConfigClusterFn).ToNot(BeNil(), "Invalid argument. input.ConfigClusterFn can't be nil") Expect(input.BootstrapClusterProxy).ToNot(BeNil(), "Invalid argument. input.BootstrapClusterProxy can't be nil") - Expect(input.AWSSession).ToNot(BeNil(), "Invalid argument. input.AWSSession can't be nil") + Expect(input.AWSSessionV2).ToNot(BeNil(), "Invalid argument. input.AWSSessionV2 can't be nil") Expect(input.Namespace).NotTo(BeNil(), "Invalid argument. input.Namespace can't be nil") Expect(input.ClusterName).ShouldNot(BeEmpty(), "Invalid argument. input.ClusterName can't be empty") diff --git a/test/e2e/suites/managed/machine_pool.go b/test/e2e/suites/managed/machine_pool.go index bbad25b6f5..a8c7ff053d 100644 --- a/test/e2e/suites/managed/machine_pool.go +++ b/test/e2e/suites/managed/machine_pool.go @@ -58,8 +58,7 @@ func MachinePoolSpec(ctx context.Context, inputGetter func() MachinePoolSpecInpu Expect(input.E2EConfig).ToNot(BeNil(), "Invalid argument. input.E2EConfig can't be nil") Expect(input.ConfigClusterFn).ToNot(BeNil(), "Invalid argument. input.ConfigClusterFn can't be nil") Expect(input.BootstrapClusterProxy).ToNot(BeNil(), "Invalid argument. input.BootstrapClusterProxy can't be nil") - Expect(input.AWSSession).ToNot(BeNil(), "Invalid argument. input.AWSSession can't be nil") - Expect(input.AWSSessionV2).ToNot(BeNil(), "Invalid argument. input.AWSCfg can't be nil") + Expect(input.AWSSessionV2).ToNot(BeNil(), "Invalid argument. input.AWSSessionV2 can't be nil") Expect(input.Namespace).NotTo(BeNil(), "Invalid argument. input.Namespace can't be nil") Expect(input.ClusterName).ShouldNot(BeEmpty(), "Invalid argument. input.ClusterName can't be empty") Expect(input.Flavor).ShouldNot(BeEmpty(), "Invalid argument. input.Flavor can't be empty") diff --git a/test/e2e/suites/managed/upgrade_test.go b/test/e2e/suites/managed/upgrade_test.go index 464c0ff3b8..7bb870530e 100644 --- a/test/e2e/suites/managed/upgrade_test.go +++ b/test/e2e/suites/managed/upgrade_test.go @@ -67,7 +67,6 @@ var _ = ginkgo.Describe("EKS Cluster upgrade test", func() { E2EConfig: e2eCtx.E2EConfig, ConfigClusterFn: defaultConfigCluster, BootstrapClusterProxy: e2eCtx.Environment.BootstrapClusterProxy, - AWSSession: e2eCtx.BootstrapUserAWSSession, AWSSessionV2: e2eCtx.BootstrapUserAWSSessionV2, Namespace: namespace, ClusterName: clusterName, @@ -100,7 +99,7 @@ var _ = ginkgo.Describe("EKS Cluster upgrade test", func() { UpgradeControlPlaneVersionSpec(ctx, func() UpgradeControlPlaneVersionSpecInput { return UpgradeControlPlaneVersionSpecInput{ E2EConfig: e2eCtx.E2EConfig, - AWSSession: e2eCtx.BootstrapUserAWSSessionV2, + AWSSessionV2: e2eCtx.BootstrapUserAWSSessionV2, BootstrapClusterProxy: e2eCtx.Environment.BootstrapClusterProxy, ClusterName: clusterName, Namespace: namespace, diff --git a/test/e2e/suites/unmanaged/gc_test.go b/test/e2e/suites/unmanaged/gc_test.go index 01d6807e9b..8686ec2a36 100644 --- a/test/e2e/suites/unmanaged/gc_test.go +++ b/test/e2e/suites/unmanaged/gc_test.go @@ -91,18 +91,18 @@ var _ = ginkgo.Context("[unmanaged] [gc]", func() { ginkgo.By("Checking we have the load balancers in AWS") shared.WaitForLoadBalancerToExistForService(ctx, shared.WaitForLoadBalancerToExistForServiceInput{ - AWSSession: e2eCtx.BootstrapUserAWSSessionV2, - ServiceName: "podinfo-nlb", - ServiceNamespace: "default", - ClusterName: clusterName, - Type: infrav1.LoadBalancerTypeNLB, + AWSSessionV2: e2eCtx.BootstrapUserAWSSessionV2, + ServiceName: "podinfo-nlb", + ServiceNamespace: "default", + ClusterName: clusterName, + Type: infrav1.LoadBalancerTypeNLB, }, e2eCtx.E2EConfig.GetIntervals("", "wait-loadbalancer-ready")...) shared.WaitForLoadBalancerToExistForService(ctx, shared.WaitForLoadBalancerToExistForServiceInput{ - AWSSession: e2eCtx.BootstrapUserAWSSessionV2, - ServiceName: "podinfo-elb", - ServiceNamespace: "default", - ClusterName: clusterName, - Type: infrav1.LoadBalancerTypeELB, + AWSSessionV2: e2eCtx.BootstrapUserAWSSessionV2, + ServiceName: "podinfo-elb", + ServiceNamespace: "default", + ClusterName: clusterName, + Type: infrav1.LoadBalancerTypeELB, }, e2eCtx.E2EConfig.GetIntervals("", "wait-loadbalancer-ready")...) ginkgo.By(fmt.Sprintf("Deleting workload/tenant cluster %s", clusterName)) @@ -119,20 +119,20 @@ var _ = ginkgo.Context("[unmanaged] [gc]", func() { ginkgo.By("Getting counts of service load balancers") arns, err := shared.GetLoadBalancerARNs(ctx, shared.GetLoadBalancerARNsInput{ - AWSSession: e2eCtx.BootstrapUserAWSSessionV2, - ServiceName: "podinfo-nlb", - ServiceNamespace: "default", - ClusterName: clusterName, - Type: infrav1.LoadBalancerTypeNLB, + AWSSessionV2: e2eCtx.BootstrapUserAWSSessionV2, + ServiceName: "podinfo-nlb", + ServiceNamespace: "default", + ClusterName: clusterName, + Type: infrav1.LoadBalancerTypeNLB, }) Expect(err).NotTo(HaveOccurred()) Expect(arns).To(BeEmpty(), "there are %d service load balancers (nlb) still", len(arns)) arns, err = shared.GetLoadBalancerARNs(ctx, shared.GetLoadBalancerARNsInput{ - AWSSession: e2eCtx.BootstrapUserAWSSessionV2, - ServiceName: "podinfo-elb", - ServiceNamespace: "default", - ClusterName: clusterName, - Type: infrav1.LoadBalancerTypeELB, + AWSSessionV2: e2eCtx.BootstrapUserAWSSessionV2, + ServiceName: "podinfo-elb", + ServiceNamespace: "default", + ClusterName: clusterName, + Type: infrav1.LoadBalancerTypeELB, }) Expect(err).NotTo(HaveOccurred()) Expect(arns).To(BeEmpty(), "there are %d service load balancers (elb) still", len(arns)) @@ -197,18 +197,18 @@ var _ = ginkgo.Context("[unmanaged] [gc]", func() { ginkgo.By("Checking we have the load balancers in AWS") shared.WaitForLoadBalancerToExistForService(ctx, shared.WaitForLoadBalancerToExistForServiceInput{ - AWSSession: e2eCtx.BootstrapUserAWSSessionV2, - ServiceName: "podinfo-nlb", - ServiceNamespace: "default", - ClusterName: clusterName, - Type: infrav1.LoadBalancerTypeNLB, + AWSSessionV2: e2eCtx.BootstrapUserAWSSessionV2, + ServiceName: "podinfo-nlb", + ServiceNamespace: "default", + ClusterName: clusterName, + Type: infrav1.LoadBalancerTypeNLB, }, e2eCtx.E2EConfig.GetIntervals("", "wait-loadbalancer-ready")...) shared.WaitForLoadBalancerToExistForService(ctx, shared.WaitForLoadBalancerToExistForServiceInput{ - AWSSession: e2eCtx.BootstrapUserAWSSessionV2, - ServiceName: "podinfo-elb", - ServiceNamespace: "default", - ClusterName: clusterName, - Type: infrav1.LoadBalancerTypeELB, + AWSSessionV2: e2eCtx.BootstrapUserAWSSessionV2, + ServiceName: "podinfo-elb", + ServiceNamespace: "default", + ClusterName: clusterName, + Type: infrav1.LoadBalancerTypeELB, }, e2eCtx.E2EConfig.GetIntervals("", "wait-loadbalancer-ready")...) ginkgo.By(fmt.Sprintf("Deleting workload/tenant cluster %s", clusterName)) @@ -225,20 +225,20 @@ var _ = ginkgo.Context("[unmanaged] [gc]", func() { ginkgo.By("Getting counts of service load balancers") arns, err := shared.GetLoadBalancerARNs(ctx, shared.GetLoadBalancerARNsInput{ - AWSSession: e2eCtx.BootstrapUserAWSSessionV2, - ServiceName: "podinfo-nlb", - ServiceNamespace: "default", - ClusterName: clusterName, - Type: infrav1.LoadBalancerTypeNLB, + AWSSessionV2: e2eCtx.BootstrapUserAWSSessionV2, + ServiceName: "podinfo-nlb", + ServiceNamespace: "default", + ClusterName: clusterName, + Type: infrav1.LoadBalancerTypeNLB, }) Expect(err).NotTo(HaveOccurred()) Expect(arns).To(BeEmpty(), "there are %d service load balancers (nlb) still", len(arns)) arns, err = shared.GetLoadBalancerARNs(ctx, shared.GetLoadBalancerARNsInput{ - AWSSession: e2eCtx.BootstrapUserAWSSessionV2, - ServiceName: "podinfo-elb", - ServiceNamespace: "default", - ClusterName: clusterName, - Type: infrav1.LoadBalancerTypeELB, + AWSSessionV2: e2eCtx.BootstrapUserAWSSessionV2, + ServiceName: "podinfo-elb", + ServiceNamespace: "default", + ClusterName: clusterName, + Type: infrav1.LoadBalancerTypeELB, }) Expect(err).NotTo(HaveOccurred()) Expect(arns).To(BeEmpty(), "there are %d service load balancers (elb) still", len(arns)) diff --git a/test/e2e/suites/unmanaged/unmanaged_classic_elb_upgrade_test.go b/test/e2e/suites/unmanaged/unmanaged_classic_elb_upgrade_test.go index 4fba43f453..48e85c187c 100644 --- a/test/e2e/suites/unmanaged/unmanaged_classic_elb_upgrade_test.go +++ b/test/e2e/suites/unmanaged/unmanaged_classic_elb_upgrade_test.go @@ -191,9 +191,9 @@ var _ = ginkgo.Context("[unmanaged] [upgrade]", func() { Expect(err).NotTo(HaveOccurred(), "failed to get the AWS cluster") shared.CheckClassicElbHealthCheck(ctx, shared.CheckClassicElbHealthCheckInput{ - AWSSession: e2eCtx.BootstrapUserAWSSessionV2, - LoadBalancerName: awsCluster.Status.Network.APIServerELB.Name, - ExpectedTarget: "SSL:6443", + AWSSessionV2: e2eCtx.BootstrapUserAWSSessionV2, + LoadBalancerName: awsCluster.Status.Network.APIServerELB.Name, + ExpectedTarget: "SSL:6443", }, e2eCtx.E2EConfig.GetIntervals(specName, "wait-classic-elb-health-check-short")...) ginkgo.By("Now the workload cluster is ready upgrade CAPA to main version") @@ -210,9 +210,9 @@ var _ = ginkgo.Context("[unmanaged] [upgrade]", func() { ginkgo.By("Management cluster is upgraded to main version") shared.CheckClassicElbHealthCheck(ctx, shared.CheckClassicElbHealthCheckInput{ - AWSSession: e2eCtx.BootstrapUserAWSSessionV2, - LoadBalancerName: awsCluster.Status.Network.APIServerELB.Name, - ExpectedTarget: "TCP:6443", + AWSSessionV2: e2eCtx.BootstrapUserAWSSessionV2, + LoadBalancerName: awsCluster.Status.Network.APIServerELB.Name, + ExpectedTarget: "TCP:6443", }, e2eCtx.E2EConfig.GetIntervals(specName, "wait-classic-elb-health-check-long")...) shared.Byf("Upgrading the control plane to %s", kubernetesVersionTo) diff --git a/test/mocks/capa_clusterscoper_mock.go b/test/mocks/capa_clusterscoper_mock.go index ed5b72fc72..e3664a61e0 100644 --- a/test/mocks/capa_clusterscoper_mock.go +++ b/test/mocks/capa_clusterscoper_mock.go @@ -34,7 +34,7 @@ import ( throttle "sigs.k8s.io/cluster-api-provider-aws/v2/pkg/cloud/throttle" logger "sigs.k8s.io/cluster-api-provider-aws/v2/pkg/logger" v1beta1 "sigs.k8s.io/cluster-api/api/v1beta1" - client0 "sigs.k8s.io/controller-runtime/pkg/client" + client "sigs.k8s.io/controller-runtime/pkg/client" ) // MockClusterScoper is a mock of ClusterScoper interface. @@ -266,10 +266,10 @@ func (mr *MockClusterScoperMockRecorder) KubernetesClusterName() *gomock.Call { } // ListOptionsLabelSelector mocks base method. -func (m *MockClusterScoper) ListOptionsLabelSelector() client0.ListOption { +func (m *MockClusterScoper) ListOptionsLabelSelector() client.ListOption { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "ListOptionsLabelSelector") - ret0, _ := ret[0].(client0.ListOption) + ret0, _ := ret[0].(client.ListOption) return ret0 } @@ -363,18 +363,18 @@ func (mr *MockClusterScoperMockRecorder) ServiceLimiter(arg0 interface{}) *gomoc return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ServiceLimiter", reflect.TypeOf((*MockClusterScoper)(nil).ServiceLimiter), arg0) } -// SessionV2 mocks base method. +// Session mocks base method. func (m *MockClusterScoper) Session() aws.Config { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "SessionV2") + ret := m.ctrl.Call(m, "Session") ret0, _ := ret[0].(aws.Config) return ret0 } -// SessionV2 indicates an expected call of SessionV2. +// Session indicates an expected call of Session. func (mr *MockClusterScoperMockRecorder) Session() *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SessionV2", reflect.TypeOf((*MockClusterScoper)(nil).Session)) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Session", reflect.TypeOf((*MockClusterScoper)(nil).Session)) } // SetFailureDomain mocks base method. From 0188c60c3afb6ee72e31470cdc1a0a8b8ffa490d Mon Sep 17 00:00:00 2001 From: Liangquan Li Date: Tue, 5 Aug 2025 20:20:05 +0800 Subject: [PATCH 4/8] fix lint error --- pkg/cloud/scope/clients.go | 22 - pkg/cloud/scope/cluster.go | 2 +- pkg/cloud/scope/fargate.go | 2 +- pkg/cloud/scope/managedcontrolplane.go | 2 +- pkg/cloud/scope/rosacontrolplane.go | 2 +- pkg/cloud/scope/rosamachinepool.go | 2 +- pkg/cloud/scope/session.go | 14 +- .../gomock_reflect_2588283099/prog.go | 66 --- pkg/cloud/services/s3/mock_stsiface/doc.go | 22 - .../services/secretsmanager/secret_test.go | 2 +- .../sts/mock_stsiface/stsiface_mock_v1.go | 395 +++++++++++++++++- test/e2e/shared/aws_helpers.go | 26 +- test/e2e/suites/managed/gc_test.go | 80 ++-- test/e2e/suites/unmanaged/gc_test.go | 80 ++-- .../unmanaged_classic_elb_upgrade_test.go | 12 +- 15 files changed, 500 insertions(+), 229 deletions(-) delete mode 100644 pkg/cloud/services/mock_services/gomock_reflect_2588283099/prog.go delete mode 100644 pkg/cloud/services/s3/mock_stsiface/doc.go diff --git a/pkg/cloud/scope/clients.go b/pkg/cloud/scope/clients.go index b5285c29ef..721dacd99a 100644 --- a/pkg/cloud/scope/clients.go +++ b/pkg/cloud/scope/clients.go @@ -30,8 +30,6 @@ import ( "github.com/aws/aws-sdk-go-v2/service/sqs" "github.com/aws/aws-sdk-go-v2/service/ssm" stsv2 "github.com/aws/aws-sdk-go-v2/service/sts" - "github.com/aws/aws-sdk-go/aws/awserr" - "github.com/aws/aws-sdk-go/aws/request" "k8s.io/apimachinery/pkg/runtime" "sigs.k8s.io/cluster-api-provider-aws/v2/pkg/cloud" @@ -41,8 +39,6 @@ import ( stsservice "sigs.k8s.io/cluster-api-provider-aws/v2/pkg/cloud/services/sts" "sigs.k8s.io/cluster-api-provider-aws/v2/pkg/cloud/throttle" "sigs.k8s.io/cluster-api-provider-aws/v2/pkg/logger" - "sigs.k8s.io/cluster-api-provider-aws/v2/pkg/record" - "sigs.k8s.io/cluster-api-provider-aws/v2/version" ) // NewASGClient creates a new ASG API client for a given session. @@ -336,24 +332,6 @@ func NewS3Client(scopeUser cloud.ScopeUsage, session cloud.Session, logger logge return s3.NewFromConfig(cfg, s3Opts...) } -func recordAWSPermissionsIssue(target runtime.Object) func(r *request.Request) { - return func(r *request.Request) { - if awsErr, ok := r.Error.(awserr.Error); ok { - switch awsErr.Code() { - case "AuthFailure", "UnauthorizedOperation", "NoCredentialProviders": - record.Warnf(target, awsErr.Code(), "Operation %s failed with a credentials or permission issue", r.Operation.Name) - } - } - } -} - -func getUserAgentHandler() request.NamedHandler { - return request.NamedHandler{ - Name: "capa/user-agent", - Fn: request.MakeAddToUserAgentHandler("aws.cluster.x-k8s.io", version.Get().String()), - } -} - // AWSClients contains all the aws clients used by the scopes. type AWSClients struct { ELB *elb.Client diff --git a/pkg/cloud/scope/cluster.go b/pkg/cloud/scope/cluster.go index 04f8942d2d..4627882a99 100644 --- a/pkg/cloud/scope/cluster.go +++ b/pkg/cloud/scope/cluster.go @@ -77,7 +77,7 @@ func NewClusterScope(params ClusterScopeParams) (*ClusterScope, error) { maxWaitActiveUpdateDelete: params.MaxWaitActiveUpdateDelete, } - _, serviceLimiters, err := sessionForClusterWithRegion(params.Client, clusterScope, params.AWSCluster.Spec.Region, params.Endpoints, params.Logger) + serviceLimiters, err := sessionForClusterWithRegion(params.Client, clusterScope, params.AWSCluster.Spec.Region, params.Endpoints, params.Logger) if err != nil { return nil, errors.Errorf("failed to create aws session: %v", err) } diff --git a/pkg/cloud/scope/fargate.go b/pkg/cloud/scope/fargate.go index 1e5d424a5a..32845de577 100644 --- a/pkg/cloud/scope/fargate.go +++ b/pkg/cloud/scope/fargate.go @@ -70,7 +70,7 @@ func NewFargateProfileScope(params FargateProfileScopeParams) (*FargateProfileSc controllerName: params.ControllerName, } - _, serviceLimiters, err := sessionForClusterWithRegion(params.Client, managedScope, params.ControlPlane.Spec.Region, params.Endpoints, params.Logger) + serviceLimiters, err := sessionForClusterWithRegion(params.Client, managedScope, params.ControlPlane.Spec.Region, params.Endpoints, params.Logger) if err != nil { return nil, errors.Errorf("failed to create aws session: %v", err) } diff --git a/pkg/cloud/scope/managedcontrolplane.go b/pkg/cloud/scope/managedcontrolplane.go index 803a2cfe74..3b2db58ac7 100644 --- a/pkg/cloud/scope/managedcontrolplane.go +++ b/pkg/cloud/scope/managedcontrolplane.go @@ -98,7 +98,7 @@ func NewManagedControlPlaneScope(params ManagedControlPlaneScopeParams) (*Manage enableIAM: params.EnableIAM, tagUnmanagedNetworkResources: params.TagUnmanagedNetworkResources, } - _, serviceLimiters, err := sessionForClusterWithRegion(params.Client, managedScope, params.ControlPlane.Spec.Region, params.Endpoints, params.Logger) + serviceLimiters, err := sessionForClusterWithRegion(params.Client, managedScope, params.ControlPlane.Spec.Region, params.Endpoints, params.Logger) if err != nil { return nil, errors.Errorf("failed to create aws session: %v", err) } diff --git a/pkg/cloud/scope/rosacontrolplane.go b/pkg/cloud/scope/rosacontrolplane.go index 2e20c4c352..95d304de80 100644 --- a/pkg/cloud/scope/rosacontrolplane.go +++ b/pkg/cloud/scope/rosacontrolplane.go @@ -72,7 +72,7 @@ func NewROSAControlPlaneScope(params ROSAControlPlaneScopeParams) (*ROSAControlP controllerName: params.ControllerName, } - _, serviceLimiters, err := sessionForClusterWithRegion(params.Client, managedScope, params.ControlPlane.Spec.Region, params.Endpoints, params.Logger) + serviceLimiters, err := sessionForClusterWithRegion(params.Client, managedScope, params.ControlPlane.Spec.Region, params.Endpoints, params.Logger) if err != nil { return nil, errors.Errorf("failed to create aws session: %v", err) } diff --git a/pkg/cloud/scope/rosamachinepool.go b/pkg/cloud/scope/rosamachinepool.go index 8ae0114ba1..89022d0593 100644 --- a/pkg/cloud/scope/rosamachinepool.go +++ b/pkg/cloud/scope/rosamachinepool.go @@ -88,7 +88,7 @@ func NewRosaMachinePoolScope(params RosaMachinePoolScopeParams) (*RosaMachinePoo controllerName: params.ControllerName, } - _, serviceLimiters, err := sessionForClusterWithRegion(params.Client, scope, params.ControlPlane.Spec.Region, params.Endpoints, params.Logger) + serviceLimiters, err := sessionForClusterWithRegion(params.Client, scope, params.ControlPlane.Spec.Region, params.Endpoints, params.Logger) if err != nil { return nil, errors.Errorf("failed to create aws session: %v", err) } diff --git a/pkg/cloud/scope/session.go b/pkg/cloud/scope/session.go index 163404aa9c..3a4f3b9206 100644 --- a/pkg/cloud/scope/session.go +++ b/pkg/cloud/scope/session.go @@ -137,7 +137,7 @@ func sessionForRegionV2(region string) (*awsv2.Config, throttle.ServiceLimiters, return &ns, sl, nil } -func sessionForClusterWithRegion(k8sClient client.Client, clusterScoper cloud.SessionMetadata, region string, endpoint []ServiceEndpoint, log logger.Wrapper) (*session.Session, throttle.ServiceLimiters, error) { +func sessionForClusterWithRegion(k8sClient client.Client, clusterScoper cloud.SessionMetadata, region string, endpoint []ServiceEndpoint, log logger.Wrapper) (throttle.ServiceLimiters, error) { log = log.WithName("identity") log.Trace("Creating an AWS Session") @@ -157,7 +157,7 @@ func sessionForClusterWithRegion(k8sClient client.Client, clusterScoper cloud.Se if err != nil { // could not get providers and retrieve the credentials conditions.MarkFalse(clusterScoper.InfraCluster(), infrav1.PrincipalCredentialRetrievedCondition, infrav1.PrincipalCredentialRetrievalFailedReason, clusterv1.ConditionSeverityError, "%s", err.Error()) - return nil, nil, errors.Wrap(err, "Failed to get providers for cluster") + return nil, errors.Wrap(err, "Failed to get providers for cluster") } isChanged := false @@ -166,7 +166,7 @@ func sessionForClusterWithRegion(k8sClient client.Client, clusterScoper cloud.Se // load an existing matching providers from the cache if such a providers exists providerHash, err := provider.Hash() if err != nil { - return nil, nil, errors.Wrap(err, "Failed to calculate provider hash") + return nil, errors.Wrap(err, "Failed to calculate provider hash") } cachedProvider, ok := providerCache.Load(providerHash) if ok { @@ -182,7 +182,7 @@ func sessionForClusterWithRegion(k8sClient client.Client, clusterScoper cloud.Se if !isChanged { if s, ok := sessionCache.Load(getSessionName(region, clusterScoper)); ok { entry := s.(*sessionCacheEntry) - return entry.session, entry.serviceLimiters, nil + return entry.serviceLimiters, nil } } awsConfig := &aws.Config{ @@ -199,7 +199,7 @@ func sessionForClusterWithRegion(k8sClient client.Client, clusterScoper cloud.Se // delete the existing session from cache. Otherwise, we give back a defective session on next method invocation with same cluster scope sessionCache.Delete(getSessionName(region, clusterScoper)) - return nil, nil, errors.Wrap(err, "Failed to retrieve identity credentials") + return nil, errors.Wrap(err, "Failed to retrieve identity credentials") } awsConfig = awsConfig.WithCredentials(credentials.NewChainCredentials(awsProviders)) } @@ -208,7 +208,7 @@ func sessionForClusterWithRegion(k8sClient client.Client, clusterScoper cloud.Se ns, err := session.NewSession(awsConfig) if err != nil { - return nil, nil, errors.Wrap(err, "Failed to create a new AWS session") + return nil, errors.Wrap(err, "Failed to create a new AWS session") } sl := newServiceLimiters() sessionCache.Store(getSessionName(region, clusterScoper), &sessionCacheEntry{ @@ -217,7 +217,7 @@ func sessionForClusterWithRegion(k8sClient client.Client, clusterScoper cloud.Se sessionV2: nil, }) - return ns, sl, nil + return sl, nil } func sessionForClusterWithRegionV2(k8sClient client.Client, clusterScoper cloud.SessionMetadata, region string, _ []ServiceEndpoint, log logger.Wrapper) (*awsv2.Config, throttle.ServiceLimiters, error) { diff --git a/pkg/cloud/services/mock_services/gomock_reflect_2588283099/prog.go b/pkg/cloud/services/mock_services/gomock_reflect_2588283099/prog.go deleted file mode 100644 index 3b5e87d123..0000000000 --- a/pkg/cloud/services/mock_services/gomock_reflect_2588283099/prog.go +++ /dev/null @@ -1,66 +0,0 @@ - -package main - -import ( - "encoding/gob" - "flag" - "fmt" - "os" - "path" - "reflect" - - "github.com/golang/mock/mockgen/model" - - pkg_ "sigs.k8s.io/cluster-api-provider-aws/v2/pkg/cloud/services" -) - -var output = flag.String("output", "", "The output file name, or empty to use stdout.") - -func main() { - flag.Parse() - - its := []struct{ - sym string - typ reflect.Type - }{ - - { "ELBInterface", reflect.TypeOf((*pkg_.ELBInterface)(nil)).Elem()}, - - } - pkg := &model.Package{ - // NOTE: This behaves contrary to documented behaviour if the - // package name is not the final component of the import path. - // The reflect package doesn't expose the package name, though. - Name: path.Base("sigs.k8s.io/cluster-api-provider-aws/v2/pkg/cloud/services"), - } - - for _, it := range its { - intf, err := model.InterfaceFromInterfaceType(it.typ) - if err != nil { - fmt.Fprintf(os.Stderr, "Reflection: %v\n", err) - os.Exit(1) - } - intf.Name = it.sym - pkg.Interfaces = append(pkg.Interfaces, intf) - } - - outfile := os.Stdout - if len(*output) != 0 { - var err error - outfile, err = os.Create(*output) - if err != nil { - fmt.Fprintf(os.Stderr, "failed to open output file %q", *output) - } - defer func() { - if err := outfile.Close(); err != nil { - fmt.Fprintf(os.Stderr, "failed to close output file %q", *output) - os.Exit(1) - } - }() - } - - if err := gob.NewEncoder(outfile).Encode(pkg); err != nil { - fmt.Fprintf(os.Stderr, "gob encode: %v\n", err) - os.Exit(1) - } -} diff --git a/pkg/cloud/services/s3/mock_stsiface/doc.go b/pkg/cloud/services/s3/mock_stsiface/doc.go deleted file mode 100644 index 9cfa86a225..0000000000 --- a/pkg/cloud/services/s3/mock_stsiface/doc.go +++ /dev/null @@ -1,22 +0,0 @@ -/* -Copyright 2019 The Kubernetes Authors. - -Licensed under the Apache License, Version 2.0 (the "License"); -you may not use this file except in compliance with the License. -You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - -Unless required by applicable law or agreed to in writing, software -distributed under the License is distributed on an "AS IS" BASIS, -WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -See the License for the specific language governing permissions and -limitations under the License. -*/ - -// Package mock_stsiface provides a mock implementation for the STSAPI interface. -// Run go generate to regenerate this mock. -// -//go:generate ../../../../../hack/tools/bin/mockgen -destination stsapi_mock.go -package mock_stsiface sigs.k8s.io/cluster-api-provider-aws/v2/pkg/cloud/services/s3 STSAPI -//go:generate /usr/bin/env bash -c "cat ../../../../../hack/boilerplate/boilerplate.generatego.txt stsapi_mock.go > _stsapi_mock.go && mv _stsapi_mock.go stsapi_mock.go" -package mock_stsiface //nolint:stylecheck diff --git a/pkg/cloud/services/secretsmanager/secret_test.go b/pkg/cloud/services/secretsmanager/secret_test.go index 26ee62c780..05576174fa 100644 --- a/pkg/cloud/services/secretsmanager/secret_test.go +++ b/pkg/cloud/services/secretsmanager/secret_test.go @@ -24,6 +24,7 @@ import ( "github.com/aws/aws-sdk-go-v2/aws" "github.com/aws/aws-sdk-go-v2/service/secretsmanager" + "github.com/aws/aws-sdk-go-v2/service/secretsmanager/types" "github.com/golang/mock/gomock" . "github.com/onsi/gomega" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" @@ -31,7 +32,6 @@ import ( "sigs.k8s.io/controller-runtime/pkg/client" "sigs.k8s.io/controller-runtime/pkg/client/fake" - "github.com/aws/aws-sdk-go-v2/service/secretsmanager/types" infrav1 "sigs.k8s.io/cluster-api-provider-aws/v2/api/v1beta2" "sigs.k8s.io/cluster-api-provider-aws/v2/pkg/cloud/scope" "sigs.k8s.io/cluster-api-provider-aws/v2/pkg/cloud/services/secretsmanager/mock_secretsmanageriface" diff --git a/pkg/cloud/services/sts/mock_stsiface/stsiface_mock_v1.go b/pkg/cloud/services/sts/mock_stsiface/stsiface_mock_v1.go index 93b56832b9..047c9491fc 100644 --- a/pkg/cloud/services/sts/mock_stsiface/stsiface_mock_v1.go +++ b/pkg/cloud/services/sts/mock_stsiface/stsiface_mock_v1.go @@ -15,7 +15,7 @@ limitations under the License. */ // Code generated by MockGen. DO NOT EDIT. -// Source: sigs.k8s.io/cluster-api-provider-aws/v2/pkg/cloud/services/s3 (interfaces: STSAPI) +// Source: github.com/aws/aws-sdk-go/service/sts/stsiface (interfaces: STSAPI) // Package mock_stsiface is a generated GoMock package. package mock_stsiface @@ -24,7 +24,8 @@ import ( context "context" reflect "reflect" - sts "github.com/aws/aws-sdk-go-v2/service/sts" + request "github.com/aws/aws-sdk-go/aws/request" + sts "github.com/aws/aws-sdk-go/service/sts" gomock "github.com/golang/mock/gomock" ) @@ -51,22 +52,402 @@ func (m *MockSTSAPI) EXPECT() *MockSTSAPIMockRecorder { return m.recorder } -// GetCallerIdentity mocks base method. -func (m *MockSTSAPI) GetCallerIdentity(arg0 context.Context, arg1 *sts.GetCallerIdentityInput, arg2 ...func(*sts.Options)) (*sts.GetCallerIdentityOutput, error) { +// AssumeRole mocks base method. +func (m *MockSTSAPI) AssumeRole(arg0 *sts.AssumeRoleInput) (*sts.AssumeRoleOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AssumeRole", arg0) + ret0, _ := ret[0].(*sts.AssumeRoleOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// AssumeRole indicates an expected call of AssumeRole. +func (mr *MockSTSAPIMockRecorder) AssumeRole(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssumeRole", reflect.TypeOf((*MockSTSAPI)(nil).AssumeRole), arg0) +} + +// AssumeRoleRequest mocks base method. +func (m *MockSTSAPI) AssumeRoleRequest(arg0 *sts.AssumeRoleInput) (*request.Request, *sts.AssumeRoleOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AssumeRoleRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*sts.AssumeRoleOutput) + return ret0, ret1 +} + +// AssumeRoleRequest indicates an expected call of AssumeRoleRequest. +func (mr *MockSTSAPIMockRecorder) AssumeRoleRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssumeRoleRequest", reflect.TypeOf((*MockSTSAPI)(nil).AssumeRoleRequest), arg0) +} + +// AssumeRoleWithContext mocks base method. +func (m *MockSTSAPI) AssumeRoleWithContext(arg0 context.Context, arg1 *sts.AssumeRoleInput, arg2 ...request.Option) (*sts.AssumeRoleOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "AssumeRoleWithContext", varargs...) + ret0, _ := ret[0].(*sts.AssumeRoleOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// AssumeRoleWithContext indicates an expected call of AssumeRoleWithContext. +func (mr *MockSTSAPIMockRecorder) AssumeRoleWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssumeRoleWithContext", reflect.TypeOf((*MockSTSAPI)(nil).AssumeRoleWithContext), varargs...) +} + +// AssumeRoleWithSAML mocks base method. +func (m *MockSTSAPI) AssumeRoleWithSAML(arg0 *sts.AssumeRoleWithSAMLInput) (*sts.AssumeRoleWithSAMLOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AssumeRoleWithSAML", arg0) + ret0, _ := ret[0].(*sts.AssumeRoleWithSAMLOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// AssumeRoleWithSAML indicates an expected call of AssumeRoleWithSAML. +func (mr *MockSTSAPIMockRecorder) AssumeRoleWithSAML(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssumeRoleWithSAML", reflect.TypeOf((*MockSTSAPI)(nil).AssumeRoleWithSAML), arg0) +} + +// AssumeRoleWithSAMLRequest mocks base method. +func (m *MockSTSAPI) AssumeRoleWithSAMLRequest(arg0 *sts.AssumeRoleWithSAMLInput) (*request.Request, *sts.AssumeRoleWithSAMLOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AssumeRoleWithSAMLRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*sts.AssumeRoleWithSAMLOutput) + return ret0, ret1 +} + +// AssumeRoleWithSAMLRequest indicates an expected call of AssumeRoleWithSAMLRequest. +func (mr *MockSTSAPIMockRecorder) AssumeRoleWithSAMLRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssumeRoleWithSAMLRequest", reflect.TypeOf((*MockSTSAPI)(nil).AssumeRoleWithSAMLRequest), arg0) +} + +// AssumeRoleWithSAMLWithContext mocks base method. +func (m *MockSTSAPI) AssumeRoleWithSAMLWithContext(arg0 context.Context, arg1 *sts.AssumeRoleWithSAMLInput, arg2 ...request.Option) (*sts.AssumeRoleWithSAMLOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "AssumeRoleWithSAMLWithContext", varargs...) + ret0, _ := ret[0].(*sts.AssumeRoleWithSAMLOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// AssumeRoleWithSAMLWithContext indicates an expected call of AssumeRoleWithSAMLWithContext. +func (mr *MockSTSAPIMockRecorder) AssumeRoleWithSAMLWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssumeRoleWithSAMLWithContext", reflect.TypeOf((*MockSTSAPI)(nil).AssumeRoleWithSAMLWithContext), varargs...) +} + +// AssumeRoleWithWebIdentity mocks base method. +func (m *MockSTSAPI) AssumeRoleWithWebIdentity(arg0 *sts.AssumeRoleWithWebIdentityInput) (*sts.AssumeRoleWithWebIdentityOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AssumeRoleWithWebIdentity", arg0) + ret0, _ := ret[0].(*sts.AssumeRoleWithWebIdentityOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// AssumeRoleWithWebIdentity indicates an expected call of AssumeRoleWithWebIdentity. +func (mr *MockSTSAPIMockRecorder) AssumeRoleWithWebIdentity(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssumeRoleWithWebIdentity", reflect.TypeOf((*MockSTSAPI)(nil).AssumeRoleWithWebIdentity), arg0) +} + +// AssumeRoleWithWebIdentityRequest mocks base method. +func (m *MockSTSAPI) AssumeRoleWithWebIdentityRequest(arg0 *sts.AssumeRoleWithWebIdentityInput) (*request.Request, *sts.AssumeRoleWithWebIdentityOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AssumeRoleWithWebIdentityRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*sts.AssumeRoleWithWebIdentityOutput) + return ret0, ret1 +} + +// AssumeRoleWithWebIdentityRequest indicates an expected call of AssumeRoleWithWebIdentityRequest. +func (mr *MockSTSAPIMockRecorder) AssumeRoleWithWebIdentityRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssumeRoleWithWebIdentityRequest", reflect.TypeOf((*MockSTSAPI)(nil).AssumeRoleWithWebIdentityRequest), arg0) +} + +// AssumeRoleWithWebIdentityWithContext mocks base method. +func (m *MockSTSAPI) AssumeRoleWithWebIdentityWithContext(arg0 context.Context, arg1 *sts.AssumeRoleWithWebIdentityInput, arg2 ...request.Option) (*sts.AssumeRoleWithWebIdentityOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "AssumeRoleWithWebIdentityWithContext", varargs...) + ret0, _ := ret[0].(*sts.AssumeRoleWithWebIdentityOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// AssumeRoleWithWebIdentityWithContext indicates an expected call of AssumeRoleWithWebIdentityWithContext. +func (mr *MockSTSAPIMockRecorder) AssumeRoleWithWebIdentityWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssumeRoleWithWebIdentityWithContext", reflect.TypeOf((*MockSTSAPI)(nil).AssumeRoleWithWebIdentityWithContext), varargs...) +} + +// DecodeAuthorizationMessage mocks base method. +func (m *MockSTSAPI) DecodeAuthorizationMessage(arg0 *sts.DecodeAuthorizationMessageInput) (*sts.DecodeAuthorizationMessageOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DecodeAuthorizationMessage", arg0) + ret0, _ := ret[0].(*sts.DecodeAuthorizationMessageOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DecodeAuthorizationMessage indicates an expected call of DecodeAuthorizationMessage. +func (mr *MockSTSAPIMockRecorder) DecodeAuthorizationMessage(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DecodeAuthorizationMessage", reflect.TypeOf((*MockSTSAPI)(nil).DecodeAuthorizationMessage), arg0) +} + +// DecodeAuthorizationMessageRequest mocks base method. +func (m *MockSTSAPI) DecodeAuthorizationMessageRequest(arg0 *sts.DecodeAuthorizationMessageInput) (*request.Request, *sts.DecodeAuthorizationMessageOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DecodeAuthorizationMessageRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*sts.DecodeAuthorizationMessageOutput) + return ret0, ret1 +} + +// DecodeAuthorizationMessageRequest indicates an expected call of DecodeAuthorizationMessageRequest. +func (mr *MockSTSAPIMockRecorder) DecodeAuthorizationMessageRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DecodeAuthorizationMessageRequest", reflect.TypeOf((*MockSTSAPI)(nil).DecodeAuthorizationMessageRequest), arg0) +} + +// DecodeAuthorizationMessageWithContext mocks base method. +func (m *MockSTSAPI) DecodeAuthorizationMessageWithContext(arg0 context.Context, arg1 *sts.DecodeAuthorizationMessageInput, arg2 ...request.Option) (*sts.DecodeAuthorizationMessageOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DecodeAuthorizationMessageWithContext", varargs...) + ret0, _ := ret[0].(*sts.DecodeAuthorizationMessageOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DecodeAuthorizationMessageWithContext indicates an expected call of DecodeAuthorizationMessageWithContext. +func (mr *MockSTSAPIMockRecorder) DecodeAuthorizationMessageWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DecodeAuthorizationMessageWithContext", reflect.TypeOf((*MockSTSAPI)(nil).DecodeAuthorizationMessageWithContext), varargs...) +} + +// GetAccessKeyInfo mocks base method. +func (m *MockSTSAPI) GetAccessKeyInfo(arg0 *sts.GetAccessKeyInfoInput) (*sts.GetAccessKeyInfoOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetAccessKeyInfo", arg0) + ret0, _ := ret[0].(*sts.GetAccessKeyInfoOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetAccessKeyInfo indicates an expected call of GetAccessKeyInfo. +func (mr *MockSTSAPIMockRecorder) GetAccessKeyInfo(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAccessKeyInfo", reflect.TypeOf((*MockSTSAPI)(nil).GetAccessKeyInfo), arg0) +} + +// GetAccessKeyInfoRequest mocks base method. +func (m *MockSTSAPI) GetAccessKeyInfoRequest(arg0 *sts.GetAccessKeyInfoInput) (*request.Request, *sts.GetAccessKeyInfoOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetAccessKeyInfoRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*sts.GetAccessKeyInfoOutput) + return ret0, ret1 +} + +// GetAccessKeyInfoRequest indicates an expected call of GetAccessKeyInfoRequest. +func (mr *MockSTSAPIMockRecorder) GetAccessKeyInfoRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAccessKeyInfoRequest", reflect.TypeOf((*MockSTSAPI)(nil).GetAccessKeyInfoRequest), arg0) +} + +// GetAccessKeyInfoWithContext mocks base method. +func (m *MockSTSAPI) GetAccessKeyInfoWithContext(arg0 context.Context, arg1 *sts.GetAccessKeyInfoInput, arg2 ...request.Option) (*sts.GetAccessKeyInfoOutput, error) { m.ctrl.T.Helper() varargs := []interface{}{arg0, arg1} for _, a := range arg2 { varargs = append(varargs, a) } - ret := m.ctrl.Call(m, "GetCallerIdentity", varargs...) + ret := m.ctrl.Call(m, "GetAccessKeyInfoWithContext", varargs...) + ret0, _ := ret[0].(*sts.GetAccessKeyInfoOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetAccessKeyInfoWithContext indicates an expected call of GetAccessKeyInfoWithContext. +func (mr *MockSTSAPIMockRecorder) GetAccessKeyInfoWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAccessKeyInfoWithContext", reflect.TypeOf((*MockSTSAPI)(nil).GetAccessKeyInfoWithContext), varargs...) +} + +// GetCallerIdentity mocks base method. +func (m *MockSTSAPI) GetCallerIdentity(arg0 *sts.GetCallerIdentityInput) (*sts.GetCallerIdentityOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetCallerIdentity", arg0) ret0, _ := ret[0].(*sts.GetCallerIdentityOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // GetCallerIdentity indicates an expected call of GetCallerIdentity. -func (mr *MockSTSAPIMockRecorder) GetCallerIdentity(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { +func (mr *MockSTSAPIMockRecorder) GetCallerIdentity(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCallerIdentity", reflect.TypeOf((*MockSTSAPI)(nil).GetCallerIdentity), arg0) +} + +// GetCallerIdentityRequest mocks base method. +func (m *MockSTSAPI) GetCallerIdentityRequest(arg0 *sts.GetCallerIdentityInput) (*request.Request, *sts.GetCallerIdentityOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetCallerIdentityRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*sts.GetCallerIdentityOutput) + return ret0, ret1 +} + +// GetCallerIdentityRequest indicates an expected call of GetCallerIdentityRequest. +func (mr *MockSTSAPIMockRecorder) GetCallerIdentityRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCallerIdentityRequest", reflect.TypeOf((*MockSTSAPI)(nil).GetCallerIdentityRequest), arg0) +} + +// GetCallerIdentityWithContext mocks base method. +func (m *MockSTSAPI) GetCallerIdentityWithContext(arg0 context.Context, arg1 *sts.GetCallerIdentityInput, arg2 ...request.Option) (*sts.GetCallerIdentityOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetCallerIdentityWithContext", varargs...) + ret0, _ := ret[0].(*sts.GetCallerIdentityOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetCallerIdentityWithContext indicates an expected call of GetCallerIdentityWithContext. +func (mr *MockSTSAPIMockRecorder) GetCallerIdentityWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCallerIdentityWithContext", reflect.TypeOf((*MockSTSAPI)(nil).GetCallerIdentityWithContext), varargs...) +} + +// GetFederationToken mocks base method. +func (m *MockSTSAPI) GetFederationToken(arg0 *sts.GetFederationTokenInput) (*sts.GetFederationTokenOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetFederationToken", arg0) + ret0, _ := ret[0].(*sts.GetFederationTokenOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetFederationToken indicates an expected call of GetFederationToken. +func (mr *MockSTSAPIMockRecorder) GetFederationToken(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetFederationToken", reflect.TypeOf((*MockSTSAPI)(nil).GetFederationToken), arg0) +} + +// GetFederationTokenRequest mocks base method. +func (m *MockSTSAPI) GetFederationTokenRequest(arg0 *sts.GetFederationTokenInput) (*request.Request, *sts.GetFederationTokenOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetFederationTokenRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*sts.GetFederationTokenOutput) + return ret0, ret1 +} + +// GetFederationTokenRequest indicates an expected call of GetFederationTokenRequest. +func (mr *MockSTSAPIMockRecorder) GetFederationTokenRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetFederationTokenRequest", reflect.TypeOf((*MockSTSAPI)(nil).GetFederationTokenRequest), arg0) +} + +// GetFederationTokenWithContext mocks base method. +func (m *MockSTSAPI) GetFederationTokenWithContext(arg0 context.Context, arg1 *sts.GetFederationTokenInput, arg2 ...request.Option) (*sts.GetFederationTokenOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetFederationTokenWithContext", varargs...) + ret0, _ := ret[0].(*sts.GetFederationTokenOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetFederationTokenWithContext indicates an expected call of GetFederationTokenWithContext. +func (mr *MockSTSAPIMockRecorder) GetFederationTokenWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetFederationTokenWithContext", reflect.TypeOf((*MockSTSAPI)(nil).GetFederationTokenWithContext), varargs...) +} + +// GetSessionToken mocks base method. +func (m *MockSTSAPI) GetSessionToken(arg0 *sts.GetSessionTokenInput) (*sts.GetSessionTokenOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetSessionToken", arg0) + ret0, _ := ret[0].(*sts.GetSessionTokenOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetSessionToken indicates an expected call of GetSessionToken. +func (mr *MockSTSAPIMockRecorder) GetSessionToken(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSessionToken", reflect.TypeOf((*MockSTSAPI)(nil).GetSessionToken), arg0) +} + +// GetSessionTokenRequest mocks base method. +func (m *MockSTSAPI) GetSessionTokenRequest(arg0 *sts.GetSessionTokenInput) (*request.Request, *sts.GetSessionTokenOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetSessionTokenRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*sts.GetSessionTokenOutput) + return ret0, ret1 +} + +// GetSessionTokenRequest indicates an expected call of GetSessionTokenRequest. +func (mr *MockSTSAPIMockRecorder) GetSessionTokenRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSessionTokenRequest", reflect.TypeOf((*MockSTSAPI)(nil).GetSessionTokenRequest), arg0) +} + +// GetSessionTokenWithContext mocks base method. +func (m *MockSTSAPI) GetSessionTokenWithContext(arg0 context.Context, arg1 *sts.GetSessionTokenInput, arg2 ...request.Option) (*sts.GetSessionTokenOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetSessionTokenWithContext", varargs...) + ret0, _ := ret[0].(*sts.GetSessionTokenOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetSessionTokenWithContext indicates an expected call of GetSessionTokenWithContext. +func (mr *MockSTSAPIMockRecorder) GetSessionTokenWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCallerIdentity", reflect.TypeOf((*MockSTSAPI)(nil).GetCallerIdentity), varargs...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSessionTokenWithContext", reflect.TypeOf((*MockSTSAPI)(nil).GetSessionTokenWithContext), varargs...) } diff --git a/test/e2e/shared/aws_helpers.go b/test/e2e/shared/aws_helpers.go index cb8cbfbaed..560c86eba3 100644 --- a/test/e2e/shared/aws_helpers.go +++ b/test/e2e/shared/aws_helpers.go @@ -37,11 +37,11 @@ import ( ) type WaitForLoadBalancerToExistForServiceInput struct { - AWSSessionV2 *aws.Config - ServiceName string - ServiceNamespace string - ClusterName string - Type infrav1.LoadBalancerType + AWSSessionV2 *aws.Config + ServiceName string + ServiceNamespace string + ClusterName string + Type infrav1.LoadBalancerType } func WaitForLoadBalancerToExistForService(ctx context.Context, input WaitForLoadBalancerToExistForServiceInput, intervals ...interface{}) { @@ -65,11 +65,11 @@ func WaitForLoadBalancerToExistForService(ctx context.Context, input WaitForLoad } type GetLoadBalancerARNsInput struct { - AWSSessionV2 *aws.Config - ServiceName string - ServiceNamespace string - ClusterName string - Type infrav1.LoadBalancerType + AWSSessionV2 *aws.Config + ServiceName string + ServiceNamespace string + ClusterName string + Type infrav1.LoadBalancerType } func GetLoadBalancerARNs(ctx context.Context, input GetLoadBalancerARNsInput) ([]string, error) { @@ -164,9 +164,9 @@ func DescribeResourcesByTags(ctx context.Context, input DescribeResourcesByTagsI } type CheckClassicElbHealthCheckInput struct { - AWSSessionV2 *aws.Config - LoadBalancerName string - ExpectedTarget string + AWSSessionV2 *aws.Config + LoadBalancerName string + ExpectedTarget string } func CheckClassicElbHealthCheck(ctx context.Context, input CheckClassicElbHealthCheckInput, intervals ...interface{}) { diff --git a/test/e2e/suites/managed/gc_test.go b/test/e2e/suites/managed/gc_test.go index 9a1e3052fb..6785adc1d1 100644 --- a/test/e2e/suites/managed/gc_test.go +++ b/test/e2e/suites/managed/gc_test.go @@ -111,18 +111,18 @@ var _ = ginkgo.Describe("[managed] [gc] EKS Cluster external resource GC tests", ginkgo.By("Checking we have the load balancers in AWS") shared.WaitForLoadBalancerToExistForService(ctx, shared.WaitForLoadBalancerToExistForServiceInput{ - AWSSessionV2: e2eCtx.BootstrapUserAWSSessionV2, - ServiceName: "podinfo-nlb", - ServiceNamespace: "default", - ClusterName: cp.Spec.EKSClusterName, - Type: infrav1.LoadBalancerTypeNLB, + AWSSessionV2: e2eCtx.BootstrapUserAWSSessionV2, + ServiceName: "podinfo-nlb", + ServiceNamespace: "default", + ClusterName: cp.Spec.EKSClusterName, + Type: infrav1.LoadBalancerTypeNLB, }, e2eCtx.E2EConfig.GetIntervals("", "wait-loadbalancer-ready")...) shared.WaitForLoadBalancerToExistForService(ctx, shared.WaitForLoadBalancerToExistForServiceInput{ - AWSSessionV2: e2eCtx.BootstrapUserAWSSessionV2, - ServiceName: "podinfo-elb", - ServiceNamespace: "default", - ClusterName: cp.Spec.EKSClusterName, - Type: infrav1.LoadBalancerTypeELB, + AWSSessionV2: e2eCtx.BootstrapUserAWSSessionV2, + ServiceName: "podinfo-elb", + ServiceNamespace: "default", + ClusterName: cp.Spec.EKSClusterName, + Type: infrav1.LoadBalancerTypeELB, }, e2eCtx.E2EConfig.GetIntervals("", "wait-loadbalancer-ready")...) ginkgo.By(fmt.Sprintf("Deleting workload/tenant cluster %s", clusterName)) @@ -139,20 +139,20 @@ var _ = ginkgo.Describe("[managed] [gc] EKS Cluster external resource GC tests", ginkgo.By("Getting counts of service load balancers") arns, err := shared.GetLoadBalancerARNs(ctx, shared.GetLoadBalancerARNsInput{ - AWSSessionV2: e2eCtx.BootstrapUserAWSSessionV2, - ServiceName: "podinfo-nlb", - ServiceNamespace: "default", - ClusterName: cp.Spec.EKSClusterName, - Type: infrav1.LoadBalancerTypeNLB, + AWSSessionV2: e2eCtx.BootstrapUserAWSSessionV2, + ServiceName: "podinfo-nlb", + ServiceNamespace: "default", + ClusterName: cp.Spec.EKSClusterName, + Type: infrav1.LoadBalancerTypeNLB, }) Expect(err).NotTo(HaveOccurred()) Expect(arns).To(BeEmpty(), "there are %d service load balancers (nlb) still", len(arns)) arns, err = shared.GetLoadBalancerARNs(ctx, shared.GetLoadBalancerARNsInput{ - AWSSessionV2: e2eCtx.BootstrapUserAWSSessionV2, - ServiceName: "podinfo-elb", - ServiceNamespace: "default", - ClusterName: cp.Spec.EKSClusterName, - Type: infrav1.LoadBalancerTypeELB, + AWSSessionV2: e2eCtx.BootstrapUserAWSSessionV2, + ServiceName: "podinfo-elb", + ServiceNamespace: "default", + ClusterName: cp.Spec.EKSClusterName, + Type: infrav1.LoadBalancerTypeELB, }) Expect(err).NotTo(HaveOccurred()) Expect(arns).To(BeEmpty(), "there are %d service load balancers (elb) still", len(arns)) @@ -234,18 +234,18 @@ var _ = ginkgo.Describe("[managed] [gc] EKS Cluster external resource GC tests", ginkgo.By("Checking we have the load balancers in AWS") shared.WaitForLoadBalancerToExistForService(ctx, shared.WaitForLoadBalancerToExistForServiceInput{ - AWSSessionV2: e2eCtx.BootstrapUserAWSSessionV2, - ServiceName: "podinfo-nlb", - ServiceNamespace: "default", - ClusterName: cp.Spec.EKSClusterName, - Type: infrav1.LoadBalancerTypeNLB, + AWSSessionV2: e2eCtx.BootstrapUserAWSSessionV2, + ServiceName: "podinfo-nlb", + ServiceNamespace: "default", + ClusterName: cp.Spec.EKSClusterName, + Type: infrav1.LoadBalancerTypeNLB, }, e2eCtx.E2EConfig.GetIntervals("", "wait-loadbalancer-ready")...) shared.WaitForLoadBalancerToExistForService(ctx, shared.WaitForLoadBalancerToExistForServiceInput{ - AWSSessionV2: e2eCtx.BootstrapUserAWSSessionV2, - ServiceName: "podinfo-elb", - ServiceNamespace: "default", - ClusterName: cp.Spec.EKSClusterName, - Type: infrav1.LoadBalancerTypeELB, + AWSSessionV2: e2eCtx.BootstrapUserAWSSessionV2, + ServiceName: "podinfo-elb", + ServiceNamespace: "default", + ClusterName: cp.Spec.EKSClusterName, + Type: infrav1.LoadBalancerTypeELB, }, e2eCtx.E2EConfig.GetIntervals("", "wait-loadbalancer-ready")...) ginkgo.By(fmt.Sprintf("Deleting workload/tenant cluster %s", clusterName)) @@ -262,20 +262,20 @@ var _ = ginkgo.Describe("[managed] [gc] EKS Cluster external resource GC tests", ginkgo.By("Getting counts of service load balancers") arns, err := shared.GetLoadBalancerARNs(ctx, shared.GetLoadBalancerARNsInput{ - AWSSessionV2: e2eCtx.BootstrapUserAWSSessionV2, - ServiceName: "podinfo-nlb", - ServiceNamespace: "default", - ClusterName: cp.Spec.EKSClusterName, - Type: infrav1.LoadBalancerTypeNLB, + AWSSessionV2: e2eCtx.BootstrapUserAWSSessionV2, + ServiceName: "podinfo-nlb", + ServiceNamespace: "default", + ClusterName: cp.Spec.EKSClusterName, + Type: infrav1.LoadBalancerTypeNLB, }) Expect(err).NotTo(HaveOccurred()) Expect(arns).To(BeEmpty(), "there are %d service load balancers (nlb) still", len(arns)) arns, err = shared.GetLoadBalancerARNs(ctx, shared.GetLoadBalancerARNsInput{ - AWSSessionV2: e2eCtx.BootstrapUserAWSSessionV2, - ServiceName: "podinfo-elb", - ServiceNamespace: "default", - ClusterName: cp.Spec.EKSClusterName, - Type: infrav1.LoadBalancerTypeELB, + AWSSessionV2: e2eCtx.BootstrapUserAWSSessionV2, + ServiceName: "podinfo-elb", + ServiceNamespace: "default", + ClusterName: cp.Spec.EKSClusterName, + Type: infrav1.LoadBalancerTypeELB, }) Expect(err).NotTo(HaveOccurred()) Expect(arns).To(BeEmpty(), "there are %d service load balancers (elb) still", len(arns)) diff --git a/test/e2e/suites/unmanaged/gc_test.go b/test/e2e/suites/unmanaged/gc_test.go index 8686ec2a36..492a9267ef 100644 --- a/test/e2e/suites/unmanaged/gc_test.go +++ b/test/e2e/suites/unmanaged/gc_test.go @@ -91,18 +91,18 @@ var _ = ginkgo.Context("[unmanaged] [gc]", func() { ginkgo.By("Checking we have the load balancers in AWS") shared.WaitForLoadBalancerToExistForService(ctx, shared.WaitForLoadBalancerToExistForServiceInput{ - AWSSessionV2: e2eCtx.BootstrapUserAWSSessionV2, - ServiceName: "podinfo-nlb", - ServiceNamespace: "default", - ClusterName: clusterName, - Type: infrav1.LoadBalancerTypeNLB, + AWSSessionV2: e2eCtx.BootstrapUserAWSSessionV2, + ServiceName: "podinfo-nlb", + ServiceNamespace: "default", + ClusterName: clusterName, + Type: infrav1.LoadBalancerTypeNLB, }, e2eCtx.E2EConfig.GetIntervals("", "wait-loadbalancer-ready")...) shared.WaitForLoadBalancerToExistForService(ctx, shared.WaitForLoadBalancerToExistForServiceInput{ - AWSSessionV2: e2eCtx.BootstrapUserAWSSessionV2, - ServiceName: "podinfo-elb", - ServiceNamespace: "default", - ClusterName: clusterName, - Type: infrav1.LoadBalancerTypeELB, + AWSSessionV2: e2eCtx.BootstrapUserAWSSessionV2, + ServiceName: "podinfo-elb", + ServiceNamespace: "default", + ClusterName: clusterName, + Type: infrav1.LoadBalancerTypeELB, }, e2eCtx.E2EConfig.GetIntervals("", "wait-loadbalancer-ready")...) ginkgo.By(fmt.Sprintf("Deleting workload/tenant cluster %s", clusterName)) @@ -119,20 +119,20 @@ var _ = ginkgo.Context("[unmanaged] [gc]", func() { ginkgo.By("Getting counts of service load balancers") arns, err := shared.GetLoadBalancerARNs(ctx, shared.GetLoadBalancerARNsInput{ - AWSSessionV2: e2eCtx.BootstrapUserAWSSessionV2, - ServiceName: "podinfo-nlb", - ServiceNamespace: "default", - ClusterName: clusterName, - Type: infrav1.LoadBalancerTypeNLB, + AWSSessionV2: e2eCtx.BootstrapUserAWSSessionV2, + ServiceName: "podinfo-nlb", + ServiceNamespace: "default", + ClusterName: clusterName, + Type: infrav1.LoadBalancerTypeNLB, }) Expect(err).NotTo(HaveOccurred()) Expect(arns).To(BeEmpty(), "there are %d service load balancers (nlb) still", len(arns)) arns, err = shared.GetLoadBalancerARNs(ctx, shared.GetLoadBalancerARNsInput{ - AWSSessionV2: e2eCtx.BootstrapUserAWSSessionV2, - ServiceName: "podinfo-elb", - ServiceNamespace: "default", - ClusterName: clusterName, - Type: infrav1.LoadBalancerTypeELB, + AWSSessionV2: e2eCtx.BootstrapUserAWSSessionV2, + ServiceName: "podinfo-elb", + ServiceNamespace: "default", + ClusterName: clusterName, + Type: infrav1.LoadBalancerTypeELB, }) Expect(err).NotTo(HaveOccurred()) Expect(arns).To(BeEmpty(), "there are %d service load balancers (elb) still", len(arns)) @@ -197,18 +197,18 @@ var _ = ginkgo.Context("[unmanaged] [gc]", func() { ginkgo.By("Checking we have the load balancers in AWS") shared.WaitForLoadBalancerToExistForService(ctx, shared.WaitForLoadBalancerToExistForServiceInput{ - AWSSessionV2: e2eCtx.BootstrapUserAWSSessionV2, - ServiceName: "podinfo-nlb", - ServiceNamespace: "default", - ClusterName: clusterName, - Type: infrav1.LoadBalancerTypeNLB, + AWSSessionV2: e2eCtx.BootstrapUserAWSSessionV2, + ServiceName: "podinfo-nlb", + ServiceNamespace: "default", + ClusterName: clusterName, + Type: infrav1.LoadBalancerTypeNLB, }, e2eCtx.E2EConfig.GetIntervals("", "wait-loadbalancer-ready")...) shared.WaitForLoadBalancerToExistForService(ctx, shared.WaitForLoadBalancerToExistForServiceInput{ - AWSSessionV2: e2eCtx.BootstrapUserAWSSessionV2, - ServiceName: "podinfo-elb", - ServiceNamespace: "default", - ClusterName: clusterName, - Type: infrav1.LoadBalancerTypeELB, + AWSSessionV2: e2eCtx.BootstrapUserAWSSessionV2, + ServiceName: "podinfo-elb", + ServiceNamespace: "default", + ClusterName: clusterName, + Type: infrav1.LoadBalancerTypeELB, }, e2eCtx.E2EConfig.GetIntervals("", "wait-loadbalancer-ready")...) ginkgo.By(fmt.Sprintf("Deleting workload/tenant cluster %s", clusterName)) @@ -225,20 +225,20 @@ var _ = ginkgo.Context("[unmanaged] [gc]", func() { ginkgo.By("Getting counts of service load balancers") arns, err := shared.GetLoadBalancerARNs(ctx, shared.GetLoadBalancerARNsInput{ - AWSSessionV2: e2eCtx.BootstrapUserAWSSessionV2, - ServiceName: "podinfo-nlb", - ServiceNamespace: "default", - ClusterName: clusterName, - Type: infrav1.LoadBalancerTypeNLB, + AWSSessionV2: e2eCtx.BootstrapUserAWSSessionV2, + ServiceName: "podinfo-nlb", + ServiceNamespace: "default", + ClusterName: clusterName, + Type: infrav1.LoadBalancerTypeNLB, }) Expect(err).NotTo(HaveOccurred()) Expect(arns).To(BeEmpty(), "there are %d service load balancers (nlb) still", len(arns)) arns, err = shared.GetLoadBalancerARNs(ctx, shared.GetLoadBalancerARNsInput{ - AWSSessionV2: e2eCtx.BootstrapUserAWSSessionV2, - ServiceName: "podinfo-elb", - ServiceNamespace: "default", - ClusterName: clusterName, - Type: infrav1.LoadBalancerTypeELB, + AWSSessionV2: e2eCtx.BootstrapUserAWSSessionV2, + ServiceName: "podinfo-elb", + ServiceNamespace: "default", + ClusterName: clusterName, + Type: infrav1.LoadBalancerTypeELB, }) Expect(err).NotTo(HaveOccurred()) Expect(arns).To(BeEmpty(), "there are %d service load balancers (elb) still", len(arns)) diff --git a/test/e2e/suites/unmanaged/unmanaged_classic_elb_upgrade_test.go b/test/e2e/suites/unmanaged/unmanaged_classic_elb_upgrade_test.go index 48e85c187c..1cfc6eae8c 100644 --- a/test/e2e/suites/unmanaged/unmanaged_classic_elb_upgrade_test.go +++ b/test/e2e/suites/unmanaged/unmanaged_classic_elb_upgrade_test.go @@ -191,9 +191,9 @@ var _ = ginkgo.Context("[unmanaged] [upgrade]", func() { Expect(err).NotTo(HaveOccurred(), "failed to get the AWS cluster") shared.CheckClassicElbHealthCheck(ctx, shared.CheckClassicElbHealthCheckInput{ - AWSSessionV2: e2eCtx.BootstrapUserAWSSessionV2, - LoadBalancerName: awsCluster.Status.Network.APIServerELB.Name, - ExpectedTarget: "SSL:6443", + AWSSessionV2: e2eCtx.BootstrapUserAWSSessionV2, + LoadBalancerName: awsCluster.Status.Network.APIServerELB.Name, + ExpectedTarget: "SSL:6443", }, e2eCtx.E2EConfig.GetIntervals(specName, "wait-classic-elb-health-check-short")...) ginkgo.By("Now the workload cluster is ready upgrade CAPA to main version") @@ -210,9 +210,9 @@ var _ = ginkgo.Context("[unmanaged] [upgrade]", func() { ginkgo.By("Management cluster is upgraded to main version") shared.CheckClassicElbHealthCheck(ctx, shared.CheckClassicElbHealthCheckInput{ - AWSSessionV2: e2eCtx.BootstrapUserAWSSessionV2, - LoadBalancerName: awsCluster.Status.Network.APIServerELB.Name, - ExpectedTarget: "TCP:6443", + AWSSessionV2: e2eCtx.BootstrapUserAWSSessionV2, + LoadBalancerName: awsCluster.Status.Network.APIServerELB.Name, + ExpectedTarget: "TCP:6443", }, e2eCtx.E2EConfig.GetIntervals(specName, "wait-classic-elb-health-check-long")...) shared.Byf("Upgrading the control plane to %s", kubernetesVersionTo) From 7f6f80a9b445f8d36071df9cd86a4f4e5d0edfe0 Mon Sep 17 00:00:00 2001 From: Liangquan Li Date: Wed, 6 Aug 2025 15:23:44 +0800 Subject: [PATCH 5/8] fix e2e job --- pkg/cloud/services/wait/wait_test.go | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/pkg/cloud/services/wait/wait_test.go b/pkg/cloud/services/wait/wait_test.go index 284786915c..24e97b0d8a 100644 --- a/pkg/cloud/services/wait/wait_test.go +++ b/pkg/cloud/services/wait/wait_test.go @@ -21,14 +21,14 @@ import ( "testing" "time" - "github.com/aws/aws-sdk-go/aws/awserr" + "github.com/aws/smithy-go" "k8s.io/apimachinery/pkg/util/wait" . "sigs.k8s.io/cluster-api-provider-aws/v2/pkg/cloud/services/wait" ) var ( - errRetryable = awserr.New("retryable error", "", nil) + errRetryable = &smithy.GenericAPIError{Code: "retryable error", Message: "retryable error"} errNonRetryable = errors.New("non retryable error") retryableErrorCodes = []string{"retryable error"} ) From 86dd8945cf73b8441771188f7f2a3f175352dee5 Mon Sep 17 00:00:00 2001 From: Liangquan Li Date: Wed, 6 Aug 2025 16:21:56 +0800 Subject: [PATCH 6/8] rebase --- test/e2e/shared/aws_helpers.go | 18 +++++++------- test/e2e/suites/managed/addon.go | 8 +++---- test/e2e/suites/managed/addon_helpers.go | 12 +++++----- test/e2e/suites/managed/aws_node_env.go | 4 ++-- test/e2e/suites/managed/cluster.go | 9 ++++--- test/e2e/suites/managed/control_plane.go | 6 ++--- .../suites/managed/control_plane_helpers.go | 6 ++--- test/e2e/suites/managed/eks_ipv6_test.go | 4 ++-- test/e2e/suites/managed/eks_legacy_test.go | 4 ++-- test/e2e/suites/managed/eks_test.go | 14 +++++------ test/e2e/suites/managed/gc_test.go | 24 +++++++++---------- test/e2e/suites/managed/machine_deployment.go | 4 ++-- test/e2e/suites/managed/machine_pool.go | 9 ++++--- test/e2e/suites/managed/upgrade_test.go | 4 ++-- test/e2e/suites/unmanaged/gc_test.go | 16 ++++++------- .../unmanaged_classic_elb_upgrade_test.go | 4 ++-- 16 files changed, 72 insertions(+), 74 deletions(-) diff --git a/test/e2e/shared/aws_helpers.go b/test/e2e/shared/aws_helpers.go index 560c86eba3..a338741f75 100644 --- a/test/e2e/shared/aws_helpers.go +++ b/test/e2e/shared/aws_helpers.go @@ -37,7 +37,7 @@ import ( ) type WaitForLoadBalancerToExistForServiceInput struct { - AWSSessionV2 *aws.Config + AWSSession *aws.Config ServiceName string ServiceNamespace string ClusterName string @@ -65,7 +65,7 @@ func WaitForLoadBalancerToExistForService(ctx context.Context, input WaitForLoad } type GetLoadBalancerARNsInput struct { - AWSSessionV2 *aws.Config + AWSSession *aws.Config ServiceName string ServiceNamespace string ClusterName string @@ -81,8 +81,8 @@ func GetLoadBalancerARNs(ctx context.Context, input GetLoadBalancerARNsInput) ([ serviceTag: {string(infrav1.ResourceLifecycleOwned)}, } descInput := &DescribeResourcesByTagsInput{ - AWSSessionV2: input.AWSSessionV2, - Tags: tags, + AWSSession: input.AWSSession, + Tags: tags, } descOutput, err := DescribeResourcesByTags(ctx, *descInput) @@ -123,8 +123,8 @@ func GetLoadBalancerARNs(ctx context.Context, input GetLoadBalancerARNsInput) ([ } type DescribeResourcesByTagsInput struct { - AWSSessionV2 *aws.Config - Tags map[string][]string + AWSSession *aws.Config + Tags map[string][]string } type DescribeResourcesByTagsOutput struct { @@ -147,7 +147,7 @@ func DescribeResourcesByTags(ctx context.Context, input DescribeResourcesByTagsI }) } - rgSvc := rgapi.NewFromConfig(*input.AWSSessionV2) + rgSvc := rgapi.NewFromConfig(*input.AWSSession) awsOutput, err := rgSvc.GetResources(ctx, &awsInput) if err != nil { return nil, fmt.Errorf("getting resources by tags: %w", err) @@ -164,7 +164,7 @@ func DescribeResourcesByTags(ctx context.Context, input DescribeResourcesByTagsI } type CheckClassicElbHealthCheckInput struct { - AWSSessionV2 *aws.Config + AWSSession *aws.Config LoadBalancerName string ExpectedTarget string } @@ -172,7 +172,7 @@ type CheckClassicElbHealthCheckInput struct { func CheckClassicElbHealthCheck(ctx context.Context, input CheckClassicElbHealthCheckInput, intervals ...interface{}) { Byf("Checking the health check for the classic load balancer %s", input.LoadBalancerName) - elbSvc := elb.NewFromConfig(*input.AWSSessionV2) + elbSvc := elb.NewFromConfig(*input.AWSSession) Eventually(func() error { out, err := elbSvc.DescribeLoadBalancers(ctx, &elb.DescribeLoadBalancersInput{ diff --git a/test/e2e/suites/managed/addon.go b/test/e2e/suites/managed/addon.go index 5ecab3c2f3..52de46b52c 100644 --- a/test/e2e/suites/managed/addon.go +++ b/test/e2e/suites/managed/addon.go @@ -38,7 +38,7 @@ import ( type CheckAddonExistsSpecInput struct { E2EConfig *clusterctl.E2EConfig BootstrapClusterProxy framework.ClusterProxy - AWSSessionV2 *awsv2.Config + AWSSession *awsv2.Config Namespace *corev1.Namespace ClusterName string AddonName string @@ -51,7 +51,7 @@ func CheckAddonExistsSpec(ctx context.Context, inputGetter func() CheckAddonExis input := inputGetter() Expect(input.E2EConfig).ToNot(BeNil(), "Invalid argument. input.E2EConfig can't be nil") Expect(input.BootstrapClusterProxy).ToNot(BeNil(), "Invalid argument. input.BootstrapClusterProxy can't be nil") - Expect(input.AWSSessionV2).ToNot(BeNil(), "Invalid argument. input.AWSSessionV2 can't be nil") + Expect(input.AWSSession).ToNot(BeNil(), "Invalid argument. input.AWSSession can't be nil") Expect(input.Namespace).NotTo(BeNil(), "Invalid argument. input.Namespace can't be nil") Expect(input.ClusterName).ShouldNot(BeEmpty(), "Invalid argument. input.ClusterName can't be empty") Expect(input.AddonName).ShouldNot(BeEmpty(), "Invalid argument. input.AddonName can't be empty") @@ -69,7 +69,7 @@ func CheckAddonExistsSpec(ctx context.Context, inputGetter func() CheckAddonExis By(fmt.Sprintf("Checking EKS addon %s is installed on cluster %s and is active", input.AddonName, input.ClusterName)) waitForEKSAddonToHaveStatus(ctx, waitForEKSAddonToHaveStatusInput{ ControlPlane: controlPlane, - AWSSessionV2: input.AWSSessionV2, + AWSSession: input.AWSSession, AddonName: input.AddonName, AddonVersion: input.AddonVersion, AddonStatus: []string{string(ekstypes.AddonStatusActive), string(ekstypes.AddonStatusDegraded)}, @@ -79,7 +79,7 @@ func CheckAddonExistsSpec(ctx context.Context, inputGetter func() CheckAddonExis By(fmt.Sprintf("Checking EKS addon %s has the correct configuration", input.AddonName)) checkEKSAddonConfiguration(ctx, checkEKSAddonConfigurationInput{ ControlPlane: controlPlane, - AWSSessionV2: input.AWSSessionV2, + AWSSession: input.AWSSession, AddonName: input.AddonName, AddonVersion: input.AddonVersion, AddonConfiguration: input.AddonConfiguration, diff --git a/test/e2e/suites/managed/addon_helpers.go b/test/e2e/suites/managed/addon_helpers.go index 96442d7a1e..7643275277 100644 --- a/test/e2e/suites/managed/addon_helpers.go +++ b/test/e2e/suites/managed/addon_helpers.go @@ -32,7 +32,7 @@ import ( type waitForEKSAddonToHaveStatusInput struct { ControlPlane *ekscontrolplanev1.AWSManagedControlPlane - AWSSessionV2 *aws.Config + AWSSession *aws.Config AddonName string AddonVersion string AddonStatus []string @@ -40,7 +40,7 @@ type waitForEKSAddonToHaveStatusInput struct { func waitForEKSAddonToHaveStatus(ctx context.Context, input waitForEKSAddonToHaveStatusInput, intervals ...interface{}) { Expect(input.ControlPlane).ToNot(BeNil(), "Invalid argument. input.ControlPlane can't be nil") - Expect(input.AWSSessionV2).ToNot(BeNil(), "Invalid argument. input.AWSSessionV2 can't be nil") + Expect(input.AWSSession).ToNot(BeNil(), "Invalid argument. input.AWSSession can't be nil") Expect(input.AddonName).ShouldNot(BeEmpty(), "Invalid argument. input.AddonName can't be empty") Expect(input.AddonVersion).ShouldNot(BeEmpty(), "Invalid argument. input.AddonVersion can't be empty") Expect(input.AddonStatus).ShouldNot(BeEmpty(), "Invalid argument. input.AddonStatus can't be empty") @@ -48,7 +48,7 @@ func waitForEKSAddonToHaveStatus(ctx context.Context, input waitForEKSAddonToHav ginkgo.By(fmt.Sprintf("Ensuring EKS addon %s has status in %q for EKS cluster %s", input.AddonName, input.AddonStatus, input.ControlPlane.Spec.EKSClusterName)) Eventually(func() (bool, error) { - installedAddon, err := getEKSClusterAddon(ctx, input.ControlPlane.Spec.EKSClusterName, input.AddonName, input.AWSSessionV2) + installedAddon, err := getEKSClusterAddon(ctx, input.ControlPlane.Spec.EKSClusterName, input.AddonName, input.AWSSession) if err != nil { return false, err } @@ -71,7 +71,7 @@ func waitForEKSAddonToHaveStatus(ctx context.Context, input waitForEKSAddonToHav type checkEKSAddonConfigurationInput struct { ControlPlane *ekscontrolplanev1.AWSManagedControlPlane - AWSSessionV2 *aws.Config + AWSSession *aws.Config AddonName string AddonVersion string AddonConfiguration string @@ -79,7 +79,7 @@ type checkEKSAddonConfigurationInput struct { func checkEKSAddonConfiguration(ctx context.Context, input checkEKSAddonConfigurationInput, intervals ...interface{}) { Expect(input.ControlPlane).ToNot(BeNil(), "Invalid argument. input.ControlPlane can't be nil") - Expect(input.AWSSessionV2).ToNot(BeNil(), "Invalid argument. input.AWSSessionV2 can't be nil") + Expect(input.AWSSession).ToNot(BeNil(), "Invalid argument. input.AWSSession can't be nil") Expect(input.AddonName).ShouldNot(BeEmpty(), "Invalid argument. input.AddonName can't be empty") Expect(input.AddonVersion).ShouldNot(BeEmpty(), "Invalid argument. input.AddonVersion can't be empty") Expect(input.AddonConfiguration).ShouldNot(BeEmpty(), "Invalid argument. input.AddonConfiguration can't be empty") @@ -87,7 +87,7 @@ func checkEKSAddonConfiguration(ctx context.Context, input checkEKSAddonConfigur ginkgo.By(fmt.Sprintf("Ensuring EKS addon %s has config in %q for EKS cluster %s", input.AddonName, input.AddonConfiguration, input.ControlPlane.Spec.EKSClusterName)) Eventually(func() (bool, error) { - installedAddon, err := getEKSClusterAddon(ctx, input.ControlPlane.Spec.EKSClusterName, input.AddonName, input.AWSSessionV2) + installedAddon, err := getEKSClusterAddon(ctx, input.ControlPlane.Spec.EKSClusterName, input.AddonName, input.AWSSession) if err != nil { return false, err } diff --git a/test/e2e/suites/managed/aws_node_env.go b/test/e2e/suites/managed/aws_node_env.go index f4554649ac..82359d1dc7 100644 --- a/test/e2e/suites/managed/aws_node_env.go +++ b/test/e2e/suites/managed/aws_node_env.go @@ -39,7 +39,7 @@ import ( type UpdateAwsNodeVersionSpecInput struct { E2EConfig *clusterctl.E2EConfig BootstrapClusterProxy framework.ClusterProxy - AWSSessionV2 *aws.Config + AWSSession *aws.Config Namespace *corev1.Namespace ClusterName string } @@ -49,7 +49,7 @@ func CheckAwsNodeEnvVarsSet(ctx context.Context, inputGetter func() UpdateAwsNod input := inputGetter() Expect(input.E2EConfig).ToNot(BeNil(), "Invalid argument. input.E2EConfig can't be nil") Expect(input.BootstrapClusterProxy).ToNot(BeNil(), "Invalid argument. input.BootstrapClusterProxy can't be nil") - Expect(input.AWSSessionV2).ToNot(BeNil(), "Invalid argument. input.AWSSessionV2 can't be nil") + Expect(input.AWSSession).ToNot(BeNil(), "Invalid argument. input.AWSSession can't be nil") Expect(input.Namespace).NotTo(BeNil(), "Invalid argument. input.Namespace can't be nil") Expect(input.ClusterName).ShouldNot(BeEmpty(), "Invalid argument. input.ClusterName can't be empty") diff --git a/test/e2e/suites/managed/cluster.go b/test/e2e/suites/managed/cluster.go index 7994be269c..396d898591 100644 --- a/test/e2e/suites/managed/cluster.go +++ b/test/e2e/suites/managed/cluster.go @@ -43,8 +43,7 @@ type ManagedClusterSpecInput struct { E2EConfig *clusterctl.E2EConfig ConfigClusterFn DefaultConfigClusterFn BootstrapClusterProxy framework.ClusterProxy - AWSSession aws.Config - AWSSessionV2 *aws.Config + AWSSession *aws.Config Namespace *corev1.Namespace ClusterName string Flavour string @@ -88,14 +87,14 @@ func ManagedClusterSpec(ctx context.Context, inputGetter func() ManagedClusterSp ginkgo.By("Checking EKS cluster is active") eksClusterName := getEKSClusterName(input.Namespace.Name, input.ClusterName) - verifyClusterActiveAndOwned(ctx, eksClusterName, input.AWSSessionV2) + verifyClusterActiveAndOwned(ctx, eksClusterName, input.AWSSession) if input.CluserSpecificRoles { ginkgo.By("Checking that the cluster specific IAM role exists") - VerifyRoleExistsAndOwned(ctx, fmt.Sprintf("%s-iam-service-role", input.ClusterName), eksClusterName, true, input.AWSSessionV2) + VerifyRoleExistsAndOwned(ctx, fmt.Sprintf("%s-iam-service-role", input.ClusterName), eksClusterName, true, input.AWSSession) } else { ginkgo.By("Checking that the cluster default IAM role exists") - VerifyRoleExistsAndOwned(ctx, ekscontrolplanev1.DefaultEKSControlPlaneRole, eksClusterName, false, input.AWSSessionV2) + VerifyRoleExistsAndOwned(ctx, ekscontrolplanev1.DefaultEKSControlPlaneRole, eksClusterName, false, input.AWSSession) } ginkgo.By("Checking kubeconfig secrets exist") diff --git a/test/e2e/suites/managed/control_plane.go b/test/e2e/suites/managed/control_plane.go index d2d4369843..1b820a7b11 100644 --- a/test/e2e/suites/managed/control_plane.go +++ b/test/e2e/suites/managed/control_plane.go @@ -38,7 +38,7 @@ import ( // UpgradeControlPlaneVersionSpecInput is the input type for UpgradeControlPlaneVersionSpec. type UpgradeControlPlaneVersionSpecInput struct { E2EConfig *clusterctl.E2EConfig - AWSSessionV2 *aws.Config + AWSSession *aws.Config BootstrapClusterProxy framework.ClusterProxy ClusterName string Namespace *corev1.Namespace @@ -49,7 +49,7 @@ type UpgradeControlPlaneVersionSpecInput struct { func UpgradeControlPlaneVersionSpec(ctx context.Context, inputGetter func() UpgradeControlPlaneVersionSpecInput) { input := inputGetter() Expect(input.E2EConfig).ToNot(BeNil(), "Invalid argument. input.E2EConfig can't be nil") - Expect(input.AWSSessionV2).ToNot(BeNil(), "Invalid argument. input.AWSSessionV2 can't be nil") + Expect(input.AWSSession).ToNot(BeNil(), "Invalid argument. input.AWSSession can't be nil") Expect(input.BootstrapClusterProxy).ToNot(BeNil(), "Invalid argument. input.BootstrapClusterProxy can't be nil") Expect(input.ClusterName).ToNot(BeNil(), "Invalid argument. input.ClusterName can't be nil") Expect(input.Namespace).ToNot(BeNil(), "Invalid argument. input.Namespace can't be nil") @@ -72,7 +72,7 @@ func UpgradeControlPlaneVersionSpec(ctx context.Context, inputGetter func() Upgr ginkgo.By("Waiting for EKS control-plane to be upgraded to new version") waitForControlPlaneToBeUpgraded(ctx, waitForControlPlaneToBeUpgradedInput{ ControlPlane: controlPlane, - AWSSessionV2: input.AWSSessionV2, + AWSSession: input.AWSSession, UpgradeVersion: input.UpgradeVersion, }, input.E2EConfig.GetIntervals("", "wait-control-plane-upgrade")...) } diff --git a/test/e2e/suites/managed/control_plane_helpers.go b/test/e2e/suites/managed/control_plane_helpers.go index d96c098074..0178236d32 100644 --- a/test/e2e/suites/managed/control_plane_helpers.go +++ b/test/e2e/suites/managed/control_plane_helpers.go @@ -40,13 +40,13 @@ import ( type waitForControlPlaneToBeUpgradedInput struct { ControlPlane *ekscontrolplanev1.AWSManagedControlPlane - AWSSessionV2 *aws.Config + AWSSession *aws.Config UpgradeVersion string } func waitForControlPlaneToBeUpgraded(ctx context.Context, input waitForControlPlaneToBeUpgradedInput, intervals ...interface{}) { Expect(input.ControlPlane).ToNot(BeNil(), "Invalid argument. input.ControlPlane can't be nil") - Expect(input.AWSSessionV2).ToNot(BeNil(), "Invalid argument. input.AWSSessionV2 can't be nil") + Expect(input.AWSSession).ToNot(BeNil(), "Invalid argument. input.AWSSession can't be nil") Expect(input.UpgradeVersion).ToNot(BeNil(), "Invalid argument. input.UpgradeVersion can't be nil") By(fmt.Sprintf("Ensuring EKS control-plane has been upgraded to kubernetes version %s", input.UpgradeVersion)) @@ -55,7 +55,7 @@ func waitForControlPlaneToBeUpgraded(ctx context.Context, input waitForControlPl expectedVersion := fmt.Sprintf("%d.%d", v.Major(), v.Minor()) Eventually(func() (bool, error) { - cluster, err := getEKSCluster(ctx, input.ControlPlane.Spec.EKSClusterName, input.AWSSessionV2) + cluster, err := getEKSCluster(ctx, input.ControlPlane.Spec.EKSClusterName, input.AWSSession) if err != nil { return false, err } diff --git a/test/e2e/suites/managed/eks_ipv6_test.go b/test/e2e/suites/managed/eks_ipv6_test.go index b0212b34e5..a9f691d142 100644 --- a/test/e2e/suites/managed/eks_ipv6_test.go +++ b/test/e2e/suites/managed/eks_ipv6_test.go @@ -66,7 +66,7 @@ var _ = ginkgo.Describe("[managed] [general] [ipv6] EKS cluster tests", func() { E2EConfig: e2eCtx.E2EConfig, ConfigClusterFn: defaultConfigCluster, BootstrapClusterProxy: e2eCtx.Environment.BootstrapClusterProxy, - AWSSessionV2: e2eCtx.BootstrapUserAWSSessionV2, + AWSSession: e2eCtx.BootstrapUserAWSSessionV2, Namespace: namespace, ClusterName: clusterName, Flavour: EKSIPv6ClusterFlavor, @@ -81,7 +81,7 @@ var _ = ginkgo.Describe("[managed] [general] [ipv6] EKS cluster tests", func() { E2EConfig: e2eCtx.E2EConfig, ConfigClusterFn: defaultConfigCluster, BootstrapClusterProxy: e2eCtx.Environment.BootstrapClusterProxy, - AWSSessionV2: e2eCtx.BootstrapUserAWSSessionV2, + AWSSession: e2eCtx.BootstrapUserAWSSessionV2, Namespace: namespace, ClusterName: clusterName, IncludeScaling: false, diff --git a/test/e2e/suites/managed/eks_legacy_test.go b/test/e2e/suites/managed/eks_legacy_test.go index 52ca56e079..900760f3b2 100644 --- a/test/e2e/suites/managed/eks_legacy_test.go +++ b/test/e2e/suites/managed/eks_legacy_test.go @@ -66,7 +66,7 @@ var _ = ginkgo.Describe("[managed] [legacy] EKS cluster tests - single kind", fu E2EConfig: e2eCtx.E2EConfig, ConfigClusterFn: defaultConfigCluster, BootstrapClusterProxy: e2eCtx.Environment.BootstrapClusterProxy, - AWSSessionV2: e2eCtx.BootstrapUserAWSSessionV2, + AWSSession: e2eCtx.BootstrapUserAWSSessionV2, Namespace: namespace, ClusterName: clusterName, Flavour: EKSControlPlaneOnlyLegacyFlavor, @@ -81,7 +81,7 @@ var _ = ginkgo.Describe("[managed] [legacy] EKS cluster tests - single kind", fu E2EConfig: e2eCtx.E2EConfig, ConfigClusterFn: defaultConfigCluster, BootstrapClusterProxy: e2eCtx.Environment.BootstrapClusterProxy, - AWSSessionV2: e2eCtx.BootstrapUserAWSSessionV2, + AWSSession: e2eCtx.BootstrapUserAWSSessionV2, Namespace: namespace, ClusterName: clusterName, IncludeScaling: false, diff --git a/test/e2e/suites/managed/eks_test.go b/test/e2e/suites/managed/eks_test.go index 206aba4dc7..cddc0a83ed 100644 --- a/test/e2e/suites/managed/eks_test.go +++ b/test/e2e/suites/managed/eks_test.go @@ -64,7 +64,7 @@ var _ = ginkgo.Describe("[managed] [general] EKS cluster tests", func() { E2EConfig: e2eCtx.E2EConfig, ConfigClusterFn: defaultConfigCluster, BootstrapClusterProxy: e2eCtx.Environment.BootstrapClusterProxy, - AWSSessionV2: e2eCtx.BootstrapUserAWSSessionV2, + AWSSession: e2eCtx.BootstrapUserAWSSessionV2, Namespace: namespace, ClusterName: clusterName, Flavour: EKSControlPlaneOnlyWithAddonFlavor, @@ -78,7 +78,7 @@ var _ = ginkgo.Describe("[managed] [general] EKS cluster tests", func() { return UpdateAwsNodeVersionSpecInput{ E2EConfig: e2eCtx.E2EConfig, BootstrapClusterProxy: e2eCtx.Environment.BootstrapClusterProxy, - AWSSessionV2: e2eCtx.BootstrapUserAWSSessionV2, + AWSSession: e2eCtx.BootstrapUserAWSSessionV2, Namespace: namespace, ClusterName: clusterName, } @@ -89,7 +89,7 @@ var _ = ginkgo.Describe("[managed] [general] EKS cluster tests", func() { return CheckAddonExistsSpecInput{ E2EConfig: e2eCtx.E2EConfig, BootstrapClusterProxy: e2eCtx.Environment.BootstrapClusterProxy, - AWSSessionV2: e2eCtx.BootstrapUserAWSSessionV2, + AWSSession: e2eCtx.BootstrapUserAWSSessionV2, Namespace: namespace, ClusterName: clusterName, AddonName: cniAddonName, @@ -103,7 +103,7 @@ var _ = ginkgo.Describe("[managed] [general] EKS cluster tests", func() { E2EConfig: e2eCtx.E2EConfig, ConfigClusterFn: defaultConfigCluster, BootstrapClusterProxy: e2eCtx.Environment.BootstrapClusterProxy, - AWSSessionV2: e2eCtx.BootstrapUserAWSSessionV2, + AWSSession: e2eCtx.BootstrapUserAWSSessionV2, Namespace: namespace, ClusterName: clusterName, Replicas: 1, @@ -117,7 +117,7 @@ var _ = ginkgo.Describe("[managed] [general] EKS cluster tests", func() { E2EConfig: e2eCtx.E2EConfig, ConfigClusterFn: defaultConfigCluster, BootstrapClusterProxy: e2eCtx.Environment.BootstrapClusterProxy, - AWSSessionV2: e2eCtx.BootstrapUserAWSSessionV2, + AWSSession: e2eCtx.BootstrapUserAWSSessionV2, Namespace: namespace, ClusterName: clusterName, IncludeScaling: true, @@ -133,7 +133,7 @@ var _ = ginkgo.Describe("[managed] [general] EKS cluster tests", func() { E2EConfig: e2eCtx.E2EConfig, ConfigClusterFn: defaultConfigCluster, BootstrapClusterProxy: e2eCtx.Environment.BootstrapClusterProxy, - AWSSessionV2: e2eCtx.BootstrapUserAWSSessionV2, + AWSSession: e2eCtx.BootstrapUserAWSSessionV2, Namespace: namespace, ClusterName: clusterName, IncludeScaling: true, @@ -150,7 +150,7 @@ var _ = ginkgo.Describe("[managed] [general] EKS cluster tests", func() { E2EConfig: e2eCtx.E2EConfig, ConfigClusterFn: defaultConfigCluster, BootstrapClusterProxy: e2eCtx.Environment.BootstrapClusterProxy, - AWSSessionV2: e2eCtx.BootstrapUserAWSSessionV2, + AWSSession: e2eCtx.BootstrapUserAWSSessionV2, Namespace: namespace, ClusterName: clusterName, IncludeScaling: true, diff --git a/test/e2e/suites/managed/gc_test.go b/test/e2e/suites/managed/gc_test.go index 6785adc1d1..64f33e88ed 100644 --- a/test/e2e/suites/managed/gc_test.go +++ b/test/e2e/suites/managed/gc_test.go @@ -55,7 +55,7 @@ var _ = ginkgo.Describe("[managed] [gc] EKS Cluster external resource GC tests", clusterName = fmt.Sprintf("%s-%s", specName, util.RandomString(6)) ginkgo.By("default iam role should exist") - VerifyRoleExistsAndOwned(ctx, ekscontrolplanev1.DefaultEKSControlPlaneRole, clusterName, false, e2eCtx.AWSSessionV2) + VerifyRoleExistsAndOwned(ctx, ekscontrolplanev1.DefaultEKSControlPlaneRole, clusterName, false, e2eCtx.BootstrapUserAWSSessionV2) ginkgo.By("should create an EKS control plane") ManagedClusterSpec(ctx, func() ManagedClusterSpecInput { @@ -63,7 +63,7 @@ var _ = ginkgo.Describe("[managed] [gc] EKS Cluster external resource GC tests", E2EConfig: e2eCtx.E2EConfig, ConfigClusterFn: defaultConfigCluster, BootstrapClusterProxy: e2eCtx.Environment.BootstrapClusterProxy, - AWSSessionV2: e2eCtx.BootstrapUserAWSSessionV2, + AWSSession: e2eCtx.BootstrapUserAWSSessionV2, Namespace: namespace, ClusterName: clusterName, Flavour: EKSManagedPoolFlavor, @@ -111,14 +111,14 @@ var _ = ginkgo.Describe("[managed] [gc] EKS Cluster external resource GC tests", ginkgo.By("Checking we have the load balancers in AWS") shared.WaitForLoadBalancerToExistForService(ctx, shared.WaitForLoadBalancerToExistForServiceInput{ - AWSSessionV2: e2eCtx.BootstrapUserAWSSessionV2, + AWSSession: e2eCtx.BootstrapUserAWSSessionV2, ServiceName: "podinfo-nlb", ServiceNamespace: "default", ClusterName: cp.Spec.EKSClusterName, Type: infrav1.LoadBalancerTypeNLB, }, e2eCtx.E2EConfig.GetIntervals("", "wait-loadbalancer-ready")...) shared.WaitForLoadBalancerToExistForService(ctx, shared.WaitForLoadBalancerToExistForServiceInput{ - AWSSessionV2: e2eCtx.BootstrapUserAWSSessionV2, + AWSSession: e2eCtx.BootstrapUserAWSSessionV2, ServiceName: "podinfo-elb", ServiceNamespace: "default", ClusterName: cp.Spec.EKSClusterName, @@ -139,7 +139,7 @@ var _ = ginkgo.Describe("[managed] [gc] EKS Cluster external resource GC tests", ginkgo.By("Getting counts of service load balancers") arns, err := shared.GetLoadBalancerARNs(ctx, shared.GetLoadBalancerARNsInput{ - AWSSessionV2: e2eCtx.BootstrapUserAWSSessionV2, + AWSSession: e2eCtx.BootstrapUserAWSSessionV2, ServiceName: "podinfo-nlb", ServiceNamespace: "default", ClusterName: cp.Spec.EKSClusterName, @@ -148,7 +148,7 @@ var _ = ginkgo.Describe("[managed] [gc] EKS Cluster external resource GC tests", Expect(err).NotTo(HaveOccurred()) Expect(arns).To(BeEmpty(), "there are %d service load balancers (nlb) still", len(arns)) arns, err = shared.GetLoadBalancerARNs(ctx, shared.GetLoadBalancerARNsInput{ - AWSSessionV2: e2eCtx.BootstrapUserAWSSessionV2, + AWSSession: e2eCtx.BootstrapUserAWSSessionV2, ServiceName: "podinfo-elb", ServiceNamespace: "default", ClusterName: cp.Spec.EKSClusterName, @@ -178,7 +178,7 @@ var _ = ginkgo.Describe("[managed] [gc] EKS Cluster external resource GC tests", clusterName = fmt.Sprintf("%s-%s", specName, util.RandomString(6)) ginkgo.By("default iam role should exist") - VerifyRoleExistsAndOwned(ctx, ekscontrolplanev1.DefaultEKSControlPlaneRole, clusterName, false, e2eCtx.AWSSessionV2) + VerifyRoleExistsAndOwned(ctx, ekscontrolplanev1.DefaultEKSControlPlaneRole, clusterName, false, e2eCtx.BootstrapUserAWSSessionV2) ginkgo.By("should create an EKS control plane") ManagedClusterSpec(ctx, func() ManagedClusterSpecInput { @@ -186,7 +186,7 @@ var _ = ginkgo.Describe("[managed] [gc] EKS Cluster external resource GC tests", E2EConfig: e2eCtx.E2EConfig, ConfigClusterFn: defaultConfigCluster, BootstrapClusterProxy: e2eCtx.Environment.BootstrapClusterProxy, - AWSSessionV2: e2eCtx.BootstrapUserAWSSessionV2, + AWSSession: e2eCtx.BootstrapUserAWSSessionV2, Namespace: namespace, ClusterName: clusterName, Flavour: EKSManagedPoolFlavor, @@ -234,14 +234,14 @@ var _ = ginkgo.Describe("[managed] [gc] EKS Cluster external resource GC tests", ginkgo.By("Checking we have the load balancers in AWS") shared.WaitForLoadBalancerToExistForService(ctx, shared.WaitForLoadBalancerToExistForServiceInput{ - AWSSessionV2: e2eCtx.BootstrapUserAWSSessionV2, + AWSSession: e2eCtx.BootstrapUserAWSSessionV2, ServiceName: "podinfo-nlb", ServiceNamespace: "default", ClusterName: cp.Spec.EKSClusterName, Type: infrav1.LoadBalancerTypeNLB, }, e2eCtx.E2EConfig.GetIntervals("", "wait-loadbalancer-ready")...) shared.WaitForLoadBalancerToExistForService(ctx, shared.WaitForLoadBalancerToExistForServiceInput{ - AWSSessionV2: e2eCtx.BootstrapUserAWSSessionV2, + AWSSession: e2eCtx.BootstrapUserAWSSessionV2, ServiceName: "podinfo-elb", ServiceNamespace: "default", ClusterName: cp.Spec.EKSClusterName, @@ -262,7 +262,7 @@ var _ = ginkgo.Describe("[managed] [gc] EKS Cluster external resource GC tests", ginkgo.By("Getting counts of service load balancers") arns, err := shared.GetLoadBalancerARNs(ctx, shared.GetLoadBalancerARNsInput{ - AWSSessionV2: e2eCtx.BootstrapUserAWSSessionV2, + AWSSession: e2eCtx.BootstrapUserAWSSessionV2, ServiceName: "podinfo-nlb", ServiceNamespace: "default", ClusterName: cp.Spec.EKSClusterName, @@ -271,7 +271,7 @@ var _ = ginkgo.Describe("[managed] [gc] EKS Cluster external resource GC tests", Expect(err).NotTo(HaveOccurred()) Expect(arns).To(BeEmpty(), "there are %d service load balancers (nlb) still", len(arns)) arns, err = shared.GetLoadBalancerARNs(ctx, shared.GetLoadBalancerARNsInput{ - AWSSessionV2: e2eCtx.BootstrapUserAWSSessionV2, + AWSSession: e2eCtx.BootstrapUserAWSSessionV2, ServiceName: "podinfo-elb", ServiceNamespace: "default", ClusterName: cp.Spec.EKSClusterName, diff --git a/test/e2e/suites/managed/machine_deployment.go b/test/e2e/suites/managed/machine_deployment.go index bd576f70bc..4ef19a0f8d 100644 --- a/test/e2e/suites/managed/machine_deployment.go +++ b/test/e2e/suites/managed/machine_deployment.go @@ -40,7 +40,7 @@ type MachineDeploymentSpecInput struct { E2EConfig *clusterctl.E2EConfig ConfigClusterFn DefaultConfigClusterFn BootstrapClusterProxy framework.ClusterProxy - AWSSessionV2 *aws.Config + AWSSession *aws.Config Namespace *corev1.Namespace Replicas int64 ClusterName string @@ -53,7 +53,7 @@ func MachineDeploymentSpec(ctx context.Context, inputGetter func() MachineDeploy Expect(input.E2EConfig).ToNot(BeNil(), "Invalid argument. input.E2EConfig can't be nil") Expect(input.ConfigClusterFn).ToNot(BeNil(), "Invalid argument. input.ConfigClusterFn can't be nil") Expect(input.BootstrapClusterProxy).ToNot(BeNil(), "Invalid argument. input.BootstrapClusterProxy can't be nil") - Expect(input.AWSSessionV2).ToNot(BeNil(), "Invalid argument. input.AWSSessionV2 can't be nil") + Expect(input.AWSSession).ToNot(BeNil(), "Invalid argument. input.AWSSession can't be nil") Expect(input.Namespace).NotTo(BeNil(), "Invalid argument. input.Namespace can't be nil") Expect(input.ClusterName).ShouldNot(BeEmpty(), "Invalid argument. input.ClusterName can't be empty") diff --git a/test/e2e/suites/managed/machine_pool.go b/test/e2e/suites/managed/machine_pool.go index a8c7ff053d..429f82a5b7 100644 --- a/test/e2e/suites/managed/machine_pool.go +++ b/test/e2e/suites/managed/machine_pool.go @@ -41,8 +41,7 @@ type MachinePoolSpecInput struct { E2EConfig *clusterctl.E2EConfig ConfigClusterFn DefaultConfigClusterFn BootstrapClusterProxy framework.ClusterProxy - AWSSession aws.Config - AWSSessionV2 *aws.Config + AWSSession *aws.Config Namespace *corev1.Namespace ClusterName string IncludeScaling bool @@ -58,7 +57,7 @@ func MachinePoolSpec(ctx context.Context, inputGetter func() MachinePoolSpecInpu Expect(input.E2EConfig).ToNot(BeNil(), "Invalid argument. input.E2EConfig can't be nil") Expect(input.ConfigClusterFn).ToNot(BeNil(), "Invalid argument. input.ConfigClusterFn can't be nil") Expect(input.BootstrapClusterProxy).ToNot(BeNil(), "Invalid argument. input.BootstrapClusterProxy can't be nil") - Expect(input.AWSSessionV2).ToNot(BeNil(), "Invalid argument. input.AWSSessionV2 can't be nil") + Expect(input.AWSSession).ToNot(BeNil(), "Invalid argument. input.AWSSession can't be nil") Expect(input.Namespace).NotTo(BeNil(), "Invalid argument. input.Namespace can't be nil") Expect(input.ClusterName).ShouldNot(BeEmpty(), "Invalid argument. input.ClusterName can't be empty") Expect(input.Flavor).ShouldNot(BeEmpty(), "Invalid argument. input.Flavor can't be empty") @@ -108,10 +107,10 @@ func MachinePoolSpec(ctx context.Context, inputGetter func() MachinePoolSpecInpu } else { nodeGroupName = getEKSNodegroupName(input.Namespace.Name, input.ClusterName) } - verifyManagedNodeGroup(ctx, eksClusterName, nodeGroupName, true, input.AWSSessionV2) + verifyManagedNodeGroup(ctx, eksClusterName, nodeGroupName, true, input.AWSSession) } else { asgName := getASGName(input.ClusterName) - verifyASG(eksClusterName, asgName, true, input.AWSSessionV2) + verifyASG(eksClusterName, asgName, true, input.AWSSession) } if input.IncludeScaling { // TODO (richardcase): should this be a separate spec? diff --git a/test/e2e/suites/managed/upgrade_test.go b/test/e2e/suites/managed/upgrade_test.go index 7bb870530e..dd7e1f3b32 100644 --- a/test/e2e/suites/managed/upgrade_test.go +++ b/test/e2e/suites/managed/upgrade_test.go @@ -67,7 +67,7 @@ var _ = ginkgo.Describe("EKS Cluster upgrade test", func() { E2EConfig: e2eCtx.E2EConfig, ConfigClusterFn: defaultConfigCluster, BootstrapClusterProxy: e2eCtx.Environment.BootstrapClusterProxy, - AWSSessionV2: e2eCtx.BootstrapUserAWSSessionV2, + AWSSession: e2eCtx.BootstrapUserAWSSessionV2, Namespace: namespace, ClusterName: clusterName, Flavour: EKSControlPlaneOnlyFlavor, // TODO (richardcase) - change in the future when upgrades to machinepools work @@ -99,7 +99,7 @@ var _ = ginkgo.Describe("EKS Cluster upgrade test", func() { UpgradeControlPlaneVersionSpec(ctx, func() UpgradeControlPlaneVersionSpecInput { return UpgradeControlPlaneVersionSpecInput{ E2EConfig: e2eCtx.E2EConfig, - AWSSessionV2: e2eCtx.BootstrapUserAWSSessionV2, + AWSSession: e2eCtx.BootstrapUserAWSSessionV2, BootstrapClusterProxy: e2eCtx.Environment.BootstrapClusterProxy, ClusterName: clusterName, Namespace: namespace, diff --git a/test/e2e/suites/unmanaged/gc_test.go b/test/e2e/suites/unmanaged/gc_test.go index 492a9267ef..01d6807e9b 100644 --- a/test/e2e/suites/unmanaged/gc_test.go +++ b/test/e2e/suites/unmanaged/gc_test.go @@ -91,14 +91,14 @@ var _ = ginkgo.Context("[unmanaged] [gc]", func() { ginkgo.By("Checking we have the load balancers in AWS") shared.WaitForLoadBalancerToExistForService(ctx, shared.WaitForLoadBalancerToExistForServiceInput{ - AWSSessionV2: e2eCtx.BootstrapUserAWSSessionV2, + AWSSession: e2eCtx.BootstrapUserAWSSessionV2, ServiceName: "podinfo-nlb", ServiceNamespace: "default", ClusterName: clusterName, Type: infrav1.LoadBalancerTypeNLB, }, e2eCtx.E2EConfig.GetIntervals("", "wait-loadbalancer-ready")...) shared.WaitForLoadBalancerToExistForService(ctx, shared.WaitForLoadBalancerToExistForServiceInput{ - AWSSessionV2: e2eCtx.BootstrapUserAWSSessionV2, + AWSSession: e2eCtx.BootstrapUserAWSSessionV2, ServiceName: "podinfo-elb", ServiceNamespace: "default", ClusterName: clusterName, @@ -119,7 +119,7 @@ var _ = ginkgo.Context("[unmanaged] [gc]", func() { ginkgo.By("Getting counts of service load balancers") arns, err := shared.GetLoadBalancerARNs(ctx, shared.GetLoadBalancerARNsInput{ - AWSSessionV2: e2eCtx.BootstrapUserAWSSessionV2, + AWSSession: e2eCtx.BootstrapUserAWSSessionV2, ServiceName: "podinfo-nlb", ServiceNamespace: "default", ClusterName: clusterName, @@ -128,7 +128,7 @@ var _ = ginkgo.Context("[unmanaged] [gc]", func() { Expect(err).NotTo(HaveOccurred()) Expect(arns).To(BeEmpty(), "there are %d service load balancers (nlb) still", len(arns)) arns, err = shared.GetLoadBalancerARNs(ctx, shared.GetLoadBalancerARNsInput{ - AWSSessionV2: e2eCtx.BootstrapUserAWSSessionV2, + AWSSession: e2eCtx.BootstrapUserAWSSessionV2, ServiceName: "podinfo-elb", ServiceNamespace: "default", ClusterName: clusterName, @@ -197,14 +197,14 @@ var _ = ginkgo.Context("[unmanaged] [gc]", func() { ginkgo.By("Checking we have the load balancers in AWS") shared.WaitForLoadBalancerToExistForService(ctx, shared.WaitForLoadBalancerToExistForServiceInput{ - AWSSessionV2: e2eCtx.BootstrapUserAWSSessionV2, + AWSSession: e2eCtx.BootstrapUserAWSSessionV2, ServiceName: "podinfo-nlb", ServiceNamespace: "default", ClusterName: clusterName, Type: infrav1.LoadBalancerTypeNLB, }, e2eCtx.E2EConfig.GetIntervals("", "wait-loadbalancer-ready")...) shared.WaitForLoadBalancerToExistForService(ctx, shared.WaitForLoadBalancerToExistForServiceInput{ - AWSSessionV2: e2eCtx.BootstrapUserAWSSessionV2, + AWSSession: e2eCtx.BootstrapUserAWSSessionV2, ServiceName: "podinfo-elb", ServiceNamespace: "default", ClusterName: clusterName, @@ -225,7 +225,7 @@ var _ = ginkgo.Context("[unmanaged] [gc]", func() { ginkgo.By("Getting counts of service load balancers") arns, err := shared.GetLoadBalancerARNs(ctx, shared.GetLoadBalancerARNsInput{ - AWSSessionV2: e2eCtx.BootstrapUserAWSSessionV2, + AWSSession: e2eCtx.BootstrapUserAWSSessionV2, ServiceName: "podinfo-nlb", ServiceNamespace: "default", ClusterName: clusterName, @@ -234,7 +234,7 @@ var _ = ginkgo.Context("[unmanaged] [gc]", func() { Expect(err).NotTo(HaveOccurred()) Expect(arns).To(BeEmpty(), "there are %d service load balancers (nlb) still", len(arns)) arns, err = shared.GetLoadBalancerARNs(ctx, shared.GetLoadBalancerARNsInput{ - AWSSessionV2: e2eCtx.BootstrapUserAWSSessionV2, + AWSSession: e2eCtx.BootstrapUserAWSSessionV2, ServiceName: "podinfo-elb", ServiceNamespace: "default", ClusterName: clusterName, diff --git a/test/e2e/suites/unmanaged/unmanaged_classic_elb_upgrade_test.go b/test/e2e/suites/unmanaged/unmanaged_classic_elb_upgrade_test.go index 1cfc6eae8c..4fba43f453 100644 --- a/test/e2e/suites/unmanaged/unmanaged_classic_elb_upgrade_test.go +++ b/test/e2e/suites/unmanaged/unmanaged_classic_elb_upgrade_test.go @@ -191,7 +191,7 @@ var _ = ginkgo.Context("[unmanaged] [upgrade]", func() { Expect(err).NotTo(HaveOccurred(), "failed to get the AWS cluster") shared.CheckClassicElbHealthCheck(ctx, shared.CheckClassicElbHealthCheckInput{ - AWSSessionV2: e2eCtx.BootstrapUserAWSSessionV2, + AWSSession: e2eCtx.BootstrapUserAWSSessionV2, LoadBalancerName: awsCluster.Status.Network.APIServerELB.Name, ExpectedTarget: "SSL:6443", }, e2eCtx.E2EConfig.GetIntervals(specName, "wait-classic-elb-health-check-short")...) @@ -210,7 +210,7 @@ var _ = ginkgo.Context("[unmanaged] [upgrade]", func() { ginkgo.By("Management cluster is upgraded to main version") shared.CheckClassicElbHealthCheck(ctx, shared.CheckClassicElbHealthCheckInput{ - AWSSessionV2: e2eCtx.BootstrapUserAWSSessionV2, + AWSSession: e2eCtx.BootstrapUserAWSSessionV2, LoadBalancerName: awsCluster.Status.Network.APIServerELB.Name, ExpectedTarget: "TCP:6443", }, e2eCtx.E2EConfig.GetIntervals(specName, "wait-classic-elb-health-check-long")...) From a9358f4bf628356c4cbc28ce2ba0010b2ef71c55 Mon Sep 17 00:00:00 2001 From: Liangquan Li Date: Wed, 6 Aug 2025 19:09:30 +0800 Subject: [PATCH 7/8] fix e2e job --- pkg/cloud/awserrors/errors.go | 12 ++++++++++++ pkg/cloud/scope/managedcontrolplane.go | 5 ----- pkg/cloud/services/network/eips_test.go | 9 ++++----- pkg/cloud/services/network/vpc.go | 8 ++++++++ pkg/cloud/services/network/vpc_test.go | 15 +++++++-------- pkg/cloud/services/ssm/secret.go | 21 --------------------- pkg/cloud/services/ssm/secret_test.go | 10 +++++----- pkg/cloud/services/wait/wait.go | 12 +++++++++--- test/e2e/suites/managed/gc_test.go | 4 ++-- 9 files changed, 47 insertions(+), 49 deletions(-) diff --git a/pkg/cloud/awserrors/errors.go b/pkg/cloud/awserrors/errors.go index 70e708c02c..aa8e644e60 100644 --- a/pkg/cloud/awserrors/errors.go +++ b/pkg/cloud/awserrors/errors.go @@ -69,6 +69,12 @@ func Code(err error) (string, bool) { if awserr, ok := err.(awserr.Error); ok { return awserr.Code(), true } + + // Handle smithy errors from AWS SDK v2 + if smithyErr := ParseSmithyError(err); smithyErr != nil && smithyErr.ErrorCode() != "" { + return smithyErr.ErrorCode(), true + } + return "", false } @@ -77,6 +83,12 @@ func Message(err error) string { if awserr, ok := err.(awserr.Error); ok { return awserr.Message() } + + // Handle smithy errors from AWS SDK v2 + if smithyErr := ParseSmithyError(err); smithyErr != nil { + return smithyErr.ErrorMessage() + } + return "" } diff --git a/pkg/cloud/scope/managedcontrolplane.go b/pkg/cloud/scope/managedcontrolplane.go index 3b2db58ac7..ed74238a93 100644 --- a/pkg/cloud/scope/managedcontrolplane.go +++ b/pkg/cloud/scope/managedcontrolplane.go @@ -336,11 +336,6 @@ func (s *ManagedControlPlaneScope) Session() awsv2.Config { return s.session } -// SessionV2 returns the AWS SDK V2 config. Used for creating clients. -func (s *ManagedControlPlaneScope) SessionV2() awsv2.Config { - return s.session -} - // Bastion returns the bastion details. func (s *ManagedControlPlaneScope) Bastion() *infrav1.Bastion { return &s.ControlPlane.Spec.Bastion diff --git a/pkg/cloud/services/network/eips_test.go b/pkg/cloud/services/network/eips_test.go index d23fdf4319..d844663169 100644 --- a/pkg/cloud/services/network/eips_test.go +++ b/pkg/cloud/services/network/eips_test.go @@ -23,10 +23,9 @@ import ( "github.com/aws/aws-sdk-go-v2/service/ec2" "github.com/aws/aws-sdk-go-v2/service/ec2/types" "github.com/aws/aws-sdk-go/aws" - "github.com/aws/aws-sdk-go/aws/awserr" + "github.com/aws/smithy-go" "github.com/golang/mock/gomock" . "github.com/onsi/gomega" - "github.com/pkg/errors" "k8s.io/apimachinery/pkg/runtime" "sigs.k8s.io/controller-runtime/pkg/client/fake" @@ -104,7 +103,7 @@ func TestServiceReleaseAddresses(t *testing.T) { }, }, nil) m.DisassociateAddress(context.TODO(), gomock.AssignableToTypeOf(&ec2.DisassociateAddressInput{})).Return(nil, nil).Times(2) - m.ReleaseAddress(context.TODO(), gomock.AssignableToTypeOf(&ec2.ReleaseAddressInput{})).Return(nil, awserr.New(awserrors.AuthFailure, awserrors.AuthFailure, errors.Errorf(awserrors.AuthFailure))) + m.ReleaseAddress(context.TODO(), gomock.AssignableToTypeOf(&ec2.ReleaseAddressInput{})).Return(nil, &smithy.GenericAPIError{Code: awserrors.AuthFailure, Message: awserrors.AuthFailure}) m.ReleaseAddress(context.TODO(), gomock.AssignableToTypeOf(&ec2.ReleaseAddressInput{})).Return(nil, nil) }, }, @@ -121,7 +120,7 @@ func TestServiceReleaseAddresses(t *testing.T) { }, }, nil) m.DisassociateAddress(context.TODO(), gomock.AssignableToTypeOf(&ec2.DisassociateAddressInput{})).Return(nil, nil).Times(2) - m.ReleaseAddress(context.TODO(), gomock.AssignableToTypeOf(&ec2.ReleaseAddressInput{})).Return(nil, awserr.New(awserrors.InUseIPAddress, awserrors.InUseIPAddress, errors.Errorf(awserrors.InUseIPAddress))) + m.ReleaseAddress(context.TODO(), gomock.AssignableToTypeOf(&ec2.ReleaseAddressInput{})).Return(nil, &smithy.GenericAPIError{Code: awserrors.InUseIPAddress, Message: awserrors.InUseIPAddress}) m.ReleaseAddress(context.TODO(), gomock.AssignableToTypeOf(&ec2.ReleaseAddressInput{})).Return(nil, nil) }, }, @@ -138,7 +137,7 @@ func TestServiceReleaseAddresses(t *testing.T) { }, }, nil) m.DisassociateAddress(context.TODO(), gomock.AssignableToTypeOf(&ec2.DisassociateAddressInput{})).Return(nil, nil).Times(2) - m.ReleaseAddress(context.TODO(), gomock.AssignableToTypeOf(&ec2.ReleaseAddressInput{})).Return(nil, awserr.New("dependency-failure", "dependency-failure", errors.Errorf("dependency-failure"))) + m.ReleaseAddress(context.TODO(), gomock.AssignableToTypeOf(&ec2.ReleaseAddressInput{})).Return(nil, &smithy.GenericAPIError{Code: "dependency-failure", Message: "dependency-failure"}) }, wantErr: true, }, diff --git a/pkg/cloud/services/network/vpc.go b/pkg/cloud/services/network/vpc.go index a620831681..9f4e510a99 100644 --- a/pkg/cloud/services/network/vpc.go +++ b/pkg/cloud/services/network/vpc.go @@ -326,6 +326,10 @@ func (s *Service) ensureManagedVPCAttributes(vpc *infrav1.VPCSpec) error { if code, ok := awserrors.Code(errors.Cause(err)); ok && code == awserrors.VPCNotFound { return err } + // Also check for smithy errors + if smithyErr := awserrors.ParseSmithyError(err); smithyErr != nil && smithyErr.ErrorCode() == awserrors.VPCNotFound { + return err + } errs = append(errs, errors.Wrap(err, "failed to describe enableDnsHostnames vpc attribute")) } else if !aws.BoolValue(vpcAttr.EnableDnsHostnames.Value) { attrInput := &ec2.ModifyVpcAttributeInput{ @@ -349,6 +353,10 @@ func (s *Service) ensureManagedVPCAttributes(vpc *infrav1.VPCSpec) error { if code, ok := awserrors.Code(errors.Cause(err)); ok && code == awserrors.VPCNotFound { return err } + // Also check for smithy errors + if smithyErr := awserrors.ParseSmithyError(err); smithyErr != nil && smithyErr.ErrorCode() == awserrors.VPCNotFound { + return err + } errs = append(errs, errors.Wrap(err, "failed to describe enableDnsSupport vpc attribute")) } else if !aws.BoolValue(vpcAttr.EnableDnsSupport.Value) { attrInput := &ec2.ModifyVpcAttributeInput{ diff --git a/pkg/cloud/services/network/vpc_test.go b/pkg/cloud/services/network/vpc_test.go index 70be9c4142..059f642ee6 100644 --- a/pkg/cloud/services/network/vpc_test.go +++ b/pkg/cloud/services/network/vpc_test.go @@ -23,8 +23,8 @@ import ( "github.com/aws/aws-sdk-go-v2/service/ec2" "github.com/aws/aws-sdk-go-v2/service/ec2/types" "github.com/aws/aws-sdk-go/aws" - "github.com/aws/aws-sdk-go/aws/awserr" "github.com/aws/aws-sdk-go/aws/request" + "github.com/aws/smithy-go" "github.com/golang/mock/gomock" . "github.com/onsi/gomega" "github.com/pkg/errors" @@ -33,7 +33,6 @@ import ( "sigs.k8s.io/controller-runtime/pkg/client/fake" infrav1 "sigs.k8s.io/cluster-api-provider-aws/v2/api/v1beta2" - "sigs.k8s.io/cluster-api-provider-aws/v2/pkg/cloud/awserrors" "sigs.k8s.io/cluster-api-provider-aws/v2/pkg/cloud/scope" "sigs.k8s.io/cluster-api-provider-aws/v2/test/mocks" clusterv1 "sigs.k8s.io/cluster-api/api/v1beta1" @@ -414,7 +413,7 @@ func TestReconcileVPC(t *testing.T) { Values: []string{string(types.VpcStatePending), string(types.VpcStateAvailable)}, }, }, - })).Return(nil, awserr.New("404", "http not found err", errors.New("err"))) + })).Return(nil, &smithy.GenericAPIError{Code: "404", Message: "http not found err"}) }, }, { @@ -464,7 +463,7 @@ func TestReconcileVPC(t *testing.T) { }, }, }, nil) - m.DescribeVpcAttribute(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeVpcAttributeInput{})).Return(nil, awserr.New("InvalidVpcID.NotFound", "not found", nil)) + m.DescribeVpcAttribute(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeVpcAttributeInput{})).Return(nil, &smithy.GenericAPIError{Code: "InvalidVpcID.NotFound", Message: "not found"}) m.DescribeVpcAttribute(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeVpcAttributeInput{})). DoAndReturn(describeVpcAttributeTrue).AnyTimes() }, @@ -494,7 +493,7 @@ func TestReconcileVPC(t *testing.T) { }, }, }, nil) - m.DescribeVpcAttribute(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeVpcAttributeInput{})).AnyTimes().Return(nil, awserrors.NewFailedDependency("failed dependency")) + m.DescribeVpcAttribute(context.TODO(), gomock.AssignableToTypeOf(&ec2.DescribeVpcAttributeInput{})).AnyTimes().Return(nil, &smithy.GenericAPIError{Code: "FailedDependency", Message: "failed dependency"}) }, }, { @@ -510,7 +509,7 @@ func TestReconcileVPC(t *testing.T) { }, }, })).Return(&ec2.DescribeVpcsOutput{Vpcs: []types.Vpc{}}, nil) - m.CreateVpc(context.TODO(), gomock.AssignableToTypeOf(&ec2.CreateVpcInput{})).After(describeVPCByNameCall).Return(nil, awserrors.NewFailedDependency("failed dependency")) + m.CreateVpc(context.TODO(), gomock.AssignableToTypeOf(&ec2.CreateVpcInput{})).After(describeVPCByNameCall).Return(nil, &smithy.GenericAPIError{Code: "FailedDependency", Message: "failed dependency"}) }, }, { @@ -610,7 +609,7 @@ func TestDeleteVPC(t *testing.T) { expect: func(m *mocks.MockEC2APIMockRecorder) { m.DeleteVpc(context.TODO(), gomock.Eq(&ec2.DeleteVpcInput{ VpcId: aws.String("managed-vpc"), - })).Return(nil, awserrors.NewFailedDependency("failed dependency")) + })).Return(nil, &smithy.GenericAPIError{Code: "FailedDependency", Message: "failed dependency"}) }, }, { @@ -636,7 +635,7 @@ func TestDeleteVPC(t *testing.T) { expect: func(m *mocks.MockEC2APIMockRecorder) { m.DeleteVpc(context.TODO(), gomock.Eq(&ec2.DeleteVpcInput{ VpcId: aws.String("managed-vpc"), - })).Return(nil, awserr.New("InvalidVpcID.NotFound", "not found", nil)) + })).Return(nil, &smithy.GenericAPIError{Code: "InvalidVpcID.NotFound", Message: "not found"}) }, }, } diff --git a/pkg/cloud/services/ssm/secret.go b/pkg/cloud/services/ssm/secret.go index 8d7b269957..309ef3ab1a 100644 --- a/pkg/cloud/services/ssm/secret.go +++ b/pkg/cloud/services/ssm/secret.go @@ -31,7 +31,6 @@ import ( "k8s.io/apimachinery/pkg/util/uuid" infrav1 "sigs.k8s.io/cluster-api-provider-aws/v2/api/v1beta2" - "sigs.k8s.io/cluster-api-provider-aws/v2/pkg/cloud/awserrors" "sigs.k8s.io/cluster-api-provider-aws/v2/pkg/cloud/converters" "sigs.k8s.io/cluster-api-provider-aws/v2/pkg/cloud/scope" "sigs.k8s.io/cluster-api-provider-aws/v2/pkg/cloud/services/wait" @@ -49,29 +48,9 @@ var ( prefixRe = regexp.MustCompile(`(?i)^[\/]?(aws|ssm)[.]?`) retryableErrors = []string{ "ParameterLimitExceeded", - "ParameterAlreadyExists", } ) -func isErrorRetryable(err error, retryableCodes []string) bool { - // Use the ParseSmithyError utility to parse the error - smithyErr := awserrors.ParseSmithyError(err) - if smithyErr == nil { - return false - } - - // Get the error code from the parsed error - codeToCheck := smithyErr.ErrorCode() - - // Compare the extracted string with your list - for _, code := range retryableCodes { - if codeToCheck == code { - return true // It's a match! - } - } - return false -} - // Create stores data in AWS SSM for a given machine, chunking at 4kb per secret. The prefix of the secret // ARN and the number of chunks are returned. func (s *Service) Create(m *scope.MachineScope, data []byte) (string, int32, error) { diff --git a/pkg/cloud/services/ssm/secret_test.go b/pkg/cloud/services/ssm/secret_test.go index 5393659304..d140cc9ecb 100644 --- a/pkg/cloud/services/ssm/secret_test.go +++ b/pkg/cloud/services/ssm/secret_test.go @@ -36,7 +36,6 @@ import ( "sigs.k8s.io/controller-runtime/pkg/client/fake" infrav1 "sigs.k8s.io/cluster-api-provider-aws/v2/api/v1beta2" - "sigs.k8s.io/cluster-api-provider-aws/v2/pkg/cloud/awserrors" "sigs.k8s.io/cluster-api-provider-aws/v2/pkg/cloud/scope" "sigs.k8s.io/cluster-api-provider-aws/v2/pkg/cloud/services/ssm/mock_ssmiface" clusterv1 "sigs.k8s.io/cluster-api/api/v1beta1" @@ -87,7 +86,7 @@ func TestServiceCreate(t *testing.T) { if !strings.HasPrefix(actualPrefix, expectedPrefix) { t.Fatalf("Prefix is not as expected: %v", actualPrefix) } - if (err != nil) != isErrorRetryable(err, retryableErrors) { + if (err != nil) != IsErrorExpected { t.Fatalf("Unexpected error value, error = %v, expectedError %v", err, IsErrorExpected) } } @@ -214,6 +213,7 @@ func TestServiceCreate(t *testing.T) { m.PutParameter(context.TODO(), gomock.AssignableToTypeOf(&ssm.PutParameterInput{})).Return(nil, &mockAPIError{ "ParameterLimitExceeded", "parameter limit exceeded"}) + m.PutParameter(context.TODO(), gomock.AssignableToTypeOf(&ssm.PutParameterInput{})).Return(&ssm.PutParameterOutput{}, nil) }, }, } @@ -275,7 +275,7 @@ func TestServiceDelete(t *testing.T) { expect: func(m *mock_ssmiface.MockSSMAPIMockRecorder) { m.DeleteParameter(context.TODO(), gomock.Eq(&ssm.DeleteParameterInput{ Name: aws.String("prefix/0"), - })).Return(nil, awserrors.NewFailedDependency("failed dependency")) + })).Return(nil, &smithy.GenericAPIError{Code: "FailedDependency", Message: "failed dependency"}) m.DeleteParameter(context.TODO(), gomock.Eq(&ssm.DeleteParameterInput{ Name: aws.String("prefix/1"), })).Return(nil, &mockAPIError{ @@ -284,11 +284,11 @@ func TestServiceDelete(t *testing.T) { }) m.DeleteParameter(context.TODO(), gomock.Eq(&ssm.DeleteParameterInput{ Name: aws.String("prefix/2"), - })).Return(nil, awserrors.NewConflict("new conflict")) + })).Return(nil, &smithy.GenericAPIError{Code: "Conflict", Message: "new conflict"}) }, wantErr: true, check: func(err error) { - if err.Error() != "[failed dependency, new conflict]" { + if err.Error() != "[api error FailedDependency: failed dependency, api error Conflict: new conflict]" { t.Fatalf("Unexpected error: %v", err) } }, diff --git a/pkg/cloud/services/wait/wait.go b/pkg/cloud/services/wait/wait.go index aa97bd9487..7f90e3f2ca 100644 --- a/pkg/cloud/services/wait/wait.go +++ b/pkg/cloud/services/wait/wait.go @@ -68,12 +68,18 @@ func WaitForWithRetryable(backoff wait.Backoff, condition wait.ConditionFunc, re // If the returned error isn't empty, check if the error is a retryable one, // or return immediately. + // Also check for smithy errors + var code string smithyErr := awserrors.ParseSmithyError(err) - if smithyErr == nil { - return false, err + if smithyErr != nil { + code = smithyErr.ErrorCode() + } else { + code, ok = awserrors.Code(errors.Cause(err)) + if !ok { + return false, err + } } - code := smithyErr.ErrorCode() for _, r := range retryableErrors { if code == r { // We should retry. diff --git a/test/e2e/suites/managed/gc_test.go b/test/e2e/suites/managed/gc_test.go index 64f33e88ed..d8a0f7d00d 100644 --- a/test/e2e/suites/managed/gc_test.go +++ b/test/e2e/suites/managed/gc_test.go @@ -55,7 +55,7 @@ var _ = ginkgo.Describe("[managed] [gc] EKS Cluster external resource GC tests", clusterName = fmt.Sprintf("%s-%s", specName, util.RandomString(6)) ginkgo.By("default iam role should exist") - VerifyRoleExistsAndOwned(ctx, ekscontrolplanev1.DefaultEKSControlPlaneRole, clusterName, false, e2eCtx.BootstrapUserAWSSessionV2) + VerifyRoleExistsAndOwned(ctx, ekscontrolplanev1.DefaultEKSControlPlaneRole, clusterName, false, e2eCtx.AWSSessionV2) ginkgo.By("should create an EKS control plane") ManagedClusterSpec(ctx, func() ManagedClusterSpecInput { @@ -178,7 +178,7 @@ var _ = ginkgo.Describe("[managed] [gc] EKS Cluster external resource GC tests", clusterName = fmt.Sprintf("%s-%s", specName, util.RandomString(6)) ginkgo.By("default iam role should exist") - VerifyRoleExistsAndOwned(ctx, ekscontrolplanev1.DefaultEKSControlPlaneRole, clusterName, false, e2eCtx.BootstrapUserAWSSessionV2) + VerifyRoleExistsAndOwned(ctx, ekscontrolplanev1.DefaultEKSControlPlaneRole, clusterName, false, e2eCtx.AWSSessionV2) ginkgo.By("should create an EKS control plane") ManagedClusterSpec(ctx, func() ManagedClusterSpecInput { From bf14108092476fd6d7460ba4c26a7ef59b133037 Mon Sep 17 00:00:00 2001 From: Liangquan Li Date: Mon, 11 Aug 2025 21:53:32 +0800 Subject: [PATCH 8/8] debug debug --- pkg/cloud/scope/cluster.go | 15 ++--- pkg/cloud/scope/fargate.go | 33 ++++------ pkg/cloud/scope/managedcontrolplane.go | 15 ++--- pkg/cloud/scope/rosacontrolplane.go | 17 ++---- pkg/cloud/scope/rosamachinepool.go | 13 +--- pkg/cloud/scope/session.go | 85 -------------------------- test/e2e/shared/suite.go | 4 ++ 7 files changed, 33 insertions(+), 149 deletions(-) diff --git a/pkg/cloud/scope/cluster.go b/pkg/cloud/scope/cluster.go index 4627882a99..51b6315bb6 100644 --- a/pkg/cloud/scope/cluster.go +++ b/pkg/cloud/scope/cluster.go @@ -77,11 +77,6 @@ func NewClusterScope(params ClusterScopeParams) (*ClusterScope, error) { maxWaitActiveUpdateDelete: params.MaxWaitActiveUpdateDelete, } - serviceLimiters, err := sessionForClusterWithRegion(params.Client, clusterScope, params.AWSCluster.Spec.Region, params.Endpoints, params.Logger) - if err != nil { - return nil, errors.Errorf("failed to create aws session: %v", err) - } - sessionv2, serviceLimitersv2, err := sessionForClusterWithRegionV2(params.Client, clusterScope, params.AWSCluster.Spec.Region, params.Endpoints, params.Logger) if err != nil { return nil, errors.Errorf("failed to create aws V2 session: %v", err) @@ -94,8 +89,7 @@ func NewClusterScope(params ClusterScopeParams) (*ClusterScope, error) { clusterScope.patchHelper = helper clusterScope.session = *sessionv2 - clusterScope.serviceLimiters = serviceLimiters - clusterScope.serviceLimitersV2 = serviceLimitersv2 + clusterScope.serviceLimiters = serviceLimitersv2 return clusterScope, nil } @@ -109,10 +103,9 @@ type ClusterScope struct { Cluster *clusterv1.Cluster AWSCluster *infrav1.AWSCluster - session awsv2.Config - serviceLimiters throttle.ServiceLimiters - serviceLimitersV2 throttle.ServiceLimiters - controllerName string + session awsv2.Config + serviceLimiters throttle.ServiceLimiters + controllerName string tagUnmanagedNetworkResources bool maxWaitActiveUpdateDelete time.Duration diff --git a/pkg/cloud/scope/fargate.go b/pkg/cloud/scope/fargate.go index 32845de577..96aa21cf34 100644 --- a/pkg/cloud/scope/fargate.go +++ b/pkg/cloud/scope/fargate.go @@ -70,11 +70,6 @@ func NewFargateProfileScope(params FargateProfileScopeParams) (*FargateProfileSc controllerName: params.ControllerName, } - serviceLimiters, err := sessionForClusterWithRegion(params.Client, managedScope, params.ControlPlane.Spec.Region, params.Endpoints, params.Logger) - if err != nil { - return nil, errors.Errorf("failed to create aws session: %v", err) - } - sessionv2, serviceLimitersv2, err := sessionForClusterWithRegionV2(params.Client, managedScope, params.ControlPlane.Spec.Region, params.Endpoints, params.Logger) if err != nil { return nil, errors.Errorf("failed to create aws v2 session: %v", err) @@ -86,17 +81,16 @@ func NewFargateProfileScope(params FargateProfileScopeParams) (*FargateProfileSc } return &FargateProfileScope{ - Logger: *params.Logger, - Client: params.Client, - Cluster: params.Cluster, - ControlPlane: params.ControlPlane, - FargateProfile: params.FargateProfile, - patchHelper: helper, - session: *sessionv2, - serviceLimiters: serviceLimiters, - serviceLimitersV2: serviceLimitersv2, - controllerName: params.ControllerName, - enableIAM: params.EnableIAM, + Logger: *params.Logger, + Client: params.Client, + Cluster: params.Cluster, + ControlPlane: params.ControlPlane, + FargateProfile: params.FargateProfile, + patchHelper: helper, + session: *sessionv2, + serviceLimiters: serviceLimitersv2, + controllerName: params.ControllerName, + enableIAM: params.EnableIAM, }, nil } @@ -110,10 +104,9 @@ type FargateProfileScope struct { ControlPlane *ekscontrolplanev1.AWSManagedControlPlane FargateProfile *expinfrav1.AWSFargateProfile - session awsv2.Config - serviceLimiters throttle.ServiceLimiters - serviceLimitersV2 throttle.ServiceLimiters - controllerName string + session awsv2.Config + serviceLimiters throttle.ServiceLimiters + controllerName string enableIAM bool } diff --git a/pkg/cloud/scope/managedcontrolplane.go b/pkg/cloud/scope/managedcontrolplane.go index ed74238a93..856eb29dfe 100644 --- a/pkg/cloud/scope/managedcontrolplane.go +++ b/pkg/cloud/scope/managedcontrolplane.go @@ -98,19 +98,13 @@ func NewManagedControlPlaneScope(params ManagedControlPlaneScopeParams) (*Manage enableIAM: params.EnableIAM, tagUnmanagedNetworkResources: params.TagUnmanagedNetworkResources, } - serviceLimiters, err := sessionForClusterWithRegion(params.Client, managedScope, params.ControlPlane.Spec.Region, params.Endpoints, params.Logger) - if err != nil { - return nil, errors.Errorf("failed to create aws session: %v", err) - } - sessionv2, serviceLimitersv2, err := sessionForClusterWithRegionV2(params.Client, managedScope, params.ControlPlane.Spec.Region, params.Endpoints, params.Logger) if err != nil { return nil, errors.Errorf("failed to create aws V2 session: %v", err) } managedScope.session = *sessionv2 - managedScope.serviceLimiters = serviceLimiters - managedScope.serviceLimitersV2 = serviceLimitersv2 + managedScope.serviceLimiters = serviceLimitersv2 helper, err := patch.NewHelper(params.ControlPlane, params.Client) if err != nil { @@ -131,10 +125,9 @@ type ManagedControlPlaneScope struct { ControlPlane *ekscontrolplanev1.AWSManagedControlPlane MaxWaitActiveUpdateDelete time.Duration - session awsv2.Config - serviceLimiters throttle.ServiceLimiters - serviceLimitersV2 throttle.ServiceLimiters - controllerName string + session awsv2.Config + serviceLimiters throttle.ServiceLimiters + controllerName string enableIAM bool allowAdditionalRoles bool diff --git a/pkg/cloud/scope/rosacontrolplane.go b/pkg/cloud/scope/rosacontrolplane.go index 95d304de80..5d8ab5e265 100644 --- a/pkg/cloud/scope/rosacontrolplane.go +++ b/pkg/cloud/scope/rosacontrolplane.go @@ -72,11 +72,6 @@ func NewROSAControlPlaneScope(params ROSAControlPlaneScopeParams) (*ROSAControlP controllerName: params.ControllerName, } - serviceLimiters, err := sessionForClusterWithRegion(params.Client, managedScope, params.ControlPlane.Spec.Region, params.Endpoints, params.Logger) - if err != nil { - return nil, errors.Errorf("failed to create aws session: %v", err) - } - sessionv2, serviceLimitersv2, err := sessionForClusterWithRegionV2(params.Client, managedScope, params.ControlPlane.Spec.Region, params.Endpoints, params.Logger) if err != nil { return nil, errors.Errorf("failed to create aws V2 session: %v", err) @@ -89,8 +84,7 @@ func NewROSAControlPlaneScope(params ROSAControlPlaneScopeParams) (*ROSAControlP managedScope.patchHelper = helper managedScope.session = *sessionv2 - managedScope.serviceLimiters = serviceLimiters - managedScope.serviceLimitersV2 = serviceLimitersv2 + managedScope.serviceLimiters = serviceLimitersv2 stsClient := params.NewStsClient(managedScope, managedScope, managedScope, managedScope.ControlPlane) identity, err := stsClient.GetCallerIdentity(context.TODO(), &stsv2.GetCallerIdentityInput{}) @@ -111,11 +105,10 @@ type ROSAControlPlaneScope struct { Cluster *clusterv1.Cluster ControlPlane *rosacontrolplanev1.ROSAControlPlane - session awsv2.Config - serviceLimiters throttle.ServiceLimiters - serviceLimitersV2 throttle.ServiceLimiters - controllerName string - Identity *stsv2.GetCallerIdentityOutput + session awsv2.Config + serviceLimiters throttle.ServiceLimiters + controllerName string + Identity *stsv2.GetCallerIdentityOutput } // InfraCluster returns the AWSManagedControlPlane object. diff --git a/pkg/cloud/scope/rosamachinepool.go b/pkg/cloud/scope/rosamachinepool.go index 89022d0593..1186c8d883 100644 --- a/pkg/cloud/scope/rosamachinepool.go +++ b/pkg/cloud/scope/rosamachinepool.go @@ -88,19 +88,13 @@ func NewRosaMachinePoolScope(params RosaMachinePoolScopeParams) (*RosaMachinePoo controllerName: params.ControllerName, } - serviceLimiters, err := sessionForClusterWithRegion(params.Client, scope, params.ControlPlane.Spec.Region, params.Endpoints, params.Logger) - if err != nil { - return nil, errors.Errorf("failed to create aws session: %v", err) - } - sessionv2, serviceLimitersv2, err := sessionForClusterWithRegionV2(params.Client, scope, params.ControlPlane.Spec.Region, params.Endpoints, params.Logger) if err != nil { return nil, errors.Errorf("failed to create aws V2 session: %v", err) } scope.session = *sessionv2 - scope.serviceLimiters = serviceLimiters - scope.serviceLimitersV2 = serviceLimitersv2 + scope.serviceLimiters = serviceLimitersv2 return scope, nil } @@ -119,9 +113,8 @@ type RosaMachinePoolScope struct { RosaMachinePool *expinfrav1.ROSAMachinePool MachinePool *expclusterv1.MachinePool - session awsv2.Config - serviceLimiters throttle.ServiceLimiters - serviceLimitersV2 throttle.ServiceLimiters + session awsv2.Config + serviceLimiters throttle.ServiceLimiters controllerName string } diff --git a/pkg/cloud/scope/session.go b/pkg/cloud/scope/session.go index 3a4f3b9206..d501e349c7 100644 --- a/pkg/cloud/scope/session.go +++ b/pkg/cloud/scope/session.go @@ -29,7 +29,6 @@ import ( "github.com/aws/aws-sdk-go-v2/service/resourcegroupstaggingapi" "github.com/aws/aws-sdk-go-v2/service/secretsmanager" "github.com/aws/aws-sdk-go/aws" - "github.com/aws/aws-sdk-go/aws/credentials" "github.com/aws/aws-sdk-go/aws/endpoints" "github.com/aws/aws-sdk-go/aws/session" "github.com/google/go-cmp/cmp" @@ -64,7 +63,6 @@ type ServiceEndpoint struct { var sessionCache sync.Map var sessionCacheV2 sync.Map -var providerCache sync.Map var providerCacheV2 sync.Map type sessionCacheEntry struct { @@ -137,89 +135,6 @@ func sessionForRegionV2(region string) (*awsv2.Config, throttle.ServiceLimiters, return &ns, sl, nil } -func sessionForClusterWithRegion(k8sClient client.Client, clusterScoper cloud.SessionMetadata, region string, endpoint []ServiceEndpoint, log logger.Wrapper) (throttle.ServiceLimiters, error) { - log = log.WithName("identity") - log.Trace("Creating an AWS Session") - - resolver := func(service, region string, optFns ...func(*endpoints.Options)) (endpoints.ResolvedEndpoint, error) { - for _, s := range endpoint { - if service == s.ServiceID { - return endpoints.ResolvedEndpoint{ - URL: s.URL, - SigningRegion: s.SigningRegion, - }, nil - } - } - return endpoints.DefaultResolver().EndpointFor(service, region, optFns...) - } - - providers, err := getProvidersForCluster(context.Background(), k8sClient, clusterScoper, region, log) - if err != nil { - // could not get providers and retrieve the credentials - conditions.MarkFalse(clusterScoper.InfraCluster(), infrav1.PrincipalCredentialRetrievedCondition, infrav1.PrincipalCredentialRetrievalFailedReason, clusterv1.ConditionSeverityError, "%s", err.Error()) - return nil, errors.Wrap(err, "Failed to get providers for cluster") - } - - isChanged := false - awsProviders := make([]credentials.Provider, len(providers)) - for i, provider := range providers { - // load an existing matching providers from the cache if such a providers exists - providerHash, err := provider.Hash() - if err != nil { - return nil, errors.Wrap(err, "Failed to calculate provider hash") - } - cachedProvider, ok := providerCache.Load(providerHash) - if ok { - provider = cachedProvider.(identity.AWSPrincipalTypeProvider) - } else { - isChanged = true - // add this provider to the cache - providerCache.Store(providerHash, provider) - } - awsProviders[i] = provider.(credentials.Provider) - } - - if !isChanged { - if s, ok := sessionCache.Load(getSessionName(region, clusterScoper)); ok { - entry := s.(*sessionCacheEntry) - return entry.serviceLimiters, nil - } - } - awsConfig := &aws.Config{ - Region: aws.String(region), - EndpointResolver: endpoints.ResolverFunc(resolver), - } - - if len(providers) > 0 { - // Check if identity credentials can be retrieved. One reason this will fail is that source identity is not authorized for assume role. - _, err := providers[0].Retrieve() - if err != nil { - conditions.MarkUnknown(clusterScoper.InfraCluster(), infrav1.PrincipalCredentialRetrievedCondition, infrav1.CredentialProviderBuildFailedReason, "%s", err.Error()) - - // delete the existing session from cache. Otherwise, we give back a defective session on next method invocation with same cluster scope - sessionCache.Delete(getSessionName(region, clusterScoper)) - - return nil, errors.Wrap(err, "Failed to retrieve identity credentials") - } - awsConfig = awsConfig.WithCredentials(credentials.NewChainCredentials(awsProviders)) - } - - conditions.MarkTrue(clusterScoper.InfraCluster(), infrav1.PrincipalCredentialRetrievedCondition) - - ns, err := session.NewSession(awsConfig) - if err != nil { - return nil, errors.Wrap(err, "Failed to create a new AWS session") - } - sl := newServiceLimiters() - sessionCache.Store(getSessionName(region, clusterScoper), &sessionCacheEntry{ - session: ns, - serviceLimiters: sl, - sessionV2: nil, - }) - - return sl, nil -} - func sessionForClusterWithRegionV2(k8sClient client.Client, clusterScoper cloud.SessionMetadata, region string, _ []ServiceEndpoint, log logger.Wrapper) (*awsv2.Config, throttle.ServiceLimiters, error) { log = log.WithName("identity") log.Trace("Creating an AWS Session") diff --git a/test/e2e/shared/suite.go b/test/e2e/shared/suite.go index 6d9f0bbe71..f53f7039e5 100644 --- a/test/e2e/shared/suite.go +++ b/test/e2e/shared/suite.go @@ -158,6 +158,10 @@ func Node1BeforeSuite(e2eCtx *E2EContext) []byte { e2eCtx.Environment.BootstrapAccessKey = newUserAccessKey(context.TODO(), e2eCtx.AWSSessionV2, bootstrapTemplate.Spec.BootstrapUser.UserName) e2eCtx.BootstrapUserAWSSession = NewAWSSessionWithKey(e2eCtx.Environment.BootstrapAccessKey) e2eCtx.BootstrapUserAWSSessionV2 = NewAWSSessionWithKeyV2(e2eCtx.Environment.BootstrapAccessKey) + + By("Waiting for access key to propagate...") + time.Sleep(10 * time.Second) + Expect(ensureTestImageUploaded(e2eCtx)).NotTo(HaveOccurred()) // Image ID is needed when using a CI Kubernetes version. This is used in conformance test and upgrade to main test.