diff --git a/controllers/awscluster_controller.go b/controllers/awscluster_controller.go
index 0389681f9f..eb3cf93d0d 100644
--- a/controllers/awscluster_controller.go
+++ b/controllers/awscluster_controller.go
@@ -199,7 +199,7 @@ func (r *AWSClusterReconciler) Reconcile(ctx context.Context, req ctrl.Request)
}
// Handle non-deleted clusters
- return r.reconcileNormal(clusterScope)
+ return r.reconcileNormal(ctx, clusterScope)
}
func (r *AWSClusterReconciler) reconcileDelete(ctx context.Context, clusterScope *scope.ClusterScope) (ctrl.Result, error) {
@@ -246,7 +246,7 @@ func (r *AWSClusterReconciler) reconcileDelete(ctx context.Context, clusterScope
// when external controllers might be using them.
allErrs := []error{}
- if err := s3Service.DeleteBucket(); err != nil {
+ if err := s3Service.DeleteBucket(ctx); err != nil {
allErrs = append(allErrs, errors.Wrapf(err, "error deleting S3 Bucket"))
}
@@ -314,7 +314,7 @@ func (r *AWSClusterReconciler) reconcileLoadBalancer(clusterScope *scope.Cluster
return nil, nil
}
-func (r *AWSClusterReconciler) reconcileNormal(clusterScope *scope.ClusterScope) (reconcile.Result, error) {
+func (r *AWSClusterReconciler) reconcileNormal(ctx context.Context, clusterScope *scope.ClusterScope) (reconcile.Result, error) {
clusterScope.Info("Reconciling AWSCluster")
awsCluster := clusterScope.AWSCluster
@@ -363,7 +363,7 @@ func (r *AWSClusterReconciler) reconcileNormal(clusterScope *scope.ClusterScope)
return reconcile.Result{RequeueAfter: *requeueAfter}, err
}
- if err := s3Service.ReconcileBucket(); err != nil {
+ if err := s3Service.ReconcileBucket(ctx); err != nil {
conditions.MarkFalse(awsCluster, infrav1.S3BucketReadyCondition, infrav1.S3BucketFailedReason, clusterv1.ConditionSeverityError, "%s", err.Error())
return reconcile.Result{}, errors.Wrapf(err, "failed to reconcile S3 Bucket for AWSCluster %s/%s", awsCluster.Namespace, awsCluster.Name)
}
diff --git a/controllers/awscluster_controller_test.go b/controllers/awscluster_controller_test.go
index 474abaaf99..f5af060449 100644
--- a/controllers/awscluster_controller_test.go
+++ b/controllers/awscluster_controller_test.go
@@ -146,7 +146,7 @@ func TestAWSClusterReconcilerIntegrationTests(t *testing.T) {
},
})
- _, err = reconciler.reconcileNormal(cs)
+ _, err = reconciler.reconcileNormal(context.TODO(), cs)
g.Expect(err).To(BeNil())
cluster := &infrav1.AWSCluster{}
@@ -170,7 +170,7 @@ func TestAWSClusterReconcilerIntegrationTests(t *testing.T) {
})).To(Succeed())
// Executing back a second reconciliation:
// the AWS Cluster should be ready with no LoadBalancer false condition.
- _, err = reconciler.reconcileNormal(cs)
+ _, err = reconciler.reconcileNormal(context.TODO(), cs)
g.Expect(err).To(BeNil())
g.Expect(cs.VPC().ID).To(Equal("vpc-exists"))
expectAWSClusterConditions(g, cs.AWSCluster, []conditionAssertion{
@@ -269,7 +269,7 @@ func TestAWSClusterReconcilerIntegrationTests(t *testing.T) {
IsPublic: false,
},
})
- _, err = reconciler.reconcileNormal(cs)
+ _, err = reconciler.reconcileNormal(context.TODO(), cs)
g.Expect(err).To(BeNil())
g.Expect(cs.VPC().ID).To(Equal("vpc-exists"))
expectAWSClusterConditions(g, cs.AWSCluster, []conditionAssertion{
@@ -376,7 +376,7 @@ func TestAWSClusterReconcilerIntegrationTests(t *testing.T) {
IsPublic: false,
},
})
- _, err = reconciler.reconcileNormal(cs)
+ _, err = reconciler.reconcileNormal(context.TODO(), cs)
g.Expect(err).To(BeNil())
g.Expect(cs.VPC().ID).To(Equal("vpc-exists"))
expectAWSClusterConditions(g, cs.AWSCluster, []conditionAssertion{
@@ -469,7 +469,7 @@ func TestAWSClusterReconcilerIntegrationTests(t *testing.T) {
reconciler.elbServiceFactory = func(elbScope scope.ELBScope) services.ELBInterface {
return elbSvc
}
- _, err = reconciler.reconcileNormal(cs)
+ _, err = reconciler.reconcileNormal(context.TODO(), cs)
g.Expect(err).To(BeNil())
g.Expect(cs.VPC().ID).To(Equal("vpc-new"))
expectAWSClusterConditions(g, cs.AWSCluster, []conditionAssertion{
@@ -565,7 +565,7 @@ func TestAWSClusterReconcilerIntegrationTests(t *testing.T) {
return ec2Svc
}
- _, err = reconciler.reconcileNormal(cs)
+ _, err = reconciler.reconcileNormal(context.TODO(), cs)
g.Expect(err.Error()).To(ContainSubstring("The maximum number of VPCs has been reached"))
_, err = reconciler.reconcileDelete(ctx, cs)
diff --git a/controllers/awscluster_controller_unit_test.go b/controllers/awscluster_controller_unit_test.go
index 0ea2bfaed9..716bc543a2 100644
--- a/controllers/awscluster_controller_unit_test.go
+++ b/controllers/awscluster_controller_unit_test.go
@@ -244,7 +244,7 @@ func TestAWSClusterReconcileOperations(t *testing.T) {
IsPublic: false,
},
})
- _, err = reconciler.reconcileNormal(cs)
+ _, err = reconciler.reconcileNormal(context.TODO(), cs)
g.Expect(err).To(BeNil())
expectAWSClusterConditions(g, cs.AWSCluster, []conditionAssertion{{infrav1.LoadBalancerReadyCondition, corev1.ConditionTrue, "", ""}})
g.Expect(awsCluster.GetFinalizers()).To(ContainElement(infrav1.ClusterFinalizer))
@@ -276,7 +276,7 @@ func TestAWSClusterReconcileOperations(t *testing.T) {
PublicIpv4PoolFallBackOrder: ptr.To(infrav1.PublicIpv4PoolFallbackOrderAmazonPool),
}
g.Expect(err).To(Not(HaveOccurred()))
- _, err = reconciler.reconcileNormal(cs)
+ _, err = reconciler.reconcileNormal(context.TODO(), cs)
g.Expect(err).To(Not(HaveOccurred()))
})
})
@@ -299,7 +299,7 @@ func TestAWSClusterReconcileOperations(t *testing.T) {
},
)
g.Expect(err).To(BeNil())
- _, err = reconciler.reconcileNormal(cs)
+ _, err = reconciler.reconcileNormal(context.TODO(), cs)
g.Expect(err).Should(Equal(expectedErr))
})
t.Run("Should fail AWSCluster create with ClusterSecurityGroupsReadyCondition status false", func(t *testing.T) {
@@ -320,7 +320,7 @@ func TestAWSClusterReconcileOperations(t *testing.T) {
},
)
g.Expect(err).To(BeNil())
- _, err = reconciler.reconcileNormal(cs)
+ _, err = reconciler.reconcileNormal(context.TODO(), cs)
g.Expect(err).ToNot(BeNil())
expectAWSClusterConditions(g, cs.AWSCluster, []conditionAssertion{{infrav1.ClusterSecurityGroupsReadyCondition, corev1.ConditionFalse, clusterv1.ConditionSeverityWarning, infrav1.ClusterSecurityGroupReconciliationFailedReason}})
})
@@ -343,7 +343,7 @@ func TestAWSClusterReconcileOperations(t *testing.T) {
},
)
g.Expect(err).To(BeNil())
- _, err = reconciler.reconcileNormal(cs)
+ _, err = reconciler.reconcileNormal(context.TODO(), cs)
g.Expect(err).ToNot(BeNil())
expectAWSClusterConditions(g, cs.AWSCluster, []conditionAssertion{{infrav1.BastionHostReadyCondition, corev1.ConditionFalse, clusterv1.ConditionSeverityWarning, infrav1.BastionHostFailedReason}})
})
@@ -367,7 +367,7 @@ func TestAWSClusterReconcileOperations(t *testing.T) {
},
)
g.Expect(err).To(BeNil())
- _, err = reconciler.reconcileNormal(cs)
+ _, err = reconciler.reconcileNormal(context.TODO(), cs)
g.Expect(err).ToNot(BeNil())
expectAWSClusterConditions(g, cs.AWSCluster, []conditionAssertion{{infrav1.LoadBalancerReadyCondition, corev1.ConditionFalse, clusterv1.ConditionSeverityWarning, infrav1.LoadBalancerFailedReason}})
})
@@ -391,7 +391,7 @@ func TestAWSClusterReconcileOperations(t *testing.T) {
},
)
g.Expect(err).To(BeNil())
- _, err = reconciler.reconcileNormal(cs)
+ _, err = reconciler.reconcileNormal(context.TODO(), cs)
g.Expect(err).To(BeNil())
expectAWSClusterConditions(g, cs.AWSCluster, []conditionAssertion{{infrav1.LoadBalancerReadyCondition, corev1.ConditionFalse, clusterv1.ConditionSeverityInfo, infrav1.WaitForDNSNameReason}})
})
diff --git a/controllers/awsmachine_controller.go b/controllers/awsmachine_controller.go
index 96c63ccc89..e439d39ce4 100644
--- a/controllers/awsmachine_controller.go
+++ b/controllers/awsmachine_controller.go
@@ -224,13 +224,13 @@ func (r *AWSMachineReconciler) Reconcile(ctx context.Context, req ctrl.Request)
switch infraScope := infraCluster.(type) {
case *scope.ManagedControlPlaneScope:
if !awsMachine.ObjectMeta.DeletionTimestamp.IsZero() {
- return r.reconcileDelete(machineScope, infraScope, infraScope, nil, nil)
+ return r.reconcileDelete(ctx, machineScope, infraScope, infraScope, nil, nil)
}
return r.reconcileNormal(ctx, machineScope, infraScope, infraScope, nil, nil)
case *scope.ClusterScope:
if !awsMachine.ObjectMeta.DeletionTimestamp.IsZero() {
- return r.reconcileDelete(machineScope, infraScope, infraScope, infraScope, infraScope)
+ return r.reconcileDelete(ctx, machineScope, infraScope, infraScope, infraScope, infraScope)
}
return r.reconcileNormal(ctx, machineScope, infraScope, infraScope, infraScope, infraScope)
@@ -298,12 +298,12 @@ func (r *AWSMachineReconciler) SetupWithManager(ctx context.Context, mgr ctrl.Ma
)
}
-func (r *AWSMachineReconciler) reconcileDelete(machineScope *scope.MachineScope, clusterScope cloud.ClusterScoper, ec2Scope scope.EC2Scope, elbScope scope.ELBScope, objectStoreScope scope.S3Scope) (ctrl.Result, error) {
+func (r *AWSMachineReconciler) reconcileDelete(ctx context.Context, machineScope *scope.MachineScope, clusterScope cloud.ClusterScoper, ec2Scope scope.EC2Scope, elbScope scope.ELBScope, objectStoreScope scope.S3Scope) (ctrl.Result, error) {
machineScope.Info("Handling deleted AWSMachine")
ec2Service := r.getEC2Service(ec2Scope)
- if err := r.deleteBootstrapData(machineScope, clusterScope, objectStoreScope); err != nil {
+ if err := r.deleteBootstrapData(ctx, machineScope, clusterScope, objectStoreScope); err != nil {
machineScope.Error(err, "unable to delete machine")
return ctrl.Result{}, err
}
@@ -460,7 +460,7 @@ func (r *AWSMachineReconciler) findInstance(machineScope *scope.MachineScope, ec
}
//nolint:gocyclo
-func (r *AWSMachineReconciler) reconcileNormal(_ context.Context, machineScope *scope.MachineScope, clusterScope cloud.ClusterScoper, ec2Scope scope.EC2Scope, elbScope scope.ELBScope, objectStoreScope scope.S3Scope) (ctrl.Result, error) {
+func (r *AWSMachineReconciler) reconcileNormal(ctx context.Context, machineScope *scope.MachineScope, clusterScope cloud.ClusterScoper, ec2Scope scope.EC2Scope, elbScope scope.ELBScope, objectStoreScope scope.S3Scope) (ctrl.Result, error) {
machineScope.Trace("Reconciling AWSMachine")
// If the AWSMachine is in an error state, return early.
@@ -468,7 +468,7 @@ func (r *AWSMachineReconciler) reconcileNormal(_ context.Context, machineScope *
machineScope.Info("Error state detected, skipping reconciliation")
// If we are in a failed state, delete the secret regardless of instance state.
- if err := r.deleteBootstrapData(machineScope, clusterScope, objectStoreScope); err != nil {
+ if err := r.deleteBootstrapData(ctx, machineScope, clusterScope, objectStoreScope); err != nil {
machineScope.Error(err, "unable to reconcile machine")
return ctrl.Result{}, err
}
@@ -531,7 +531,7 @@ func (r *AWSMachineReconciler) reconcileNormal(_ context.Context, machineScope *
objectStoreSvc = r.getObjectStoreService(objectStoreScope)
}
- instance, err = r.createInstance(ec2svc, machineScope, clusterScope, objectStoreSvc)
+ instance, err = r.createInstance(ctx, ec2svc, machineScope, clusterScope, objectStoreSvc)
if err != nil {
machineScope.Error(err, "unable to create instance")
conditions.MarkFalse(machineScope.AWSMachine, infrav1.InstanceReadyCondition, infrav1.InstanceProvisionFailedReason, clusterv1.ConditionSeverityError, "%s", err.Error())
@@ -616,7 +616,7 @@ func (r *AWSMachineReconciler) reconcileNormal(_ context.Context, machineScope *
// reconcile the deletion of the bootstrap data secret now that we have updated instance state
if !machineScope.IsMachinePoolMachine() {
- if deleteSecretErr := r.deleteBootstrapData(machineScope, clusterScope, objectStoreScope); deleteSecretErr != nil {
+ if deleteSecretErr := r.deleteBootstrapData(ctx, machineScope, clusterScope, objectStoreScope); deleteSecretErr != nil {
r.Log.Error(deleteSecretErr, "unable to delete secrets")
return ctrl.Result{}, deleteSecretErr
}
@@ -729,10 +729,10 @@ func (r *AWSMachineReconciler) deleteEncryptedBootstrapDataSecret(machineScope *
return nil
}
-func (r *AWSMachineReconciler) createInstance(ec2svc services.EC2Interface, machineScope *scope.MachineScope, clusterScope cloud.ClusterScoper, objectStoreSvc services.ObjectStoreInterface) (*infrav1.Instance, error) {
+func (r *AWSMachineReconciler) createInstance(ctx context.Context, ec2svc services.EC2Interface, machineScope *scope.MachineScope, clusterScope cloud.ClusterScoper, objectStoreSvc services.ObjectStoreInterface) (*infrav1.Instance, error) {
machineScope.Info("Creating EC2 instance")
- userData, userDataFormat, userDataErr := r.resolveUserData(machineScope, clusterScope, objectStoreSvc)
+ userData, userDataFormat, userDataErr := r.resolveUserData(ctx, machineScope, clusterScope, objectStoreSvc)
if userDataErr != nil {
return nil, errors.Wrapf(userDataErr, "failed to resolve userdata")
}
@@ -745,7 +745,7 @@ func (r *AWSMachineReconciler) createInstance(ec2svc services.EC2Interface, mach
return instance, nil
}
-func (r *AWSMachineReconciler) resolveUserData(machineScope *scope.MachineScope, clusterScope cloud.ClusterScoper, objectStoreSvc services.ObjectStoreInterface) ([]byte, string, error) {
+func (r *AWSMachineReconciler) resolveUserData(ctx context.Context, machineScope *scope.MachineScope, clusterScope cloud.ClusterScoper, objectStoreSvc services.ObjectStoreInterface) ([]byte, string, error) {
userData, userDataFormat, err := machineScope.GetRawBootstrapDataWithFormat()
if err != nil {
r.Recorder.Eventf(machineScope.AWSMachine, corev1.EventTypeWarning, "FailedGetBootstrapData", err.Error())
@@ -766,7 +766,7 @@ func (r *AWSMachineReconciler) resolveUserData(machineScope *scope.MachineScope,
switch ignitionStorageType {
case infrav1.IgnitionStorageTypeOptionClusterObjectStore:
- userData, err = r.generateIgnitionWithRemoteStorage(machineScope, objectStoreSvc, userData)
+ userData, err = r.generateIgnitionWithRemoteStorage(ctx, machineScope, objectStoreSvc, userData)
case infrav1.IgnitionStorageTypeOptionUnencryptedUserData:
// No further modifications to userdata are needed for plain storage in UnencryptedUserData.
default:
@@ -813,13 +813,13 @@ func (r *AWSMachineReconciler) cloudInitUserData(machineScope *scope.MachineScop
// generateIgnitionWithRemoteStorage uses a remote object storage (S3 bucket) and stores user data in it,
// then returns the config to instruct ignition on how to pull the user data from the bucket.
-func (r *AWSMachineReconciler) generateIgnitionWithRemoteStorage(scope *scope.MachineScope, objectStoreSvc services.ObjectStoreInterface, userData []byte) ([]byte, error) {
+func (r *AWSMachineReconciler) generateIgnitionWithRemoteStorage(ctx context.Context, scope *scope.MachineScope, objectStoreSvc services.ObjectStoreInterface, userData []byte) ([]byte, error) {
if objectStoreSvc == nil {
return nil, errors.New("using Ignition by default requires a cluster wide object storage configured at `AWSCluster.Spec.Ignition.S3Bucket`. " +
"You must configure one or instruct Ignition to use EC2 user data instead, by setting `AWSMachine.Spec.Ignition.StorageType` to `UnencryptedUserData`")
}
- objectURL, err := objectStoreSvc.Create(scope, userData)
+ objectURL, err := objectStoreSvc.Create(ctx, scope, userData)
if err != nil {
return nil, errors.Wrap(err, "creating userdata object")
}
@@ -895,7 +895,7 @@ func getIgnitionVersion(scope *scope.MachineScope) string {
return scope.AWSMachine.Spec.Ignition.Version
}
-func (r *AWSMachineReconciler) deleteBootstrapData(machineScope *scope.MachineScope, clusterScope cloud.ClusterScoper, objectStoreScope scope.S3Scope) error {
+func (r *AWSMachineReconciler) deleteBootstrapData(ctx context.Context, machineScope *scope.MachineScope, clusterScope cloud.ClusterScoper, objectStoreScope scope.S3Scope) error {
var userDataFormat string
var err error
if machineScope.Machine.Spec.Bootstrap.DataSecretName != nil {
@@ -913,7 +913,7 @@ func (r *AWSMachineReconciler) deleteBootstrapData(machineScope *scope.MachineSc
if objectStoreScope != nil {
// Bootstrap data will be removed from S3 if it is already populated.
- if err := r.deleteIgnitionBootstrapDataFromS3(machineScope, r.getObjectStoreService(objectStoreScope)); err != nil {
+ if err := r.deleteIgnitionBootstrapDataFromS3(ctx, machineScope, r.getObjectStoreService(objectStoreScope)); err != nil {
return err
}
}
@@ -921,7 +921,7 @@ func (r *AWSMachineReconciler) deleteBootstrapData(machineScope *scope.MachineSc
return nil
}
-func (r *AWSMachineReconciler) deleteIgnitionBootstrapDataFromS3(machineScope *scope.MachineScope, objectStoreSvc services.ObjectStoreInterface) error {
+func (r *AWSMachineReconciler) deleteIgnitionBootstrapDataFromS3(ctx context.Context, machineScope *scope.MachineScope, objectStoreSvc services.ObjectStoreInterface) error {
// Do nothing if the AWSMachine is not in a failed state, and is operational from an EC2 perspective, but does not have a node reference
if !machineScope.HasFailed() && machineScope.InstanceIsOperational() && machineScope.Machine.Status.NodeRef == nil && !machineScope.AWSMachineIsDeleted() {
return nil
@@ -945,7 +945,7 @@ func (r *AWSMachineReconciler) deleteIgnitionBootstrapDataFromS3(machineScope *s
return nil
}
- if err := objectStoreSvc.Delete(machineScope); err != nil {
+ if err := objectStoreSvc.Delete(ctx, machineScope); err != nil {
return errors.Wrap(err, "deleting bootstrap data object")
}
diff --git a/controllers/awsmachine_controller_test.go b/controllers/awsmachine_controller_test.go
index ed23de976b..f7687ca0d1 100644
--- a/controllers/awsmachine_controller_test.go
+++ b/controllers/awsmachine_controller_test.go
@@ -237,7 +237,7 @@ func TestAWSMachineReconcilerIntegrationTests(t *testing.T) {
return elbSvc
}
- _, err = reconciler.reconcileDelete(ms, cs, cs, cs, cs)
+ _, err = reconciler.reconcileDelete(context.TODO(), ms, cs, cs, cs, cs)
g.Expect(err).To(BeNil())
expectConditions(g, ms.AWSMachine, []conditionAssertion{
{infrav1.InstanceReadyCondition, corev1.ConditionFalse, clusterv1.ConditionSeverityInfo, clusterv1.DeletedReason},
@@ -418,7 +418,7 @@ func TestAWSMachineReconcilerIntegrationTests(t *testing.T) {
return elbSvc
}
- _, err = reconciler.reconcileDelete(ms, cs, cs, cs, cs)
+ _, err = reconciler.reconcileDelete(context.TODO(), ms, cs, cs, cs, cs)
g.Expect(err).Should(HaveOccurred())
expectConditions(g, ms.AWSMachine, []conditionAssertion{
{infrav1.InstanceReadyCondition, corev1.ConditionFalse, clusterv1.ConditionSeverityWarning, "DeletingFailed"},
diff --git a/controllers/awsmachine_controller_unit_test.go b/controllers/awsmachine_controller_unit_test.go
index a888fb0592..89207fed27 100644
--- a/controllers/awsmachine_controller_unit_test.go
+++ b/controllers/awsmachine_controller_unit_test.go
@@ -1122,7 +1122,7 @@ func TestAWSMachineReconciler(t *testing.T) {
instance.State = infrav1.InstanceStateRunning
secretSvc.EXPECT().Delete(gomock.Any()).Return(nil).Times(1)
ec2Svc.EXPECT().TerminateInstance(gomock.Any()).Return(nil).AnyTimes()
- _, _ = reconciler.reconcileDelete(ms, cs, cs, cs, cs)
+ _, _ = reconciler.reconcileDelete(context.TODO(), ms, cs, cs, cs, cs)
})
t.Run("should delete the secret if the AWSMachine is in a failure condition", func(t *testing.T) {
@@ -1135,7 +1135,7 @@ func TestAWSMachineReconciler(t *testing.T) {
ms.AWSMachine.Status.FailureReason = ptr.To("UpdateError")
secretSvc.EXPECT().Delete(gomock.Any()).Return(nil).Times(1)
ec2Svc.EXPECT().TerminateInstance(gomock.Any()).Return(nil).AnyTimes()
- _, _ = reconciler.reconcileDelete(ms, cs, cs, cs, cs)
+ _, _ = reconciler.reconcileDelete(context.TODO(), ms, cs, cs, cs, cs)
})
t.Run("should not attempt to delete the secret if InsecureSkipSecretsManager is set on CloudInit", func(t *testing.T) {
g := NewWithT(t)
@@ -1149,7 +1149,7 @@ func TestAWSMachineReconciler(t *testing.T) {
secretSvc.EXPECT().Delete(gomock.Any()).Return(nil).Times(0)
ec2Svc.EXPECT().TerminateInstance(gomock.Any()).Return(nil).AnyTimes()
- _, _ = reconciler.reconcileDelete(ms, cs, cs, cs, cs)
+ _, _ = reconciler.reconcileDelete(context.TODO(), ms, cs, cs, cs, cs)
})
t.Run("should delete the secret from the S3 bucket if StorageType ClusterObjectStore is set for Ignition", func(t *testing.T) {
g := NewWithT(t)
@@ -1167,10 +1167,10 @@ func TestAWSMachineReconciler(t *testing.T) {
buf := new(bytes.Buffer)
klog.SetOutput(buf)
- objectStoreSvc.EXPECT().Delete(gomock.Any()).Return(nil).Times(1)
+ objectStoreSvc.EXPECT().Delete(gomock.Any(), gomock.Any()).Return(nil).Times(1)
ec2Svc.EXPECT().TerminateInstance(gomock.Any()).Return(nil).AnyTimes()
- _, err := reconciler.reconcileDelete(ms, cs, cs, cs, cs)
+ _, err := reconciler.reconcileDelete(context.TODO(), ms, cs, cs, cs, cs)
g.Expect(err).To(BeNil())
})
t.Run("should not delete the secret from the S3 bucket if StorageType UnencryptedUserData is set for Ignition", func(t *testing.T) {
@@ -1189,10 +1189,10 @@ func TestAWSMachineReconciler(t *testing.T) {
buf := new(bytes.Buffer)
klog.SetOutput(buf)
- objectStoreSvc.EXPECT().Delete(gomock.Any()).Return(nil).Times(0)
+ objectStoreSvc.EXPECT().Delete(gomock.Any(), gomock.Any()).Return(nil).Times(0)
ec2Svc.EXPECT().TerminateInstance(gomock.Any()).Return(nil).AnyTimes()
- _, err := reconciler.reconcileDelete(ms, cs, cs, cs, cs)
+ _, err := reconciler.reconcileDelete(context.TODO(), ms, cs, cs, cs, cs)
g.Expect(err).To(BeNil())
})
})
@@ -1252,7 +1252,7 @@ func TestAWSMachineReconciler(t *testing.T) {
instance.State = infrav1.InstanceStateRunning
secretSvc.EXPECT().Delete(gomock.Any()).Return(nil).Times(1)
ec2Svc.EXPECT().TerminateInstance(gomock.Any()).Return(nil).AnyTimes()
- _, _ = reconciler.reconcileDelete(ms, cs, cs, cs, cs)
+ _, _ = reconciler.reconcileDelete(context.TODO(), ms, cs, cs, cs, cs)
})
t.Run("should delete the secret if the AWSMachine is in a failure condition", func(t *testing.T) {
@@ -1265,7 +1265,7 @@ func TestAWSMachineReconciler(t *testing.T) {
ms.AWSMachine.Status.FailureReason = ptr.To("UpdateError")
secretSvc.EXPECT().Delete(gomock.Any()).Return(nil).Times(1)
ec2Svc.EXPECT().TerminateInstance(gomock.Any()).Return(nil).AnyTimes()
- _, _ = reconciler.reconcileDelete(ms, cs, cs, cs, cs)
+ _, _ = reconciler.reconcileDelete(context.TODO(), ms, cs, cs, cs, cs)
})
})
@@ -1356,7 +1356,7 @@ func TestAWSMachineReconciler(t *testing.T) {
}
fakeS3URL := "s3://foo"
- objectStoreSvc.EXPECT().Create(gomock.Any(), gomock.Any()).Return(fakeS3URL, nil).Times(1)
+ objectStoreSvc.EXPECT().Create(gomock.Any(), gomock.Any(), gomock.Any()).Return(fakeS3URL, nil).Times(1)
ec2Svc.EXPECT().CreateInstance(gomock.Any(), gomock.Any(), gomock.Any()).Return(instance, nil).AnyTimes()
ec2Svc.EXPECT().GetInstanceSecurityGroups(gomock.Any()).Return(map[string][]string{"eid": {}}, nil).Times(1)
ec2Svc.EXPECT().GetCoreSecurityGroups(gomock.Any()).Return([]string{}, nil).Times(1)
@@ -1391,7 +1391,7 @@ func TestAWSMachineReconciler(t *testing.T) {
//nolint:gosec
presigned := "https://cluster-api-aws.s3.us-west-2.amazonaws.com/bootstrap-data.yaml?X-Amz-Algorithm=AWS4-HMAC-SHA256&X-Amz-Credential=AKIA3SGQVQG7FGA6KKA6%2F20221104%2Fus-west-2%2Fs3%2Faws4_request&X-Amz-Date=20221104T140227Z&X-Amz-Expires=3600&X-Amz-SignedHeaders=host&X-Amz-Signature=b228dbec8c1008c80c162e1210e4503dceead1e4d4751b4d9787314fd6da4d55"
- objectStoreSvc.EXPECT().Create(gomock.Any(), gomock.Any()).Return(presigned, nil).Times(1)
+ objectStoreSvc.EXPECT().Create(gomock.Any(), gomock.Any(), gomock.Any()).Return(presigned, nil).Times(1)
ec2Svc.EXPECT().CreateInstance(gomock.Any(), gomock.Any(), gomock.Any()).Return(instance, nil).AnyTimes()
ec2Svc.EXPECT().GetInstanceSecurityGroups(gomock.Any()).Return(map[string][]string{"eid": {}}, nil).Times(1)
ec2Svc.EXPECT().GetCoreSecurityGroups(gomock.Any()).Return([]string{}, nil).Times(1)
@@ -1434,7 +1434,7 @@ func TestAWSMachineReconciler(t *testing.T) {
instance.State = infrav1.InstanceStateRunning
ec2Svc.EXPECT().GetInstanceSecurityGroups(gomock.Any()).Return(map[string][]string{"eid": {}}, nil).Times(1)
- objectStoreSvc.EXPECT().Delete(gomock.Any()).Return(nil).Times(1)
+ objectStoreSvc.EXPECT().Delete(gomock.Any(), gomock.Any()).Return(nil).Times(1)
ec2Svc.EXPECT().GetCoreSecurityGroups(gomock.Any()).Return([]string{}, nil).Times(1)
ec2Svc.EXPECT().GetAdditionalSecurityGroupsIDs(gomock.Any()).Return(nil, nil)
@@ -1450,7 +1450,7 @@ func TestAWSMachineReconciler(t *testing.T) {
useIgnitionWithClusterObjectStore(t, g)
instance.State = infrav1.InstanceStateTerminated
- objectStoreSvc.EXPECT().Delete(gomock.Any()).Return(nil).Times(1)
+ objectStoreSvc.EXPECT().Delete(gomock.Any(), gomock.Any()).Return(nil).Times(1)
_, _ = reconciler.reconcileNormal(context.Background(), ms, cs, cs, cs, cs)
})
@@ -1464,10 +1464,10 @@ func TestAWSMachineReconciler(t *testing.T) {
useIgnitionWithClusterObjectStore(t, g)
instance.State = infrav1.InstanceStateRunning
- objectStoreSvc.EXPECT().Delete(gomock.Any()).Return(nil).Times(1)
+ objectStoreSvc.EXPECT().Delete(gomock.Any(), gomock.Any()).Return(nil).Times(1)
ec2Svc.EXPECT().TerminateInstance(gomock.Any()).Return(nil).AnyTimes()
- _, _ = reconciler.reconcileDelete(ms, cs, cs, cs, cs)
+ _, _ = reconciler.reconcileDelete(context.TODO(), ms, cs, cs, cs, cs)
})
t.Run("should delete the object if the AWSMachine is in a failure condition", func(t *testing.T) {
@@ -1481,10 +1481,10 @@ func TestAWSMachineReconciler(t *testing.T) {
// TODO: This seems to have no effect on the test result.
ms.AWSMachine.Status.FailureReason = ptr.To("UpdateError")
- objectStoreSvc.EXPECT().Delete(gomock.Any()).Return(nil).Times(1)
+ objectStoreSvc.EXPECT().Delete(gomock.Any(), gomock.Any()).Return(nil).Times(1)
ec2Svc.EXPECT().TerminateInstance(gomock.Any()).Return(nil).AnyTimes()
- _, _ = reconciler.reconcileDelete(ms, cs, cs, cs, cs)
+ _, _ = reconciler.reconcileDelete(context.TODO(), ms, cs, cs, cs, cs)
})
})
@@ -1511,7 +1511,7 @@ func TestAWSMachineReconciler(t *testing.T) {
ec2Svc.EXPECT().GetInstanceSecurityGroups(gomock.Any()).Return(map[string][]string{"eid": {}}, nil).Times(1)
ec2Svc.EXPECT().GetCoreSecurityGroups(gomock.Any()).Return([]string{}, nil).Times(1)
ec2Svc.EXPECT().GetAdditionalSecurityGroupsIDs(gomock.Any()).Return(nil, nil)
- objectStoreSvc.EXPECT().Delete(gomock.Any()).Return(nil).MaxTimes(0)
+ objectStoreSvc.EXPECT().Delete(gomock.Any(), gomock.Any()).Return(nil).MaxTimes(0)
_, _ = reconciler.reconcileNormal(context.Background(), ms, cs, cs, cs, cs)
})
@@ -1524,7 +1524,7 @@ func TestAWSMachineReconciler(t *testing.T) {
useIgnitionWithClusterObjectStore(t, g)
instance.State = infrav1.InstanceStateTerminated
- objectStoreSvc.EXPECT().Delete(gomock.Any()).Return(nil).Times(1)
+ objectStoreSvc.EXPECT().Delete(gomock.Any(), gomock.Any()).Return(nil).Times(1)
_, _ = reconciler.reconcileNormal(context.Background(), ms, cs, cs, cs, cs)
})
@@ -1537,9 +1537,9 @@ func TestAWSMachineReconciler(t *testing.T) {
useIgnitionWithClusterObjectStore(t, g)
instance.State = infrav1.InstanceStateRunning
- objectStoreSvc.EXPECT().Delete(gomock.Any()).Return(nil).Times(1)
+ objectStoreSvc.EXPECT().Delete(gomock.Any(), gomock.Any()).Return(nil).Times(1)
ec2Svc.EXPECT().TerminateInstance(gomock.Any()).Return(nil).AnyTimes()
- _, _ = reconciler.reconcileDelete(ms, cs, cs, cs, cs)
+ _, _ = reconciler.reconcileDelete(context.TODO(), ms, cs, cs, cs, cs)
})
t.Run("should delete the object if the AWSMachine is in a failure condition", func(t *testing.T) {
@@ -1552,9 +1552,9 @@ func TestAWSMachineReconciler(t *testing.T) {
// TODO: This seems to have no effect on the test result.
ms.AWSMachine.Status.FailureReason = ptr.To("UpdateError")
- objectStoreSvc.EXPECT().Delete(gomock.Any()).Return(nil).Times(1)
+ objectStoreSvc.EXPECT().Delete(gomock.Any(), gomock.Any()).Return(nil).Times(1)
ec2Svc.EXPECT().TerminateInstance(gomock.Any()).Return(nil).AnyTimes()
- _, _ = reconciler.reconcileDelete(ms, cs, cs, cs, cs)
+ _, _ = reconciler.reconcileDelete(context.TODO(), ms, cs, cs, cs, cs)
})
})
@@ -1567,7 +1567,7 @@ func TestAWSMachineReconciler(t *testing.T) {
useIgnitionWithClusterObjectStore(t, g)
ec2Svc.EXPECT().GetRunningInstanceByTags(gomock.Any()).Return(nil, nil).AnyTimes()
- objectStoreSvc.EXPECT().Create(gomock.Any(), gomock.Any()).Return("", errors.New("connection error")).Times(1)
+ objectStoreSvc.EXPECT().Create(gomock.Any(), gomock.Any(), gomock.Any()).Return("", errors.New("connection error")).Times(1)
_, err := reconciler.reconcileNormal(context.Background(), ms, cs, cs, cs, cs)
g.Expect(err).ToNot(BeNil())
g.Expect(err.Error()).To(ContainSubstring("connection error"))
@@ -1609,7 +1609,7 @@ func TestAWSMachineReconciler(t *testing.T) {
fakeS3URL := "s3://foo"
// Expect no Cluster Object Store to be created.
- objectStoreSvc.EXPECT().Create(gomock.Any(), gomock.Any()).Return(fakeS3URL, nil).Times(0)
+ objectStoreSvc.EXPECT().Create(gomock.Any(), gomock.Any(), gomock.Any()).Return(fakeS3URL, nil).Times(0)
ec2Svc.EXPECT().CreateInstance(gomock.Any(), gomock.Any(), gomock.Any()).Return(instance, nil).AnyTimes()
ec2Svc.EXPECT().GetInstanceSecurityGroups(gomock.Any()).Return(map[string][]string{"eid": {}}, nil).Times(1)
@@ -1646,7 +1646,7 @@ func TestAWSMachineReconciler(t *testing.T) {
ec2Svc.EXPECT().GetRunningInstanceByTags(gomock.Any()).Return(nil, expectedErr).AnyTimes()
secretSvc.EXPECT().Delete(gomock.Any()).Return(nil).AnyTimes()
- _, err := reconciler.reconcileDelete(ms, cs, cs, cs, cs)
+ _, err := reconciler.reconcileDelete(context.TODO(), ms, cs, cs, cs, cs)
g.Expect(errors.Cause(err)).To(MatchError(expectedErr))
})
t.Run("should log and remove finalizer when no machine exists", func(t *testing.T) {
@@ -1662,7 +1662,7 @@ func TestAWSMachineReconciler(t *testing.T) {
buf := new(bytes.Buffer)
klog.SetOutput(buf)
- _, err := reconciler.reconcileDelete(ms, cs, cs, cs, cs)
+ _, err := reconciler.reconcileDelete(context.TODO(), ms, cs, cs, cs, cs)
g.Expect(err).To(BeNil())
g.Expect(buf.String()).To(ContainSubstring("Unable to locate EC2 instance by ID or tags"))
g.Expect(ms.AWSMachine.Finalizers).To(ConsistOf(metav1.FinalizerDeleteDependents))
@@ -1683,7 +1683,7 @@ func TestAWSMachineReconciler(t *testing.T) {
buf := new(bytes.Buffer)
klog.SetOutput(buf)
- _, err := reconciler.reconcileDelete(ms, cs, cs, cs, cs)
+ _, err := reconciler.reconcileDelete(context.TODO(), ms, cs, cs, cs, cs)
g.Expect(err).To(BeNil())
g.Expect(buf.String()).To(ContainSubstring("EC2 instance is shutting down or already terminated"))
})
@@ -1702,7 +1702,7 @@ func TestAWSMachineReconciler(t *testing.T) {
buf := new(bytes.Buffer)
klog.SetOutput(buf)
- _, err := reconciler.reconcileDelete(ms, cs, cs, cs, cs)
+ _, err := reconciler.reconcileDelete(context.TODO(), ms, cs, cs, cs, cs)
g.Expect(err).To(BeNil())
g.Expect(buf.String()).To(ContainSubstring("EC2 instance terminated successfully"))
g.Expect(ms.AWSMachine.Finalizers).To(ConsistOf(metav1.FinalizerDeleteDependents))
@@ -1728,7 +1728,7 @@ func TestAWSMachineReconciler(t *testing.T) {
buf := new(bytes.Buffer)
klog.SetOutput(buf)
- _, err := reconciler.reconcileDelete(ms, cs, cs, cs, cs)
+ _, err := reconciler.reconcileDelete(context.TODO(), ms, cs, cs, cs, cs)
g.Expect(errors.Cause(err)).To(MatchError(expected))
g.Expect(buf.String()).To(ContainSubstring("Terminating EC2 instance"))
g.Eventually(recorder.Events).Should(Receive(ContainSubstring("FailedTerminate")))
@@ -1756,7 +1756,7 @@ func TestAWSMachineReconciler(t *testing.T) {
expected := errors.New("can't reach AWS to list security groups")
ec2Svc.EXPECT().GetCoreSecurityGroups(gomock.Any()).Return(nil, expected)
- _, err := reconciler.reconcileDelete(ms, cs, cs, cs, cs)
+ _, err := reconciler.reconcileDelete(context.TODO(), ms, cs, cs, cs, cs)
g.Expect(errors.Cause(err)).To(MatchError(expected))
})
@@ -1777,7 +1777,7 @@ func TestAWSMachineReconciler(t *testing.T) {
ec2Svc.EXPECT().GetCoreSecurityGroups(gomock.Any()).Return([]string{"sg0", "sg1"}, nil)
ec2Svc.EXPECT().DetachSecurityGroupsFromNetworkInterface(gomock.Any(), gomock.Any()).Return(expected)
- _, err := reconciler.reconcileDelete(ms, cs, cs, cs, cs)
+ _, err := reconciler.reconcileDelete(context.TODO(), ms, cs, cs, cs, cs)
g.Expect(errors.Cause(err)).To(MatchError(expected))
})
@@ -1799,7 +1799,7 @@ func TestAWSMachineReconciler(t *testing.T) {
ec2Svc.EXPECT().DetachSecurityGroupsFromNetworkInterface(groups, "eth0").Return(nil)
ec2Svc.EXPECT().DetachSecurityGroupsFromNetworkInterface(groups, "eth1").Return(nil)
- _, err := reconciler.reconcileDelete(ms, cs, cs, cs, cs)
+ _, err := reconciler.reconcileDelete(context.TODO(), ms, cs, cs, cs, cs)
g.Expect(err).To(BeNil())
})
@@ -1812,7 +1812,7 @@ func TestAWSMachineReconciler(t *testing.T) {
getRunningInstance(t, g)
terminateInstance(t, g)
- _, err := reconciler.reconcileDelete(ms, cs, cs, cs, cs)
+ _, err := reconciler.reconcileDelete(context.TODO(), ms, cs, cs, cs, cs)
g.Expect(err).To(BeNil())
})
@@ -1833,7 +1833,7 @@ func TestAWSMachineReconciler(t *testing.T) {
}, nil)
elbSvc.EXPECT().IsInstanceRegisteredWithAPIServerELB(gomock.Any()).Return(false, errors.New("error describing ELB"))
- _, err := reconciler.reconcileDelete(ms, cs, cs, cs, cs)
+ _, err := reconciler.reconcileDelete(context.TODO(), ms, cs, cs, cs, cs)
g.Expect(err).ToNot(BeNil())
g.Expect(err.Error()).To(ContainSubstring("error describing ELB"))
g.Expect(ms.AWSMachine.Finalizers).To(ContainElement(metav1.FinalizerDeleteDependents))
@@ -1858,7 +1858,7 @@ func TestAWSMachineReconciler(t *testing.T) {
}, nil)
elbSvc.EXPECT().IsInstanceRegisteredWithAPIServerELB(gomock.Any()).Return(false, nil)
- _, err := reconciler.reconcileDelete(ms, cs, cs, cs, cs)
+ _, err := reconciler.reconcileDelete(context.TODO(), ms, cs, cs, cs, cs)
g.Expect(err).To(BeNil())
g.Expect(ms.AWSMachine.Finalizers).To(ContainElement(metav1.FinalizerDeleteDependents))
expectConditions(g, ms.AWSMachine, []conditionAssertion{{infrav1.ELBAttachedCondition, corev1.ConditionFalse, clusterv1.ConditionSeverityInfo, clusterv1.DeletedReason}})
@@ -1884,7 +1884,7 @@ func TestAWSMachineReconciler(t *testing.T) {
elbSvc.EXPECT().IsInstanceRegisteredWithAPIServerELB(gomock.Any()).Return(true, nil)
elbSvc.EXPECT().DeregisterInstanceFromAPIServerELB(gomock.Any()).Return(nil)
- _, err := reconciler.reconcileDelete(ms, cs, cs, cs, cs)
+ _, err := reconciler.reconcileDelete(context.TODO(), ms, cs, cs, cs, cs)
g.Expect(err).To(BeNil())
g.Expect(ms.AWSMachine.Finalizers).To(ContainElement(metav1.FinalizerDeleteDependents))
expectConditions(g, ms.AWSMachine, []conditionAssertion{{infrav1.ELBAttachedCondition, corev1.ConditionFalse, clusterv1.ConditionSeverityInfo, clusterv1.DeletedReason}})
@@ -1907,7 +1907,7 @@ func TestAWSMachineReconciler(t *testing.T) {
elbSvc.EXPECT().IsInstanceRegisteredWithAPIServerELB(gomock.Any()).Return(true, nil)
elbSvc.EXPECT().DeregisterInstanceFromAPIServerELB(gomock.Any()).Return(errors.New("Duplicate access point name for load balancer"))
- _, err := reconciler.reconcileDelete(ms, cs, cs, cs, cs)
+ _, err := reconciler.reconcileDelete(context.TODO(), ms, cs, cs, cs, cs)
g.Expect(err).ToNot(BeNil())
g.Expect(err.Error()).To(ContainSubstring("Duplicate access point name for load balancer"))
g.Expect(ms.AWSMachine.Finalizers).To(ContainElement(metav1.FinalizerDeleteDependents))
@@ -1922,7 +1922,7 @@ func TestAWSMachineReconciler(t *testing.T) {
ms.SetSecretPrefix("test")
ms.SetSecretCount(0)
- _, err := reconciler.reconcileDelete(ms, cs, cs, cs, cs)
+ _, err := reconciler.reconcileDelete(context.TODO(), ms, cs, cs, cs, cs)
g.Expect(err).To(MatchError(ContainSubstring("secretPrefix present, but secretCount is not set")))
g.Expect(ms.AWSMachine.Finalizers).To(ContainElement(metav1.FinalizerDeleteDependents))
})
@@ -1934,7 +1934,7 @@ func TestAWSMachineReconciler(t *testing.T) {
finalizer(t, g)
ms.AWSMachine.Spec.CloudInit.SecureSecretsBackend = "InvalidSecretBackend"
- _, err := reconciler.reconcileDelete(ms, cs, cs, cs, cs)
+ _, err := reconciler.reconcileDelete(context.TODO(), ms, cs, cs, cs, cs)
g.Expect(err).To(MatchError(ContainSubstring("invalid secret backend")))
g.Expect(ms.AWSMachine.Finalizers).To(ContainElement(metav1.FinalizerDeleteDependents))
})
@@ -1948,7 +1948,7 @@ func TestAWSMachineReconciler(t *testing.T) {
ms.SetSecretCount(1)
secretSvc.EXPECT().Delete(gomock.Any()).Return(errors.New("Hierarchy Type Mismatch Exception"))
- _, err := reconciler.reconcileDelete(ms, cs, cs, cs, cs)
+ _, err := reconciler.reconcileDelete(context.TODO(), ms, cs, cs, cs, cs)
g.Expect(err).To(MatchError(ContainSubstring("Hierarchy Type Mismatch Exception")))
g.Expect(ms.AWSMachine.Finalizers).To(ContainElement(metav1.FinalizerDeleteDependents))
})
diff --git a/go.mod b/go.mod
index ee962015b5..c762768303 100644
--- a/go.mod
+++ b/go.mod
@@ -11,7 +11,12 @@ require (
github.com/aws/amazon-vpc-cni-k8s v1.15.5
github.com/aws/aws-lambda-go v1.41.0
github.com/aws/aws-sdk-go v1.55.5
+ github.com/aws/aws-sdk-go-v2 v1.30.3
+ github.com/aws/aws-sdk-go-v2/config v1.27.11
+ github.com/aws/aws-sdk-go-v2/credentials v1.17.11
+ github.com/aws/aws-sdk-go-v2/service/s3 v1.53.1
github.com/aws/aws-sdk-go-v2/service/sts v1.28.6
+ github.com/aws/smithy-go v1.22.2
github.com/awslabs/goformation/v4 v4.19.5
github.com/blang/semver v3.5.1+incompatible
github.com/coreos/ignition v0.35.0
@@ -70,10 +75,7 @@ require (
github.com/adrg/xdg v0.5.3 // indirect
github.com/antlr4-go/antlr/v4 v4.13.0 // indirect
github.com/asaskevich/govalidator v0.0.0-20200428143746-21a406dcc535 // indirect
- github.com/aws/aws-sdk-go-v2 v1.30.3 // indirect
github.com/aws/aws-sdk-go-v2/aws/protocol/eventstream v1.6.2 // indirect
- github.com/aws/aws-sdk-go-v2/config v1.27.11 // indirect
- github.com/aws/aws-sdk-go-v2/credentials v1.17.11 // indirect
github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.16.1 // indirect
github.com/aws/aws-sdk-go-v2/internal/configsources v1.3.15 // indirect
github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.6.15 // indirect
@@ -87,12 +89,10 @@ require (
github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.11.7 // indirect
github.com/aws/aws-sdk-go-v2/service/internal/s3shared v1.17.5 // indirect
github.com/aws/aws-sdk-go-v2/service/organizations v1.27.3 // indirect
- github.com/aws/aws-sdk-go-v2/service/s3 v1.53.1 // indirect
github.com/aws/aws-sdk-go-v2/service/secretsmanager v1.28.6 // indirect
github.com/aws/aws-sdk-go-v2/service/servicequotas v1.21.4 // indirect
github.com/aws/aws-sdk-go-v2/service/sso v1.20.5 // indirect
github.com/aws/aws-sdk-go-v2/service/ssooidc v1.23.4 // indirect
- github.com/aws/smithy-go v1.20.3 // indirect
github.com/aymerick/douceur v0.2.0 // indirect
github.com/beorn7/perks v1.0.1 // indirect
github.com/blang/semver/v4 v4.0.0 // indirect
diff --git a/go.sum b/go.sum
index a68003df24..7e7a4967b4 100644
--- a/go.sum
+++ b/go.sum
@@ -90,8 +90,8 @@ github.com/aws/aws-sdk-go-v2/service/ssooidc v1.23.4 h1:Jux+gDDyi1Lruk+KHF91tK2K
github.com/aws/aws-sdk-go-v2/service/ssooidc v1.23.4/go.mod h1:mUYPBhaF2lGiukDEjJX2BLRRKTmoUSitGDUgM4tRxak=
github.com/aws/aws-sdk-go-v2/service/sts v1.28.6 h1:cwIxeBttqPN3qkaAjcEcsh8NYr8n2HZPkcKgPAi1phU=
github.com/aws/aws-sdk-go-v2/service/sts v1.28.6/go.mod h1:FZf1/nKNEkHdGGJP/cI2MoIMquumuRK6ol3QQJNDxmw=
-github.com/aws/smithy-go v1.20.3 h1:ryHwveWzPV5BIof6fyDvor6V3iUL7nTfiTKXHiW05nE=
-github.com/aws/smithy-go v1.20.3/go.mod h1:krry+ya/rV9RDcV/Q16kpu6ypI4K2czasz0NC3qS14E=
+github.com/aws/smithy-go v1.22.2 h1:6D9hW43xKFrRx/tXXfAlIZc4JI+yQe6snnWcQyxSyLQ=
+github.com/aws/smithy-go v1.22.2/go.mod h1:irrKGvNn1InZwb2d7fkIRNucdfwR8R+Ts3wxYa/cJHg=
github.com/awslabs/goformation/v4 v4.19.5 h1:Y+Tzh01tWg8gf//AgGKUamaja7Wx9NPiJf1FpZu4/iU=
github.com/awslabs/goformation/v4 v4.19.5/go.mod h1:JoNpnVCBOUtEz9bFxc9sjy8uBUCLF5c4D1L7RhRTVM8=
github.com/aymerick/douceur v0.2.0 h1:Mv+mAeH1Q+n9Fr+oyamOlAkUNPWPlA8PPGR0QAaYuPk=
diff --git a/pkg/cloud/endpoints/endpoints.go b/pkg/cloud/endpoints/endpoints.go
index 33a87b11cc..14298455d8 100644
--- a/pkg/cloud/endpoints/endpoints.go
+++ b/pkg/cloud/endpoints/endpoints.go
@@ -24,6 +24,7 @@ import (
"github.com/aws/aws-sdk-go/aws/endpoints"
+ "sigs.k8s.io/cluster-api-provider-aws/v2/pkg/cloud/endpointsv2"
"sigs.k8s.io/cluster-api-provider-aws/v2/pkg/cloud/scope"
)
@@ -104,6 +105,8 @@ func ParseFlag(serviceEndpoints string) ([]scope.ServiceEndpoint, error) {
})
}
}
+ // For Go SDK V2 migration
+ saveToServiceEndpointV2Map(endpoints)
return endpoints, nil
}
@@ -117,3 +120,15 @@ func containsString(slice []string, s string) bool {
return false
}
+
+// TODO: punkwalker - remove this after Go SDK V2 migration.
+func saveToServiceEndpointV2Map(src []scope.ServiceEndpoint) {
+ for _, svc := range src {
+ endpoint := endpointsv2.ServiceEndpoint{
+ ServiceID: svc.ServiceID,
+ URL: svc.URL,
+ SigningRegion: svc.SigningRegion,
+ }
+ endpointsv2.ServiceEndpointsMap[svc.ServiceID] = endpoint
+ }
+}
diff --git a/pkg/cloud/endpointsv2/endpoints.go b/pkg/cloud/endpointsv2/endpoints.go
new file mode 100644
index 0000000000..2daac9e608
--- /dev/null
+++ b/pkg/cloud/endpointsv2/endpoints.go
@@ -0,0 +1,115 @@
+/*
+Copyright 2020 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 endpointsv2 contains aws endpoint related utilities.
+package endpointsv2
+
+import (
+ "context"
+ "errors"
+ "net/url"
+ "strings"
+
+ "github.com/aws/aws-sdk-go-v2/service/s3"
+ smithyendpoints "github.com/aws/smithy-go/endpoints"
+)
+
+var (
+ errServiceEndpointFormat = errors.New("must be formatted as ${ServiceID}=${URL}")
+ errServiceEndpointSigningRegion = errors.New("must be formatted as ${SigningRegion}:${ServiceID1}=${URL1},${ServiceID2}=${URL2...}")
+ errServiceEndpointURL = errors.New("must use a valid URL as a service-endpoint")
+ errServiceEndpointDuplicateServiceID = errors.New("same serviceID defined twice for signing region")
+ // ServiceEndpointsMap Can be made private after Go SDK V2 migration.
+ ServiceEndpointsMap = map[string]ServiceEndpoint{}
+)
+
+// ServiceEndpoint contains AWS Service resolution information for SDK V2.
+type ServiceEndpoint struct {
+ ServiceID string
+ URL string
+ SigningRegion string
+}
+
+// ParseFlag parses the command line flag of service endponts in the format ${SigningRegion1}:${ServiceID1}=${URL1},${ServiceID2}=${URL2}...;${SigningRegion2}...
+// returning a set of ServiceEndpoints.
+func ParseFlag(serviceEndpoints string) error {
+ if serviceEndpoints == "" {
+ return nil
+ }
+
+ signingRegionConfigs := strings.Split(serviceEndpoints, ";")
+ for _, regionConfig := range signingRegionConfigs {
+ components := strings.SplitN(regionConfig, ":", 2)
+ if len(components) != 2 {
+ return errServiceEndpointSigningRegion
+ }
+ signingRegion := components[0]
+ servicePairs := strings.Split(components[1], ",")
+ for _, servicePair := range servicePairs {
+ kv := strings.Split(servicePair, "=")
+ if len(kv) != 2 {
+ return errServiceEndpointFormat
+ }
+ var serviceID = kv[0]
+ if _, ok := ServiceEndpointsMap[serviceID]; ok {
+ return errServiceEndpointDuplicateServiceID
+ }
+
+ URL, err := url.ParseRequestURI(kv[1])
+ if err != nil {
+ return errServiceEndpointURL
+ }
+ ServiceEndpointsMap[serviceID] = ServiceEndpoint{
+ ServiceID: serviceID,
+ URL: URL.String(),
+ SigningRegion: signingRegion,
+ }
+ }
+ }
+ return nil
+}
+
+// Custom EndpointResolverV2 ResolveEndpoint handlers.
+
+// MultiServiceEndpointResolver implements EndpointResolverV2 interface for services.
+type MultiServiceEndpointResolver struct {
+ endpoints map[string]ServiceEndpoint
+}
+
+// NewMultiServiceEndpointResolver returns new MultiServiceEndpointResolver.
+func NewMultiServiceEndpointResolver() *MultiServiceEndpointResolver {
+ return &MultiServiceEndpointResolver{
+ endpoints: ServiceEndpointsMap,
+ }
+}
+
+// S3EndpointResolver implements EndpointResolverV2 interface for S3.
+type S3EndpointResolver struct {
+ *MultiServiceEndpointResolver
+}
+
+// ResolveEndpoint for S3.
+func (s *S3EndpointResolver) ResolveEndpoint(ctx context.Context, params s3.EndpointParameters) (smithyendpoints.Endpoint, error) {
+ // If custom endpoint not found, return default endpoint for the service
+ if _, ok := s.endpoints[s3.ServiceID]; !ok {
+ return s3.NewDefaultEndpointResolverV2().ResolveEndpoint(ctx, params)
+ }
+
+ endpoint := ServiceEndpointsMap[s3.ServiceID]
+ params.Endpoint = &endpoint.URL
+ params.Region = &endpoint.SigningRegion
+ return s3.NewDefaultEndpointResolverV2().ResolveEndpoint(ctx, params)
+}
diff --git a/pkg/cloud/identityv2/identity.go b/pkg/cloud/identityv2/identity.go
new file mode 100644
index 0000000000..da180b87d2
--- /dev/null
+++ b/pkg/cloud/identityv2/identity.go
@@ -0,0 +1,179 @@
+/*
+Copyright 2021 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 identityv2 provides the AWSPrincipalTypeProvider interface and its implementations.
+package identityv2
+
+import (
+ "bytes"
+ "context"
+ "crypto/sha256"
+ "encoding/gob"
+ "time"
+
+ "github.com/aws/aws-sdk-go-v2/aws"
+ "github.com/aws/aws-sdk-go-v2/config"
+ "github.com/aws/aws-sdk-go-v2/credentials"
+ "github.com/aws/aws-sdk-go-v2/credentials/stscreds"
+ "github.com/aws/aws-sdk-go-v2/service/sts"
+ corev1 "k8s.io/api/core/v1"
+
+ infrav1 "sigs.k8s.io/cluster-api-provider-aws/v2/api/v1beta2"
+ "sigs.k8s.io/cluster-api-provider-aws/v2/pkg/logger"
+)
+
+// AWSPrincipalTypeProvider defines the interface for AWS Principal Type Provider.
+type AWSPrincipalTypeProvider interface {
+ aws.CredentialsProvider
+ // Hash returns a unique hash of the data forming the V2 credentials
+ // for this Principal
+ Hash() (string, error)
+ Name() string
+}
+
+// NewAWSStaticPrincipalTypeProvider will create a new AWSStaticPrincipalTypeProvider from a given AWSClusterStaticIdentity.
+func NewAWSStaticPrincipalTypeProvider(identity *infrav1.AWSClusterStaticIdentity, secret *corev1.Secret) *AWSStaticPrincipalTypeProvider {
+ accessKeyID := string(secret.Data["AccessKeyID"])
+ secretAccessKey := string(secret.Data["SecretAccessKey"])
+ sessionToken := string(secret.Data["SessionToken"])
+
+ credProvider := credentials.NewStaticCredentialsProvider(accessKeyID, secretAccessKey, sessionToken)
+ credCache := aws.NewCredentialsCache(credProvider)
+ return &AWSStaticPrincipalTypeProvider{
+ Principal: identity,
+ credentials: credCache,
+ AccessKeyID: accessKeyID,
+ SecretAccessKey: secretAccessKey,
+ SessionToken: sessionToken,
+ }
+}
+
+// GetAssumeRoleCredentialsCache will return the CredentialsCache of a given AWSRolePrincipalTypeProvider.
+func GetAssumeRoleCredentialsCache(roleIdentityProvider *AWSRolePrincipalTypeProvider, optFns []func(*config.LoadOptions) error) (*aws.CredentialsCache, error) {
+ cfg, err := config.LoadDefaultConfig(context.TODO(), optFns...)
+ if err != nil {
+ return nil, err
+ }
+
+ stsClient := sts.NewFromConfig(cfg)
+ credsProvider := stscreds.NewAssumeRoleProvider(stsClient, roleIdentityProvider.Principal.Spec.RoleArn, func(o *stscreds.AssumeRoleOptions) {
+ if roleIdentityProvider.Principal.Spec.ExternalID != "" {
+ o.ExternalID = aws.String(roleIdentityProvider.Principal.Spec.ExternalID)
+ }
+ o.RoleSessionName = roleIdentityProvider.Principal.Spec.SessionName
+ if roleIdentityProvider.Principal.Spec.InlinePolicy != "" {
+ o.Policy = aws.String(roleIdentityProvider.Principal.Spec.InlinePolicy)
+ }
+ o.Duration = time.Duration(roleIdentityProvider.Principal.Spec.DurationSeconds) * time.Second
+ // For testing
+ if roleIdentityProvider.stsClient != nil {
+ o.Client = roleIdentityProvider.stsClient
+ }
+ })
+
+ return aws.NewCredentialsCache(credsProvider), nil
+}
+
+// NewAWSRolePrincipalTypeProvider will create a new AWSRolePrincipalTypeProvider from an AWSClusterRoleIdentity.
+func NewAWSRolePrincipalTypeProvider(identity *infrav1.AWSClusterRoleIdentity, sourceProvider AWSPrincipalTypeProvider, region string, log logger.Wrapper) *AWSRolePrincipalTypeProvider {
+ return &AWSRolePrincipalTypeProvider{
+ credentials: nil,
+ stsClient: nil,
+ region: region,
+ Principal: identity,
+ sourceProvider: sourceProvider,
+ log: log.WithName("AWSRolePrincipalTypeProvider"),
+ }
+}
+
+// AWSStaticPrincipalTypeProvider defines the specs for a static AWSPrincipalTypeProvider.
+type AWSStaticPrincipalTypeProvider struct {
+ Principal *infrav1.AWSClusterStaticIdentity
+ credentials *aws.CredentialsCache
+ // these are for tests :/
+ AccessKeyID string
+ SecretAccessKey string
+ SessionToken string
+}
+
+// Hash returns the byte encoded AWSStaticPrincipalTypeProvider.
+func (p *AWSStaticPrincipalTypeProvider) Hash() (string, error) {
+ var roleIdentityValue bytes.Buffer
+ err := gob.NewEncoder(&roleIdentityValue).Encode(p)
+ if err != nil {
+ return "", err
+ }
+ hash := sha256.New()
+ return string(hash.Sum(roleIdentityValue.Bytes())), nil
+}
+
+// Retrieve returns the credential values for the AWSStaticPrincipalTypeProvider.
+func (p *AWSStaticPrincipalTypeProvider) Retrieve(ctx context.Context) (aws.Credentials, error) {
+ return p.credentials.Retrieve(ctx)
+}
+
+// Name returns the name of the AWSStaticPrincipalTypeProvider.
+func (p *AWSStaticPrincipalTypeProvider) Name() string {
+ return p.Principal.Name
+}
+
+// AWSRolePrincipalTypeProvider defines the specs for a AWSPrincipalTypeProvider with a role.
+type AWSRolePrincipalTypeProvider struct {
+ Principal *infrav1.AWSClusterRoleIdentity
+ credentials *aws.CredentialsCache
+ region string
+ sourceProvider AWSPrincipalTypeProvider
+ log logger.Wrapper
+ stsClient stscreds.AssumeRoleAPIClient
+}
+
+// Hash returns the byte encoded AWSRolePrincipalTypeProvider.
+func (p *AWSRolePrincipalTypeProvider) Hash() (string, error) {
+ var roleIdentityValue bytes.Buffer
+ err := gob.NewEncoder(&roleIdentityValue).Encode(p)
+ if err != nil {
+ return "", err
+ }
+ hash := sha256.New()
+ return string(hash.Sum(roleIdentityValue.Bytes())), nil
+}
+
+// Name returns the name of the AWSRolePrincipalTypeProvider.
+func (p *AWSRolePrincipalTypeProvider) Name() string {
+ return p.Principal.Name
+}
+
+// Retrieve returns the credential values for the AWSRolePrincipalTypeProvider.
+func (p *AWSRolePrincipalTypeProvider) Retrieve(ctx context.Context) (aws.Credentials, error) {
+ if p.credentials == nil {
+ optFns := []func(*config.LoadOptions) error{config.WithRegion(p.region)}
+ if p.sourceProvider != nil {
+ sourceCreds, err := p.sourceProvider.Retrieve(ctx)
+ if err != nil {
+ return aws.Credentials{}, err
+ }
+ optFns = append(optFns, config.WithCredentialsProvider(credentials.NewStaticCredentialsProvider(sourceCreds.AccessKeyID, sourceCreds.SecretAccessKey, sourceCreds.SessionToken)))
+ }
+
+ creds, err := GetAssumeRoleCredentialsCache(p, optFns)
+ if err != nil {
+ return aws.Credentials{}, err
+ }
+ // Update credentials
+ p.credentials = creds
+ }
+ return p.credentials.Retrieve(ctx)
+}
diff --git a/pkg/cloud/interfaces.go b/pkg/cloud/interfaces.go
index 0ebc12e383..4cb8e3c91c 100644
--- a/pkg/cloud/interfaces.go
+++ b/pkg/cloud/interfaces.go
@@ -18,6 +18,7 @@ limitations under the License.
package cloud
import (
+ 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"
@@ -32,6 +33,7 @@ import (
// Session represents an AWS session.
type Session interface {
Session() awsclient.ConfigProvider
+ SessionV2() awsv2.Config
ServiceLimiter(service string) *throttle.ServiceLimiter
}
diff --git a/pkg/cloud/logs/logs.go b/pkg/cloud/logs/logs.go
index af22708f12..73fbf5359c 100644
--- a/pkg/cloud/logs/logs.go
+++ b/pkg/cloud/logs/logs.go
@@ -18,6 +18,7 @@ limitations under the License.
package logs
import (
+ awsv2 "github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/aws-sdk-go/aws"
"github.com/go-logr/logr"
)
@@ -40,6 +41,19 @@ func GetAWSLogLevel(logger logr.Logger) aws.LogLevelType {
return aws.LogOff
}
+// GetAWSLogLevelV2 will return the log level of an AWS Logger.
+func GetAWSLogLevelV2(logger logr.Logger) awsv2.ClientLogMode {
+ if logger.V(logWithHTTPBody).Enabled() {
+ return awsv2.LogRequestWithBody | awsv2.LogResponseWithBody
+ }
+
+ if logger.V(logWithHTTPHeader).Enabled() {
+ return awsv2.LogRequest | awsv2.LogResponse
+ }
+
+ return awsv2.LogRequestEventMessage
+}
+
// NewWrapLogr will create an AWS Logger wrapper.
func NewWrapLogr(logger logr.Logger) aws.Logger {
return &logrWrapper{
diff --git a/pkg/cloud/metrics/metrics.go b/pkg/cloud/metrics/metrics.go
index 4c3e5e988d..36201d15d7 100644
--- a/pkg/cloud/metrics/metrics.go
+++ b/pkg/cloud/metrics/metrics.go
@@ -69,6 +69,9 @@ func init() {
metrics.Registry.MustRegister(awsCallRetries)
}
+// TODO: mjlshen rewrite this for aws-sdk-go-v2
+// https://docs.aws.amazon.com/sdk-for-go/v2/developer-guide/sdk-timing.html
+
// CaptureRequestMetrics will monitor and capture request metrics.
func CaptureRequestMetrics(controller string) func(r *request.Request) {
return func(r *request.Request) {
diff --git a/pkg/cloud/metricsv2/metrics.go b/pkg/cloud/metricsv2/metrics.go
new file mode 100644
index 0000000000..580316ac68
--- /dev/null
+++ b/pkg/cloud/metricsv2/metrics.go
@@ -0,0 +1,236 @@
+/*
+Copyright 2020 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 metricsv2 provides a way to capture request metrics.
+package metricsv2
+
+import (
+ "context"
+ "errors"
+ "fmt"
+ "net/http"
+ "strconv"
+ "time"
+
+ awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
+ "github.com/aws/smithy-go"
+ "github.com/aws/smithy-go/middleware"
+ smithyhttp "github.com/aws/smithy-go/transport/http"
+ "github.com/prometheus/client_golang/prometheus"
+ "k8s.io/apimachinery/pkg/runtime"
+ "sigs.k8s.io/controller-runtime/pkg/metrics"
+
+ "sigs.k8s.io/cluster-api-provider-aws/v2/pkg/record"
+ "sigs.k8s.io/cluster-api-provider-aws/v2/version"
+)
+
+const (
+ metricAWSSubsystem = "aws"
+ metricRequestCountKey = "api_requests_total_v2"
+ metricRequestDurationKey = "api_request_duration_seconds_v2"
+ metricAPICallRetries = "api_call_retries_v2"
+ metricServiceLabel = "service"
+ metricRegionLabel = "region"
+ metricOperationLabel = "operation"
+ metricControllerLabel = "controller"
+ metricStatusCodeLabel = "status_code"
+ metricErrorCodeLabel = "error_code"
+)
+
+var (
+ awsRequestCount = prometheus.NewCounterVec(prometheus.CounterOpts{
+ Subsystem: metricAWSSubsystem,
+ Name: metricRequestCountKey,
+ Help: "Total number of AWS requests",
+ }, []string{metricControllerLabel, metricServiceLabel, metricRegionLabel, metricOperationLabel, metricStatusCodeLabel, metricErrorCodeLabel})
+ awsRequestDurationSeconds = prometheus.NewHistogramVec(prometheus.HistogramOpts{
+ Subsystem: metricAWSSubsystem,
+ Name: metricRequestDurationKey,
+ Help: "Latency of HTTP requests to AWS",
+ }, []string{metricControllerLabel, metricServiceLabel, metricRegionLabel, metricOperationLabel})
+ awsCallRetries = prometheus.NewHistogramVec(prometheus.HistogramOpts{
+ Subsystem: metricAWSSubsystem,
+ Name: metricAPICallRetries,
+ Help: "Number of retries made against an AWS API",
+ Buckets: []float64{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10},
+ }, []string{metricControllerLabel, metricServiceLabel, metricRegionLabel, metricOperationLabel})
+ getRawResponse = func(metadata middleware.Metadata) *http.Response {
+ switch res := awsmiddleware.GetRawResponse(metadata).(type) {
+ case *http.Response:
+ return res
+ default:
+ return nil
+ }
+ }
+)
+
+func init() {
+ metrics.Registry.MustRegister(awsRequestCount)
+ metrics.Registry.MustRegister(awsRequestDurationSeconds)
+ metrics.Registry.MustRegister(awsCallRetries)
+}
+
+type requestContextKey struct{}
+
+// RequestData holds information related to request metrics.
+type RequestData struct {
+ RequestStartTime time.Time
+ RequestEndTime time.Time
+ StatusCode int
+ ErrorCode string
+ RequestCount int
+ Service string
+ OperationName string
+ Region string
+ UserAgent string
+ Controller string
+ Target runtime.Object
+ Attempts int
+}
+
+// WithMiddlewares adds instrumentation middleware stacks to AWS GO SDK V2 service clients.
+// Inspired by https://github.com/jonathan-innis/aws-sdk-go-prometheus/v2.
+func WithMiddlewares(controller string, target runtime.Object) func(stack *middleware.Stack) error {
+ return func(stack *middleware.Stack) error {
+ if err := stack.Initialize.Add(getMetricCollectionMiddleware(controller, target), middleware.Before); err != nil {
+ return err
+ }
+ if err := stack.Build.Add(getAddToUserAgentMiddleware(), middleware.Before); err != nil {
+ return err
+ }
+ if err := stack.Finalize.Add(getRequestMetricContextMiddleware(), middleware.Before); err != nil {
+ return err
+ }
+ if err := stack.Finalize.Insert(getAttemptContextMiddleware(), "Retry", middleware.After); err != nil {
+ return err
+ }
+ return stack.Deserialize.Add(getRecordAWSPermissionsIssueMiddleware(target), middleware.After)
+ }
+}
+
+func getMetricCollectionMiddleware(controller string, target runtime.Object) middleware.InitializeMiddleware {
+ return middleware.InitializeMiddlewareFunc("capa/MetricCollectionMiddleware", func(ctx context.Context, input middleware.InitializeInput, handler middleware.InitializeHandler) (middleware.InitializeOutput, middleware.Metadata, error) {
+ ctx = initRequestContext(ctx, controller, target)
+ request := getContext(ctx)
+
+ request.RequestStartTime = time.Now().UTC()
+ out, metadata, err := handler.HandleInitialize(ctx, input)
+ request.RequestEndTime = time.Now().UTC()
+
+ request.CaptureRequestMetrics()
+
+ return out, metadata, err
+ })
+}
+
+func getRequestMetricContextMiddleware() middleware.FinalizeMiddleware {
+ return middleware.FinalizeMiddlewareFunc("capa/RequestMetricContextMiddleware", func(ctx context.Context, input middleware.FinalizeInput, handler middleware.FinalizeHandler) (middleware.FinalizeOutput, middleware.Metadata, error) {
+ request := getContext(ctx)
+ request.Service = awsmiddleware.GetServiceID(ctx)
+ request.OperationName = awsmiddleware.GetOperationName(ctx)
+ request.Region = awsmiddleware.GetRegion(ctx)
+
+ return handler.HandleFinalize(ctx, input)
+ })
+}
+
+// For capturing retry count and status codes.
+func getAttemptContextMiddleware() middleware.FinalizeMiddleware {
+ return middleware.FinalizeMiddlewareFunc("capa/AttemptMetricContextMiddleware", func(ctx context.Context, input middleware.FinalizeInput, handler middleware.FinalizeHandler) (middleware.FinalizeOutput, middleware.Metadata, error) {
+ request := getContext(ctx)
+ request.Attempts++
+ out, metadata, err := handler.HandleFinalize(ctx, input)
+ response := getRawResponse(metadata)
+
+ if response.Body != nil {
+ defer response.Body.Close()
+ }
+
+ // This will record only last attempts status code.
+ // Can be further extended to capture status codes of all attempts
+ if response != nil {
+ request.StatusCode = response.StatusCode
+ } else {
+ request.StatusCode = -1
+ }
+
+ return out, metadata, err
+ })
+}
+func getRecordAWSPermissionsIssueMiddleware(target runtime.Object) middleware.DeserializeMiddleware {
+ return middleware.DeserializeMiddlewareFunc("capa/RecordAWSPermissionsIssueMiddleware", func(ctx context.Context, input middleware.DeserializeInput, handler middleware.DeserializeHandler) (middleware.DeserializeOutput, middleware.Metadata, error) {
+ output, metadata, err := handler.HandleDeserialize(ctx, input)
+ if err != nil {
+ var re *smithyhttp.ResponseError
+ if errors.As(err, &re) {
+ var ae smithy.APIError
+ if errors.As(re.Err, &ae) {
+ switch ae.ErrorCode() {
+ case "AuthFailure", "UnauthorizedOperation", "NoCredentialProviders":
+ record.Warnf(target, ae.ErrorCode(), "Operation %s failed with a credentials or permission issue", awsmiddleware.GetOperationName(ctx))
+ }
+ }
+ }
+ }
+ return output, metadata, err
+ })
+}
+
+func getAddToUserAgentMiddleware() middleware.BuildMiddleware {
+ return middleware.BuildMiddlewareFunc("capa/AddUserAgentMiddleware", func(ctx context.Context, input middleware.BuildInput, handler middleware.BuildHandler) (middleware.BuildOutput, middleware.Metadata, error) {
+ request := getContext(ctx)
+ r, ok := input.Request.(*smithyhttp.Request)
+ if !ok {
+ return middleware.BuildOutput{}, middleware.Metadata{}, fmt.Errorf("unknown transport type %T", input.Request)
+ }
+
+ if curUA := r.Header.Get("User-Agent"); curUA != "" {
+ request.UserAgent = curUA + " " + request.UserAgent
+ }
+ r.Header.Set("User-Agent", request.UserAgent)
+
+ return handler.HandleBuild(ctx, input)
+ })
+}
+
+func initRequestContext(ctx context.Context, controller string, target runtime.Object) context.Context {
+ if middleware.GetStackValue(ctx, requestContextKey{}) == nil {
+ ctx = middleware.WithStackValue(ctx, requestContextKey{}, &RequestData{
+ Controller: controller,
+ Target: target,
+ UserAgent: fmt.Sprintf("aws.cluster.x-k8s.io/%s", version.Get().String()),
+ })
+ }
+ return ctx
+}
+
+func getContext(ctx context.Context) *RequestData {
+ rctx := middleware.GetStackValue(ctx, requestContextKey{})
+ if rctx == nil {
+ return nil
+ }
+ return rctx.(*RequestData)
+}
+
+// CaptureRequestMetrics will monitor and capture request metrics.
+func (r *RequestData) CaptureRequestMetrics() {
+ requestDuration := r.RequestStartTime.Sub(r.RequestEndTime)
+ retryCount := r.Attempts - 1
+
+ awsRequestCount.WithLabelValues(r.Controller, r.Service, r.Region, r.OperationName, strconv.Itoa(r.StatusCode), r.ErrorCode).Inc()
+ awsRequestDurationSeconds.WithLabelValues(r.Controller, r.Service, r.Region, r.OperationName).Observe(requestDuration.Seconds())
+ awsCallRetries.WithLabelValues(r.Controller, r.Service, r.Region, r.OperationName).Observe(float64(retryCount))
+}
diff --git a/pkg/cloud/scope/clients.go b/pkg/cloud/scope/clients.go
index bd0fa05edf..7abde2b8da 100644
--- a/pkg/cloud/scope/clients.go
+++ b/pkg/cloud/scope/clients.go
@@ -17,6 +17,7 @@ limitations under the License.
package scope
import (
+ "github.com/aws/aws-sdk-go-v2/service/s3"
"github.com/aws/aws-sdk-go/aws"
"github.com/aws/aws-sdk-go/aws/awserr"
"github.com/aws/aws-sdk-go/aws/request"
@@ -36,8 +37,6 @@ import (
"github.com/aws/aws-sdk-go/service/iam/iamiface"
"github.com/aws/aws-sdk-go/service/resourcegroupstaggingapi"
"github.com/aws/aws-sdk-go/service/resourcegroupstaggingapi/resourcegroupstaggingapiiface"
- "github.com/aws/aws-sdk-go/service/s3"
- "github.com/aws/aws-sdk-go/service/s3/s3iface"
"github.com/aws/aws-sdk-go/service/secretsmanager"
"github.com/aws/aws-sdk-go/service/secretsmanager/secretsmanageriface"
"github.com/aws/aws-sdk-go/service/sqs"
@@ -49,8 +48,10 @@ import (
"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"
"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"
@@ -200,13 +201,21 @@ 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) s3iface.S3API {
- s3Client := s3.New(session.Session(), aws.NewConfig().WithLogLevel(awslogs.GetAWSLogLevel(logger.GetLogger())).WithLogger(awslogs.NewWrapLogr(logger.GetLogger())))
- s3Client.Handlers.Build.PushFrontNamed(getUserAgentHandler())
- s3Client.Handlers.CompleteAttempt.PushFront(awsmetrics.CaptureRequestMetrics(scopeUser.ControllerName()))
- s3Client.Handlers.Complete.PushBack(recordAWSPermissionsIssue(target))
-
- return s3Client
+func NewS3Client(scopeUser cloud.ScopeUsage, session cloud.Session, logger logger.Wrapper, target runtime.Object) *s3.Client {
+ cfg := session.SessionV2()
+ multiSvcEndpointResolver := endpointsv2.NewMultiServiceEndpointResolver()
+ s3EndpointResolver := &endpointsv2.S3EndpointResolver{
+ MultiServiceEndpointResolver: multiSvcEndpointResolver,
+ }
+ s3Opts := []func(*s3.Options){
+ func(o *s3.Options) {
+ o.Logger = logger.GetAWSLogger()
+ o.ClientLogMode = awslogs.GetAWSLogLevelV2(logger.GetLogger())
+ o.EndpointResolverV2 = s3EndpointResolver
+ },
+ s3.WithAPIOptions(awsmetricsv2.WithMiddlewares(scopeUser.ControllerName(), target)),
+ }
+ return s3.NewFromConfig(cfg, s3Opts...)
}
func recordAWSPermissionsIssue(target runtime.Object) func(r *request.Request) {
diff --git a/pkg/cloud/scope/cluster.go b/pkg/cloud/scope/cluster.go
index ddea8a4fcc..c115e70c1a 100644
--- a/pkg/cloud/scope/cluster.go
+++ b/pkg/cloud/scope/cluster.go
@@ -20,6 +20,7 @@ import (
"context"
"fmt"
+ awsv2 "github.com/aws/aws-sdk-go-v2/aws"
awsclient "github.com/aws/aws-sdk-go/aws/client"
"github.com/pkg/errors"
"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
@@ -45,6 +46,7 @@ type ClusterScopeParams struct {
ControllerName string
Endpoints []ServiceEndpoint
Session awsclient.ConfigProvider
+ SessionV2 awsv2.Config
TagUnmanagedNetworkResources bool
}
@@ -77,6 +79,11 @@ func NewClusterScope(params ClusterScopeParams) (*ClusterScope, error) {
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)
+ }
+
helper, err := patch.NewHelper(params.AWSCluster, params.Client)
if err != nil {
return nil, errors.Wrap(err, "failed to init patch helper")
@@ -84,7 +91,9 @@ func NewClusterScope(params ClusterScopeParams) (*ClusterScope, error) {
clusterScope.patchHelper = helper
clusterScope.session = session
+ clusterScope.sessionV2 = *sessionv2
clusterScope.serviceLimiters = serviceLimiters
+ clusterScope.serviceLimitersV2 = serviceLimitersv2
return clusterScope, nil
}
@@ -98,9 +107,11 @@ type ClusterScope struct {
Cluster *clusterv1.Cluster
AWSCluster *infrav1.AWSCluster
- session awsclient.ConfigProvider
- serviceLimiters throttle.ServiceLimiters
- controllerName string
+ session awsclient.ConfigProvider
+ sessionV2 awsv2.Config
+ serviceLimiters throttle.ServiceLimiters
+ serviceLimitersV2 throttle.ServiceLimiters
+ controllerName string
tagUnmanagedNetworkResources bool
}
@@ -351,6 +362,11 @@ func (s *ClusterScope) Session() awsclient.ConfigProvider {
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 a5addbe134..d70a518b7b 100644
--- a/pkg/cloud/scope/fargate.go
+++ b/pkg/cloud/scope/fargate.go
@@ -19,6 +19,7 @@ package scope
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"
@@ -74,22 +75,29 @@ func NewFargateProfileScope(params FargateProfileScopeParams) (*FargateProfileSc
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)
+ }
+
helper, err := patch.NewHelper(params.FargateProfile, params.Client)
if err != nil {
return nil, errors.Wrap(err, "failed to init patch helper")
}
return &FargateProfileScope{
- Logger: *params.Logger,
- Client: params.Client,
- Cluster: params.Cluster,
- ControlPlane: params.ControlPlane,
- FargateProfile: params.FargateProfile,
- patchHelper: helper,
- session: session,
- serviceLimiters: serviceLimiters,
- controllerName: params.ControllerName,
- enableIAM: params.EnableIAM,
+ Logger: *params.Logger,
+ Client: params.Client,
+ Cluster: params.Cluster,
+ ControlPlane: params.ControlPlane,
+ FargateProfile: params.FargateProfile,
+ patchHelper: helper,
+ session: session,
+ sessionV2: *sessionv2,
+ serviceLimiters: serviceLimiters,
+ serviceLimitersV2: serviceLimitersv2,
+ controllerName: params.ControllerName,
+ enableIAM: params.EnableIAM,
}, nil
}
@@ -103,9 +111,11 @@ type FargateProfileScope struct {
ControlPlane *ekscontrolplanev1.AWSManagedControlPlane
FargateProfile *expinfrav1.AWSFargateProfile
- session awsclient.ConfigProvider
- serviceLimiters throttle.ServiceLimiters
- controllerName string
+ session awsclient.ConfigProvider
+ sessionV2 awsv2.Config
+ serviceLimiters throttle.ServiceLimiters
+ serviceLimitersV2 throttle.ServiceLimiters
+ controllerName string
enableIAM bool
}
@@ -220,6 +230,11 @@ func (s *FargateProfileScope) Session() awsclient.ConfigProvider {
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 2ecc9dbf50..31bbd4a3f6 100644
--- a/pkg/cloud/scope/global.go
+++ b/pkg/cloud/scope/global.go
@@ -18,6 +18,7 @@ limitations under the License.
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"
@@ -36,8 +37,14 @@ func NewGlobalScope(params GlobalScopeParams) (*GlobalScope, error) {
if err != nil {
return nil, errors.Wrap(err, "failed to create aws session")
}
+
+ ns2, _, err := sessionForRegionV2(params.Region, params.Endpoints)
+ if err != nil {
+ return nil, errors.Wrap(err, "failed to create aws V2 session")
+ }
return &GlobalScope{
session: ns,
+ sessionV2: *ns2,
serviceLimiters: limiters,
controllerName: params.ControllerName,
}, nil
@@ -53,6 +60,7 @@ type GlobalScopeParams struct {
// GlobalScope defines the specs for the GlobalScope.
type GlobalScope struct {
session awsclient.ConfigProvider
+ sessionV2 awsv2.Config
serviceLimiters throttle.ServiceLimiters
controllerName string
}
@@ -62,6 +70,11 @@ func (s *GlobalScope) Session() awsclient.ConfigProvider {
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 14ded92263..34144ae1ce 100644
--- a/pkg/cloud/scope/managedcontrolplane.go
+++ b/pkg/cloud/scope/managedcontrolplane.go
@@ -22,6 +22,7 @@ import (
"time"
amazoncni "github.com/aws/amazon-vpc-cni-k8s/pkg/apis/crd/v1alpha1"
+ awsv2 "github.com/aws/aws-sdk-go-v2/aws"
awsclient "github.com/aws/aws-sdk-go/aws/client"
"github.com/pkg/errors"
appsv1 "k8s.io/api/apps/v1"
@@ -101,8 +102,15 @@ func NewManagedControlPlaneScope(params ManagedControlPlaneScopeParams) (*Manage
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 = session
+ managedScope.sessionV2 = *sessionv2
managedScope.serviceLimiters = serviceLimiters
+ managedScope.serviceLimitersV2 = serviceLimitersv2
helper, err := patch.NewHelper(params.ControlPlane, params.Client)
if err != nil {
@@ -122,9 +130,11 @@ type ManagedControlPlaneScope struct {
Cluster *clusterv1.Cluster
ControlPlane *ekscontrolplanev1.AWSManagedControlPlane
- session awsclient.ConfigProvider
- serviceLimiters throttle.ServiceLimiters
- controllerName string
+ session awsclient.ConfigProvider
+ sessionV2 awsv2.Config
+ serviceLimiters throttle.ServiceLimiters
+ serviceLimitersV2 throttle.ServiceLimiters
+ controllerName string
enableIAM bool
allowAdditionalRoles bool
@@ -326,6 +336,11 @@ func (s *ManagedControlPlaneScope) Session() awsclient.ConfigProvider {
return s.session
}
+// SessionV2 returns the AWS SDK config. Used for creating clients.
+func (s *ManagedControlPlaneScope) SessionV2() awsv2.Config {
+ return s.sessionV2
+}
+
// Bastion returns the bastion details.
func (s *ManagedControlPlaneScope) Bastion() *infrav1.Bastion {
return &s.ControlPlane.Spec.Bastion
diff --git a/pkg/cloud/scope/managednodegroup.go b/pkg/cloud/scope/managednodegroup.go
index 7411cc6df3..1f2b6b7dbd 100644
--- a/pkg/cloud/scope/managednodegroup.go
+++ b/pkg/cloud/scope/managednodegroup.go
@@ -20,6 +20,7 @@ import (
"context"
"fmt"
+ 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"
@@ -89,6 +90,11 @@ func NewManagedMachinePoolScope(params ManagedMachinePoolScopeParams) (*ManagedM
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)
+ }
+
ammpHelper, err := patch.NewHelper(params.ManagedMachinePool, params.Client)
if err != nil {
return nil, errors.Wrap(err, "failed to init AWSManagedMachinePool patch helper")
@@ -110,7 +116,9 @@ func NewManagedMachinePoolScope(params ManagedMachinePoolScopeParams) (*ManagedM
MachinePool: params.MachinePool,
EC2Scope: params.InfraCluster,
session: session,
+ sessionV2: *sessionv2,
serviceLimiters: serviceLimiters,
+ serviceLimitersV2: serviceLimitersv2,
controllerName: params.ControllerName,
enableIAM: params.EnableIAM,
allowAdditionalRoles: params.AllowAdditionalRoles,
@@ -130,9 +138,11 @@ type ManagedMachinePoolScope struct {
MachinePool *expclusterv1.MachinePool
EC2Scope EC2Scope
- session awsclient.ConfigProvider
- serviceLimiters throttle.ServiceLimiters
- controllerName string
+ session awsclient.ConfigProvider
+ sessionV2 awsv2.Config
+ serviceLimiters throttle.ServiceLimiters
+ serviceLimitersV2 throttle.ServiceLimiters
+ controllerName string
enableIAM bool
allowAdditionalRoles bool
@@ -301,6 +311,11 @@ func (s *ManagedMachinePoolScope) Session() awsclient.ConfigProvider {
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/scope/rosacontrolplane.go b/pkg/cloud/scope/rosacontrolplane.go
index 166620710b..5404102ad4 100644
--- a/pkg/cloud/scope/rosacontrolplane.go
+++ b/pkg/cloud/scope/rosacontrolplane.go
@@ -20,6 +20,7 @@ import (
"context"
"fmt"
+ awsv2 "github.com/aws/aws-sdk-go-v2/aws"
awsclient "github.com/aws/aws-sdk-go/aws/client"
"github.com/aws/aws-sdk-go/service/sts"
"github.com/aws/aws-sdk-go/service/sts/stsiface"
@@ -77,6 +78,11 @@ func NewROSAControlPlaneScope(params ROSAControlPlaneScopeParams) (*ROSAControlP
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)
+ }
+
helper, err := patch.NewHelper(params.ControlPlane, params.Client)
if err != nil {
return nil, errors.Wrap(err, "failed to init patch helper")
@@ -84,7 +90,9 @@ func NewROSAControlPlaneScope(params ROSAControlPlaneScopeParams) (*ROSAControlP
managedScope.patchHelper = helper
managedScope.session = session
+ managedScope.sessionV2 = *sessionv2
managedScope.serviceLimiters = serviceLimiters
+ managedScope.serviceLimitersV2 = serviceLimitersv2
stsClient := params.NewStsClient(managedScope, managedScope, managedScope, managedScope.ControlPlane)
identity, err := stsClient.GetCallerIdentity(&sts.GetCallerIdentityInput{})
@@ -105,10 +113,12 @@ type ROSAControlPlaneScope struct {
Cluster *clusterv1.Cluster
ControlPlane *rosacontrolplanev1.ROSAControlPlane
- session awsclient.ConfigProvider
- serviceLimiters throttle.ServiceLimiters
- controllerName string
- Identity *sts.GetCallerIdentityOutput
+ session awsclient.ConfigProvider
+ sessionV2 awsv2.Config
+ serviceLimiters throttle.ServiceLimiters
+ serviceLimitersV2 throttle.ServiceLimiters
+ controllerName string
+ Identity *sts.GetCallerIdentityOutput
}
// InfraCluster returns the AWSManagedControlPlane object.
@@ -126,6 +136,11 @@ func (s *ROSAControlPlaneScope) Session() awsclient.ConfigProvider {
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 2904cc36ac..9155bc450d 100644
--- a/pkg/cloud/scope/rosamachinepool.go
+++ b/pkg/cloud/scope/rosamachinepool.go
@@ -19,6 +19,7 @@ package scope
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"
@@ -93,8 +94,15 @@ func NewRosaMachinePoolScope(params RosaMachinePoolScopeParams) (*RosaMachinePoo
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 = session
+ scope.sessionV2 = *sessionv2
scope.serviceLimiters = serviceLimiters
+ scope.serviceLimitersV2 = serviceLimitersv2
return scope, nil
}
@@ -114,8 +122,10 @@ type RosaMachinePoolScope struct {
RosaMachinePool *expinfrav1.ROSAMachinePool
MachinePool *expclusterv1.MachinePool
- session awsclient.ConfigProvider
- serviceLimiters throttle.ServiceLimiters
+ session awsclient.ConfigProvider
+ sessionV2 awsv2.Config
+ serviceLimiters throttle.ServiceLimiters
+ serviceLimitersV2 throttle.ServiceLimiters
controllerName string
}
@@ -174,6 +184,11 @@ func (s *RosaMachinePoolScope) Session() awsclient.ConfigProvider {
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/scope/session.go b/pkg/cloud/scope/session.go
index 4e3c891d44..3dc86042fc 100644
--- a/pkg/cloud/scope/session.go
+++ b/pkg/cloud/scope/session.go
@@ -21,6 +21,8 @@ import (
"fmt"
"sync"
+ awsv2 "github.com/aws/aws-sdk-go-v2/aws"
+ "github.com/aws/aws-sdk-go-v2/config"
"github.com/aws/aws-sdk-go/aws"
"github.com/aws/aws-sdk-go/aws/credentials"
"github.com/aws/aws-sdk-go/aws/endpoints"
@@ -39,6 +41,7 @@ import (
infrav1 "sigs.k8s.io/cluster-api-provider-aws/v2/api/v1beta2"
"sigs.k8s.io/cluster-api-provider-aws/v2/pkg/cloud"
"sigs.k8s.io/cluster-api-provider-aws/v2/pkg/cloud/identity"
+ "sigs.k8s.io/cluster-api-provider-aws/v2/pkg/cloud/identityv2"
"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/util/system"
@@ -60,10 +63,13 @@ type ServiceEndpoint struct {
}
var sessionCache sync.Map
+var sessionCacheV2 sync.Map
var providerCache sync.Map
+var providerCacheV2 sync.Map
type sessionCacheEntry struct {
session *session.Session
+ sessionV2 *awsv2.Config
serviceLimiters throttle.ServiceLimiters
}
@@ -71,6 +77,12 @@ type sessionCacheEntry struct {
var SessionInterface interface {
}
+// ChainCredentialsProvider defines custom CredentialsProvider chain
+// NewChainCredentialsProvider can be used to initialize this struct.
+type ChainCredentialsProvider struct {
+ providers []awsv2.CredentialsProvider
+}
+
func sessionForRegion(region string, endpoint []ServiceEndpoint) (*session.Session, throttle.ServiceLimiters, error) {
if s, ok := sessionCache.Load(region); ok {
entry := s.(*sessionCacheEntry)
@@ -100,10 +112,36 @@ func sessionForRegion(region string, endpoint []ServiceEndpoint) (*session.Sessi
sessionCache.Store(region, &sessionCacheEntry{
session: ns,
serviceLimiters: sl,
+ sessionV2: nil,
})
return ns, sl, nil
}
+func sessionForRegionV2(region string, _ []ServiceEndpoint) (*awsv2.Config, throttle.ServiceLimiters, error) {
+ if s, ok := sessionCacheV2.Load(region); ok {
+ entry := s.(*sessionCacheEntry)
+ return entry.sessionV2, entry.serviceLimiters, nil
+ }
+
+ optFns := []func(*config.LoadOptions) error{
+ config.WithRegion(region),
+ }
+ ns, err := config.LoadDefaultConfig(context.Background(), optFns...)
+
+ if err != nil {
+ return nil, nil, err
+ }
+
+ sl := newServiceLimiters()
+ sessionCacheV2.Store(region, &sessionCacheEntry{
+ sessionV2: &ns,
+ serviceLimiters: sl,
+ session: nil,
+ })
+ return &ns, sl, nil
+}
+
+// TODO: mjlshen rewrite this for aws-sdk-go-v2.
func sessionForClusterWithRegion(k8sClient client.Client, clusterScoper cloud.SessionMetadata, region string, endpoint []ServiceEndpoint, log logger.Wrapper) (*session.Session, throttle.ServiceLimiters, error) {
log = log.WithName("identity")
log.Trace("Creating an AWS Session")
@@ -181,11 +219,84 @@ func sessionForClusterWithRegion(k8sClient client.Client, clusterScoper cloud.Se
sessionCache.Store(getSessionName(region, clusterScoper), &sessionCacheEntry{
session: ns,
serviceLimiters: sl,
+ sessionV2: nil,
})
return ns, 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")
+
+ providers, err := getProvidersForClusterV2(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, nil, errors.Wrap(err, "Failed to get providers for cluster")
+ }
+
+ isChanged := false
+ awsProviders := make([]awsv2.CredentialsProvider, 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, nil, errors.Wrap(err, "Failed to calculate provider hash")
+ }
+ cachedProvider, ok := providerCacheV2.Load(providerHash)
+ if ok {
+ provider = cachedProvider.(identityv2.AWSPrincipalTypeProvider)
+ } else {
+ isChanged = true
+ // add this provider to the cache
+ providerCacheV2.Store(providerHash, provider)
+ }
+ awsProviders[i] = provider.(awsv2.CredentialsProvider)
+ }
+
+ if !isChanged {
+ if s, ok := sessionCacheV2.Load(getSessionName(region, clusterScoper)); ok {
+ entry := s.(*sessionCacheEntry)
+ return entry.sessionV2, entry.serviceLimiters, nil
+ }
+ }
+
+ optFns := []func(*config.LoadOptions) error{
+ config.WithRegion(region),
+ }
+
+ 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(context.Background())
+ 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, nil, errors.Wrap(err, "Failed to retrieve identity credentials")
+ }
+ chainProvider := NewChainCredentialsProvider(awsProviders)
+ optFns = append(optFns, config.WithCredentialsProvider(chainProvider))
+ }
+
+ conditions.MarkTrue(clusterScoper.InfraCluster(), infrav1.PrincipalCredentialRetrievedCondition)
+
+ ns, err := config.LoadDefaultConfig(context.Background(), optFns...)
+ if err != nil {
+ return nil, nil, errors.Wrap(err, "Failed to create a new AWS session")
+ }
+ sl := newServiceLimiters()
+ sessionCacheV2.Store(getSessionName(region, clusterScoper), &sessionCacheEntry{
+ sessionV2: &ns,
+ serviceLimiters: sl,
+ session: nil,
+ })
+
+ return &ns, sl, nil
+}
+
func getSessionName(region string, clusterScoper cloud.SessionMetadata) string {
return fmt.Sprintf("%s-%s-%s", region, clusterScoper.InfraClusterName(), clusterScoper.Namespace())
}
@@ -323,6 +434,79 @@ func buildProvidersForRef(
return providers, nil
}
+func buildProvidersForRefV2(
+ ctx context.Context,
+ providers []identityv2.AWSPrincipalTypeProvider,
+ k8sClient client.Client,
+ clusterScoper cloud.SessionMetadata,
+ ref *infrav1.AWSIdentityReference,
+ region string,
+ log logger.Wrapper) ([]identityv2.AWSPrincipalTypeProvider, error) {
+ if ref == nil {
+ log.Trace("AWSCluster does not have a IdentityRef specified")
+ return providers, nil
+ }
+
+ var provider identityv2.AWSPrincipalTypeProvider
+ identityObjectKey := client.ObjectKey{Name: ref.Name}
+ log = log.WithValues("identityKey", identityObjectKey)
+ log.Trace("Getting identity")
+
+ switch ref.Kind {
+ case infrav1.ControllerIdentityKind:
+ err := buildAWSClusterControllerIdentity(ctx, identityObjectKey, k8sClient, clusterScoper)
+ if err != nil {
+ return providers, err
+ }
+ // returning empty provider list to default to Controller Principal.
+ return []identityv2.AWSPrincipalTypeProvider{}, nil
+ case infrav1.ClusterStaticIdentityKind:
+ provider, err := buildAWSClusterStaticIdentityV2(ctx, identityObjectKey, k8sClient, clusterScoper)
+ if err != nil {
+ return providers, err
+ }
+ providers = append(providers, provider)
+ case infrav1.ClusterRoleIdentityKind:
+ roleIdentity := &infrav1.AWSClusterRoleIdentity{}
+ err := k8sClient.Get(ctx, identityObjectKey, roleIdentity)
+ if err != nil {
+ return providers, err
+ }
+ log.Trace("Principal retrieved")
+ canUse, err := isClusterPermittedToUsePrincipal(k8sClient, roleIdentity.Spec.AllowedNamespaces, clusterScoper.Namespace())
+ if err != nil {
+ return providers, err
+ }
+ if !canUse {
+ setPrincipalUsageNotAllowedCondition(infrav1.ClusterRoleIdentityKind, identityObjectKey, clusterScoper)
+ return providers, errors.Errorf(notPermittedError, infrav1.ClusterRoleIdentityKind, roleIdentity.Name)
+ }
+ setPrincipalUsageAllowedCondition(clusterScoper)
+
+ if roleIdentity.Spec.SourceIdentityRef != nil {
+ providers, err = buildProvidersForRefV2(ctx, providers, k8sClient, clusterScoper, roleIdentity.Spec.SourceIdentityRef, region, log)
+ if err != nil {
+ return providers, err
+ }
+ }
+ var sourceProvider identityv2.AWSPrincipalTypeProvider
+ if len(providers) > 0 {
+ sourceProvider = providers[len(providers)-1]
+ // Remove last provider
+ if len(providers) > 0 {
+ providers = providers[:len(providers)-1]
+ }
+ }
+
+ provider = identityv2.NewAWSRolePrincipalTypeProvider(roleIdentity, sourceProvider, region, log)
+ providers = append(providers, provider)
+ default:
+ return providers, errors.Errorf("No such provider known: '%s'", ref.Kind)
+ }
+ conditions.MarkTrue(clusterScoper.InfraCluster(), infrav1.PrincipalUsageAllowedCondition)
+ return providers, nil
+}
+
func setPrincipalUsageAllowedCondition(clusterScoper cloud.SessionMetadata) {
conditions.MarkTrue(clusterScoper.InfraCluster(), infrav1.PrincipalUsageAllowedCondition)
}
@@ -379,6 +563,48 @@ func buildAWSClusterStaticIdentity(ctx context.Context, identityObjectKey client
return identity.NewAWSStaticPrincipalTypeProvider(staticPrincipal, secret), nil
}
+func buildAWSClusterStaticIdentityV2(ctx context.Context, identityObjectKey client.ObjectKey, k8sClient client.Client, clusterScoper cloud.SessionMetadata) (*identityv2.AWSStaticPrincipalTypeProvider, error) {
+ staticPrincipal := &infrav1.AWSClusterStaticIdentity{}
+ err := k8sClient.Get(ctx, identityObjectKey, staticPrincipal)
+ if err != nil {
+ return nil, err
+ }
+ secret := &corev1.Secret{}
+ err = k8sClient.Get(ctx, client.ObjectKey{Name: staticPrincipal.Spec.SecretRef, Namespace: system.GetManagerNamespace()}, secret)
+ if err != nil {
+ return nil, err
+ }
+
+ // Set ClusterStaticPrincipal as Secret's owner reference for 'clusterctl move'.
+ patchHelper, err := patch.NewHelper(secret, k8sClient)
+ if err != nil {
+ return nil, errors.Wrapf(err, "failed to init patch helper for secret name:%s namespace:%s", secret.Name, secret.Namespace)
+ }
+
+ secret.OwnerReferences = util.EnsureOwnerRef(secret.OwnerReferences, metav1.OwnerReference{
+ APIVersion: infrav1.GroupVersion.String(),
+ Kind: string(infrav1.ClusterStaticIdentityKind),
+ Name: staticPrincipal.Name,
+ UID: staticPrincipal.UID,
+ })
+
+ if err := patchHelper.Patch(ctx, secret); err != nil {
+ return nil, errors.Wrapf(err, "failed to patch secret name:%s namespace:%s", secret.Name, secret.Namespace)
+ }
+
+ canUse, err := isClusterPermittedToUsePrincipal(k8sClient, staticPrincipal.Spec.AllowedNamespaces, clusterScoper.Namespace())
+ if err != nil {
+ return nil, err
+ }
+ if !canUse {
+ setPrincipalUsageNotAllowedCondition(infrav1.ClusterStaticIdentityKind, identityObjectKey, clusterScoper)
+ return nil, errors.Errorf(notPermittedError, infrav1.ClusterStaticIdentityKind, identityObjectKey.Name)
+ }
+ setPrincipalUsageAllowedCondition(clusterScoper)
+
+ return identityv2.NewAWSStaticPrincipalTypeProvider(staticPrincipal, secret), nil
+}
+
func buildAWSClusterControllerIdentity(ctx context.Context, identityObjectKey client.ObjectKey, k8sClient client.Client, clusterScoper cloud.SessionMetadata) error {
controllerIdentity := &infrav1.AWSClusterControllerIdentity{}
controllerIdentity.Kind = string(infrav1.ControllerIdentityKind)
@@ -415,6 +641,16 @@ func getProvidersForCluster(ctx context.Context, k8sClient client.Client, cluste
return providers, nil
}
+func getProvidersForClusterV2(ctx context.Context, k8sClient client.Client, clusterScoper cloud.SessionMetadata, region string, log logger.Wrapper) ([]identityv2.AWSPrincipalTypeProvider, error) {
+ providers := make([]identityv2.AWSPrincipalTypeProvider, 0)
+ providers, err := buildProvidersForRefV2(ctx, providers, k8sClient, clusterScoper, clusterScoper.IdentityRef(), region, log)
+ if err != nil {
+ return nil, err
+ }
+
+ return providers, nil
+}
+
func isClusterPermittedToUsePrincipal(k8sClient client.Client, allowedNs *infrav1.AllowedNamespaces, clusterNamespace string) (bool, error) {
// nil value does not match with any namespaces
if allowedNs == nil {
@@ -456,3 +692,27 @@ func isClusterPermittedToUsePrincipal(k8sClient client.Client, allowedNs *infrav
}
return false, nil
}
+
+// NewChainCredentialsProvider initializes a new ChainCredentialsProvider.
+func NewChainCredentialsProvider(providers []awsv2.CredentialsProvider) *ChainCredentialsProvider {
+ return &ChainCredentialsProvider{
+ providers: providers,
+ }
+}
+
+// Retrieve implements aws.CredentialsProvider for custom list of credenetials providers.
+// The first provider in the list without error will be used to return credentials.
+func (c *ChainCredentialsProvider) Retrieve(ctx context.Context) (awsv2.Credentials, error) {
+ var lastErr error
+ for _, provider := range c.providers {
+ creds, err := provider.Retrieve(ctx)
+ if err != nil {
+ lastErr = err
+ continue
+ }
+ if creds.AccessKeyID != "" && creds.SecretAccessKey != "" {
+ return creds, nil
+ }
+ }
+ return awsv2.Credentials{}, lastErr
+}
diff --git a/pkg/cloud/services/interfaces.go b/pkg/cloud/services/interfaces.go
index 5e0f3dc2e6..c792214360 100644
--- a/pkg/cloud/services/interfaces.go
+++ b/pkg/cloud/services/interfaces.go
@@ -133,10 +133,10 @@ type SecurityGroupInterface interface {
// ObjectStoreInterface encapsulates the methods exposed to the machine actuator.
type ObjectStoreInterface interface {
- DeleteBucket() error
- ReconcileBucket() error
- Delete(m *scope.MachineScope) error
- Create(m *scope.MachineScope, data []byte) (objectURL string, err error)
+ DeleteBucket(ctx context.Context) error
+ ReconcileBucket(ctx context.Context) error
+ Delete(ctx context.Context, m *scope.MachineScope) error
+ Create(ctx context.Context, m *scope.MachineScope, data []byte) (objectURL string, err error)
}
// AWSNodeInterface installs the CNI for EKS clusters.
diff --git a/pkg/cloud/services/mock_services/objectstore_machine_interface_mock.go b/pkg/cloud/services/mock_services/objectstore_machine_interface_mock.go
index 559f356f3a..39bbe0d8f5 100644
--- a/pkg/cloud/services/mock_services/objectstore_machine_interface_mock.go
+++ b/pkg/cloud/services/mock_services/objectstore_machine_interface_mock.go
@@ -21,6 +21,7 @@ limitations under the License.
package mock_services
import (
+ context "context"
reflect "reflect"
gomock "github.com/golang/mock/gomock"
@@ -51,58 +52,58 @@ func (m *MockObjectStoreInterface) EXPECT() *MockObjectStoreInterfaceMockRecorde
}
// Create mocks base method.
-func (m *MockObjectStoreInterface) Create(arg0 *scope.MachineScope, arg1 []byte) (string, error) {
+func (m *MockObjectStoreInterface) Create(arg0 context.Context, arg1 *scope.MachineScope, arg2 []byte) (string, error) {
m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "Create", arg0, arg1)
+ ret := m.ctrl.Call(m, "Create", arg0, arg1, arg2)
ret0, _ := ret[0].(string)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// Create indicates an expected call of Create.
-func (mr *MockObjectStoreInterfaceMockRecorder) Create(arg0, arg1 interface{}) *gomock.Call {
+func (mr *MockObjectStoreInterfaceMockRecorder) Create(arg0, arg1, arg2 interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockObjectStoreInterface)(nil).Create), arg0, arg1)
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockObjectStoreInterface)(nil).Create), arg0, arg1, arg2)
}
// Delete mocks base method.
-func (m *MockObjectStoreInterface) Delete(arg0 *scope.MachineScope) error {
+func (m *MockObjectStoreInterface) Delete(arg0 context.Context, arg1 *scope.MachineScope) error {
m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "Delete", arg0)
+ ret := m.ctrl.Call(m, "Delete", arg0, arg1)
ret0, _ := ret[0].(error)
return ret0
}
// Delete indicates an expected call of Delete.
-func (mr *MockObjectStoreInterfaceMockRecorder) Delete(arg0 interface{}) *gomock.Call {
+func (mr *MockObjectStoreInterfaceMockRecorder) Delete(arg0, arg1 interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockObjectStoreInterface)(nil).Delete), arg0)
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockObjectStoreInterface)(nil).Delete), arg0, arg1)
}
// DeleteBucket mocks base method.
-func (m *MockObjectStoreInterface) DeleteBucket() error {
+func (m *MockObjectStoreInterface) DeleteBucket(arg0 context.Context) error {
m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "DeleteBucket")
+ ret := m.ctrl.Call(m, "DeleteBucket", arg0)
ret0, _ := ret[0].(error)
return ret0
}
// DeleteBucket indicates an expected call of DeleteBucket.
-func (mr *MockObjectStoreInterfaceMockRecorder) DeleteBucket() *gomock.Call {
+func (mr *MockObjectStoreInterfaceMockRecorder) DeleteBucket(arg0 interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteBucket", reflect.TypeOf((*MockObjectStoreInterface)(nil).DeleteBucket))
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteBucket", reflect.TypeOf((*MockObjectStoreInterface)(nil).DeleteBucket), arg0)
}
// ReconcileBucket mocks base method.
-func (m *MockObjectStoreInterface) ReconcileBucket() error {
+func (m *MockObjectStoreInterface) ReconcileBucket(arg0 context.Context) error {
m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "ReconcileBucket")
+ ret := m.ctrl.Call(m, "ReconcileBucket", arg0)
ret0, _ := ret[0].(error)
return ret0
}
// ReconcileBucket indicates an expected call of ReconcileBucket.
-func (mr *MockObjectStoreInterfaceMockRecorder) ReconcileBucket() *gomock.Call {
+func (mr *MockObjectStoreInterfaceMockRecorder) ReconcileBucket(arg0 interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReconcileBucket", reflect.TypeOf((*MockObjectStoreInterface)(nil).ReconcileBucket))
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReconcileBucket", reflect.TypeOf((*MockObjectStoreInterface)(nil).ReconcileBucket), arg0)
}
diff --git a/pkg/cloud/services/s3/mock_s3iface/doc.go b/pkg/cloud/services/s3/mock_s3iface/doc.go
index 4b8b857f37..84c7814b29 100644
--- a/pkg/cloud/services/s3/mock_s3iface/doc.go
+++ b/pkg/cloud/services/s3/mock_s3iface/doc.go
@@ -14,9 +14,9 @@ See the License for the specific language governing permissions and
limitations under the License.
*/
-// Package mock_s3iface provides a mock implementation of the s3iface.S3API interface
+// Package mock_s3iface provides a mock implementation of the S3API interface
// Run go generate to regenerate this mock.
//
-//go:generate ../../../../../hack/tools/bin/mockgen -destination s3api_mock.go -package mock_s3iface github.com/aws/aws-sdk-go/service/s3/s3iface S3API
+//go:generate ../../../../../hack/tools/bin/mockgen -destination s3api_mock.go -package mock_s3iface sigs.k8s.io/cluster-api-provider-aws/v2/pkg/cloud/services/s3 S3API
//go:generate /usr/bin/env bash -c "cat ../../../../../hack/boilerplate/boilerplate.generatego.txt s3api_mock.go > _s3api_mock.go && mv _s3api_mock.go s3api_mock.go"
package mock_s3iface //nolint:stylecheck
diff --git a/pkg/cloud/services/s3/mock_s3iface/s3api_mock.go b/pkg/cloud/services/s3/mock_s3iface/s3api_mock.go
index 121d3df3fb..c64985ef8e 100644
--- a/pkg/cloud/services/s3/mock_s3iface/s3api_mock.go
+++ b/pkg/cloud/services/s3/mock_s3iface/s3api_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/s3/s3iface (interfaces: S3API)
+// Source: sigs.k8s.io/cluster-api-provider-aws/v2/pkg/cloud/services/s3 (interfaces: S3API)
// Package mock_s3iface is a generated GoMock package.
package mock_s3iface
@@ -24,8 +24,7 @@ import (
context "context"
reflect "reflect"
- request "github.com/aws/aws-sdk-go/aws/request"
- s3 "github.com/aws/aws-sdk-go/service/s3"
+ s3 "github.com/aws/aws-sdk-go-v2/service/s3"
gomock "github.com/golang/mock/gomock"
)
@@ -52,5282 +51,142 @@ func (m *MockS3API) EXPECT() *MockS3APIMockRecorder {
return m.recorder
}
-// AbortMultipartUpload mocks base method.
-func (m *MockS3API) AbortMultipartUpload(arg0 *s3.AbortMultipartUploadInput) (*s3.AbortMultipartUploadOutput, error) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "AbortMultipartUpload", arg0)
- ret0, _ := ret[0].(*s3.AbortMultipartUploadOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// AbortMultipartUpload indicates an expected call of AbortMultipartUpload.
-func (mr *MockS3APIMockRecorder) AbortMultipartUpload(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AbortMultipartUpload", reflect.TypeOf((*MockS3API)(nil).AbortMultipartUpload), arg0)
-}
-
-// AbortMultipartUploadRequest mocks base method.
-func (m *MockS3API) AbortMultipartUploadRequest(arg0 *s3.AbortMultipartUploadInput) (*request.Request, *s3.AbortMultipartUploadOutput) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "AbortMultipartUploadRequest", arg0)
- ret0, _ := ret[0].(*request.Request)
- ret1, _ := ret[1].(*s3.AbortMultipartUploadOutput)
- return ret0, ret1
-}
-
-// AbortMultipartUploadRequest indicates an expected call of AbortMultipartUploadRequest.
-func (mr *MockS3APIMockRecorder) AbortMultipartUploadRequest(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AbortMultipartUploadRequest", reflect.TypeOf((*MockS3API)(nil).AbortMultipartUploadRequest), arg0)
-}
-
-// AbortMultipartUploadWithContext mocks base method.
-func (m *MockS3API) AbortMultipartUploadWithContext(arg0 context.Context, arg1 *s3.AbortMultipartUploadInput, arg2 ...request.Option) (*s3.AbortMultipartUploadOutput, error) {
- m.ctrl.T.Helper()
- varargs := []interface{}{arg0, arg1}
- for _, a := range arg2 {
- varargs = append(varargs, a)
- }
- ret := m.ctrl.Call(m, "AbortMultipartUploadWithContext", varargs...)
- ret0, _ := ret[0].(*s3.AbortMultipartUploadOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// AbortMultipartUploadWithContext indicates an expected call of AbortMultipartUploadWithContext.
-func (mr *MockS3APIMockRecorder) AbortMultipartUploadWithContext(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, "AbortMultipartUploadWithContext", reflect.TypeOf((*MockS3API)(nil).AbortMultipartUploadWithContext), varargs...)
-}
-
-// CompleteMultipartUpload mocks base method.
-func (m *MockS3API) CompleteMultipartUpload(arg0 *s3.CompleteMultipartUploadInput) (*s3.CompleteMultipartUploadOutput, error) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "CompleteMultipartUpload", arg0)
- ret0, _ := ret[0].(*s3.CompleteMultipartUploadOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// CompleteMultipartUpload indicates an expected call of CompleteMultipartUpload.
-func (mr *MockS3APIMockRecorder) CompleteMultipartUpload(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CompleteMultipartUpload", reflect.TypeOf((*MockS3API)(nil).CompleteMultipartUpload), arg0)
-}
-
-// CompleteMultipartUploadRequest mocks base method.
-func (m *MockS3API) CompleteMultipartUploadRequest(arg0 *s3.CompleteMultipartUploadInput) (*request.Request, *s3.CompleteMultipartUploadOutput) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "CompleteMultipartUploadRequest", arg0)
- ret0, _ := ret[0].(*request.Request)
- ret1, _ := ret[1].(*s3.CompleteMultipartUploadOutput)
- return ret0, ret1
-}
-
-// CompleteMultipartUploadRequest indicates an expected call of CompleteMultipartUploadRequest.
-func (mr *MockS3APIMockRecorder) CompleteMultipartUploadRequest(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CompleteMultipartUploadRequest", reflect.TypeOf((*MockS3API)(nil).CompleteMultipartUploadRequest), arg0)
-}
-
-// CompleteMultipartUploadWithContext mocks base method.
-func (m *MockS3API) CompleteMultipartUploadWithContext(arg0 context.Context, arg1 *s3.CompleteMultipartUploadInput, arg2 ...request.Option) (*s3.CompleteMultipartUploadOutput, error) {
- m.ctrl.T.Helper()
- varargs := []interface{}{arg0, arg1}
- for _, a := range arg2 {
- varargs = append(varargs, a)
- }
- ret := m.ctrl.Call(m, "CompleteMultipartUploadWithContext", varargs...)
- ret0, _ := ret[0].(*s3.CompleteMultipartUploadOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// CompleteMultipartUploadWithContext indicates an expected call of CompleteMultipartUploadWithContext.
-func (mr *MockS3APIMockRecorder) CompleteMultipartUploadWithContext(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, "CompleteMultipartUploadWithContext", reflect.TypeOf((*MockS3API)(nil).CompleteMultipartUploadWithContext), varargs...)
-}
-
-// CopyObject mocks base method.
-func (m *MockS3API) CopyObject(arg0 *s3.CopyObjectInput) (*s3.CopyObjectOutput, error) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "CopyObject", arg0)
- ret0, _ := ret[0].(*s3.CopyObjectOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// CopyObject indicates an expected call of CopyObject.
-func (mr *MockS3APIMockRecorder) CopyObject(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CopyObject", reflect.TypeOf((*MockS3API)(nil).CopyObject), arg0)
-}
-
-// CopyObjectRequest mocks base method.
-func (m *MockS3API) CopyObjectRequest(arg0 *s3.CopyObjectInput) (*request.Request, *s3.CopyObjectOutput) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "CopyObjectRequest", arg0)
- ret0, _ := ret[0].(*request.Request)
- ret1, _ := ret[1].(*s3.CopyObjectOutput)
- return ret0, ret1
-}
-
-// CopyObjectRequest indicates an expected call of CopyObjectRequest.
-func (mr *MockS3APIMockRecorder) CopyObjectRequest(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CopyObjectRequest", reflect.TypeOf((*MockS3API)(nil).CopyObjectRequest), arg0)
-}
-
-// CopyObjectWithContext mocks base method.
-func (m *MockS3API) CopyObjectWithContext(arg0 context.Context, arg1 *s3.CopyObjectInput, arg2 ...request.Option) (*s3.CopyObjectOutput, error) {
- m.ctrl.T.Helper()
- varargs := []interface{}{arg0, arg1}
- for _, a := range arg2 {
- varargs = append(varargs, a)
- }
- ret := m.ctrl.Call(m, "CopyObjectWithContext", varargs...)
- ret0, _ := ret[0].(*s3.CopyObjectOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// CopyObjectWithContext indicates an expected call of CopyObjectWithContext.
-func (mr *MockS3APIMockRecorder) CopyObjectWithContext(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, "CopyObjectWithContext", reflect.TypeOf((*MockS3API)(nil).CopyObjectWithContext), varargs...)
-}
-
// CreateBucket mocks base method.
-func (m *MockS3API) CreateBucket(arg0 *s3.CreateBucketInput) (*s3.CreateBucketOutput, error) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "CreateBucket", arg0)
- ret0, _ := ret[0].(*s3.CreateBucketOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// CreateBucket indicates an expected call of CreateBucket.
-func (mr *MockS3APIMockRecorder) CreateBucket(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateBucket", reflect.TypeOf((*MockS3API)(nil).CreateBucket), arg0)
-}
-
-// CreateBucketRequest mocks base method.
-func (m *MockS3API) CreateBucketRequest(arg0 *s3.CreateBucketInput) (*request.Request, *s3.CreateBucketOutput) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "CreateBucketRequest", arg0)
- ret0, _ := ret[0].(*request.Request)
- ret1, _ := ret[1].(*s3.CreateBucketOutput)
- return ret0, ret1
-}
-
-// CreateBucketRequest indicates an expected call of CreateBucketRequest.
-func (mr *MockS3APIMockRecorder) CreateBucketRequest(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateBucketRequest", reflect.TypeOf((*MockS3API)(nil).CreateBucketRequest), arg0)
-}
-
-// CreateBucketWithContext mocks base method.
-func (m *MockS3API) CreateBucketWithContext(arg0 context.Context, arg1 *s3.CreateBucketInput, arg2 ...request.Option) (*s3.CreateBucketOutput, error) {
+func (m *MockS3API) CreateBucket(arg0 context.Context, arg1 *s3.CreateBucketInput, arg2 ...func(*s3.Options)) (*s3.CreateBucketOutput, error) {
m.ctrl.T.Helper()
varargs := []interface{}{arg0, arg1}
for _, a := range arg2 {
varargs = append(varargs, a)
}
- ret := m.ctrl.Call(m, "CreateBucketWithContext", varargs...)
+ ret := m.ctrl.Call(m, "CreateBucket", varargs...)
ret0, _ := ret[0].(*s3.CreateBucketOutput)
ret1, _ := ret[1].(error)
return ret0, ret1
}
-// CreateBucketWithContext indicates an expected call of CreateBucketWithContext.
-func (mr *MockS3APIMockRecorder) CreateBucketWithContext(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, "CreateBucketWithContext", reflect.TypeOf((*MockS3API)(nil).CreateBucketWithContext), varargs...)
-}
-
-// CreateMultipartUpload mocks base method.
-func (m *MockS3API) CreateMultipartUpload(arg0 *s3.CreateMultipartUploadInput) (*s3.CreateMultipartUploadOutput, error) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "CreateMultipartUpload", arg0)
- ret0, _ := ret[0].(*s3.CreateMultipartUploadOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// CreateMultipartUpload indicates an expected call of CreateMultipartUpload.
-func (mr *MockS3APIMockRecorder) CreateMultipartUpload(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateMultipartUpload", reflect.TypeOf((*MockS3API)(nil).CreateMultipartUpload), arg0)
-}
-
-// CreateMultipartUploadRequest mocks base method.
-func (m *MockS3API) CreateMultipartUploadRequest(arg0 *s3.CreateMultipartUploadInput) (*request.Request, *s3.CreateMultipartUploadOutput) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "CreateMultipartUploadRequest", arg0)
- ret0, _ := ret[0].(*request.Request)
- ret1, _ := ret[1].(*s3.CreateMultipartUploadOutput)
- return ret0, ret1
-}
-
-// CreateMultipartUploadRequest indicates an expected call of CreateMultipartUploadRequest.
-func (mr *MockS3APIMockRecorder) CreateMultipartUploadRequest(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateMultipartUploadRequest", reflect.TypeOf((*MockS3API)(nil).CreateMultipartUploadRequest), arg0)
-}
-
-// CreateMultipartUploadWithContext mocks base method.
-func (m *MockS3API) CreateMultipartUploadWithContext(arg0 context.Context, arg1 *s3.CreateMultipartUploadInput, arg2 ...request.Option) (*s3.CreateMultipartUploadOutput, error) {
- m.ctrl.T.Helper()
- varargs := []interface{}{arg0, arg1}
- for _, a := range arg2 {
- varargs = append(varargs, a)
- }
- ret := m.ctrl.Call(m, "CreateMultipartUploadWithContext", varargs...)
- ret0, _ := ret[0].(*s3.CreateMultipartUploadOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// CreateMultipartUploadWithContext indicates an expected call of CreateMultipartUploadWithContext.
-func (mr *MockS3APIMockRecorder) CreateMultipartUploadWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+// CreateBucket indicates an expected call of CreateBucket.
+func (mr *MockS3APIMockRecorder) CreateBucket(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, "CreateMultipartUploadWithContext", reflect.TypeOf((*MockS3API)(nil).CreateMultipartUploadWithContext), varargs...)
-}
-
-// CreateSession mocks base method.
-func (m *MockS3API) CreateSession(arg0 *s3.CreateSessionInput) (*s3.CreateSessionOutput, error) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "CreateSession", arg0)
- ret0, _ := ret[0].(*s3.CreateSessionOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// CreateSession indicates an expected call of CreateSession.
-func (mr *MockS3APIMockRecorder) CreateSession(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateSession", reflect.TypeOf((*MockS3API)(nil).CreateSession), arg0)
-}
-
-// CreateSessionRequest mocks base method.
-func (m *MockS3API) CreateSessionRequest(arg0 *s3.CreateSessionInput) (*request.Request, *s3.CreateSessionOutput) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "CreateSessionRequest", arg0)
- ret0, _ := ret[0].(*request.Request)
- ret1, _ := ret[1].(*s3.CreateSessionOutput)
- return ret0, ret1
-}
-
-// CreateSessionRequest indicates an expected call of CreateSessionRequest.
-func (mr *MockS3APIMockRecorder) CreateSessionRequest(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateSessionRequest", reflect.TypeOf((*MockS3API)(nil).CreateSessionRequest), arg0)
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateBucket", reflect.TypeOf((*MockS3API)(nil).CreateBucket), varargs...)
}
-// CreateSessionWithContext mocks base method.
-func (m *MockS3API) CreateSessionWithContext(arg0 context.Context, arg1 *s3.CreateSessionInput, arg2 ...request.Option) (*s3.CreateSessionOutput, error) {
+// DeleteBucket mocks base method.
+func (m *MockS3API) DeleteBucket(arg0 context.Context, arg1 *s3.DeleteBucketInput, arg2 ...func(*s3.Options)) (*s3.DeleteBucketOutput, error) {
m.ctrl.T.Helper()
varargs := []interface{}{arg0, arg1}
for _, a := range arg2 {
varargs = append(varargs, a)
}
- ret := m.ctrl.Call(m, "CreateSessionWithContext", varargs...)
- ret0, _ := ret[0].(*s3.CreateSessionOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// CreateSessionWithContext indicates an expected call of CreateSessionWithContext.
-func (mr *MockS3APIMockRecorder) CreateSessionWithContext(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, "CreateSessionWithContext", reflect.TypeOf((*MockS3API)(nil).CreateSessionWithContext), varargs...)
-}
-
-// DeleteBucket mocks base method.
-func (m *MockS3API) DeleteBucket(arg0 *s3.DeleteBucketInput) (*s3.DeleteBucketOutput, error) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "DeleteBucket", arg0)
+ ret := m.ctrl.Call(m, "DeleteBucket", varargs...)
ret0, _ := ret[0].(*s3.DeleteBucketOutput)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// DeleteBucket indicates an expected call of DeleteBucket.
-func (mr *MockS3APIMockRecorder) DeleteBucket(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteBucket", reflect.TypeOf((*MockS3API)(nil).DeleteBucket), arg0)
-}
-
-// DeleteBucketAnalyticsConfiguration mocks base method.
-func (m *MockS3API) DeleteBucketAnalyticsConfiguration(arg0 *s3.DeleteBucketAnalyticsConfigurationInput) (*s3.DeleteBucketAnalyticsConfigurationOutput, error) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "DeleteBucketAnalyticsConfiguration", arg0)
- ret0, _ := ret[0].(*s3.DeleteBucketAnalyticsConfigurationOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// DeleteBucketAnalyticsConfiguration indicates an expected call of DeleteBucketAnalyticsConfiguration.
-func (mr *MockS3APIMockRecorder) DeleteBucketAnalyticsConfiguration(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteBucketAnalyticsConfiguration", reflect.TypeOf((*MockS3API)(nil).DeleteBucketAnalyticsConfiguration), arg0)
-}
-
-// DeleteBucketAnalyticsConfigurationRequest mocks base method.
-func (m *MockS3API) DeleteBucketAnalyticsConfigurationRequest(arg0 *s3.DeleteBucketAnalyticsConfigurationInput) (*request.Request, *s3.DeleteBucketAnalyticsConfigurationOutput) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "DeleteBucketAnalyticsConfigurationRequest", arg0)
- ret0, _ := ret[0].(*request.Request)
- ret1, _ := ret[1].(*s3.DeleteBucketAnalyticsConfigurationOutput)
- return ret0, ret1
-}
-
-// DeleteBucketAnalyticsConfigurationRequest indicates an expected call of DeleteBucketAnalyticsConfigurationRequest.
-func (mr *MockS3APIMockRecorder) DeleteBucketAnalyticsConfigurationRequest(arg0 interface{}) *gomock.Call {
+func (mr *MockS3APIMockRecorder) DeleteBucket(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteBucketAnalyticsConfigurationRequest", reflect.TypeOf((*MockS3API)(nil).DeleteBucketAnalyticsConfigurationRequest), arg0)
+ varargs := append([]interface{}{arg0, arg1}, arg2...)
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteBucket", reflect.TypeOf((*MockS3API)(nil).DeleteBucket), varargs...)
}
-// DeleteBucketAnalyticsConfigurationWithContext mocks base method.
-func (m *MockS3API) DeleteBucketAnalyticsConfigurationWithContext(arg0 context.Context, arg1 *s3.DeleteBucketAnalyticsConfigurationInput, arg2 ...request.Option) (*s3.DeleteBucketAnalyticsConfigurationOutput, error) {
+// DeleteObject mocks base method.
+func (m *MockS3API) DeleteObject(arg0 context.Context, arg1 *s3.DeleteObjectInput, arg2 ...func(*s3.Options)) (*s3.DeleteObjectOutput, error) {
m.ctrl.T.Helper()
varargs := []interface{}{arg0, arg1}
for _, a := range arg2 {
varargs = append(varargs, a)
}
- ret := m.ctrl.Call(m, "DeleteBucketAnalyticsConfigurationWithContext", varargs...)
- ret0, _ := ret[0].(*s3.DeleteBucketAnalyticsConfigurationOutput)
+ ret := m.ctrl.Call(m, "DeleteObject", varargs...)
+ ret0, _ := ret[0].(*s3.DeleteObjectOutput)
ret1, _ := ret[1].(error)
return ret0, ret1
}
-// DeleteBucketAnalyticsConfigurationWithContext indicates an expected call of DeleteBucketAnalyticsConfigurationWithContext.
-func (mr *MockS3APIMockRecorder) DeleteBucketAnalyticsConfigurationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+// DeleteObject indicates an expected call of DeleteObject.
+func (mr *MockS3APIMockRecorder) DeleteObject(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, "DeleteBucketAnalyticsConfigurationWithContext", reflect.TypeOf((*MockS3API)(nil).DeleteBucketAnalyticsConfigurationWithContext), varargs...)
-}
-
-// DeleteBucketCors mocks base method.
-func (m *MockS3API) DeleteBucketCors(arg0 *s3.DeleteBucketCorsInput) (*s3.DeleteBucketCorsOutput, error) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "DeleteBucketCors", arg0)
- ret0, _ := ret[0].(*s3.DeleteBucketCorsOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// DeleteBucketCors indicates an expected call of DeleteBucketCors.
-func (mr *MockS3APIMockRecorder) DeleteBucketCors(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteBucketCors", reflect.TypeOf((*MockS3API)(nil).DeleteBucketCors), arg0)
-}
-
-// DeleteBucketCorsRequest mocks base method.
-func (m *MockS3API) DeleteBucketCorsRequest(arg0 *s3.DeleteBucketCorsInput) (*request.Request, *s3.DeleteBucketCorsOutput) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "DeleteBucketCorsRequest", arg0)
- ret0, _ := ret[0].(*request.Request)
- ret1, _ := ret[1].(*s3.DeleteBucketCorsOutput)
- return ret0, ret1
-}
-
-// DeleteBucketCorsRequest indicates an expected call of DeleteBucketCorsRequest.
-func (mr *MockS3APIMockRecorder) DeleteBucketCorsRequest(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteBucketCorsRequest", reflect.TypeOf((*MockS3API)(nil).DeleteBucketCorsRequest), arg0)
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteObject", reflect.TypeOf((*MockS3API)(nil).DeleteObject), varargs...)
}
-// DeleteBucketCorsWithContext mocks base method.
-func (m *MockS3API) DeleteBucketCorsWithContext(arg0 context.Context, arg1 *s3.DeleteBucketCorsInput, arg2 ...request.Option) (*s3.DeleteBucketCorsOutput, error) {
+// HeadObject mocks base method.
+func (m *MockS3API) HeadObject(arg0 context.Context, arg1 *s3.HeadObjectInput, arg2 ...func(*s3.Options)) (*s3.HeadObjectOutput, error) {
m.ctrl.T.Helper()
varargs := []interface{}{arg0, arg1}
for _, a := range arg2 {
varargs = append(varargs, a)
}
- ret := m.ctrl.Call(m, "DeleteBucketCorsWithContext", varargs...)
- ret0, _ := ret[0].(*s3.DeleteBucketCorsOutput)
+ ret := m.ctrl.Call(m, "HeadObject", varargs...)
+ ret0, _ := ret[0].(*s3.HeadObjectOutput)
ret1, _ := ret[1].(error)
return ret0, ret1
}
-// DeleteBucketCorsWithContext indicates an expected call of DeleteBucketCorsWithContext.
-func (mr *MockS3APIMockRecorder) DeleteBucketCorsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+// HeadObject indicates an expected call of HeadObject.
+func (mr *MockS3APIMockRecorder) HeadObject(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, "DeleteBucketCorsWithContext", reflect.TypeOf((*MockS3API)(nil).DeleteBucketCorsWithContext), varargs...)
-}
-
-// DeleteBucketEncryption mocks base method.
-func (m *MockS3API) DeleteBucketEncryption(arg0 *s3.DeleteBucketEncryptionInput) (*s3.DeleteBucketEncryptionOutput, error) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "DeleteBucketEncryption", arg0)
- ret0, _ := ret[0].(*s3.DeleteBucketEncryptionOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// DeleteBucketEncryption indicates an expected call of DeleteBucketEncryption.
-func (mr *MockS3APIMockRecorder) DeleteBucketEncryption(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteBucketEncryption", reflect.TypeOf((*MockS3API)(nil).DeleteBucketEncryption), arg0)
-}
-
-// DeleteBucketEncryptionRequest mocks base method.
-func (m *MockS3API) DeleteBucketEncryptionRequest(arg0 *s3.DeleteBucketEncryptionInput) (*request.Request, *s3.DeleteBucketEncryptionOutput) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "DeleteBucketEncryptionRequest", arg0)
- ret0, _ := ret[0].(*request.Request)
- ret1, _ := ret[1].(*s3.DeleteBucketEncryptionOutput)
- return ret0, ret1
-}
-
-// DeleteBucketEncryptionRequest indicates an expected call of DeleteBucketEncryptionRequest.
-func (mr *MockS3APIMockRecorder) DeleteBucketEncryptionRequest(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteBucketEncryptionRequest", reflect.TypeOf((*MockS3API)(nil).DeleteBucketEncryptionRequest), arg0)
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HeadObject", reflect.TypeOf((*MockS3API)(nil).HeadObject), varargs...)
}
-// DeleteBucketEncryptionWithContext mocks base method.
-func (m *MockS3API) DeleteBucketEncryptionWithContext(arg0 context.Context, arg1 *s3.DeleteBucketEncryptionInput, arg2 ...request.Option) (*s3.DeleteBucketEncryptionOutput, error) {
+// PutBucketPolicy mocks base method.
+func (m *MockS3API) PutBucketPolicy(arg0 context.Context, arg1 *s3.PutBucketPolicyInput, arg2 ...func(*s3.Options)) (*s3.PutBucketPolicyOutput, error) {
m.ctrl.T.Helper()
varargs := []interface{}{arg0, arg1}
for _, a := range arg2 {
varargs = append(varargs, a)
}
- ret := m.ctrl.Call(m, "DeleteBucketEncryptionWithContext", varargs...)
- ret0, _ := ret[0].(*s3.DeleteBucketEncryptionOutput)
+ ret := m.ctrl.Call(m, "PutBucketPolicy", varargs...)
+ ret0, _ := ret[0].(*s3.PutBucketPolicyOutput)
ret1, _ := ret[1].(error)
return ret0, ret1
}
-// DeleteBucketEncryptionWithContext indicates an expected call of DeleteBucketEncryptionWithContext.
-func (mr *MockS3APIMockRecorder) DeleteBucketEncryptionWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+// PutBucketPolicy indicates an expected call of PutBucketPolicy.
+func (mr *MockS3APIMockRecorder) PutBucketPolicy(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, "DeleteBucketEncryptionWithContext", reflect.TypeOf((*MockS3API)(nil).DeleteBucketEncryptionWithContext), varargs...)
-}
-
-// DeleteBucketIntelligentTieringConfiguration mocks base method.
-func (m *MockS3API) DeleteBucketIntelligentTieringConfiguration(arg0 *s3.DeleteBucketIntelligentTieringConfigurationInput) (*s3.DeleteBucketIntelligentTieringConfigurationOutput, error) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "DeleteBucketIntelligentTieringConfiguration", arg0)
- ret0, _ := ret[0].(*s3.DeleteBucketIntelligentTieringConfigurationOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// DeleteBucketIntelligentTieringConfiguration indicates an expected call of DeleteBucketIntelligentTieringConfiguration.
-func (mr *MockS3APIMockRecorder) DeleteBucketIntelligentTieringConfiguration(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteBucketIntelligentTieringConfiguration", reflect.TypeOf((*MockS3API)(nil).DeleteBucketIntelligentTieringConfiguration), arg0)
-}
-
-// DeleteBucketIntelligentTieringConfigurationRequest mocks base method.
-func (m *MockS3API) DeleteBucketIntelligentTieringConfigurationRequest(arg0 *s3.DeleteBucketIntelligentTieringConfigurationInput) (*request.Request, *s3.DeleteBucketIntelligentTieringConfigurationOutput) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "DeleteBucketIntelligentTieringConfigurationRequest", arg0)
- ret0, _ := ret[0].(*request.Request)
- ret1, _ := ret[1].(*s3.DeleteBucketIntelligentTieringConfigurationOutput)
- return ret0, ret1
-}
-
-// DeleteBucketIntelligentTieringConfigurationRequest indicates an expected call of DeleteBucketIntelligentTieringConfigurationRequest.
-func (mr *MockS3APIMockRecorder) DeleteBucketIntelligentTieringConfigurationRequest(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteBucketIntelligentTieringConfigurationRequest", reflect.TypeOf((*MockS3API)(nil).DeleteBucketIntelligentTieringConfigurationRequest), arg0)
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutBucketPolicy", reflect.TypeOf((*MockS3API)(nil).PutBucketPolicy), varargs...)
}
-// DeleteBucketIntelligentTieringConfigurationWithContext mocks base method.
-func (m *MockS3API) DeleteBucketIntelligentTieringConfigurationWithContext(arg0 context.Context, arg1 *s3.DeleteBucketIntelligentTieringConfigurationInput, arg2 ...request.Option) (*s3.DeleteBucketIntelligentTieringConfigurationOutput, error) {
+// PutBucketTagging mocks base method.
+func (m *MockS3API) PutBucketTagging(arg0 context.Context, arg1 *s3.PutBucketTaggingInput, arg2 ...func(*s3.Options)) (*s3.PutBucketTaggingOutput, error) {
m.ctrl.T.Helper()
varargs := []interface{}{arg0, arg1}
for _, a := range arg2 {
varargs = append(varargs, a)
}
- ret := m.ctrl.Call(m, "DeleteBucketIntelligentTieringConfigurationWithContext", varargs...)
- ret0, _ := ret[0].(*s3.DeleteBucketIntelligentTieringConfigurationOutput)
+ ret := m.ctrl.Call(m, "PutBucketTagging", varargs...)
+ ret0, _ := ret[0].(*s3.PutBucketTaggingOutput)
ret1, _ := ret[1].(error)
return ret0, ret1
}
-// DeleteBucketIntelligentTieringConfigurationWithContext indicates an expected call of DeleteBucketIntelligentTieringConfigurationWithContext.
-func (mr *MockS3APIMockRecorder) DeleteBucketIntelligentTieringConfigurationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+// PutBucketTagging indicates an expected call of PutBucketTagging.
+func (mr *MockS3APIMockRecorder) PutBucketTagging(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, "DeleteBucketIntelligentTieringConfigurationWithContext", reflect.TypeOf((*MockS3API)(nil).DeleteBucketIntelligentTieringConfigurationWithContext), varargs...)
-}
-
-// DeleteBucketInventoryConfiguration mocks base method.
-func (m *MockS3API) DeleteBucketInventoryConfiguration(arg0 *s3.DeleteBucketInventoryConfigurationInput) (*s3.DeleteBucketInventoryConfigurationOutput, error) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "DeleteBucketInventoryConfiguration", arg0)
- ret0, _ := ret[0].(*s3.DeleteBucketInventoryConfigurationOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// DeleteBucketInventoryConfiguration indicates an expected call of DeleteBucketInventoryConfiguration.
-func (mr *MockS3APIMockRecorder) DeleteBucketInventoryConfiguration(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteBucketInventoryConfiguration", reflect.TypeOf((*MockS3API)(nil).DeleteBucketInventoryConfiguration), arg0)
-}
-
-// DeleteBucketInventoryConfigurationRequest mocks base method.
-func (m *MockS3API) DeleteBucketInventoryConfigurationRequest(arg0 *s3.DeleteBucketInventoryConfigurationInput) (*request.Request, *s3.DeleteBucketInventoryConfigurationOutput) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "DeleteBucketInventoryConfigurationRequest", arg0)
- ret0, _ := ret[0].(*request.Request)
- ret1, _ := ret[1].(*s3.DeleteBucketInventoryConfigurationOutput)
- return ret0, ret1
-}
-
-// DeleteBucketInventoryConfigurationRequest indicates an expected call of DeleteBucketInventoryConfigurationRequest.
-func (mr *MockS3APIMockRecorder) DeleteBucketInventoryConfigurationRequest(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteBucketInventoryConfigurationRequest", reflect.TypeOf((*MockS3API)(nil).DeleteBucketInventoryConfigurationRequest), arg0)
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutBucketTagging", reflect.TypeOf((*MockS3API)(nil).PutBucketTagging), varargs...)
}
-// DeleteBucketInventoryConfigurationWithContext mocks base method.
-func (m *MockS3API) DeleteBucketInventoryConfigurationWithContext(arg0 context.Context, arg1 *s3.DeleteBucketInventoryConfigurationInput, arg2 ...request.Option) (*s3.DeleteBucketInventoryConfigurationOutput, error) {
+// PutObject mocks base method.
+func (m *MockS3API) PutObject(arg0 context.Context, arg1 *s3.PutObjectInput, arg2 ...func(*s3.Options)) (*s3.PutObjectOutput, error) {
m.ctrl.T.Helper()
varargs := []interface{}{arg0, arg1}
for _, a := range arg2 {
varargs = append(varargs, a)
}
- ret := m.ctrl.Call(m, "DeleteBucketInventoryConfigurationWithContext", varargs...)
- ret0, _ := ret[0].(*s3.DeleteBucketInventoryConfigurationOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// DeleteBucketInventoryConfigurationWithContext indicates an expected call of DeleteBucketInventoryConfigurationWithContext.
-func (mr *MockS3APIMockRecorder) DeleteBucketInventoryConfigurationWithContext(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, "DeleteBucketInventoryConfigurationWithContext", reflect.TypeOf((*MockS3API)(nil).DeleteBucketInventoryConfigurationWithContext), varargs...)
-}
-
-// DeleteBucketLifecycle mocks base method.
-func (m *MockS3API) DeleteBucketLifecycle(arg0 *s3.DeleteBucketLifecycleInput) (*s3.DeleteBucketLifecycleOutput, error) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "DeleteBucketLifecycle", arg0)
- ret0, _ := ret[0].(*s3.DeleteBucketLifecycleOutput)
+ ret := m.ctrl.Call(m, "PutObject", varargs...)
+ ret0, _ := ret[0].(*s3.PutObjectOutput)
ret1, _ := ret[1].(error)
return ret0, ret1
}
-// DeleteBucketLifecycle indicates an expected call of DeleteBucketLifecycle.
-func (mr *MockS3APIMockRecorder) DeleteBucketLifecycle(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteBucketLifecycle", reflect.TypeOf((*MockS3API)(nil).DeleteBucketLifecycle), arg0)
-}
-
-// DeleteBucketLifecycleRequest mocks base method.
-func (m *MockS3API) DeleteBucketLifecycleRequest(arg0 *s3.DeleteBucketLifecycleInput) (*request.Request, *s3.DeleteBucketLifecycleOutput) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "DeleteBucketLifecycleRequest", arg0)
- ret0, _ := ret[0].(*request.Request)
- ret1, _ := ret[1].(*s3.DeleteBucketLifecycleOutput)
- return ret0, ret1
-}
-
-// DeleteBucketLifecycleRequest indicates an expected call of DeleteBucketLifecycleRequest.
-func (mr *MockS3APIMockRecorder) DeleteBucketLifecycleRequest(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteBucketLifecycleRequest", reflect.TypeOf((*MockS3API)(nil).DeleteBucketLifecycleRequest), arg0)
-}
-
-// DeleteBucketLifecycleWithContext mocks base method.
-func (m *MockS3API) DeleteBucketLifecycleWithContext(arg0 context.Context, arg1 *s3.DeleteBucketLifecycleInput, arg2 ...request.Option) (*s3.DeleteBucketLifecycleOutput, error) {
- m.ctrl.T.Helper()
- varargs := []interface{}{arg0, arg1}
- for _, a := range arg2 {
- varargs = append(varargs, a)
- }
- ret := m.ctrl.Call(m, "DeleteBucketLifecycleWithContext", varargs...)
- ret0, _ := ret[0].(*s3.DeleteBucketLifecycleOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// DeleteBucketLifecycleWithContext indicates an expected call of DeleteBucketLifecycleWithContext.
-func (mr *MockS3APIMockRecorder) DeleteBucketLifecycleWithContext(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, "DeleteBucketLifecycleWithContext", reflect.TypeOf((*MockS3API)(nil).DeleteBucketLifecycleWithContext), varargs...)
-}
-
-// DeleteBucketMetricsConfiguration mocks base method.
-func (m *MockS3API) DeleteBucketMetricsConfiguration(arg0 *s3.DeleteBucketMetricsConfigurationInput) (*s3.DeleteBucketMetricsConfigurationOutput, error) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "DeleteBucketMetricsConfiguration", arg0)
- ret0, _ := ret[0].(*s3.DeleteBucketMetricsConfigurationOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// DeleteBucketMetricsConfiguration indicates an expected call of DeleteBucketMetricsConfiguration.
-func (mr *MockS3APIMockRecorder) DeleteBucketMetricsConfiguration(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteBucketMetricsConfiguration", reflect.TypeOf((*MockS3API)(nil).DeleteBucketMetricsConfiguration), arg0)
-}
-
-// DeleteBucketMetricsConfigurationRequest mocks base method.
-func (m *MockS3API) DeleteBucketMetricsConfigurationRequest(arg0 *s3.DeleteBucketMetricsConfigurationInput) (*request.Request, *s3.DeleteBucketMetricsConfigurationOutput) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "DeleteBucketMetricsConfigurationRequest", arg0)
- ret0, _ := ret[0].(*request.Request)
- ret1, _ := ret[1].(*s3.DeleteBucketMetricsConfigurationOutput)
- return ret0, ret1
-}
-
-// DeleteBucketMetricsConfigurationRequest indicates an expected call of DeleteBucketMetricsConfigurationRequest.
-func (mr *MockS3APIMockRecorder) DeleteBucketMetricsConfigurationRequest(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteBucketMetricsConfigurationRequest", reflect.TypeOf((*MockS3API)(nil).DeleteBucketMetricsConfigurationRequest), arg0)
-}
-
-// DeleteBucketMetricsConfigurationWithContext mocks base method.
-func (m *MockS3API) DeleteBucketMetricsConfigurationWithContext(arg0 context.Context, arg1 *s3.DeleteBucketMetricsConfigurationInput, arg2 ...request.Option) (*s3.DeleteBucketMetricsConfigurationOutput, error) {
- m.ctrl.T.Helper()
- varargs := []interface{}{arg0, arg1}
- for _, a := range arg2 {
- varargs = append(varargs, a)
- }
- ret := m.ctrl.Call(m, "DeleteBucketMetricsConfigurationWithContext", varargs...)
- ret0, _ := ret[0].(*s3.DeleteBucketMetricsConfigurationOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// DeleteBucketMetricsConfigurationWithContext indicates an expected call of DeleteBucketMetricsConfigurationWithContext.
-func (mr *MockS3APIMockRecorder) DeleteBucketMetricsConfigurationWithContext(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, "DeleteBucketMetricsConfigurationWithContext", reflect.TypeOf((*MockS3API)(nil).DeleteBucketMetricsConfigurationWithContext), varargs...)
-}
-
-// DeleteBucketOwnershipControls mocks base method.
-func (m *MockS3API) DeleteBucketOwnershipControls(arg0 *s3.DeleteBucketOwnershipControlsInput) (*s3.DeleteBucketOwnershipControlsOutput, error) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "DeleteBucketOwnershipControls", arg0)
- ret0, _ := ret[0].(*s3.DeleteBucketOwnershipControlsOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// DeleteBucketOwnershipControls indicates an expected call of DeleteBucketOwnershipControls.
-func (mr *MockS3APIMockRecorder) DeleteBucketOwnershipControls(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteBucketOwnershipControls", reflect.TypeOf((*MockS3API)(nil).DeleteBucketOwnershipControls), arg0)
-}
-
-// DeleteBucketOwnershipControlsRequest mocks base method.
-func (m *MockS3API) DeleteBucketOwnershipControlsRequest(arg0 *s3.DeleteBucketOwnershipControlsInput) (*request.Request, *s3.DeleteBucketOwnershipControlsOutput) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "DeleteBucketOwnershipControlsRequest", arg0)
- ret0, _ := ret[0].(*request.Request)
- ret1, _ := ret[1].(*s3.DeleteBucketOwnershipControlsOutput)
- return ret0, ret1
-}
-
-// DeleteBucketOwnershipControlsRequest indicates an expected call of DeleteBucketOwnershipControlsRequest.
-func (mr *MockS3APIMockRecorder) DeleteBucketOwnershipControlsRequest(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteBucketOwnershipControlsRequest", reflect.TypeOf((*MockS3API)(nil).DeleteBucketOwnershipControlsRequest), arg0)
-}
-
-// DeleteBucketOwnershipControlsWithContext mocks base method.
-func (m *MockS3API) DeleteBucketOwnershipControlsWithContext(arg0 context.Context, arg1 *s3.DeleteBucketOwnershipControlsInput, arg2 ...request.Option) (*s3.DeleteBucketOwnershipControlsOutput, error) {
- m.ctrl.T.Helper()
- varargs := []interface{}{arg0, arg1}
- for _, a := range arg2 {
- varargs = append(varargs, a)
- }
- ret := m.ctrl.Call(m, "DeleteBucketOwnershipControlsWithContext", varargs...)
- ret0, _ := ret[0].(*s3.DeleteBucketOwnershipControlsOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// DeleteBucketOwnershipControlsWithContext indicates an expected call of DeleteBucketOwnershipControlsWithContext.
-func (mr *MockS3APIMockRecorder) DeleteBucketOwnershipControlsWithContext(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, "DeleteBucketOwnershipControlsWithContext", reflect.TypeOf((*MockS3API)(nil).DeleteBucketOwnershipControlsWithContext), varargs...)
-}
-
-// DeleteBucketPolicy mocks base method.
-func (m *MockS3API) DeleteBucketPolicy(arg0 *s3.DeleteBucketPolicyInput) (*s3.DeleteBucketPolicyOutput, error) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "DeleteBucketPolicy", arg0)
- ret0, _ := ret[0].(*s3.DeleteBucketPolicyOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// DeleteBucketPolicy indicates an expected call of DeleteBucketPolicy.
-func (mr *MockS3APIMockRecorder) DeleteBucketPolicy(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteBucketPolicy", reflect.TypeOf((*MockS3API)(nil).DeleteBucketPolicy), arg0)
-}
-
-// DeleteBucketPolicyRequest mocks base method.
-func (m *MockS3API) DeleteBucketPolicyRequest(arg0 *s3.DeleteBucketPolicyInput) (*request.Request, *s3.DeleteBucketPolicyOutput) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "DeleteBucketPolicyRequest", arg0)
- ret0, _ := ret[0].(*request.Request)
- ret1, _ := ret[1].(*s3.DeleteBucketPolicyOutput)
- return ret0, ret1
-}
-
-// DeleteBucketPolicyRequest indicates an expected call of DeleteBucketPolicyRequest.
-func (mr *MockS3APIMockRecorder) DeleteBucketPolicyRequest(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteBucketPolicyRequest", reflect.TypeOf((*MockS3API)(nil).DeleteBucketPolicyRequest), arg0)
-}
-
-// DeleteBucketPolicyWithContext mocks base method.
-func (m *MockS3API) DeleteBucketPolicyWithContext(arg0 context.Context, arg1 *s3.DeleteBucketPolicyInput, arg2 ...request.Option) (*s3.DeleteBucketPolicyOutput, error) {
- m.ctrl.T.Helper()
- varargs := []interface{}{arg0, arg1}
- for _, a := range arg2 {
- varargs = append(varargs, a)
- }
- ret := m.ctrl.Call(m, "DeleteBucketPolicyWithContext", varargs...)
- ret0, _ := ret[0].(*s3.DeleteBucketPolicyOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// DeleteBucketPolicyWithContext indicates an expected call of DeleteBucketPolicyWithContext.
-func (mr *MockS3APIMockRecorder) DeleteBucketPolicyWithContext(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, "DeleteBucketPolicyWithContext", reflect.TypeOf((*MockS3API)(nil).DeleteBucketPolicyWithContext), varargs...)
-}
-
-// DeleteBucketReplication mocks base method.
-func (m *MockS3API) DeleteBucketReplication(arg0 *s3.DeleteBucketReplicationInput) (*s3.DeleteBucketReplicationOutput, error) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "DeleteBucketReplication", arg0)
- ret0, _ := ret[0].(*s3.DeleteBucketReplicationOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// DeleteBucketReplication indicates an expected call of DeleteBucketReplication.
-func (mr *MockS3APIMockRecorder) DeleteBucketReplication(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteBucketReplication", reflect.TypeOf((*MockS3API)(nil).DeleteBucketReplication), arg0)
-}
-
-// DeleteBucketReplicationRequest mocks base method.
-func (m *MockS3API) DeleteBucketReplicationRequest(arg0 *s3.DeleteBucketReplicationInput) (*request.Request, *s3.DeleteBucketReplicationOutput) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "DeleteBucketReplicationRequest", arg0)
- ret0, _ := ret[0].(*request.Request)
- ret1, _ := ret[1].(*s3.DeleteBucketReplicationOutput)
- return ret0, ret1
-}
-
-// DeleteBucketReplicationRequest indicates an expected call of DeleteBucketReplicationRequest.
-func (mr *MockS3APIMockRecorder) DeleteBucketReplicationRequest(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteBucketReplicationRequest", reflect.TypeOf((*MockS3API)(nil).DeleteBucketReplicationRequest), arg0)
-}
-
-// DeleteBucketReplicationWithContext mocks base method.
-func (m *MockS3API) DeleteBucketReplicationWithContext(arg0 context.Context, arg1 *s3.DeleteBucketReplicationInput, arg2 ...request.Option) (*s3.DeleteBucketReplicationOutput, error) {
- m.ctrl.T.Helper()
- varargs := []interface{}{arg0, arg1}
- for _, a := range arg2 {
- varargs = append(varargs, a)
- }
- ret := m.ctrl.Call(m, "DeleteBucketReplicationWithContext", varargs...)
- ret0, _ := ret[0].(*s3.DeleteBucketReplicationOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// DeleteBucketReplicationWithContext indicates an expected call of DeleteBucketReplicationWithContext.
-func (mr *MockS3APIMockRecorder) DeleteBucketReplicationWithContext(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, "DeleteBucketReplicationWithContext", reflect.TypeOf((*MockS3API)(nil).DeleteBucketReplicationWithContext), varargs...)
-}
-
-// DeleteBucketRequest mocks base method.
-func (m *MockS3API) DeleteBucketRequest(arg0 *s3.DeleteBucketInput) (*request.Request, *s3.DeleteBucketOutput) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "DeleteBucketRequest", arg0)
- ret0, _ := ret[0].(*request.Request)
- ret1, _ := ret[1].(*s3.DeleteBucketOutput)
- return ret0, ret1
-}
-
-// DeleteBucketRequest indicates an expected call of DeleteBucketRequest.
-func (mr *MockS3APIMockRecorder) DeleteBucketRequest(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteBucketRequest", reflect.TypeOf((*MockS3API)(nil).DeleteBucketRequest), arg0)
-}
-
-// DeleteBucketTagging mocks base method.
-func (m *MockS3API) DeleteBucketTagging(arg0 *s3.DeleteBucketTaggingInput) (*s3.DeleteBucketTaggingOutput, error) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "DeleteBucketTagging", arg0)
- ret0, _ := ret[0].(*s3.DeleteBucketTaggingOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// DeleteBucketTagging indicates an expected call of DeleteBucketTagging.
-func (mr *MockS3APIMockRecorder) DeleteBucketTagging(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteBucketTagging", reflect.TypeOf((*MockS3API)(nil).DeleteBucketTagging), arg0)
-}
-
-// DeleteBucketTaggingRequest mocks base method.
-func (m *MockS3API) DeleteBucketTaggingRequest(arg0 *s3.DeleteBucketTaggingInput) (*request.Request, *s3.DeleteBucketTaggingOutput) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "DeleteBucketTaggingRequest", arg0)
- ret0, _ := ret[0].(*request.Request)
- ret1, _ := ret[1].(*s3.DeleteBucketTaggingOutput)
- return ret0, ret1
-}
-
-// DeleteBucketTaggingRequest indicates an expected call of DeleteBucketTaggingRequest.
-func (mr *MockS3APIMockRecorder) DeleteBucketTaggingRequest(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteBucketTaggingRequest", reflect.TypeOf((*MockS3API)(nil).DeleteBucketTaggingRequest), arg0)
-}
-
-// DeleteBucketTaggingWithContext mocks base method.
-func (m *MockS3API) DeleteBucketTaggingWithContext(arg0 context.Context, arg1 *s3.DeleteBucketTaggingInput, arg2 ...request.Option) (*s3.DeleteBucketTaggingOutput, error) {
- m.ctrl.T.Helper()
- varargs := []interface{}{arg0, arg1}
- for _, a := range arg2 {
- varargs = append(varargs, a)
- }
- ret := m.ctrl.Call(m, "DeleteBucketTaggingWithContext", varargs...)
- ret0, _ := ret[0].(*s3.DeleteBucketTaggingOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// DeleteBucketTaggingWithContext indicates an expected call of DeleteBucketTaggingWithContext.
-func (mr *MockS3APIMockRecorder) DeleteBucketTaggingWithContext(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, "DeleteBucketTaggingWithContext", reflect.TypeOf((*MockS3API)(nil).DeleteBucketTaggingWithContext), varargs...)
-}
-
-// DeleteBucketWebsite mocks base method.
-func (m *MockS3API) DeleteBucketWebsite(arg0 *s3.DeleteBucketWebsiteInput) (*s3.DeleteBucketWebsiteOutput, error) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "DeleteBucketWebsite", arg0)
- ret0, _ := ret[0].(*s3.DeleteBucketWebsiteOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// DeleteBucketWebsite indicates an expected call of DeleteBucketWebsite.
-func (mr *MockS3APIMockRecorder) DeleteBucketWebsite(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteBucketWebsite", reflect.TypeOf((*MockS3API)(nil).DeleteBucketWebsite), arg0)
-}
-
-// DeleteBucketWebsiteRequest mocks base method.
-func (m *MockS3API) DeleteBucketWebsiteRequest(arg0 *s3.DeleteBucketWebsiteInput) (*request.Request, *s3.DeleteBucketWebsiteOutput) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "DeleteBucketWebsiteRequest", arg0)
- ret0, _ := ret[0].(*request.Request)
- ret1, _ := ret[1].(*s3.DeleteBucketWebsiteOutput)
- return ret0, ret1
-}
-
-// DeleteBucketWebsiteRequest indicates an expected call of DeleteBucketWebsiteRequest.
-func (mr *MockS3APIMockRecorder) DeleteBucketWebsiteRequest(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteBucketWebsiteRequest", reflect.TypeOf((*MockS3API)(nil).DeleteBucketWebsiteRequest), arg0)
-}
-
-// DeleteBucketWebsiteWithContext mocks base method.
-func (m *MockS3API) DeleteBucketWebsiteWithContext(arg0 context.Context, arg1 *s3.DeleteBucketWebsiteInput, arg2 ...request.Option) (*s3.DeleteBucketWebsiteOutput, error) {
- m.ctrl.T.Helper()
- varargs := []interface{}{arg0, arg1}
- for _, a := range arg2 {
- varargs = append(varargs, a)
- }
- ret := m.ctrl.Call(m, "DeleteBucketWebsiteWithContext", varargs...)
- ret0, _ := ret[0].(*s3.DeleteBucketWebsiteOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// DeleteBucketWebsiteWithContext indicates an expected call of DeleteBucketWebsiteWithContext.
-func (mr *MockS3APIMockRecorder) DeleteBucketWebsiteWithContext(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, "DeleteBucketWebsiteWithContext", reflect.TypeOf((*MockS3API)(nil).DeleteBucketWebsiteWithContext), varargs...)
-}
-
-// DeleteBucketWithContext mocks base method.
-func (m *MockS3API) DeleteBucketWithContext(arg0 context.Context, arg1 *s3.DeleteBucketInput, arg2 ...request.Option) (*s3.DeleteBucketOutput, error) {
- m.ctrl.T.Helper()
- varargs := []interface{}{arg0, arg1}
- for _, a := range arg2 {
- varargs = append(varargs, a)
- }
- ret := m.ctrl.Call(m, "DeleteBucketWithContext", varargs...)
- ret0, _ := ret[0].(*s3.DeleteBucketOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// DeleteBucketWithContext indicates an expected call of DeleteBucketWithContext.
-func (mr *MockS3APIMockRecorder) DeleteBucketWithContext(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, "DeleteBucketWithContext", reflect.TypeOf((*MockS3API)(nil).DeleteBucketWithContext), varargs...)
-}
-
-// DeleteObject mocks base method.
-func (m *MockS3API) DeleteObject(arg0 *s3.DeleteObjectInput) (*s3.DeleteObjectOutput, error) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "DeleteObject", arg0)
- ret0, _ := ret[0].(*s3.DeleteObjectOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// DeleteObject indicates an expected call of DeleteObject.
-func (mr *MockS3APIMockRecorder) DeleteObject(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteObject", reflect.TypeOf((*MockS3API)(nil).DeleteObject), arg0)
-}
-
-// DeleteObjectRequest mocks base method.
-func (m *MockS3API) DeleteObjectRequest(arg0 *s3.DeleteObjectInput) (*request.Request, *s3.DeleteObjectOutput) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "DeleteObjectRequest", arg0)
- ret0, _ := ret[0].(*request.Request)
- ret1, _ := ret[1].(*s3.DeleteObjectOutput)
- return ret0, ret1
-}
-
-// DeleteObjectRequest indicates an expected call of DeleteObjectRequest.
-func (mr *MockS3APIMockRecorder) DeleteObjectRequest(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteObjectRequest", reflect.TypeOf((*MockS3API)(nil).DeleteObjectRequest), arg0)
-}
-
-// DeleteObjectTagging mocks base method.
-func (m *MockS3API) DeleteObjectTagging(arg0 *s3.DeleteObjectTaggingInput) (*s3.DeleteObjectTaggingOutput, error) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "DeleteObjectTagging", arg0)
- ret0, _ := ret[0].(*s3.DeleteObjectTaggingOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// DeleteObjectTagging indicates an expected call of DeleteObjectTagging.
-func (mr *MockS3APIMockRecorder) DeleteObjectTagging(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteObjectTagging", reflect.TypeOf((*MockS3API)(nil).DeleteObjectTagging), arg0)
-}
-
-// DeleteObjectTaggingRequest mocks base method.
-func (m *MockS3API) DeleteObjectTaggingRequest(arg0 *s3.DeleteObjectTaggingInput) (*request.Request, *s3.DeleteObjectTaggingOutput) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "DeleteObjectTaggingRequest", arg0)
- ret0, _ := ret[0].(*request.Request)
- ret1, _ := ret[1].(*s3.DeleteObjectTaggingOutput)
- return ret0, ret1
-}
-
-// DeleteObjectTaggingRequest indicates an expected call of DeleteObjectTaggingRequest.
-func (mr *MockS3APIMockRecorder) DeleteObjectTaggingRequest(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteObjectTaggingRequest", reflect.TypeOf((*MockS3API)(nil).DeleteObjectTaggingRequest), arg0)
-}
-
-// DeleteObjectTaggingWithContext mocks base method.
-func (m *MockS3API) DeleteObjectTaggingWithContext(arg0 context.Context, arg1 *s3.DeleteObjectTaggingInput, arg2 ...request.Option) (*s3.DeleteObjectTaggingOutput, error) {
- m.ctrl.T.Helper()
- varargs := []interface{}{arg0, arg1}
- for _, a := range arg2 {
- varargs = append(varargs, a)
- }
- ret := m.ctrl.Call(m, "DeleteObjectTaggingWithContext", varargs...)
- ret0, _ := ret[0].(*s3.DeleteObjectTaggingOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// DeleteObjectTaggingWithContext indicates an expected call of DeleteObjectTaggingWithContext.
-func (mr *MockS3APIMockRecorder) DeleteObjectTaggingWithContext(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, "DeleteObjectTaggingWithContext", reflect.TypeOf((*MockS3API)(nil).DeleteObjectTaggingWithContext), varargs...)
-}
-
-// DeleteObjectWithContext mocks base method.
-func (m *MockS3API) DeleteObjectWithContext(arg0 context.Context, arg1 *s3.DeleteObjectInput, arg2 ...request.Option) (*s3.DeleteObjectOutput, error) {
- m.ctrl.T.Helper()
- varargs := []interface{}{arg0, arg1}
- for _, a := range arg2 {
- varargs = append(varargs, a)
- }
- ret := m.ctrl.Call(m, "DeleteObjectWithContext", varargs...)
- ret0, _ := ret[0].(*s3.DeleteObjectOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// DeleteObjectWithContext indicates an expected call of DeleteObjectWithContext.
-func (mr *MockS3APIMockRecorder) DeleteObjectWithContext(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, "DeleteObjectWithContext", reflect.TypeOf((*MockS3API)(nil).DeleteObjectWithContext), varargs...)
-}
-
-// DeleteObjects mocks base method.
-func (m *MockS3API) DeleteObjects(arg0 *s3.DeleteObjectsInput) (*s3.DeleteObjectsOutput, error) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "DeleteObjects", arg0)
- ret0, _ := ret[0].(*s3.DeleteObjectsOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// DeleteObjects indicates an expected call of DeleteObjects.
-func (mr *MockS3APIMockRecorder) DeleteObjects(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteObjects", reflect.TypeOf((*MockS3API)(nil).DeleteObjects), arg0)
-}
-
-// DeleteObjectsRequest mocks base method.
-func (m *MockS3API) DeleteObjectsRequest(arg0 *s3.DeleteObjectsInput) (*request.Request, *s3.DeleteObjectsOutput) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "DeleteObjectsRequest", arg0)
- ret0, _ := ret[0].(*request.Request)
- ret1, _ := ret[1].(*s3.DeleteObjectsOutput)
- return ret0, ret1
-}
-
-// DeleteObjectsRequest indicates an expected call of DeleteObjectsRequest.
-func (mr *MockS3APIMockRecorder) DeleteObjectsRequest(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteObjectsRequest", reflect.TypeOf((*MockS3API)(nil).DeleteObjectsRequest), arg0)
-}
-
-// DeleteObjectsWithContext mocks base method.
-func (m *MockS3API) DeleteObjectsWithContext(arg0 context.Context, arg1 *s3.DeleteObjectsInput, arg2 ...request.Option) (*s3.DeleteObjectsOutput, error) {
- m.ctrl.T.Helper()
- varargs := []interface{}{arg0, arg1}
- for _, a := range arg2 {
- varargs = append(varargs, a)
- }
- ret := m.ctrl.Call(m, "DeleteObjectsWithContext", varargs...)
- ret0, _ := ret[0].(*s3.DeleteObjectsOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// DeleteObjectsWithContext indicates an expected call of DeleteObjectsWithContext.
-func (mr *MockS3APIMockRecorder) DeleteObjectsWithContext(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, "DeleteObjectsWithContext", reflect.TypeOf((*MockS3API)(nil).DeleteObjectsWithContext), varargs...)
-}
-
-// DeletePublicAccessBlock mocks base method.
-func (m *MockS3API) DeletePublicAccessBlock(arg0 *s3.DeletePublicAccessBlockInput) (*s3.DeletePublicAccessBlockOutput, error) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "DeletePublicAccessBlock", arg0)
- ret0, _ := ret[0].(*s3.DeletePublicAccessBlockOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// DeletePublicAccessBlock indicates an expected call of DeletePublicAccessBlock.
-func (mr *MockS3APIMockRecorder) DeletePublicAccessBlock(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeletePublicAccessBlock", reflect.TypeOf((*MockS3API)(nil).DeletePublicAccessBlock), arg0)
-}
-
-// DeletePublicAccessBlockRequest mocks base method.
-func (m *MockS3API) DeletePublicAccessBlockRequest(arg0 *s3.DeletePublicAccessBlockInput) (*request.Request, *s3.DeletePublicAccessBlockOutput) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "DeletePublicAccessBlockRequest", arg0)
- ret0, _ := ret[0].(*request.Request)
- ret1, _ := ret[1].(*s3.DeletePublicAccessBlockOutput)
- return ret0, ret1
-}
-
-// DeletePublicAccessBlockRequest indicates an expected call of DeletePublicAccessBlockRequest.
-func (mr *MockS3APIMockRecorder) DeletePublicAccessBlockRequest(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeletePublicAccessBlockRequest", reflect.TypeOf((*MockS3API)(nil).DeletePublicAccessBlockRequest), arg0)
-}
-
-// DeletePublicAccessBlockWithContext mocks base method.
-func (m *MockS3API) DeletePublicAccessBlockWithContext(arg0 context.Context, arg1 *s3.DeletePublicAccessBlockInput, arg2 ...request.Option) (*s3.DeletePublicAccessBlockOutput, error) {
- m.ctrl.T.Helper()
- varargs := []interface{}{arg0, arg1}
- for _, a := range arg2 {
- varargs = append(varargs, a)
- }
- ret := m.ctrl.Call(m, "DeletePublicAccessBlockWithContext", varargs...)
- ret0, _ := ret[0].(*s3.DeletePublicAccessBlockOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// DeletePublicAccessBlockWithContext indicates an expected call of DeletePublicAccessBlockWithContext.
-func (mr *MockS3APIMockRecorder) DeletePublicAccessBlockWithContext(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, "DeletePublicAccessBlockWithContext", reflect.TypeOf((*MockS3API)(nil).DeletePublicAccessBlockWithContext), varargs...)
-}
-
-// GetBucketAccelerateConfiguration mocks base method.
-func (m *MockS3API) GetBucketAccelerateConfiguration(arg0 *s3.GetBucketAccelerateConfigurationInput) (*s3.GetBucketAccelerateConfigurationOutput, error) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "GetBucketAccelerateConfiguration", arg0)
- ret0, _ := ret[0].(*s3.GetBucketAccelerateConfigurationOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// GetBucketAccelerateConfiguration indicates an expected call of GetBucketAccelerateConfiguration.
-func (mr *MockS3APIMockRecorder) GetBucketAccelerateConfiguration(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketAccelerateConfiguration", reflect.TypeOf((*MockS3API)(nil).GetBucketAccelerateConfiguration), arg0)
-}
-
-// GetBucketAccelerateConfigurationRequest mocks base method.
-func (m *MockS3API) GetBucketAccelerateConfigurationRequest(arg0 *s3.GetBucketAccelerateConfigurationInput) (*request.Request, *s3.GetBucketAccelerateConfigurationOutput) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "GetBucketAccelerateConfigurationRequest", arg0)
- ret0, _ := ret[0].(*request.Request)
- ret1, _ := ret[1].(*s3.GetBucketAccelerateConfigurationOutput)
- return ret0, ret1
-}
-
-// GetBucketAccelerateConfigurationRequest indicates an expected call of GetBucketAccelerateConfigurationRequest.
-func (mr *MockS3APIMockRecorder) GetBucketAccelerateConfigurationRequest(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketAccelerateConfigurationRequest", reflect.TypeOf((*MockS3API)(nil).GetBucketAccelerateConfigurationRequest), arg0)
-}
-
-// GetBucketAccelerateConfigurationWithContext mocks base method.
-func (m *MockS3API) GetBucketAccelerateConfigurationWithContext(arg0 context.Context, arg1 *s3.GetBucketAccelerateConfigurationInput, arg2 ...request.Option) (*s3.GetBucketAccelerateConfigurationOutput, error) {
- m.ctrl.T.Helper()
- varargs := []interface{}{arg0, arg1}
- for _, a := range arg2 {
- varargs = append(varargs, a)
- }
- ret := m.ctrl.Call(m, "GetBucketAccelerateConfigurationWithContext", varargs...)
- ret0, _ := ret[0].(*s3.GetBucketAccelerateConfigurationOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// GetBucketAccelerateConfigurationWithContext indicates an expected call of GetBucketAccelerateConfigurationWithContext.
-func (mr *MockS3APIMockRecorder) GetBucketAccelerateConfigurationWithContext(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, "GetBucketAccelerateConfigurationWithContext", reflect.TypeOf((*MockS3API)(nil).GetBucketAccelerateConfigurationWithContext), varargs...)
-}
-
-// GetBucketAcl mocks base method.
-func (m *MockS3API) GetBucketAcl(arg0 *s3.GetBucketAclInput) (*s3.GetBucketAclOutput, error) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "GetBucketAcl", arg0)
- ret0, _ := ret[0].(*s3.GetBucketAclOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// GetBucketAcl indicates an expected call of GetBucketAcl.
-func (mr *MockS3APIMockRecorder) GetBucketAcl(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketAcl", reflect.TypeOf((*MockS3API)(nil).GetBucketAcl), arg0)
-}
-
-// GetBucketAclRequest mocks base method.
-func (m *MockS3API) GetBucketAclRequest(arg0 *s3.GetBucketAclInput) (*request.Request, *s3.GetBucketAclOutput) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "GetBucketAclRequest", arg0)
- ret0, _ := ret[0].(*request.Request)
- ret1, _ := ret[1].(*s3.GetBucketAclOutput)
- return ret0, ret1
-}
-
-// GetBucketAclRequest indicates an expected call of GetBucketAclRequest.
-func (mr *MockS3APIMockRecorder) GetBucketAclRequest(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketAclRequest", reflect.TypeOf((*MockS3API)(nil).GetBucketAclRequest), arg0)
-}
-
-// GetBucketAclWithContext mocks base method.
-func (m *MockS3API) GetBucketAclWithContext(arg0 context.Context, arg1 *s3.GetBucketAclInput, arg2 ...request.Option) (*s3.GetBucketAclOutput, error) {
- m.ctrl.T.Helper()
- varargs := []interface{}{arg0, arg1}
- for _, a := range arg2 {
- varargs = append(varargs, a)
- }
- ret := m.ctrl.Call(m, "GetBucketAclWithContext", varargs...)
- ret0, _ := ret[0].(*s3.GetBucketAclOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// GetBucketAclWithContext indicates an expected call of GetBucketAclWithContext.
-func (mr *MockS3APIMockRecorder) GetBucketAclWithContext(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, "GetBucketAclWithContext", reflect.TypeOf((*MockS3API)(nil).GetBucketAclWithContext), varargs...)
-}
-
-// GetBucketAnalyticsConfiguration mocks base method.
-func (m *MockS3API) GetBucketAnalyticsConfiguration(arg0 *s3.GetBucketAnalyticsConfigurationInput) (*s3.GetBucketAnalyticsConfigurationOutput, error) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "GetBucketAnalyticsConfiguration", arg0)
- ret0, _ := ret[0].(*s3.GetBucketAnalyticsConfigurationOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// GetBucketAnalyticsConfiguration indicates an expected call of GetBucketAnalyticsConfiguration.
-func (mr *MockS3APIMockRecorder) GetBucketAnalyticsConfiguration(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketAnalyticsConfiguration", reflect.TypeOf((*MockS3API)(nil).GetBucketAnalyticsConfiguration), arg0)
-}
-
-// GetBucketAnalyticsConfigurationRequest mocks base method.
-func (m *MockS3API) GetBucketAnalyticsConfigurationRequest(arg0 *s3.GetBucketAnalyticsConfigurationInput) (*request.Request, *s3.GetBucketAnalyticsConfigurationOutput) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "GetBucketAnalyticsConfigurationRequest", arg0)
- ret0, _ := ret[0].(*request.Request)
- ret1, _ := ret[1].(*s3.GetBucketAnalyticsConfigurationOutput)
- return ret0, ret1
-}
-
-// GetBucketAnalyticsConfigurationRequest indicates an expected call of GetBucketAnalyticsConfigurationRequest.
-func (mr *MockS3APIMockRecorder) GetBucketAnalyticsConfigurationRequest(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketAnalyticsConfigurationRequest", reflect.TypeOf((*MockS3API)(nil).GetBucketAnalyticsConfigurationRequest), arg0)
-}
-
-// GetBucketAnalyticsConfigurationWithContext mocks base method.
-func (m *MockS3API) GetBucketAnalyticsConfigurationWithContext(arg0 context.Context, arg1 *s3.GetBucketAnalyticsConfigurationInput, arg2 ...request.Option) (*s3.GetBucketAnalyticsConfigurationOutput, error) {
- m.ctrl.T.Helper()
- varargs := []interface{}{arg0, arg1}
- for _, a := range arg2 {
- varargs = append(varargs, a)
- }
- ret := m.ctrl.Call(m, "GetBucketAnalyticsConfigurationWithContext", varargs...)
- ret0, _ := ret[0].(*s3.GetBucketAnalyticsConfigurationOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// GetBucketAnalyticsConfigurationWithContext indicates an expected call of GetBucketAnalyticsConfigurationWithContext.
-func (mr *MockS3APIMockRecorder) GetBucketAnalyticsConfigurationWithContext(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, "GetBucketAnalyticsConfigurationWithContext", reflect.TypeOf((*MockS3API)(nil).GetBucketAnalyticsConfigurationWithContext), varargs...)
-}
-
-// GetBucketCors mocks base method.
-func (m *MockS3API) GetBucketCors(arg0 *s3.GetBucketCorsInput) (*s3.GetBucketCorsOutput, error) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "GetBucketCors", arg0)
- ret0, _ := ret[0].(*s3.GetBucketCorsOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// GetBucketCors indicates an expected call of GetBucketCors.
-func (mr *MockS3APIMockRecorder) GetBucketCors(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketCors", reflect.TypeOf((*MockS3API)(nil).GetBucketCors), arg0)
-}
-
-// GetBucketCorsRequest mocks base method.
-func (m *MockS3API) GetBucketCorsRequest(arg0 *s3.GetBucketCorsInput) (*request.Request, *s3.GetBucketCorsOutput) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "GetBucketCorsRequest", arg0)
- ret0, _ := ret[0].(*request.Request)
- ret1, _ := ret[1].(*s3.GetBucketCorsOutput)
- return ret0, ret1
-}
-
-// GetBucketCorsRequest indicates an expected call of GetBucketCorsRequest.
-func (mr *MockS3APIMockRecorder) GetBucketCorsRequest(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketCorsRequest", reflect.TypeOf((*MockS3API)(nil).GetBucketCorsRequest), arg0)
-}
-
-// GetBucketCorsWithContext mocks base method.
-func (m *MockS3API) GetBucketCorsWithContext(arg0 context.Context, arg1 *s3.GetBucketCorsInput, arg2 ...request.Option) (*s3.GetBucketCorsOutput, error) {
- m.ctrl.T.Helper()
- varargs := []interface{}{arg0, arg1}
- for _, a := range arg2 {
- varargs = append(varargs, a)
- }
- ret := m.ctrl.Call(m, "GetBucketCorsWithContext", varargs...)
- ret0, _ := ret[0].(*s3.GetBucketCorsOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// GetBucketCorsWithContext indicates an expected call of GetBucketCorsWithContext.
-func (mr *MockS3APIMockRecorder) GetBucketCorsWithContext(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, "GetBucketCorsWithContext", reflect.TypeOf((*MockS3API)(nil).GetBucketCorsWithContext), varargs...)
-}
-
-// GetBucketEncryption mocks base method.
-func (m *MockS3API) GetBucketEncryption(arg0 *s3.GetBucketEncryptionInput) (*s3.GetBucketEncryptionOutput, error) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "GetBucketEncryption", arg0)
- ret0, _ := ret[0].(*s3.GetBucketEncryptionOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// GetBucketEncryption indicates an expected call of GetBucketEncryption.
-func (mr *MockS3APIMockRecorder) GetBucketEncryption(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketEncryption", reflect.TypeOf((*MockS3API)(nil).GetBucketEncryption), arg0)
-}
-
-// GetBucketEncryptionRequest mocks base method.
-func (m *MockS3API) GetBucketEncryptionRequest(arg0 *s3.GetBucketEncryptionInput) (*request.Request, *s3.GetBucketEncryptionOutput) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "GetBucketEncryptionRequest", arg0)
- ret0, _ := ret[0].(*request.Request)
- ret1, _ := ret[1].(*s3.GetBucketEncryptionOutput)
- return ret0, ret1
-}
-
-// GetBucketEncryptionRequest indicates an expected call of GetBucketEncryptionRequest.
-func (mr *MockS3APIMockRecorder) GetBucketEncryptionRequest(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketEncryptionRequest", reflect.TypeOf((*MockS3API)(nil).GetBucketEncryptionRequest), arg0)
-}
-
-// GetBucketEncryptionWithContext mocks base method.
-func (m *MockS3API) GetBucketEncryptionWithContext(arg0 context.Context, arg1 *s3.GetBucketEncryptionInput, arg2 ...request.Option) (*s3.GetBucketEncryptionOutput, error) {
- m.ctrl.T.Helper()
- varargs := []interface{}{arg0, arg1}
- for _, a := range arg2 {
- varargs = append(varargs, a)
- }
- ret := m.ctrl.Call(m, "GetBucketEncryptionWithContext", varargs...)
- ret0, _ := ret[0].(*s3.GetBucketEncryptionOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// GetBucketEncryptionWithContext indicates an expected call of GetBucketEncryptionWithContext.
-func (mr *MockS3APIMockRecorder) GetBucketEncryptionWithContext(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, "GetBucketEncryptionWithContext", reflect.TypeOf((*MockS3API)(nil).GetBucketEncryptionWithContext), varargs...)
-}
-
-// GetBucketIntelligentTieringConfiguration mocks base method.
-func (m *MockS3API) GetBucketIntelligentTieringConfiguration(arg0 *s3.GetBucketIntelligentTieringConfigurationInput) (*s3.GetBucketIntelligentTieringConfigurationOutput, error) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "GetBucketIntelligentTieringConfiguration", arg0)
- ret0, _ := ret[0].(*s3.GetBucketIntelligentTieringConfigurationOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// GetBucketIntelligentTieringConfiguration indicates an expected call of GetBucketIntelligentTieringConfiguration.
-func (mr *MockS3APIMockRecorder) GetBucketIntelligentTieringConfiguration(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketIntelligentTieringConfiguration", reflect.TypeOf((*MockS3API)(nil).GetBucketIntelligentTieringConfiguration), arg0)
-}
-
-// GetBucketIntelligentTieringConfigurationRequest mocks base method.
-func (m *MockS3API) GetBucketIntelligentTieringConfigurationRequest(arg0 *s3.GetBucketIntelligentTieringConfigurationInput) (*request.Request, *s3.GetBucketIntelligentTieringConfigurationOutput) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "GetBucketIntelligentTieringConfigurationRequest", arg0)
- ret0, _ := ret[0].(*request.Request)
- ret1, _ := ret[1].(*s3.GetBucketIntelligentTieringConfigurationOutput)
- return ret0, ret1
-}
-
-// GetBucketIntelligentTieringConfigurationRequest indicates an expected call of GetBucketIntelligentTieringConfigurationRequest.
-func (mr *MockS3APIMockRecorder) GetBucketIntelligentTieringConfigurationRequest(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketIntelligentTieringConfigurationRequest", reflect.TypeOf((*MockS3API)(nil).GetBucketIntelligentTieringConfigurationRequest), arg0)
-}
-
-// GetBucketIntelligentTieringConfigurationWithContext mocks base method.
-func (m *MockS3API) GetBucketIntelligentTieringConfigurationWithContext(arg0 context.Context, arg1 *s3.GetBucketIntelligentTieringConfigurationInput, arg2 ...request.Option) (*s3.GetBucketIntelligentTieringConfigurationOutput, error) {
- m.ctrl.T.Helper()
- varargs := []interface{}{arg0, arg1}
- for _, a := range arg2 {
- varargs = append(varargs, a)
- }
- ret := m.ctrl.Call(m, "GetBucketIntelligentTieringConfigurationWithContext", varargs...)
- ret0, _ := ret[0].(*s3.GetBucketIntelligentTieringConfigurationOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// GetBucketIntelligentTieringConfigurationWithContext indicates an expected call of GetBucketIntelligentTieringConfigurationWithContext.
-func (mr *MockS3APIMockRecorder) GetBucketIntelligentTieringConfigurationWithContext(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, "GetBucketIntelligentTieringConfigurationWithContext", reflect.TypeOf((*MockS3API)(nil).GetBucketIntelligentTieringConfigurationWithContext), varargs...)
-}
-
-// GetBucketInventoryConfiguration mocks base method.
-func (m *MockS3API) GetBucketInventoryConfiguration(arg0 *s3.GetBucketInventoryConfigurationInput) (*s3.GetBucketInventoryConfigurationOutput, error) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "GetBucketInventoryConfiguration", arg0)
- ret0, _ := ret[0].(*s3.GetBucketInventoryConfigurationOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// GetBucketInventoryConfiguration indicates an expected call of GetBucketInventoryConfiguration.
-func (mr *MockS3APIMockRecorder) GetBucketInventoryConfiguration(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketInventoryConfiguration", reflect.TypeOf((*MockS3API)(nil).GetBucketInventoryConfiguration), arg0)
-}
-
-// GetBucketInventoryConfigurationRequest mocks base method.
-func (m *MockS3API) GetBucketInventoryConfigurationRequest(arg0 *s3.GetBucketInventoryConfigurationInput) (*request.Request, *s3.GetBucketInventoryConfigurationOutput) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "GetBucketInventoryConfigurationRequest", arg0)
- ret0, _ := ret[0].(*request.Request)
- ret1, _ := ret[1].(*s3.GetBucketInventoryConfigurationOutput)
- return ret0, ret1
-}
-
-// GetBucketInventoryConfigurationRequest indicates an expected call of GetBucketInventoryConfigurationRequest.
-func (mr *MockS3APIMockRecorder) GetBucketInventoryConfigurationRequest(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketInventoryConfigurationRequest", reflect.TypeOf((*MockS3API)(nil).GetBucketInventoryConfigurationRequest), arg0)
-}
-
-// GetBucketInventoryConfigurationWithContext mocks base method.
-func (m *MockS3API) GetBucketInventoryConfigurationWithContext(arg0 context.Context, arg1 *s3.GetBucketInventoryConfigurationInput, arg2 ...request.Option) (*s3.GetBucketInventoryConfigurationOutput, error) {
- m.ctrl.T.Helper()
- varargs := []interface{}{arg0, arg1}
- for _, a := range arg2 {
- varargs = append(varargs, a)
- }
- ret := m.ctrl.Call(m, "GetBucketInventoryConfigurationWithContext", varargs...)
- ret0, _ := ret[0].(*s3.GetBucketInventoryConfigurationOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// GetBucketInventoryConfigurationWithContext indicates an expected call of GetBucketInventoryConfigurationWithContext.
-func (mr *MockS3APIMockRecorder) GetBucketInventoryConfigurationWithContext(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, "GetBucketInventoryConfigurationWithContext", reflect.TypeOf((*MockS3API)(nil).GetBucketInventoryConfigurationWithContext), varargs...)
-}
-
-// GetBucketLifecycle mocks base method.
-func (m *MockS3API) GetBucketLifecycle(arg0 *s3.GetBucketLifecycleInput) (*s3.GetBucketLifecycleOutput, error) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "GetBucketLifecycle", arg0)
- ret0, _ := ret[0].(*s3.GetBucketLifecycleOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// GetBucketLifecycle indicates an expected call of GetBucketLifecycle.
-func (mr *MockS3APIMockRecorder) GetBucketLifecycle(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketLifecycle", reflect.TypeOf((*MockS3API)(nil).GetBucketLifecycle), arg0)
-}
-
-// GetBucketLifecycleConfiguration mocks base method.
-func (m *MockS3API) GetBucketLifecycleConfiguration(arg0 *s3.GetBucketLifecycleConfigurationInput) (*s3.GetBucketLifecycleConfigurationOutput, error) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "GetBucketLifecycleConfiguration", arg0)
- ret0, _ := ret[0].(*s3.GetBucketLifecycleConfigurationOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// GetBucketLifecycleConfiguration indicates an expected call of GetBucketLifecycleConfiguration.
-func (mr *MockS3APIMockRecorder) GetBucketLifecycleConfiguration(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketLifecycleConfiguration", reflect.TypeOf((*MockS3API)(nil).GetBucketLifecycleConfiguration), arg0)
-}
-
-// GetBucketLifecycleConfigurationRequest mocks base method.
-func (m *MockS3API) GetBucketLifecycleConfigurationRequest(arg0 *s3.GetBucketLifecycleConfigurationInput) (*request.Request, *s3.GetBucketLifecycleConfigurationOutput) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "GetBucketLifecycleConfigurationRequest", arg0)
- ret0, _ := ret[0].(*request.Request)
- ret1, _ := ret[1].(*s3.GetBucketLifecycleConfigurationOutput)
- return ret0, ret1
-}
-
-// GetBucketLifecycleConfigurationRequest indicates an expected call of GetBucketLifecycleConfigurationRequest.
-func (mr *MockS3APIMockRecorder) GetBucketLifecycleConfigurationRequest(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketLifecycleConfigurationRequest", reflect.TypeOf((*MockS3API)(nil).GetBucketLifecycleConfigurationRequest), arg0)
-}
-
-// GetBucketLifecycleConfigurationWithContext mocks base method.
-func (m *MockS3API) GetBucketLifecycleConfigurationWithContext(arg0 context.Context, arg1 *s3.GetBucketLifecycleConfigurationInput, arg2 ...request.Option) (*s3.GetBucketLifecycleConfigurationOutput, error) {
- m.ctrl.T.Helper()
- varargs := []interface{}{arg0, arg1}
- for _, a := range arg2 {
- varargs = append(varargs, a)
- }
- ret := m.ctrl.Call(m, "GetBucketLifecycleConfigurationWithContext", varargs...)
- ret0, _ := ret[0].(*s3.GetBucketLifecycleConfigurationOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// GetBucketLifecycleConfigurationWithContext indicates an expected call of GetBucketLifecycleConfigurationWithContext.
-func (mr *MockS3APIMockRecorder) GetBucketLifecycleConfigurationWithContext(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, "GetBucketLifecycleConfigurationWithContext", reflect.TypeOf((*MockS3API)(nil).GetBucketLifecycleConfigurationWithContext), varargs...)
-}
-
-// GetBucketLifecycleRequest mocks base method.
-func (m *MockS3API) GetBucketLifecycleRequest(arg0 *s3.GetBucketLifecycleInput) (*request.Request, *s3.GetBucketLifecycleOutput) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "GetBucketLifecycleRequest", arg0)
- ret0, _ := ret[0].(*request.Request)
- ret1, _ := ret[1].(*s3.GetBucketLifecycleOutput)
- return ret0, ret1
-}
-
-// GetBucketLifecycleRequest indicates an expected call of GetBucketLifecycleRequest.
-func (mr *MockS3APIMockRecorder) GetBucketLifecycleRequest(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketLifecycleRequest", reflect.TypeOf((*MockS3API)(nil).GetBucketLifecycleRequest), arg0)
-}
-
-// GetBucketLifecycleWithContext mocks base method.
-func (m *MockS3API) GetBucketLifecycleWithContext(arg0 context.Context, arg1 *s3.GetBucketLifecycleInput, arg2 ...request.Option) (*s3.GetBucketLifecycleOutput, error) {
- m.ctrl.T.Helper()
- varargs := []interface{}{arg0, arg1}
- for _, a := range arg2 {
- varargs = append(varargs, a)
- }
- ret := m.ctrl.Call(m, "GetBucketLifecycleWithContext", varargs...)
- ret0, _ := ret[0].(*s3.GetBucketLifecycleOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// GetBucketLifecycleWithContext indicates an expected call of GetBucketLifecycleWithContext.
-func (mr *MockS3APIMockRecorder) GetBucketLifecycleWithContext(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, "GetBucketLifecycleWithContext", reflect.TypeOf((*MockS3API)(nil).GetBucketLifecycleWithContext), varargs...)
-}
-
-// GetBucketLocation mocks base method.
-func (m *MockS3API) GetBucketLocation(arg0 *s3.GetBucketLocationInput) (*s3.GetBucketLocationOutput, error) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "GetBucketLocation", arg0)
- ret0, _ := ret[0].(*s3.GetBucketLocationOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// GetBucketLocation indicates an expected call of GetBucketLocation.
-func (mr *MockS3APIMockRecorder) GetBucketLocation(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketLocation", reflect.TypeOf((*MockS3API)(nil).GetBucketLocation), arg0)
-}
-
-// GetBucketLocationRequest mocks base method.
-func (m *MockS3API) GetBucketLocationRequest(arg0 *s3.GetBucketLocationInput) (*request.Request, *s3.GetBucketLocationOutput) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "GetBucketLocationRequest", arg0)
- ret0, _ := ret[0].(*request.Request)
- ret1, _ := ret[1].(*s3.GetBucketLocationOutput)
- return ret0, ret1
-}
-
-// GetBucketLocationRequest indicates an expected call of GetBucketLocationRequest.
-func (mr *MockS3APIMockRecorder) GetBucketLocationRequest(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketLocationRequest", reflect.TypeOf((*MockS3API)(nil).GetBucketLocationRequest), arg0)
-}
-
-// GetBucketLocationWithContext mocks base method.
-func (m *MockS3API) GetBucketLocationWithContext(arg0 context.Context, arg1 *s3.GetBucketLocationInput, arg2 ...request.Option) (*s3.GetBucketLocationOutput, error) {
- m.ctrl.T.Helper()
- varargs := []interface{}{arg0, arg1}
- for _, a := range arg2 {
- varargs = append(varargs, a)
- }
- ret := m.ctrl.Call(m, "GetBucketLocationWithContext", varargs...)
- ret0, _ := ret[0].(*s3.GetBucketLocationOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// GetBucketLocationWithContext indicates an expected call of GetBucketLocationWithContext.
-func (mr *MockS3APIMockRecorder) GetBucketLocationWithContext(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, "GetBucketLocationWithContext", reflect.TypeOf((*MockS3API)(nil).GetBucketLocationWithContext), varargs...)
-}
-
-// GetBucketLogging mocks base method.
-func (m *MockS3API) GetBucketLogging(arg0 *s3.GetBucketLoggingInput) (*s3.GetBucketLoggingOutput, error) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "GetBucketLogging", arg0)
- ret0, _ := ret[0].(*s3.GetBucketLoggingOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// GetBucketLogging indicates an expected call of GetBucketLogging.
-func (mr *MockS3APIMockRecorder) GetBucketLogging(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketLogging", reflect.TypeOf((*MockS3API)(nil).GetBucketLogging), arg0)
-}
-
-// GetBucketLoggingRequest mocks base method.
-func (m *MockS3API) GetBucketLoggingRequest(arg0 *s3.GetBucketLoggingInput) (*request.Request, *s3.GetBucketLoggingOutput) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "GetBucketLoggingRequest", arg0)
- ret0, _ := ret[0].(*request.Request)
- ret1, _ := ret[1].(*s3.GetBucketLoggingOutput)
- return ret0, ret1
-}
-
-// GetBucketLoggingRequest indicates an expected call of GetBucketLoggingRequest.
-func (mr *MockS3APIMockRecorder) GetBucketLoggingRequest(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketLoggingRequest", reflect.TypeOf((*MockS3API)(nil).GetBucketLoggingRequest), arg0)
-}
-
-// GetBucketLoggingWithContext mocks base method.
-func (m *MockS3API) GetBucketLoggingWithContext(arg0 context.Context, arg1 *s3.GetBucketLoggingInput, arg2 ...request.Option) (*s3.GetBucketLoggingOutput, error) {
- m.ctrl.T.Helper()
- varargs := []interface{}{arg0, arg1}
- for _, a := range arg2 {
- varargs = append(varargs, a)
- }
- ret := m.ctrl.Call(m, "GetBucketLoggingWithContext", varargs...)
- ret0, _ := ret[0].(*s3.GetBucketLoggingOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// GetBucketLoggingWithContext indicates an expected call of GetBucketLoggingWithContext.
-func (mr *MockS3APIMockRecorder) GetBucketLoggingWithContext(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, "GetBucketLoggingWithContext", reflect.TypeOf((*MockS3API)(nil).GetBucketLoggingWithContext), varargs...)
-}
-
-// GetBucketMetricsConfiguration mocks base method.
-func (m *MockS3API) GetBucketMetricsConfiguration(arg0 *s3.GetBucketMetricsConfigurationInput) (*s3.GetBucketMetricsConfigurationOutput, error) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "GetBucketMetricsConfiguration", arg0)
- ret0, _ := ret[0].(*s3.GetBucketMetricsConfigurationOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// GetBucketMetricsConfiguration indicates an expected call of GetBucketMetricsConfiguration.
-func (mr *MockS3APIMockRecorder) GetBucketMetricsConfiguration(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketMetricsConfiguration", reflect.TypeOf((*MockS3API)(nil).GetBucketMetricsConfiguration), arg0)
-}
-
-// GetBucketMetricsConfigurationRequest mocks base method.
-func (m *MockS3API) GetBucketMetricsConfigurationRequest(arg0 *s3.GetBucketMetricsConfigurationInput) (*request.Request, *s3.GetBucketMetricsConfigurationOutput) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "GetBucketMetricsConfigurationRequest", arg0)
- ret0, _ := ret[0].(*request.Request)
- ret1, _ := ret[1].(*s3.GetBucketMetricsConfigurationOutput)
- return ret0, ret1
-}
-
-// GetBucketMetricsConfigurationRequest indicates an expected call of GetBucketMetricsConfigurationRequest.
-func (mr *MockS3APIMockRecorder) GetBucketMetricsConfigurationRequest(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketMetricsConfigurationRequest", reflect.TypeOf((*MockS3API)(nil).GetBucketMetricsConfigurationRequest), arg0)
-}
-
-// GetBucketMetricsConfigurationWithContext mocks base method.
-func (m *MockS3API) GetBucketMetricsConfigurationWithContext(arg0 context.Context, arg1 *s3.GetBucketMetricsConfigurationInput, arg2 ...request.Option) (*s3.GetBucketMetricsConfigurationOutput, error) {
- m.ctrl.T.Helper()
- varargs := []interface{}{arg0, arg1}
- for _, a := range arg2 {
- varargs = append(varargs, a)
- }
- ret := m.ctrl.Call(m, "GetBucketMetricsConfigurationWithContext", varargs...)
- ret0, _ := ret[0].(*s3.GetBucketMetricsConfigurationOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// GetBucketMetricsConfigurationWithContext indicates an expected call of GetBucketMetricsConfigurationWithContext.
-func (mr *MockS3APIMockRecorder) GetBucketMetricsConfigurationWithContext(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, "GetBucketMetricsConfigurationWithContext", reflect.TypeOf((*MockS3API)(nil).GetBucketMetricsConfigurationWithContext), varargs...)
-}
-
-// GetBucketNotification mocks base method.
-func (m *MockS3API) GetBucketNotification(arg0 *s3.GetBucketNotificationConfigurationRequest) (*s3.NotificationConfigurationDeprecated, error) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "GetBucketNotification", arg0)
- ret0, _ := ret[0].(*s3.NotificationConfigurationDeprecated)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// GetBucketNotification indicates an expected call of GetBucketNotification.
-func (mr *MockS3APIMockRecorder) GetBucketNotification(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketNotification", reflect.TypeOf((*MockS3API)(nil).GetBucketNotification), arg0)
-}
-
-// GetBucketNotificationConfiguration mocks base method.
-func (m *MockS3API) GetBucketNotificationConfiguration(arg0 *s3.GetBucketNotificationConfigurationRequest) (*s3.NotificationConfiguration, error) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "GetBucketNotificationConfiguration", arg0)
- ret0, _ := ret[0].(*s3.NotificationConfiguration)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// GetBucketNotificationConfiguration indicates an expected call of GetBucketNotificationConfiguration.
-func (mr *MockS3APIMockRecorder) GetBucketNotificationConfiguration(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketNotificationConfiguration", reflect.TypeOf((*MockS3API)(nil).GetBucketNotificationConfiguration), arg0)
-}
-
-// GetBucketNotificationConfigurationRequest mocks base method.
-func (m *MockS3API) GetBucketNotificationConfigurationRequest(arg0 *s3.GetBucketNotificationConfigurationRequest) (*request.Request, *s3.NotificationConfiguration) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "GetBucketNotificationConfigurationRequest", arg0)
- ret0, _ := ret[0].(*request.Request)
- ret1, _ := ret[1].(*s3.NotificationConfiguration)
- return ret0, ret1
-}
-
-// GetBucketNotificationConfigurationRequest indicates an expected call of GetBucketNotificationConfigurationRequest.
-func (mr *MockS3APIMockRecorder) GetBucketNotificationConfigurationRequest(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketNotificationConfigurationRequest", reflect.TypeOf((*MockS3API)(nil).GetBucketNotificationConfigurationRequest), arg0)
-}
-
-// GetBucketNotificationConfigurationWithContext mocks base method.
-func (m *MockS3API) GetBucketNotificationConfigurationWithContext(arg0 context.Context, arg1 *s3.GetBucketNotificationConfigurationRequest, arg2 ...request.Option) (*s3.NotificationConfiguration, error) {
- m.ctrl.T.Helper()
- varargs := []interface{}{arg0, arg1}
- for _, a := range arg2 {
- varargs = append(varargs, a)
- }
- ret := m.ctrl.Call(m, "GetBucketNotificationConfigurationWithContext", varargs...)
- ret0, _ := ret[0].(*s3.NotificationConfiguration)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// GetBucketNotificationConfigurationWithContext indicates an expected call of GetBucketNotificationConfigurationWithContext.
-func (mr *MockS3APIMockRecorder) GetBucketNotificationConfigurationWithContext(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, "GetBucketNotificationConfigurationWithContext", reflect.TypeOf((*MockS3API)(nil).GetBucketNotificationConfigurationWithContext), varargs...)
-}
-
-// GetBucketNotificationRequest mocks base method.
-func (m *MockS3API) GetBucketNotificationRequest(arg0 *s3.GetBucketNotificationConfigurationRequest) (*request.Request, *s3.NotificationConfigurationDeprecated) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "GetBucketNotificationRequest", arg0)
- ret0, _ := ret[0].(*request.Request)
- ret1, _ := ret[1].(*s3.NotificationConfigurationDeprecated)
- return ret0, ret1
-}
-
-// GetBucketNotificationRequest indicates an expected call of GetBucketNotificationRequest.
-func (mr *MockS3APIMockRecorder) GetBucketNotificationRequest(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketNotificationRequest", reflect.TypeOf((*MockS3API)(nil).GetBucketNotificationRequest), arg0)
-}
-
-// GetBucketNotificationWithContext mocks base method.
-func (m *MockS3API) GetBucketNotificationWithContext(arg0 context.Context, arg1 *s3.GetBucketNotificationConfigurationRequest, arg2 ...request.Option) (*s3.NotificationConfigurationDeprecated, error) {
- m.ctrl.T.Helper()
- varargs := []interface{}{arg0, arg1}
- for _, a := range arg2 {
- varargs = append(varargs, a)
- }
- ret := m.ctrl.Call(m, "GetBucketNotificationWithContext", varargs...)
- ret0, _ := ret[0].(*s3.NotificationConfigurationDeprecated)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// GetBucketNotificationWithContext indicates an expected call of GetBucketNotificationWithContext.
-func (mr *MockS3APIMockRecorder) GetBucketNotificationWithContext(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, "GetBucketNotificationWithContext", reflect.TypeOf((*MockS3API)(nil).GetBucketNotificationWithContext), varargs...)
-}
-
-// GetBucketOwnershipControls mocks base method.
-func (m *MockS3API) GetBucketOwnershipControls(arg0 *s3.GetBucketOwnershipControlsInput) (*s3.GetBucketOwnershipControlsOutput, error) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "GetBucketOwnershipControls", arg0)
- ret0, _ := ret[0].(*s3.GetBucketOwnershipControlsOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// GetBucketOwnershipControls indicates an expected call of GetBucketOwnershipControls.
-func (mr *MockS3APIMockRecorder) GetBucketOwnershipControls(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketOwnershipControls", reflect.TypeOf((*MockS3API)(nil).GetBucketOwnershipControls), arg0)
-}
-
-// GetBucketOwnershipControlsRequest mocks base method.
-func (m *MockS3API) GetBucketOwnershipControlsRequest(arg0 *s3.GetBucketOwnershipControlsInput) (*request.Request, *s3.GetBucketOwnershipControlsOutput) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "GetBucketOwnershipControlsRequest", arg0)
- ret0, _ := ret[0].(*request.Request)
- ret1, _ := ret[1].(*s3.GetBucketOwnershipControlsOutput)
- return ret0, ret1
-}
-
-// GetBucketOwnershipControlsRequest indicates an expected call of GetBucketOwnershipControlsRequest.
-func (mr *MockS3APIMockRecorder) GetBucketOwnershipControlsRequest(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketOwnershipControlsRequest", reflect.TypeOf((*MockS3API)(nil).GetBucketOwnershipControlsRequest), arg0)
-}
-
-// GetBucketOwnershipControlsWithContext mocks base method.
-func (m *MockS3API) GetBucketOwnershipControlsWithContext(arg0 context.Context, arg1 *s3.GetBucketOwnershipControlsInput, arg2 ...request.Option) (*s3.GetBucketOwnershipControlsOutput, error) {
- m.ctrl.T.Helper()
- varargs := []interface{}{arg0, arg1}
- for _, a := range arg2 {
- varargs = append(varargs, a)
- }
- ret := m.ctrl.Call(m, "GetBucketOwnershipControlsWithContext", varargs...)
- ret0, _ := ret[0].(*s3.GetBucketOwnershipControlsOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// GetBucketOwnershipControlsWithContext indicates an expected call of GetBucketOwnershipControlsWithContext.
-func (mr *MockS3APIMockRecorder) GetBucketOwnershipControlsWithContext(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, "GetBucketOwnershipControlsWithContext", reflect.TypeOf((*MockS3API)(nil).GetBucketOwnershipControlsWithContext), varargs...)
-}
-
-// GetBucketPolicy mocks base method.
-func (m *MockS3API) GetBucketPolicy(arg0 *s3.GetBucketPolicyInput) (*s3.GetBucketPolicyOutput, error) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "GetBucketPolicy", arg0)
- ret0, _ := ret[0].(*s3.GetBucketPolicyOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// GetBucketPolicy indicates an expected call of GetBucketPolicy.
-func (mr *MockS3APIMockRecorder) GetBucketPolicy(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketPolicy", reflect.TypeOf((*MockS3API)(nil).GetBucketPolicy), arg0)
-}
-
-// GetBucketPolicyRequest mocks base method.
-func (m *MockS3API) GetBucketPolicyRequest(arg0 *s3.GetBucketPolicyInput) (*request.Request, *s3.GetBucketPolicyOutput) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "GetBucketPolicyRequest", arg0)
- ret0, _ := ret[0].(*request.Request)
- ret1, _ := ret[1].(*s3.GetBucketPolicyOutput)
- return ret0, ret1
-}
-
-// GetBucketPolicyRequest indicates an expected call of GetBucketPolicyRequest.
-func (mr *MockS3APIMockRecorder) GetBucketPolicyRequest(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketPolicyRequest", reflect.TypeOf((*MockS3API)(nil).GetBucketPolicyRequest), arg0)
-}
-
-// GetBucketPolicyStatus mocks base method.
-func (m *MockS3API) GetBucketPolicyStatus(arg0 *s3.GetBucketPolicyStatusInput) (*s3.GetBucketPolicyStatusOutput, error) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "GetBucketPolicyStatus", arg0)
- ret0, _ := ret[0].(*s3.GetBucketPolicyStatusOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// GetBucketPolicyStatus indicates an expected call of GetBucketPolicyStatus.
-func (mr *MockS3APIMockRecorder) GetBucketPolicyStatus(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketPolicyStatus", reflect.TypeOf((*MockS3API)(nil).GetBucketPolicyStatus), arg0)
-}
-
-// GetBucketPolicyStatusRequest mocks base method.
-func (m *MockS3API) GetBucketPolicyStatusRequest(arg0 *s3.GetBucketPolicyStatusInput) (*request.Request, *s3.GetBucketPolicyStatusOutput) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "GetBucketPolicyStatusRequest", arg0)
- ret0, _ := ret[0].(*request.Request)
- ret1, _ := ret[1].(*s3.GetBucketPolicyStatusOutput)
- return ret0, ret1
-}
-
-// GetBucketPolicyStatusRequest indicates an expected call of GetBucketPolicyStatusRequest.
-func (mr *MockS3APIMockRecorder) GetBucketPolicyStatusRequest(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketPolicyStatusRequest", reflect.TypeOf((*MockS3API)(nil).GetBucketPolicyStatusRequest), arg0)
-}
-
-// GetBucketPolicyStatusWithContext mocks base method.
-func (m *MockS3API) GetBucketPolicyStatusWithContext(arg0 context.Context, arg1 *s3.GetBucketPolicyStatusInput, arg2 ...request.Option) (*s3.GetBucketPolicyStatusOutput, error) {
- m.ctrl.T.Helper()
- varargs := []interface{}{arg0, arg1}
- for _, a := range arg2 {
- varargs = append(varargs, a)
- }
- ret := m.ctrl.Call(m, "GetBucketPolicyStatusWithContext", varargs...)
- ret0, _ := ret[0].(*s3.GetBucketPolicyStatusOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// GetBucketPolicyStatusWithContext indicates an expected call of GetBucketPolicyStatusWithContext.
-func (mr *MockS3APIMockRecorder) GetBucketPolicyStatusWithContext(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, "GetBucketPolicyStatusWithContext", reflect.TypeOf((*MockS3API)(nil).GetBucketPolicyStatusWithContext), varargs...)
-}
-
-// GetBucketPolicyWithContext mocks base method.
-func (m *MockS3API) GetBucketPolicyWithContext(arg0 context.Context, arg1 *s3.GetBucketPolicyInput, arg2 ...request.Option) (*s3.GetBucketPolicyOutput, error) {
- m.ctrl.T.Helper()
- varargs := []interface{}{arg0, arg1}
- for _, a := range arg2 {
- varargs = append(varargs, a)
- }
- ret := m.ctrl.Call(m, "GetBucketPolicyWithContext", varargs...)
- ret0, _ := ret[0].(*s3.GetBucketPolicyOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// GetBucketPolicyWithContext indicates an expected call of GetBucketPolicyWithContext.
-func (mr *MockS3APIMockRecorder) GetBucketPolicyWithContext(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, "GetBucketPolicyWithContext", reflect.TypeOf((*MockS3API)(nil).GetBucketPolicyWithContext), varargs...)
-}
-
-// GetBucketReplication mocks base method.
-func (m *MockS3API) GetBucketReplication(arg0 *s3.GetBucketReplicationInput) (*s3.GetBucketReplicationOutput, error) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "GetBucketReplication", arg0)
- ret0, _ := ret[0].(*s3.GetBucketReplicationOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// GetBucketReplication indicates an expected call of GetBucketReplication.
-func (mr *MockS3APIMockRecorder) GetBucketReplication(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketReplication", reflect.TypeOf((*MockS3API)(nil).GetBucketReplication), arg0)
-}
-
-// GetBucketReplicationRequest mocks base method.
-func (m *MockS3API) GetBucketReplicationRequest(arg0 *s3.GetBucketReplicationInput) (*request.Request, *s3.GetBucketReplicationOutput) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "GetBucketReplicationRequest", arg0)
- ret0, _ := ret[0].(*request.Request)
- ret1, _ := ret[1].(*s3.GetBucketReplicationOutput)
- return ret0, ret1
-}
-
-// GetBucketReplicationRequest indicates an expected call of GetBucketReplicationRequest.
-func (mr *MockS3APIMockRecorder) GetBucketReplicationRequest(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketReplicationRequest", reflect.TypeOf((*MockS3API)(nil).GetBucketReplicationRequest), arg0)
-}
-
-// GetBucketReplicationWithContext mocks base method.
-func (m *MockS3API) GetBucketReplicationWithContext(arg0 context.Context, arg1 *s3.GetBucketReplicationInput, arg2 ...request.Option) (*s3.GetBucketReplicationOutput, error) {
- m.ctrl.T.Helper()
- varargs := []interface{}{arg0, arg1}
- for _, a := range arg2 {
- varargs = append(varargs, a)
- }
- ret := m.ctrl.Call(m, "GetBucketReplicationWithContext", varargs...)
- ret0, _ := ret[0].(*s3.GetBucketReplicationOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// GetBucketReplicationWithContext indicates an expected call of GetBucketReplicationWithContext.
-func (mr *MockS3APIMockRecorder) GetBucketReplicationWithContext(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, "GetBucketReplicationWithContext", reflect.TypeOf((*MockS3API)(nil).GetBucketReplicationWithContext), varargs...)
-}
-
-// GetBucketRequestPayment mocks base method.
-func (m *MockS3API) GetBucketRequestPayment(arg0 *s3.GetBucketRequestPaymentInput) (*s3.GetBucketRequestPaymentOutput, error) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "GetBucketRequestPayment", arg0)
- ret0, _ := ret[0].(*s3.GetBucketRequestPaymentOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// GetBucketRequestPayment indicates an expected call of GetBucketRequestPayment.
-func (mr *MockS3APIMockRecorder) GetBucketRequestPayment(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketRequestPayment", reflect.TypeOf((*MockS3API)(nil).GetBucketRequestPayment), arg0)
-}
-
-// GetBucketRequestPaymentRequest mocks base method.
-func (m *MockS3API) GetBucketRequestPaymentRequest(arg0 *s3.GetBucketRequestPaymentInput) (*request.Request, *s3.GetBucketRequestPaymentOutput) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "GetBucketRequestPaymentRequest", arg0)
- ret0, _ := ret[0].(*request.Request)
- ret1, _ := ret[1].(*s3.GetBucketRequestPaymentOutput)
- return ret0, ret1
-}
-
-// GetBucketRequestPaymentRequest indicates an expected call of GetBucketRequestPaymentRequest.
-func (mr *MockS3APIMockRecorder) GetBucketRequestPaymentRequest(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketRequestPaymentRequest", reflect.TypeOf((*MockS3API)(nil).GetBucketRequestPaymentRequest), arg0)
-}
-
-// GetBucketRequestPaymentWithContext mocks base method.
-func (m *MockS3API) GetBucketRequestPaymentWithContext(arg0 context.Context, arg1 *s3.GetBucketRequestPaymentInput, arg2 ...request.Option) (*s3.GetBucketRequestPaymentOutput, error) {
- m.ctrl.T.Helper()
- varargs := []interface{}{arg0, arg1}
- for _, a := range arg2 {
- varargs = append(varargs, a)
- }
- ret := m.ctrl.Call(m, "GetBucketRequestPaymentWithContext", varargs...)
- ret0, _ := ret[0].(*s3.GetBucketRequestPaymentOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// GetBucketRequestPaymentWithContext indicates an expected call of GetBucketRequestPaymentWithContext.
-func (mr *MockS3APIMockRecorder) GetBucketRequestPaymentWithContext(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, "GetBucketRequestPaymentWithContext", reflect.TypeOf((*MockS3API)(nil).GetBucketRequestPaymentWithContext), varargs...)
-}
-
-// GetBucketTagging mocks base method.
-func (m *MockS3API) GetBucketTagging(arg0 *s3.GetBucketTaggingInput) (*s3.GetBucketTaggingOutput, error) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "GetBucketTagging", arg0)
- ret0, _ := ret[0].(*s3.GetBucketTaggingOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// GetBucketTagging indicates an expected call of GetBucketTagging.
-func (mr *MockS3APIMockRecorder) GetBucketTagging(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketTagging", reflect.TypeOf((*MockS3API)(nil).GetBucketTagging), arg0)
-}
-
-// GetBucketTaggingRequest mocks base method.
-func (m *MockS3API) GetBucketTaggingRequest(arg0 *s3.GetBucketTaggingInput) (*request.Request, *s3.GetBucketTaggingOutput) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "GetBucketTaggingRequest", arg0)
- ret0, _ := ret[0].(*request.Request)
- ret1, _ := ret[1].(*s3.GetBucketTaggingOutput)
- return ret0, ret1
-}
-
-// GetBucketTaggingRequest indicates an expected call of GetBucketTaggingRequest.
-func (mr *MockS3APIMockRecorder) GetBucketTaggingRequest(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketTaggingRequest", reflect.TypeOf((*MockS3API)(nil).GetBucketTaggingRequest), arg0)
-}
-
-// GetBucketTaggingWithContext mocks base method.
-func (m *MockS3API) GetBucketTaggingWithContext(arg0 context.Context, arg1 *s3.GetBucketTaggingInput, arg2 ...request.Option) (*s3.GetBucketTaggingOutput, error) {
- m.ctrl.T.Helper()
- varargs := []interface{}{arg0, arg1}
- for _, a := range arg2 {
- varargs = append(varargs, a)
- }
- ret := m.ctrl.Call(m, "GetBucketTaggingWithContext", varargs...)
- ret0, _ := ret[0].(*s3.GetBucketTaggingOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// GetBucketTaggingWithContext indicates an expected call of GetBucketTaggingWithContext.
-func (mr *MockS3APIMockRecorder) GetBucketTaggingWithContext(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, "GetBucketTaggingWithContext", reflect.TypeOf((*MockS3API)(nil).GetBucketTaggingWithContext), varargs...)
-}
-
-// GetBucketVersioning mocks base method.
-func (m *MockS3API) GetBucketVersioning(arg0 *s3.GetBucketVersioningInput) (*s3.GetBucketVersioningOutput, error) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "GetBucketVersioning", arg0)
- ret0, _ := ret[0].(*s3.GetBucketVersioningOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// GetBucketVersioning indicates an expected call of GetBucketVersioning.
-func (mr *MockS3APIMockRecorder) GetBucketVersioning(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketVersioning", reflect.TypeOf((*MockS3API)(nil).GetBucketVersioning), arg0)
-}
-
-// GetBucketVersioningRequest mocks base method.
-func (m *MockS3API) GetBucketVersioningRequest(arg0 *s3.GetBucketVersioningInput) (*request.Request, *s3.GetBucketVersioningOutput) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "GetBucketVersioningRequest", arg0)
- ret0, _ := ret[0].(*request.Request)
- ret1, _ := ret[1].(*s3.GetBucketVersioningOutput)
- return ret0, ret1
-}
-
-// GetBucketVersioningRequest indicates an expected call of GetBucketVersioningRequest.
-func (mr *MockS3APIMockRecorder) GetBucketVersioningRequest(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketVersioningRequest", reflect.TypeOf((*MockS3API)(nil).GetBucketVersioningRequest), arg0)
-}
-
-// GetBucketVersioningWithContext mocks base method.
-func (m *MockS3API) GetBucketVersioningWithContext(arg0 context.Context, arg1 *s3.GetBucketVersioningInput, arg2 ...request.Option) (*s3.GetBucketVersioningOutput, error) {
- m.ctrl.T.Helper()
- varargs := []interface{}{arg0, arg1}
- for _, a := range arg2 {
- varargs = append(varargs, a)
- }
- ret := m.ctrl.Call(m, "GetBucketVersioningWithContext", varargs...)
- ret0, _ := ret[0].(*s3.GetBucketVersioningOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// GetBucketVersioningWithContext indicates an expected call of GetBucketVersioningWithContext.
-func (mr *MockS3APIMockRecorder) GetBucketVersioningWithContext(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, "GetBucketVersioningWithContext", reflect.TypeOf((*MockS3API)(nil).GetBucketVersioningWithContext), varargs...)
-}
-
-// GetBucketWebsite mocks base method.
-func (m *MockS3API) GetBucketWebsite(arg0 *s3.GetBucketWebsiteInput) (*s3.GetBucketWebsiteOutput, error) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "GetBucketWebsite", arg0)
- ret0, _ := ret[0].(*s3.GetBucketWebsiteOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// GetBucketWebsite indicates an expected call of GetBucketWebsite.
-func (mr *MockS3APIMockRecorder) GetBucketWebsite(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketWebsite", reflect.TypeOf((*MockS3API)(nil).GetBucketWebsite), arg0)
-}
-
-// GetBucketWebsiteRequest mocks base method.
-func (m *MockS3API) GetBucketWebsiteRequest(arg0 *s3.GetBucketWebsiteInput) (*request.Request, *s3.GetBucketWebsiteOutput) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "GetBucketWebsiteRequest", arg0)
- ret0, _ := ret[0].(*request.Request)
- ret1, _ := ret[1].(*s3.GetBucketWebsiteOutput)
- return ret0, ret1
-}
-
-// GetBucketWebsiteRequest indicates an expected call of GetBucketWebsiteRequest.
-func (mr *MockS3APIMockRecorder) GetBucketWebsiteRequest(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketWebsiteRequest", reflect.TypeOf((*MockS3API)(nil).GetBucketWebsiteRequest), arg0)
-}
-
-// GetBucketWebsiteWithContext mocks base method.
-func (m *MockS3API) GetBucketWebsiteWithContext(arg0 context.Context, arg1 *s3.GetBucketWebsiteInput, arg2 ...request.Option) (*s3.GetBucketWebsiteOutput, error) {
- m.ctrl.T.Helper()
- varargs := []interface{}{arg0, arg1}
- for _, a := range arg2 {
- varargs = append(varargs, a)
- }
- ret := m.ctrl.Call(m, "GetBucketWebsiteWithContext", varargs...)
- ret0, _ := ret[0].(*s3.GetBucketWebsiteOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// GetBucketWebsiteWithContext indicates an expected call of GetBucketWebsiteWithContext.
-func (mr *MockS3APIMockRecorder) GetBucketWebsiteWithContext(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, "GetBucketWebsiteWithContext", reflect.TypeOf((*MockS3API)(nil).GetBucketWebsiteWithContext), varargs...)
-}
-
-// GetObject mocks base method.
-func (m *MockS3API) GetObject(arg0 *s3.GetObjectInput) (*s3.GetObjectOutput, error) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "GetObject", arg0)
- ret0, _ := ret[0].(*s3.GetObjectOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// GetObject indicates an expected call of GetObject.
-func (mr *MockS3APIMockRecorder) GetObject(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetObject", reflect.TypeOf((*MockS3API)(nil).GetObject), arg0)
-}
-
-// GetObjectAcl mocks base method.
-func (m *MockS3API) GetObjectAcl(arg0 *s3.GetObjectAclInput) (*s3.GetObjectAclOutput, error) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "GetObjectAcl", arg0)
- ret0, _ := ret[0].(*s3.GetObjectAclOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// GetObjectAcl indicates an expected call of GetObjectAcl.
-func (mr *MockS3APIMockRecorder) GetObjectAcl(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetObjectAcl", reflect.TypeOf((*MockS3API)(nil).GetObjectAcl), arg0)
-}
-
-// GetObjectAclRequest mocks base method.
-func (m *MockS3API) GetObjectAclRequest(arg0 *s3.GetObjectAclInput) (*request.Request, *s3.GetObjectAclOutput) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "GetObjectAclRequest", arg0)
- ret0, _ := ret[0].(*request.Request)
- ret1, _ := ret[1].(*s3.GetObjectAclOutput)
- return ret0, ret1
-}
-
-// GetObjectAclRequest indicates an expected call of GetObjectAclRequest.
-func (mr *MockS3APIMockRecorder) GetObjectAclRequest(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetObjectAclRequest", reflect.TypeOf((*MockS3API)(nil).GetObjectAclRequest), arg0)
-}
-
-// GetObjectAclWithContext mocks base method.
-func (m *MockS3API) GetObjectAclWithContext(arg0 context.Context, arg1 *s3.GetObjectAclInput, arg2 ...request.Option) (*s3.GetObjectAclOutput, error) {
- m.ctrl.T.Helper()
- varargs := []interface{}{arg0, arg1}
- for _, a := range arg2 {
- varargs = append(varargs, a)
- }
- ret := m.ctrl.Call(m, "GetObjectAclWithContext", varargs...)
- ret0, _ := ret[0].(*s3.GetObjectAclOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// GetObjectAclWithContext indicates an expected call of GetObjectAclWithContext.
-func (mr *MockS3APIMockRecorder) GetObjectAclWithContext(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, "GetObjectAclWithContext", reflect.TypeOf((*MockS3API)(nil).GetObjectAclWithContext), varargs...)
-}
-
-// GetObjectAttributes mocks base method.
-func (m *MockS3API) GetObjectAttributes(arg0 *s3.GetObjectAttributesInput) (*s3.GetObjectAttributesOutput, error) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "GetObjectAttributes", arg0)
- ret0, _ := ret[0].(*s3.GetObjectAttributesOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// GetObjectAttributes indicates an expected call of GetObjectAttributes.
-func (mr *MockS3APIMockRecorder) GetObjectAttributes(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetObjectAttributes", reflect.TypeOf((*MockS3API)(nil).GetObjectAttributes), arg0)
-}
-
-// GetObjectAttributesRequest mocks base method.
-func (m *MockS3API) GetObjectAttributesRequest(arg0 *s3.GetObjectAttributesInput) (*request.Request, *s3.GetObjectAttributesOutput) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "GetObjectAttributesRequest", arg0)
- ret0, _ := ret[0].(*request.Request)
- ret1, _ := ret[1].(*s3.GetObjectAttributesOutput)
- return ret0, ret1
-}
-
-// GetObjectAttributesRequest indicates an expected call of GetObjectAttributesRequest.
-func (mr *MockS3APIMockRecorder) GetObjectAttributesRequest(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetObjectAttributesRequest", reflect.TypeOf((*MockS3API)(nil).GetObjectAttributesRequest), arg0)
-}
-
-// GetObjectAttributesWithContext mocks base method.
-func (m *MockS3API) GetObjectAttributesWithContext(arg0 context.Context, arg1 *s3.GetObjectAttributesInput, arg2 ...request.Option) (*s3.GetObjectAttributesOutput, error) {
- m.ctrl.T.Helper()
- varargs := []interface{}{arg0, arg1}
- for _, a := range arg2 {
- varargs = append(varargs, a)
- }
- ret := m.ctrl.Call(m, "GetObjectAttributesWithContext", varargs...)
- ret0, _ := ret[0].(*s3.GetObjectAttributesOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// GetObjectAttributesWithContext indicates an expected call of GetObjectAttributesWithContext.
-func (mr *MockS3APIMockRecorder) GetObjectAttributesWithContext(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, "GetObjectAttributesWithContext", reflect.TypeOf((*MockS3API)(nil).GetObjectAttributesWithContext), varargs...)
-}
-
-// GetObjectLegalHold mocks base method.
-func (m *MockS3API) GetObjectLegalHold(arg0 *s3.GetObjectLegalHoldInput) (*s3.GetObjectLegalHoldOutput, error) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "GetObjectLegalHold", arg0)
- ret0, _ := ret[0].(*s3.GetObjectLegalHoldOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// GetObjectLegalHold indicates an expected call of GetObjectLegalHold.
-func (mr *MockS3APIMockRecorder) GetObjectLegalHold(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetObjectLegalHold", reflect.TypeOf((*MockS3API)(nil).GetObjectLegalHold), arg0)
-}
-
-// GetObjectLegalHoldRequest mocks base method.
-func (m *MockS3API) GetObjectLegalHoldRequest(arg0 *s3.GetObjectLegalHoldInput) (*request.Request, *s3.GetObjectLegalHoldOutput) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "GetObjectLegalHoldRequest", arg0)
- ret0, _ := ret[0].(*request.Request)
- ret1, _ := ret[1].(*s3.GetObjectLegalHoldOutput)
- return ret0, ret1
-}
-
-// GetObjectLegalHoldRequest indicates an expected call of GetObjectLegalHoldRequest.
-func (mr *MockS3APIMockRecorder) GetObjectLegalHoldRequest(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetObjectLegalHoldRequest", reflect.TypeOf((*MockS3API)(nil).GetObjectLegalHoldRequest), arg0)
-}
-
-// GetObjectLegalHoldWithContext mocks base method.
-func (m *MockS3API) GetObjectLegalHoldWithContext(arg0 context.Context, arg1 *s3.GetObjectLegalHoldInput, arg2 ...request.Option) (*s3.GetObjectLegalHoldOutput, error) {
- m.ctrl.T.Helper()
- varargs := []interface{}{arg0, arg1}
- for _, a := range arg2 {
- varargs = append(varargs, a)
- }
- ret := m.ctrl.Call(m, "GetObjectLegalHoldWithContext", varargs...)
- ret0, _ := ret[0].(*s3.GetObjectLegalHoldOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// GetObjectLegalHoldWithContext indicates an expected call of GetObjectLegalHoldWithContext.
-func (mr *MockS3APIMockRecorder) GetObjectLegalHoldWithContext(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, "GetObjectLegalHoldWithContext", reflect.TypeOf((*MockS3API)(nil).GetObjectLegalHoldWithContext), varargs...)
-}
-
-// GetObjectLockConfiguration mocks base method.
-func (m *MockS3API) GetObjectLockConfiguration(arg0 *s3.GetObjectLockConfigurationInput) (*s3.GetObjectLockConfigurationOutput, error) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "GetObjectLockConfiguration", arg0)
- ret0, _ := ret[0].(*s3.GetObjectLockConfigurationOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// GetObjectLockConfiguration indicates an expected call of GetObjectLockConfiguration.
-func (mr *MockS3APIMockRecorder) GetObjectLockConfiguration(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetObjectLockConfiguration", reflect.TypeOf((*MockS3API)(nil).GetObjectLockConfiguration), arg0)
-}
-
-// GetObjectLockConfigurationRequest mocks base method.
-func (m *MockS3API) GetObjectLockConfigurationRequest(arg0 *s3.GetObjectLockConfigurationInput) (*request.Request, *s3.GetObjectLockConfigurationOutput) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "GetObjectLockConfigurationRequest", arg0)
- ret0, _ := ret[0].(*request.Request)
- ret1, _ := ret[1].(*s3.GetObjectLockConfigurationOutput)
- return ret0, ret1
-}
-
-// GetObjectLockConfigurationRequest indicates an expected call of GetObjectLockConfigurationRequest.
-func (mr *MockS3APIMockRecorder) GetObjectLockConfigurationRequest(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetObjectLockConfigurationRequest", reflect.TypeOf((*MockS3API)(nil).GetObjectLockConfigurationRequest), arg0)
-}
-
-// GetObjectLockConfigurationWithContext mocks base method.
-func (m *MockS3API) GetObjectLockConfigurationWithContext(arg0 context.Context, arg1 *s3.GetObjectLockConfigurationInput, arg2 ...request.Option) (*s3.GetObjectLockConfigurationOutput, error) {
- m.ctrl.T.Helper()
- varargs := []interface{}{arg0, arg1}
- for _, a := range arg2 {
- varargs = append(varargs, a)
- }
- ret := m.ctrl.Call(m, "GetObjectLockConfigurationWithContext", varargs...)
- ret0, _ := ret[0].(*s3.GetObjectLockConfigurationOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// GetObjectLockConfigurationWithContext indicates an expected call of GetObjectLockConfigurationWithContext.
-func (mr *MockS3APIMockRecorder) GetObjectLockConfigurationWithContext(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, "GetObjectLockConfigurationWithContext", reflect.TypeOf((*MockS3API)(nil).GetObjectLockConfigurationWithContext), varargs...)
-}
-
-// GetObjectRequest mocks base method.
-func (m *MockS3API) GetObjectRequest(arg0 *s3.GetObjectInput) (*request.Request, *s3.GetObjectOutput) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "GetObjectRequest", arg0)
- ret0, _ := ret[0].(*request.Request)
- ret1, _ := ret[1].(*s3.GetObjectOutput)
- return ret0, ret1
-}
-
-// GetObjectRequest indicates an expected call of GetObjectRequest.
-func (mr *MockS3APIMockRecorder) GetObjectRequest(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetObjectRequest", reflect.TypeOf((*MockS3API)(nil).GetObjectRequest), arg0)
-}
-
-// GetObjectRetention mocks base method.
-func (m *MockS3API) GetObjectRetention(arg0 *s3.GetObjectRetentionInput) (*s3.GetObjectRetentionOutput, error) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "GetObjectRetention", arg0)
- ret0, _ := ret[0].(*s3.GetObjectRetentionOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// GetObjectRetention indicates an expected call of GetObjectRetention.
-func (mr *MockS3APIMockRecorder) GetObjectRetention(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetObjectRetention", reflect.TypeOf((*MockS3API)(nil).GetObjectRetention), arg0)
-}
-
-// GetObjectRetentionRequest mocks base method.
-func (m *MockS3API) GetObjectRetentionRequest(arg0 *s3.GetObjectRetentionInput) (*request.Request, *s3.GetObjectRetentionOutput) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "GetObjectRetentionRequest", arg0)
- ret0, _ := ret[0].(*request.Request)
- ret1, _ := ret[1].(*s3.GetObjectRetentionOutput)
- return ret0, ret1
-}
-
-// GetObjectRetentionRequest indicates an expected call of GetObjectRetentionRequest.
-func (mr *MockS3APIMockRecorder) GetObjectRetentionRequest(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetObjectRetentionRequest", reflect.TypeOf((*MockS3API)(nil).GetObjectRetentionRequest), arg0)
-}
-
-// GetObjectRetentionWithContext mocks base method.
-func (m *MockS3API) GetObjectRetentionWithContext(arg0 context.Context, arg1 *s3.GetObjectRetentionInput, arg2 ...request.Option) (*s3.GetObjectRetentionOutput, error) {
- m.ctrl.T.Helper()
- varargs := []interface{}{arg0, arg1}
- for _, a := range arg2 {
- varargs = append(varargs, a)
- }
- ret := m.ctrl.Call(m, "GetObjectRetentionWithContext", varargs...)
- ret0, _ := ret[0].(*s3.GetObjectRetentionOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// GetObjectRetentionWithContext indicates an expected call of GetObjectRetentionWithContext.
-func (mr *MockS3APIMockRecorder) GetObjectRetentionWithContext(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, "GetObjectRetentionWithContext", reflect.TypeOf((*MockS3API)(nil).GetObjectRetentionWithContext), varargs...)
-}
-
-// GetObjectTagging mocks base method.
-func (m *MockS3API) GetObjectTagging(arg0 *s3.GetObjectTaggingInput) (*s3.GetObjectTaggingOutput, error) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "GetObjectTagging", arg0)
- ret0, _ := ret[0].(*s3.GetObjectTaggingOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// GetObjectTagging indicates an expected call of GetObjectTagging.
-func (mr *MockS3APIMockRecorder) GetObjectTagging(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetObjectTagging", reflect.TypeOf((*MockS3API)(nil).GetObjectTagging), arg0)
-}
-
-// GetObjectTaggingRequest mocks base method.
-func (m *MockS3API) GetObjectTaggingRequest(arg0 *s3.GetObjectTaggingInput) (*request.Request, *s3.GetObjectTaggingOutput) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "GetObjectTaggingRequest", arg0)
- ret0, _ := ret[0].(*request.Request)
- ret1, _ := ret[1].(*s3.GetObjectTaggingOutput)
- return ret0, ret1
-}
-
-// GetObjectTaggingRequest indicates an expected call of GetObjectTaggingRequest.
-func (mr *MockS3APIMockRecorder) GetObjectTaggingRequest(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetObjectTaggingRequest", reflect.TypeOf((*MockS3API)(nil).GetObjectTaggingRequest), arg0)
-}
-
-// GetObjectTaggingWithContext mocks base method.
-func (m *MockS3API) GetObjectTaggingWithContext(arg0 context.Context, arg1 *s3.GetObjectTaggingInput, arg2 ...request.Option) (*s3.GetObjectTaggingOutput, error) {
- m.ctrl.T.Helper()
- varargs := []interface{}{arg0, arg1}
- for _, a := range arg2 {
- varargs = append(varargs, a)
- }
- ret := m.ctrl.Call(m, "GetObjectTaggingWithContext", varargs...)
- ret0, _ := ret[0].(*s3.GetObjectTaggingOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// GetObjectTaggingWithContext indicates an expected call of GetObjectTaggingWithContext.
-func (mr *MockS3APIMockRecorder) GetObjectTaggingWithContext(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, "GetObjectTaggingWithContext", reflect.TypeOf((*MockS3API)(nil).GetObjectTaggingWithContext), varargs...)
-}
-
-// GetObjectTorrent mocks base method.
-func (m *MockS3API) GetObjectTorrent(arg0 *s3.GetObjectTorrentInput) (*s3.GetObjectTorrentOutput, error) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "GetObjectTorrent", arg0)
- ret0, _ := ret[0].(*s3.GetObjectTorrentOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// GetObjectTorrent indicates an expected call of GetObjectTorrent.
-func (mr *MockS3APIMockRecorder) GetObjectTorrent(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetObjectTorrent", reflect.TypeOf((*MockS3API)(nil).GetObjectTorrent), arg0)
-}
-
-// GetObjectTorrentRequest mocks base method.
-func (m *MockS3API) GetObjectTorrentRequest(arg0 *s3.GetObjectTorrentInput) (*request.Request, *s3.GetObjectTorrentOutput) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "GetObjectTorrentRequest", arg0)
- ret0, _ := ret[0].(*request.Request)
- ret1, _ := ret[1].(*s3.GetObjectTorrentOutput)
- return ret0, ret1
-}
-
-// GetObjectTorrentRequest indicates an expected call of GetObjectTorrentRequest.
-func (mr *MockS3APIMockRecorder) GetObjectTorrentRequest(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetObjectTorrentRequest", reflect.TypeOf((*MockS3API)(nil).GetObjectTorrentRequest), arg0)
-}
-
-// GetObjectTorrentWithContext mocks base method.
-func (m *MockS3API) GetObjectTorrentWithContext(arg0 context.Context, arg1 *s3.GetObjectTorrentInput, arg2 ...request.Option) (*s3.GetObjectTorrentOutput, error) {
- m.ctrl.T.Helper()
- varargs := []interface{}{arg0, arg1}
- for _, a := range arg2 {
- varargs = append(varargs, a)
- }
- ret := m.ctrl.Call(m, "GetObjectTorrentWithContext", varargs...)
- ret0, _ := ret[0].(*s3.GetObjectTorrentOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// GetObjectTorrentWithContext indicates an expected call of GetObjectTorrentWithContext.
-func (mr *MockS3APIMockRecorder) GetObjectTorrentWithContext(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, "GetObjectTorrentWithContext", reflect.TypeOf((*MockS3API)(nil).GetObjectTorrentWithContext), varargs...)
-}
-
-// GetObjectWithContext mocks base method.
-func (m *MockS3API) GetObjectWithContext(arg0 context.Context, arg1 *s3.GetObjectInput, arg2 ...request.Option) (*s3.GetObjectOutput, error) {
- m.ctrl.T.Helper()
- varargs := []interface{}{arg0, arg1}
- for _, a := range arg2 {
- varargs = append(varargs, a)
- }
- ret := m.ctrl.Call(m, "GetObjectWithContext", varargs...)
- ret0, _ := ret[0].(*s3.GetObjectOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// GetObjectWithContext indicates an expected call of GetObjectWithContext.
-func (mr *MockS3APIMockRecorder) GetObjectWithContext(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, "GetObjectWithContext", reflect.TypeOf((*MockS3API)(nil).GetObjectWithContext), varargs...)
-}
-
-// GetPublicAccessBlock mocks base method.
-func (m *MockS3API) GetPublicAccessBlock(arg0 *s3.GetPublicAccessBlockInput) (*s3.GetPublicAccessBlockOutput, error) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "GetPublicAccessBlock", arg0)
- ret0, _ := ret[0].(*s3.GetPublicAccessBlockOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// GetPublicAccessBlock indicates an expected call of GetPublicAccessBlock.
-func (mr *MockS3APIMockRecorder) GetPublicAccessBlock(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPublicAccessBlock", reflect.TypeOf((*MockS3API)(nil).GetPublicAccessBlock), arg0)
-}
-
-// GetPublicAccessBlockRequest mocks base method.
-func (m *MockS3API) GetPublicAccessBlockRequest(arg0 *s3.GetPublicAccessBlockInput) (*request.Request, *s3.GetPublicAccessBlockOutput) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "GetPublicAccessBlockRequest", arg0)
- ret0, _ := ret[0].(*request.Request)
- ret1, _ := ret[1].(*s3.GetPublicAccessBlockOutput)
- return ret0, ret1
-}
-
-// GetPublicAccessBlockRequest indicates an expected call of GetPublicAccessBlockRequest.
-func (mr *MockS3APIMockRecorder) GetPublicAccessBlockRequest(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPublicAccessBlockRequest", reflect.TypeOf((*MockS3API)(nil).GetPublicAccessBlockRequest), arg0)
-}
-
-// GetPublicAccessBlockWithContext mocks base method.
-func (m *MockS3API) GetPublicAccessBlockWithContext(arg0 context.Context, arg1 *s3.GetPublicAccessBlockInput, arg2 ...request.Option) (*s3.GetPublicAccessBlockOutput, error) {
- m.ctrl.T.Helper()
- varargs := []interface{}{arg0, arg1}
- for _, a := range arg2 {
- varargs = append(varargs, a)
- }
- ret := m.ctrl.Call(m, "GetPublicAccessBlockWithContext", varargs...)
- ret0, _ := ret[0].(*s3.GetPublicAccessBlockOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// GetPublicAccessBlockWithContext indicates an expected call of GetPublicAccessBlockWithContext.
-func (mr *MockS3APIMockRecorder) GetPublicAccessBlockWithContext(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, "GetPublicAccessBlockWithContext", reflect.TypeOf((*MockS3API)(nil).GetPublicAccessBlockWithContext), varargs...)
-}
-
-// HeadBucket mocks base method.
-func (m *MockS3API) HeadBucket(arg0 *s3.HeadBucketInput) (*s3.HeadBucketOutput, error) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "HeadBucket", arg0)
- ret0, _ := ret[0].(*s3.HeadBucketOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// HeadBucket indicates an expected call of HeadBucket.
-func (mr *MockS3APIMockRecorder) HeadBucket(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HeadBucket", reflect.TypeOf((*MockS3API)(nil).HeadBucket), arg0)
-}
-
-// HeadBucketRequest mocks base method.
-func (m *MockS3API) HeadBucketRequest(arg0 *s3.HeadBucketInput) (*request.Request, *s3.HeadBucketOutput) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "HeadBucketRequest", arg0)
- ret0, _ := ret[0].(*request.Request)
- ret1, _ := ret[1].(*s3.HeadBucketOutput)
- return ret0, ret1
-}
-
-// HeadBucketRequest indicates an expected call of HeadBucketRequest.
-func (mr *MockS3APIMockRecorder) HeadBucketRequest(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HeadBucketRequest", reflect.TypeOf((*MockS3API)(nil).HeadBucketRequest), arg0)
-}
-
-// HeadBucketWithContext mocks base method.
-func (m *MockS3API) HeadBucketWithContext(arg0 context.Context, arg1 *s3.HeadBucketInput, arg2 ...request.Option) (*s3.HeadBucketOutput, error) {
- m.ctrl.T.Helper()
- varargs := []interface{}{arg0, arg1}
- for _, a := range arg2 {
- varargs = append(varargs, a)
- }
- ret := m.ctrl.Call(m, "HeadBucketWithContext", varargs...)
- ret0, _ := ret[0].(*s3.HeadBucketOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// HeadBucketWithContext indicates an expected call of HeadBucketWithContext.
-func (mr *MockS3APIMockRecorder) HeadBucketWithContext(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, "HeadBucketWithContext", reflect.TypeOf((*MockS3API)(nil).HeadBucketWithContext), varargs...)
-}
-
-// HeadObject mocks base method.
-func (m *MockS3API) HeadObject(arg0 *s3.HeadObjectInput) (*s3.HeadObjectOutput, error) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "HeadObject", arg0)
- ret0, _ := ret[0].(*s3.HeadObjectOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// HeadObject indicates an expected call of HeadObject.
-func (mr *MockS3APIMockRecorder) HeadObject(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HeadObject", reflect.TypeOf((*MockS3API)(nil).HeadObject), arg0)
-}
-
-// HeadObjectRequest mocks base method.
-func (m *MockS3API) HeadObjectRequest(arg0 *s3.HeadObjectInput) (*request.Request, *s3.HeadObjectOutput) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "HeadObjectRequest", arg0)
- ret0, _ := ret[0].(*request.Request)
- ret1, _ := ret[1].(*s3.HeadObjectOutput)
- return ret0, ret1
-}
-
-// HeadObjectRequest indicates an expected call of HeadObjectRequest.
-func (mr *MockS3APIMockRecorder) HeadObjectRequest(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HeadObjectRequest", reflect.TypeOf((*MockS3API)(nil).HeadObjectRequest), arg0)
-}
-
-// HeadObjectWithContext mocks base method.
-func (m *MockS3API) HeadObjectWithContext(arg0 context.Context, arg1 *s3.HeadObjectInput, arg2 ...request.Option) (*s3.HeadObjectOutput, error) {
- m.ctrl.T.Helper()
- varargs := []interface{}{arg0, arg1}
- for _, a := range arg2 {
- varargs = append(varargs, a)
- }
- ret := m.ctrl.Call(m, "HeadObjectWithContext", varargs...)
- ret0, _ := ret[0].(*s3.HeadObjectOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// HeadObjectWithContext indicates an expected call of HeadObjectWithContext.
-func (mr *MockS3APIMockRecorder) HeadObjectWithContext(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, "HeadObjectWithContext", reflect.TypeOf((*MockS3API)(nil).HeadObjectWithContext), varargs...)
-}
-
-// ListBucketAnalyticsConfigurations mocks base method.
-func (m *MockS3API) ListBucketAnalyticsConfigurations(arg0 *s3.ListBucketAnalyticsConfigurationsInput) (*s3.ListBucketAnalyticsConfigurationsOutput, error) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "ListBucketAnalyticsConfigurations", arg0)
- ret0, _ := ret[0].(*s3.ListBucketAnalyticsConfigurationsOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// ListBucketAnalyticsConfigurations indicates an expected call of ListBucketAnalyticsConfigurations.
-func (mr *MockS3APIMockRecorder) ListBucketAnalyticsConfigurations(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListBucketAnalyticsConfigurations", reflect.TypeOf((*MockS3API)(nil).ListBucketAnalyticsConfigurations), arg0)
-}
-
-// ListBucketAnalyticsConfigurationsRequest mocks base method.
-func (m *MockS3API) ListBucketAnalyticsConfigurationsRequest(arg0 *s3.ListBucketAnalyticsConfigurationsInput) (*request.Request, *s3.ListBucketAnalyticsConfigurationsOutput) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "ListBucketAnalyticsConfigurationsRequest", arg0)
- ret0, _ := ret[0].(*request.Request)
- ret1, _ := ret[1].(*s3.ListBucketAnalyticsConfigurationsOutput)
- return ret0, ret1
-}
-
-// ListBucketAnalyticsConfigurationsRequest indicates an expected call of ListBucketAnalyticsConfigurationsRequest.
-func (mr *MockS3APIMockRecorder) ListBucketAnalyticsConfigurationsRequest(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListBucketAnalyticsConfigurationsRequest", reflect.TypeOf((*MockS3API)(nil).ListBucketAnalyticsConfigurationsRequest), arg0)
-}
-
-// ListBucketAnalyticsConfigurationsWithContext mocks base method.
-func (m *MockS3API) ListBucketAnalyticsConfigurationsWithContext(arg0 context.Context, arg1 *s3.ListBucketAnalyticsConfigurationsInput, arg2 ...request.Option) (*s3.ListBucketAnalyticsConfigurationsOutput, error) {
- m.ctrl.T.Helper()
- varargs := []interface{}{arg0, arg1}
- for _, a := range arg2 {
- varargs = append(varargs, a)
- }
- ret := m.ctrl.Call(m, "ListBucketAnalyticsConfigurationsWithContext", varargs...)
- ret0, _ := ret[0].(*s3.ListBucketAnalyticsConfigurationsOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// ListBucketAnalyticsConfigurationsWithContext indicates an expected call of ListBucketAnalyticsConfigurationsWithContext.
-func (mr *MockS3APIMockRecorder) ListBucketAnalyticsConfigurationsWithContext(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, "ListBucketAnalyticsConfigurationsWithContext", reflect.TypeOf((*MockS3API)(nil).ListBucketAnalyticsConfigurationsWithContext), varargs...)
-}
-
-// ListBucketIntelligentTieringConfigurations mocks base method.
-func (m *MockS3API) ListBucketIntelligentTieringConfigurations(arg0 *s3.ListBucketIntelligentTieringConfigurationsInput) (*s3.ListBucketIntelligentTieringConfigurationsOutput, error) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "ListBucketIntelligentTieringConfigurations", arg0)
- ret0, _ := ret[0].(*s3.ListBucketIntelligentTieringConfigurationsOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// ListBucketIntelligentTieringConfigurations indicates an expected call of ListBucketIntelligentTieringConfigurations.
-func (mr *MockS3APIMockRecorder) ListBucketIntelligentTieringConfigurations(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListBucketIntelligentTieringConfigurations", reflect.TypeOf((*MockS3API)(nil).ListBucketIntelligentTieringConfigurations), arg0)
-}
-
-// ListBucketIntelligentTieringConfigurationsRequest mocks base method.
-func (m *MockS3API) ListBucketIntelligentTieringConfigurationsRequest(arg0 *s3.ListBucketIntelligentTieringConfigurationsInput) (*request.Request, *s3.ListBucketIntelligentTieringConfigurationsOutput) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "ListBucketIntelligentTieringConfigurationsRequest", arg0)
- ret0, _ := ret[0].(*request.Request)
- ret1, _ := ret[1].(*s3.ListBucketIntelligentTieringConfigurationsOutput)
- return ret0, ret1
-}
-
-// ListBucketIntelligentTieringConfigurationsRequest indicates an expected call of ListBucketIntelligentTieringConfigurationsRequest.
-func (mr *MockS3APIMockRecorder) ListBucketIntelligentTieringConfigurationsRequest(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListBucketIntelligentTieringConfigurationsRequest", reflect.TypeOf((*MockS3API)(nil).ListBucketIntelligentTieringConfigurationsRequest), arg0)
-}
-
-// ListBucketIntelligentTieringConfigurationsWithContext mocks base method.
-func (m *MockS3API) ListBucketIntelligentTieringConfigurationsWithContext(arg0 context.Context, arg1 *s3.ListBucketIntelligentTieringConfigurationsInput, arg2 ...request.Option) (*s3.ListBucketIntelligentTieringConfigurationsOutput, error) {
- m.ctrl.T.Helper()
- varargs := []interface{}{arg0, arg1}
- for _, a := range arg2 {
- varargs = append(varargs, a)
- }
- ret := m.ctrl.Call(m, "ListBucketIntelligentTieringConfigurationsWithContext", varargs...)
- ret0, _ := ret[0].(*s3.ListBucketIntelligentTieringConfigurationsOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// ListBucketIntelligentTieringConfigurationsWithContext indicates an expected call of ListBucketIntelligentTieringConfigurationsWithContext.
-func (mr *MockS3APIMockRecorder) ListBucketIntelligentTieringConfigurationsWithContext(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, "ListBucketIntelligentTieringConfigurationsWithContext", reflect.TypeOf((*MockS3API)(nil).ListBucketIntelligentTieringConfigurationsWithContext), varargs...)
-}
-
-// ListBucketInventoryConfigurations mocks base method.
-func (m *MockS3API) ListBucketInventoryConfigurations(arg0 *s3.ListBucketInventoryConfigurationsInput) (*s3.ListBucketInventoryConfigurationsOutput, error) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "ListBucketInventoryConfigurations", arg0)
- ret0, _ := ret[0].(*s3.ListBucketInventoryConfigurationsOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// ListBucketInventoryConfigurations indicates an expected call of ListBucketInventoryConfigurations.
-func (mr *MockS3APIMockRecorder) ListBucketInventoryConfigurations(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListBucketInventoryConfigurations", reflect.TypeOf((*MockS3API)(nil).ListBucketInventoryConfigurations), arg0)
-}
-
-// ListBucketInventoryConfigurationsRequest mocks base method.
-func (m *MockS3API) ListBucketInventoryConfigurationsRequest(arg0 *s3.ListBucketInventoryConfigurationsInput) (*request.Request, *s3.ListBucketInventoryConfigurationsOutput) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "ListBucketInventoryConfigurationsRequest", arg0)
- ret0, _ := ret[0].(*request.Request)
- ret1, _ := ret[1].(*s3.ListBucketInventoryConfigurationsOutput)
- return ret0, ret1
-}
-
-// ListBucketInventoryConfigurationsRequest indicates an expected call of ListBucketInventoryConfigurationsRequest.
-func (mr *MockS3APIMockRecorder) ListBucketInventoryConfigurationsRequest(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListBucketInventoryConfigurationsRequest", reflect.TypeOf((*MockS3API)(nil).ListBucketInventoryConfigurationsRequest), arg0)
-}
-
-// ListBucketInventoryConfigurationsWithContext mocks base method.
-func (m *MockS3API) ListBucketInventoryConfigurationsWithContext(arg0 context.Context, arg1 *s3.ListBucketInventoryConfigurationsInput, arg2 ...request.Option) (*s3.ListBucketInventoryConfigurationsOutput, error) {
- m.ctrl.T.Helper()
- varargs := []interface{}{arg0, arg1}
- for _, a := range arg2 {
- varargs = append(varargs, a)
- }
- ret := m.ctrl.Call(m, "ListBucketInventoryConfigurationsWithContext", varargs...)
- ret0, _ := ret[0].(*s3.ListBucketInventoryConfigurationsOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// ListBucketInventoryConfigurationsWithContext indicates an expected call of ListBucketInventoryConfigurationsWithContext.
-func (mr *MockS3APIMockRecorder) ListBucketInventoryConfigurationsWithContext(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, "ListBucketInventoryConfigurationsWithContext", reflect.TypeOf((*MockS3API)(nil).ListBucketInventoryConfigurationsWithContext), varargs...)
-}
-
-// ListBucketMetricsConfigurations mocks base method.
-func (m *MockS3API) ListBucketMetricsConfigurations(arg0 *s3.ListBucketMetricsConfigurationsInput) (*s3.ListBucketMetricsConfigurationsOutput, error) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "ListBucketMetricsConfigurations", arg0)
- ret0, _ := ret[0].(*s3.ListBucketMetricsConfigurationsOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// ListBucketMetricsConfigurations indicates an expected call of ListBucketMetricsConfigurations.
-func (mr *MockS3APIMockRecorder) ListBucketMetricsConfigurations(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListBucketMetricsConfigurations", reflect.TypeOf((*MockS3API)(nil).ListBucketMetricsConfigurations), arg0)
-}
-
-// ListBucketMetricsConfigurationsRequest mocks base method.
-func (m *MockS3API) ListBucketMetricsConfigurationsRequest(arg0 *s3.ListBucketMetricsConfigurationsInput) (*request.Request, *s3.ListBucketMetricsConfigurationsOutput) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "ListBucketMetricsConfigurationsRequest", arg0)
- ret0, _ := ret[0].(*request.Request)
- ret1, _ := ret[1].(*s3.ListBucketMetricsConfigurationsOutput)
- return ret0, ret1
-}
-
-// ListBucketMetricsConfigurationsRequest indicates an expected call of ListBucketMetricsConfigurationsRequest.
-func (mr *MockS3APIMockRecorder) ListBucketMetricsConfigurationsRequest(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListBucketMetricsConfigurationsRequest", reflect.TypeOf((*MockS3API)(nil).ListBucketMetricsConfigurationsRequest), arg0)
-}
-
-// ListBucketMetricsConfigurationsWithContext mocks base method.
-func (m *MockS3API) ListBucketMetricsConfigurationsWithContext(arg0 context.Context, arg1 *s3.ListBucketMetricsConfigurationsInput, arg2 ...request.Option) (*s3.ListBucketMetricsConfigurationsOutput, error) {
- m.ctrl.T.Helper()
- varargs := []interface{}{arg0, arg1}
- for _, a := range arg2 {
- varargs = append(varargs, a)
- }
- ret := m.ctrl.Call(m, "ListBucketMetricsConfigurationsWithContext", varargs...)
- ret0, _ := ret[0].(*s3.ListBucketMetricsConfigurationsOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// ListBucketMetricsConfigurationsWithContext indicates an expected call of ListBucketMetricsConfigurationsWithContext.
-func (mr *MockS3APIMockRecorder) ListBucketMetricsConfigurationsWithContext(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, "ListBucketMetricsConfigurationsWithContext", reflect.TypeOf((*MockS3API)(nil).ListBucketMetricsConfigurationsWithContext), varargs...)
-}
-
-// ListBuckets mocks base method.
-func (m *MockS3API) ListBuckets(arg0 *s3.ListBucketsInput) (*s3.ListBucketsOutput, error) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "ListBuckets", arg0)
- ret0, _ := ret[0].(*s3.ListBucketsOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// ListBuckets indicates an expected call of ListBuckets.
-func (mr *MockS3APIMockRecorder) ListBuckets(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListBuckets", reflect.TypeOf((*MockS3API)(nil).ListBuckets), arg0)
-}
-
-// ListBucketsRequest mocks base method.
-func (m *MockS3API) ListBucketsRequest(arg0 *s3.ListBucketsInput) (*request.Request, *s3.ListBucketsOutput) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "ListBucketsRequest", arg0)
- ret0, _ := ret[0].(*request.Request)
- ret1, _ := ret[1].(*s3.ListBucketsOutput)
- return ret0, ret1
-}
-
-// ListBucketsRequest indicates an expected call of ListBucketsRequest.
-func (mr *MockS3APIMockRecorder) ListBucketsRequest(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListBucketsRequest", reflect.TypeOf((*MockS3API)(nil).ListBucketsRequest), arg0)
-}
-
-// ListBucketsWithContext mocks base method.
-func (m *MockS3API) ListBucketsWithContext(arg0 context.Context, arg1 *s3.ListBucketsInput, arg2 ...request.Option) (*s3.ListBucketsOutput, error) {
- m.ctrl.T.Helper()
- varargs := []interface{}{arg0, arg1}
- for _, a := range arg2 {
- varargs = append(varargs, a)
- }
- ret := m.ctrl.Call(m, "ListBucketsWithContext", varargs...)
- ret0, _ := ret[0].(*s3.ListBucketsOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// ListBucketsWithContext indicates an expected call of ListBucketsWithContext.
-func (mr *MockS3APIMockRecorder) ListBucketsWithContext(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, "ListBucketsWithContext", reflect.TypeOf((*MockS3API)(nil).ListBucketsWithContext), varargs...)
-}
-
-// ListDirectoryBuckets mocks base method.
-func (m *MockS3API) ListDirectoryBuckets(arg0 *s3.ListDirectoryBucketsInput) (*s3.ListDirectoryBucketsOutput, error) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "ListDirectoryBuckets", arg0)
- ret0, _ := ret[0].(*s3.ListDirectoryBucketsOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// ListDirectoryBuckets indicates an expected call of ListDirectoryBuckets.
-func (mr *MockS3APIMockRecorder) ListDirectoryBuckets(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListDirectoryBuckets", reflect.TypeOf((*MockS3API)(nil).ListDirectoryBuckets), arg0)
-}
-
-// ListDirectoryBucketsPages mocks base method.
-func (m *MockS3API) ListDirectoryBucketsPages(arg0 *s3.ListDirectoryBucketsInput, arg1 func(*s3.ListDirectoryBucketsOutput, bool) bool) error {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "ListDirectoryBucketsPages", arg0, arg1)
- ret0, _ := ret[0].(error)
- return ret0
-}
-
-// ListDirectoryBucketsPages indicates an expected call of ListDirectoryBucketsPages.
-func (mr *MockS3APIMockRecorder) ListDirectoryBucketsPages(arg0, arg1 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListDirectoryBucketsPages", reflect.TypeOf((*MockS3API)(nil).ListDirectoryBucketsPages), arg0, arg1)
-}
-
-// ListDirectoryBucketsPagesWithContext mocks base method.
-func (m *MockS3API) ListDirectoryBucketsPagesWithContext(arg0 context.Context, arg1 *s3.ListDirectoryBucketsInput, arg2 func(*s3.ListDirectoryBucketsOutput, 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, "ListDirectoryBucketsPagesWithContext", varargs...)
- ret0, _ := ret[0].(error)
- return ret0
-}
-
-// ListDirectoryBucketsPagesWithContext indicates an expected call of ListDirectoryBucketsPagesWithContext.
-func (mr *MockS3APIMockRecorder) ListDirectoryBucketsPagesWithContext(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, "ListDirectoryBucketsPagesWithContext", reflect.TypeOf((*MockS3API)(nil).ListDirectoryBucketsPagesWithContext), varargs...)
-}
-
-// ListDirectoryBucketsRequest mocks base method.
-func (m *MockS3API) ListDirectoryBucketsRequest(arg0 *s3.ListDirectoryBucketsInput) (*request.Request, *s3.ListDirectoryBucketsOutput) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "ListDirectoryBucketsRequest", arg0)
- ret0, _ := ret[0].(*request.Request)
- ret1, _ := ret[1].(*s3.ListDirectoryBucketsOutput)
- return ret0, ret1
-}
-
-// ListDirectoryBucketsRequest indicates an expected call of ListDirectoryBucketsRequest.
-func (mr *MockS3APIMockRecorder) ListDirectoryBucketsRequest(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListDirectoryBucketsRequest", reflect.TypeOf((*MockS3API)(nil).ListDirectoryBucketsRequest), arg0)
-}
-
-// ListDirectoryBucketsWithContext mocks base method.
-func (m *MockS3API) ListDirectoryBucketsWithContext(arg0 context.Context, arg1 *s3.ListDirectoryBucketsInput, arg2 ...request.Option) (*s3.ListDirectoryBucketsOutput, error) {
- m.ctrl.T.Helper()
- varargs := []interface{}{arg0, arg1}
- for _, a := range arg2 {
- varargs = append(varargs, a)
- }
- ret := m.ctrl.Call(m, "ListDirectoryBucketsWithContext", varargs...)
- ret0, _ := ret[0].(*s3.ListDirectoryBucketsOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// ListDirectoryBucketsWithContext indicates an expected call of ListDirectoryBucketsWithContext.
-func (mr *MockS3APIMockRecorder) ListDirectoryBucketsWithContext(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, "ListDirectoryBucketsWithContext", reflect.TypeOf((*MockS3API)(nil).ListDirectoryBucketsWithContext), varargs...)
-}
-
-// ListMultipartUploads mocks base method.
-func (m *MockS3API) ListMultipartUploads(arg0 *s3.ListMultipartUploadsInput) (*s3.ListMultipartUploadsOutput, error) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "ListMultipartUploads", arg0)
- ret0, _ := ret[0].(*s3.ListMultipartUploadsOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// ListMultipartUploads indicates an expected call of ListMultipartUploads.
-func (mr *MockS3APIMockRecorder) ListMultipartUploads(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListMultipartUploads", reflect.TypeOf((*MockS3API)(nil).ListMultipartUploads), arg0)
-}
-
-// ListMultipartUploadsPages mocks base method.
-func (m *MockS3API) ListMultipartUploadsPages(arg0 *s3.ListMultipartUploadsInput, arg1 func(*s3.ListMultipartUploadsOutput, bool) bool) error {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "ListMultipartUploadsPages", arg0, arg1)
- ret0, _ := ret[0].(error)
- return ret0
-}
-
-// ListMultipartUploadsPages indicates an expected call of ListMultipartUploadsPages.
-func (mr *MockS3APIMockRecorder) ListMultipartUploadsPages(arg0, arg1 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListMultipartUploadsPages", reflect.TypeOf((*MockS3API)(nil).ListMultipartUploadsPages), arg0, arg1)
-}
-
-// ListMultipartUploadsPagesWithContext mocks base method.
-func (m *MockS3API) ListMultipartUploadsPagesWithContext(arg0 context.Context, arg1 *s3.ListMultipartUploadsInput, arg2 func(*s3.ListMultipartUploadsOutput, 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, "ListMultipartUploadsPagesWithContext", varargs...)
- ret0, _ := ret[0].(error)
- return ret0
-}
-
-// ListMultipartUploadsPagesWithContext indicates an expected call of ListMultipartUploadsPagesWithContext.
-func (mr *MockS3APIMockRecorder) ListMultipartUploadsPagesWithContext(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, "ListMultipartUploadsPagesWithContext", reflect.TypeOf((*MockS3API)(nil).ListMultipartUploadsPagesWithContext), varargs...)
-}
-
-// ListMultipartUploadsRequest mocks base method.
-func (m *MockS3API) ListMultipartUploadsRequest(arg0 *s3.ListMultipartUploadsInput) (*request.Request, *s3.ListMultipartUploadsOutput) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "ListMultipartUploadsRequest", arg0)
- ret0, _ := ret[0].(*request.Request)
- ret1, _ := ret[1].(*s3.ListMultipartUploadsOutput)
- return ret0, ret1
-}
-
-// ListMultipartUploadsRequest indicates an expected call of ListMultipartUploadsRequest.
-func (mr *MockS3APIMockRecorder) ListMultipartUploadsRequest(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListMultipartUploadsRequest", reflect.TypeOf((*MockS3API)(nil).ListMultipartUploadsRequest), arg0)
-}
-
-// ListMultipartUploadsWithContext mocks base method.
-func (m *MockS3API) ListMultipartUploadsWithContext(arg0 context.Context, arg1 *s3.ListMultipartUploadsInput, arg2 ...request.Option) (*s3.ListMultipartUploadsOutput, error) {
- m.ctrl.T.Helper()
- varargs := []interface{}{arg0, arg1}
- for _, a := range arg2 {
- varargs = append(varargs, a)
- }
- ret := m.ctrl.Call(m, "ListMultipartUploadsWithContext", varargs...)
- ret0, _ := ret[0].(*s3.ListMultipartUploadsOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// ListMultipartUploadsWithContext indicates an expected call of ListMultipartUploadsWithContext.
-func (mr *MockS3APIMockRecorder) ListMultipartUploadsWithContext(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, "ListMultipartUploadsWithContext", reflect.TypeOf((*MockS3API)(nil).ListMultipartUploadsWithContext), varargs...)
-}
-
-// ListObjectVersions mocks base method.
-func (m *MockS3API) ListObjectVersions(arg0 *s3.ListObjectVersionsInput) (*s3.ListObjectVersionsOutput, error) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "ListObjectVersions", arg0)
- ret0, _ := ret[0].(*s3.ListObjectVersionsOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// ListObjectVersions indicates an expected call of ListObjectVersions.
-func (mr *MockS3APIMockRecorder) ListObjectVersions(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListObjectVersions", reflect.TypeOf((*MockS3API)(nil).ListObjectVersions), arg0)
-}
-
-// ListObjectVersionsPages mocks base method.
-func (m *MockS3API) ListObjectVersionsPages(arg0 *s3.ListObjectVersionsInput, arg1 func(*s3.ListObjectVersionsOutput, bool) bool) error {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "ListObjectVersionsPages", arg0, arg1)
- ret0, _ := ret[0].(error)
- return ret0
-}
-
-// ListObjectVersionsPages indicates an expected call of ListObjectVersionsPages.
-func (mr *MockS3APIMockRecorder) ListObjectVersionsPages(arg0, arg1 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListObjectVersionsPages", reflect.TypeOf((*MockS3API)(nil).ListObjectVersionsPages), arg0, arg1)
-}
-
-// ListObjectVersionsPagesWithContext mocks base method.
-func (m *MockS3API) ListObjectVersionsPagesWithContext(arg0 context.Context, arg1 *s3.ListObjectVersionsInput, arg2 func(*s3.ListObjectVersionsOutput, 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, "ListObjectVersionsPagesWithContext", varargs...)
- ret0, _ := ret[0].(error)
- return ret0
-}
-
-// ListObjectVersionsPagesWithContext indicates an expected call of ListObjectVersionsPagesWithContext.
-func (mr *MockS3APIMockRecorder) ListObjectVersionsPagesWithContext(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, "ListObjectVersionsPagesWithContext", reflect.TypeOf((*MockS3API)(nil).ListObjectVersionsPagesWithContext), varargs...)
-}
-
-// ListObjectVersionsRequest mocks base method.
-func (m *MockS3API) ListObjectVersionsRequest(arg0 *s3.ListObjectVersionsInput) (*request.Request, *s3.ListObjectVersionsOutput) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "ListObjectVersionsRequest", arg0)
- ret0, _ := ret[0].(*request.Request)
- ret1, _ := ret[1].(*s3.ListObjectVersionsOutput)
- return ret0, ret1
-}
-
-// ListObjectVersionsRequest indicates an expected call of ListObjectVersionsRequest.
-func (mr *MockS3APIMockRecorder) ListObjectVersionsRequest(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListObjectVersionsRequest", reflect.TypeOf((*MockS3API)(nil).ListObjectVersionsRequest), arg0)
-}
-
-// ListObjectVersionsWithContext mocks base method.
-func (m *MockS3API) ListObjectVersionsWithContext(arg0 context.Context, arg1 *s3.ListObjectVersionsInput, arg2 ...request.Option) (*s3.ListObjectVersionsOutput, error) {
- m.ctrl.T.Helper()
- varargs := []interface{}{arg0, arg1}
- for _, a := range arg2 {
- varargs = append(varargs, a)
- }
- ret := m.ctrl.Call(m, "ListObjectVersionsWithContext", varargs...)
- ret0, _ := ret[0].(*s3.ListObjectVersionsOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// ListObjectVersionsWithContext indicates an expected call of ListObjectVersionsWithContext.
-func (mr *MockS3APIMockRecorder) ListObjectVersionsWithContext(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, "ListObjectVersionsWithContext", reflect.TypeOf((*MockS3API)(nil).ListObjectVersionsWithContext), varargs...)
-}
-
-// ListObjects mocks base method.
-func (m *MockS3API) ListObjects(arg0 *s3.ListObjectsInput) (*s3.ListObjectsOutput, error) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "ListObjects", arg0)
- ret0, _ := ret[0].(*s3.ListObjectsOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// ListObjects indicates an expected call of ListObjects.
-func (mr *MockS3APIMockRecorder) ListObjects(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListObjects", reflect.TypeOf((*MockS3API)(nil).ListObjects), arg0)
-}
-
-// ListObjectsPages mocks base method.
-func (m *MockS3API) ListObjectsPages(arg0 *s3.ListObjectsInput, arg1 func(*s3.ListObjectsOutput, bool) bool) error {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "ListObjectsPages", arg0, arg1)
- ret0, _ := ret[0].(error)
- return ret0
-}
-
-// ListObjectsPages indicates an expected call of ListObjectsPages.
-func (mr *MockS3APIMockRecorder) ListObjectsPages(arg0, arg1 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListObjectsPages", reflect.TypeOf((*MockS3API)(nil).ListObjectsPages), arg0, arg1)
-}
-
-// ListObjectsPagesWithContext mocks base method.
-func (m *MockS3API) ListObjectsPagesWithContext(arg0 context.Context, arg1 *s3.ListObjectsInput, arg2 func(*s3.ListObjectsOutput, 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, "ListObjectsPagesWithContext", varargs...)
- ret0, _ := ret[0].(error)
- return ret0
-}
-
-// ListObjectsPagesWithContext indicates an expected call of ListObjectsPagesWithContext.
-func (mr *MockS3APIMockRecorder) ListObjectsPagesWithContext(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, "ListObjectsPagesWithContext", reflect.TypeOf((*MockS3API)(nil).ListObjectsPagesWithContext), varargs...)
-}
-
-// ListObjectsRequest mocks base method.
-func (m *MockS3API) ListObjectsRequest(arg0 *s3.ListObjectsInput) (*request.Request, *s3.ListObjectsOutput) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "ListObjectsRequest", arg0)
- ret0, _ := ret[0].(*request.Request)
- ret1, _ := ret[1].(*s3.ListObjectsOutput)
- return ret0, ret1
-}
-
-// ListObjectsRequest indicates an expected call of ListObjectsRequest.
-func (mr *MockS3APIMockRecorder) ListObjectsRequest(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListObjectsRequest", reflect.TypeOf((*MockS3API)(nil).ListObjectsRequest), arg0)
-}
-
-// ListObjectsV2 mocks base method.
-func (m *MockS3API) ListObjectsV2(arg0 *s3.ListObjectsV2Input) (*s3.ListObjectsV2Output, error) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "ListObjectsV2", arg0)
- ret0, _ := ret[0].(*s3.ListObjectsV2Output)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// ListObjectsV2 indicates an expected call of ListObjectsV2.
-func (mr *MockS3APIMockRecorder) ListObjectsV2(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListObjectsV2", reflect.TypeOf((*MockS3API)(nil).ListObjectsV2), arg0)
-}
-
-// ListObjectsV2Pages mocks base method.
-func (m *MockS3API) ListObjectsV2Pages(arg0 *s3.ListObjectsV2Input, arg1 func(*s3.ListObjectsV2Output, bool) bool) error {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "ListObjectsV2Pages", arg0, arg1)
- ret0, _ := ret[0].(error)
- return ret0
-}
-
-// ListObjectsV2Pages indicates an expected call of ListObjectsV2Pages.
-func (mr *MockS3APIMockRecorder) ListObjectsV2Pages(arg0, arg1 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListObjectsV2Pages", reflect.TypeOf((*MockS3API)(nil).ListObjectsV2Pages), arg0, arg1)
-}
-
-// ListObjectsV2PagesWithContext mocks base method.
-func (m *MockS3API) ListObjectsV2PagesWithContext(arg0 context.Context, arg1 *s3.ListObjectsV2Input, arg2 func(*s3.ListObjectsV2Output, 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, "ListObjectsV2PagesWithContext", varargs...)
- ret0, _ := ret[0].(error)
- return ret0
-}
-
-// ListObjectsV2PagesWithContext indicates an expected call of ListObjectsV2PagesWithContext.
-func (mr *MockS3APIMockRecorder) ListObjectsV2PagesWithContext(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, "ListObjectsV2PagesWithContext", reflect.TypeOf((*MockS3API)(nil).ListObjectsV2PagesWithContext), varargs...)
-}
-
-// ListObjectsV2Request mocks base method.
-func (m *MockS3API) ListObjectsV2Request(arg0 *s3.ListObjectsV2Input) (*request.Request, *s3.ListObjectsV2Output) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "ListObjectsV2Request", arg0)
- ret0, _ := ret[0].(*request.Request)
- ret1, _ := ret[1].(*s3.ListObjectsV2Output)
- return ret0, ret1
-}
-
-// ListObjectsV2Request indicates an expected call of ListObjectsV2Request.
-func (mr *MockS3APIMockRecorder) ListObjectsV2Request(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListObjectsV2Request", reflect.TypeOf((*MockS3API)(nil).ListObjectsV2Request), arg0)
-}
-
-// ListObjectsV2WithContext mocks base method.
-func (m *MockS3API) ListObjectsV2WithContext(arg0 context.Context, arg1 *s3.ListObjectsV2Input, arg2 ...request.Option) (*s3.ListObjectsV2Output, error) {
- m.ctrl.T.Helper()
- varargs := []interface{}{arg0, arg1}
- for _, a := range arg2 {
- varargs = append(varargs, a)
- }
- ret := m.ctrl.Call(m, "ListObjectsV2WithContext", varargs...)
- ret0, _ := ret[0].(*s3.ListObjectsV2Output)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// ListObjectsV2WithContext indicates an expected call of ListObjectsV2WithContext.
-func (mr *MockS3APIMockRecorder) ListObjectsV2WithContext(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, "ListObjectsV2WithContext", reflect.TypeOf((*MockS3API)(nil).ListObjectsV2WithContext), varargs...)
-}
-
-// ListObjectsWithContext mocks base method.
-func (m *MockS3API) ListObjectsWithContext(arg0 context.Context, arg1 *s3.ListObjectsInput, arg2 ...request.Option) (*s3.ListObjectsOutput, error) {
- m.ctrl.T.Helper()
- varargs := []interface{}{arg0, arg1}
- for _, a := range arg2 {
- varargs = append(varargs, a)
- }
- ret := m.ctrl.Call(m, "ListObjectsWithContext", varargs...)
- ret0, _ := ret[0].(*s3.ListObjectsOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// ListObjectsWithContext indicates an expected call of ListObjectsWithContext.
-func (mr *MockS3APIMockRecorder) ListObjectsWithContext(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, "ListObjectsWithContext", reflect.TypeOf((*MockS3API)(nil).ListObjectsWithContext), varargs...)
-}
-
-// ListParts mocks base method.
-func (m *MockS3API) ListParts(arg0 *s3.ListPartsInput) (*s3.ListPartsOutput, error) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "ListParts", arg0)
- ret0, _ := ret[0].(*s3.ListPartsOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// ListParts indicates an expected call of ListParts.
-func (mr *MockS3APIMockRecorder) ListParts(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListParts", reflect.TypeOf((*MockS3API)(nil).ListParts), arg0)
-}
-
-// ListPartsPages mocks base method.
-func (m *MockS3API) ListPartsPages(arg0 *s3.ListPartsInput, arg1 func(*s3.ListPartsOutput, bool) bool) error {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "ListPartsPages", arg0, arg1)
- ret0, _ := ret[0].(error)
- return ret0
-}
-
-// ListPartsPages indicates an expected call of ListPartsPages.
-func (mr *MockS3APIMockRecorder) ListPartsPages(arg0, arg1 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListPartsPages", reflect.TypeOf((*MockS3API)(nil).ListPartsPages), arg0, arg1)
-}
-
-// ListPartsPagesWithContext mocks base method.
-func (m *MockS3API) ListPartsPagesWithContext(arg0 context.Context, arg1 *s3.ListPartsInput, arg2 func(*s3.ListPartsOutput, 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, "ListPartsPagesWithContext", varargs...)
- ret0, _ := ret[0].(error)
- return ret0
-}
-
-// ListPartsPagesWithContext indicates an expected call of ListPartsPagesWithContext.
-func (mr *MockS3APIMockRecorder) ListPartsPagesWithContext(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, "ListPartsPagesWithContext", reflect.TypeOf((*MockS3API)(nil).ListPartsPagesWithContext), varargs...)
-}
-
-// ListPartsRequest mocks base method.
-func (m *MockS3API) ListPartsRequest(arg0 *s3.ListPartsInput) (*request.Request, *s3.ListPartsOutput) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "ListPartsRequest", arg0)
- ret0, _ := ret[0].(*request.Request)
- ret1, _ := ret[1].(*s3.ListPartsOutput)
- return ret0, ret1
-}
-
-// ListPartsRequest indicates an expected call of ListPartsRequest.
-func (mr *MockS3APIMockRecorder) ListPartsRequest(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListPartsRequest", reflect.TypeOf((*MockS3API)(nil).ListPartsRequest), arg0)
-}
-
-// ListPartsWithContext mocks base method.
-func (m *MockS3API) ListPartsWithContext(arg0 context.Context, arg1 *s3.ListPartsInput, arg2 ...request.Option) (*s3.ListPartsOutput, error) {
- m.ctrl.T.Helper()
- varargs := []interface{}{arg0, arg1}
- for _, a := range arg2 {
- varargs = append(varargs, a)
- }
- ret := m.ctrl.Call(m, "ListPartsWithContext", varargs...)
- ret0, _ := ret[0].(*s3.ListPartsOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// ListPartsWithContext indicates an expected call of ListPartsWithContext.
-func (mr *MockS3APIMockRecorder) ListPartsWithContext(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, "ListPartsWithContext", reflect.TypeOf((*MockS3API)(nil).ListPartsWithContext), varargs...)
-}
-
-// PutBucketAccelerateConfiguration mocks base method.
-func (m *MockS3API) PutBucketAccelerateConfiguration(arg0 *s3.PutBucketAccelerateConfigurationInput) (*s3.PutBucketAccelerateConfigurationOutput, error) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "PutBucketAccelerateConfiguration", arg0)
- ret0, _ := ret[0].(*s3.PutBucketAccelerateConfigurationOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// PutBucketAccelerateConfiguration indicates an expected call of PutBucketAccelerateConfiguration.
-func (mr *MockS3APIMockRecorder) PutBucketAccelerateConfiguration(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutBucketAccelerateConfiguration", reflect.TypeOf((*MockS3API)(nil).PutBucketAccelerateConfiguration), arg0)
-}
-
-// PutBucketAccelerateConfigurationRequest mocks base method.
-func (m *MockS3API) PutBucketAccelerateConfigurationRequest(arg0 *s3.PutBucketAccelerateConfigurationInput) (*request.Request, *s3.PutBucketAccelerateConfigurationOutput) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "PutBucketAccelerateConfigurationRequest", arg0)
- ret0, _ := ret[0].(*request.Request)
- ret1, _ := ret[1].(*s3.PutBucketAccelerateConfigurationOutput)
- return ret0, ret1
-}
-
-// PutBucketAccelerateConfigurationRequest indicates an expected call of PutBucketAccelerateConfigurationRequest.
-func (mr *MockS3APIMockRecorder) PutBucketAccelerateConfigurationRequest(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutBucketAccelerateConfigurationRequest", reflect.TypeOf((*MockS3API)(nil).PutBucketAccelerateConfigurationRequest), arg0)
-}
-
-// PutBucketAccelerateConfigurationWithContext mocks base method.
-func (m *MockS3API) PutBucketAccelerateConfigurationWithContext(arg0 context.Context, arg1 *s3.PutBucketAccelerateConfigurationInput, arg2 ...request.Option) (*s3.PutBucketAccelerateConfigurationOutput, error) {
- m.ctrl.T.Helper()
- varargs := []interface{}{arg0, arg1}
- for _, a := range arg2 {
- varargs = append(varargs, a)
- }
- ret := m.ctrl.Call(m, "PutBucketAccelerateConfigurationWithContext", varargs...)
- ret0, _ := ret[0].(*s3.PutBucketAccelerateConfigurationOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// PutBucketAccelerateConfigurationWithContext indicates an expected call of PutBucketAccelerateConfigurationWithContext.
-func (mr *MockS3APIMockRecorder) PutBucketAccelerateConfigurationWithContext(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, "PutBucketAccelerateConfigurationWithContext", reflect.TypeOf((*MockS3API)(nil).PutBucketAccelerateConfigurationWithContext), varargs...)
-}
-
-// PutBucketAcl mocks base method.
-func (m *MockS3API) PutBucketAcl(arg0 *s3.PutBucketAclInput) (*s3.PutBucketAclOutput, error) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "PutBucketAcl", arg0)
- ret0, _ := ret[0].(*s3.PutBucketAclOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// PutBucketAcl indicates an expected call of PutBucketAcl.
-func (mr *MockS3APIMockRecorder) PutBucketAcl(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutBucketAcl", reflect.TypeOf((*MockS3API)(nil).PutBucketAcl), arg0)
-}
-
-// PutBucketAclRequest mocks base method.
-func (m *MockS3API) PutBucketAclRequest(arg0 *s3.PutBucketAclInput) (*request.Request, *s3.PutBucketAclOutput) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "PutBucketAclRequest", arg0)
- ret0, _ := ret[0].(*request.Request)
- ret1, _ := ret[1].(*s3.PutBucketAclOutput)
- return ret0, ret1
-}
-
-// PutBucketAclRequest indicates an expected call of PutBucketAclRequest.
-func (mr *MockS3APIMockRecorder) PutBucketAclRequest(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutBucketAclRequest", reflect.TypeOf((*MockS3API)(nil).PutBucketAclRequest), arg0)
-}
-
-// PutBucketAclWithContext mocks base method.
-func (m *MockS3API) PutBucketAclWithContext(arg0 context.Context, arg1 *s3.PutBucketAclInput, arg2 ...request.Option) (*s3.PutBucketAclOutput, error) {
- m.ctrl.T.Helper()
- varargs := []interface{}{arg0, arg1}
- for _, a := range arg2 {
- varargs = append(varargs, a)
- }
- ret := m.ctrl.Call(m, "PutBucketAclWithContext", varargs...)
- ret0, _ := ret[0].(*s3.PutBucketAclOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// PutBucketAclWithContext indicates an expected call of PutBucketAclWithContext.
-func (mr *MockS3APIMockRecorder) PutBucketAclWithContext(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, "PutBucketAclWithContext", reflect.TypeOf((*MockS3API)(nil).PutBucketAclWithContext), varargs...)
-}
-
-// PutBucketAnalyticsConfiguration mocks base method.
-func (m *MockS3API) PutBucketAnalyticsConfiguration(arg0 *s3.PutBucketAnalyticsConfigurationInput) (*s3.PutBucketAnalyticsConfigurationOutput, error) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "PutBucketAnalyticsConfiguration", arg0)
- ret0, _ := ret[0].(*s3.PutBucketAnalyticsConfigurationOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// PutBucketAnalyticsConfiguration indicates an expected call of PutBucketAnalyticsConfiguration.
-func (mr *MockS3APIMockRecorder) PutBucketAnalyticsConfiguration(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutBucketAnalyticsConfiguration", reflect.TypeOf((*MockS3API)(nil).PutBucketAnalyticsConfiguration), arg0)
-}
-
-// PutBucketAnalyticsConfigurationRequest mocks base method.
-func (m *MockS3API) PutBucketAnalyticsConfigurationRequest(arg0 *s3.PutBucketAnalyticsConfigurationInput) (*request.Request, *s3.PutBucketAnalyticsConfigurationOutput) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "PutBucketAnalyticsConfigurationRequest", arg0)
- ret0, _ := ret[0].(*request.Request)
- ret1, _ := ret[1].(*s3.PutBucketAnalyticsConfigurationOutput)
- return ret0, ret1
-}
-
-// PutBucketAnalyticsConfigurationRequest indicates an expected call of PutBucketAnalyticsConfigurationRequest.
-func (mr *MockS3APIMockRecorder) PutBucketAnalyticsConfigurationRequest(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutBucketAnalyticsConfigurationRequest", reflect.TypeOf((*MockS3API)(nil).PutBucketAnalyticsConfigurationRequest), arg0)
-}
-
-// PutBucketAnalyticsConfigurationWithContext mocks base method.
-func (m *MockS3API) PutBucketAnalyticsConfigurationWithContext(arg0 context.Context, arg1 *s3.PutBucketAnalyticsConfigurationInput, arg2 ...request.Option) (*s3.PutBucketAnalyticsConfigurationOutput, error) {
- m.ctrl.T.Helper()
- varargs := []interface{}{arg0, arg1}
- for _, a := range arg2 {
- varargs = append(varargs, a)
- }
- ret := m.ctrl.Call(m, "PutBucketAnalyticsConfigurationWithContext", varargs...)
- ret0, _ := ret[0].(*s3.PutBucketAnalyticsConfigurationOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// PutBucketAnalyticsConfigurationWithContext indicates an expected call of PutBucketAnalyticsConfigurationWithContext.
-func (mr *MockS3APIMockRecorder) PutBucketAnalyticsConfigurationWithContext(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, "PutBucketAnalyticsConfigurationWithContext", reflect.TypeOf((*MockS3API)(nil).PutBucketAnalyticsConfigurationWithContext), varargs...)
-}
-
-// PutBucketCors mocks base method.
-func (m *MockS3API) PutBucketCors(arg0 *s3.PutBucketCorsInput) (*s3.PutBucketCorsOutput, error) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "PutBucketCors", arg0)
- ret0, _ := ret[0].(*s3.PutBucketCorsOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// PutBucketCors indicates an expected call of PutBucketCors.
-func (mr *MockS3APIMockRecorder) PutBucketCors(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutBucketCors", reflect.TypeOf((*MockS3API)(nil).PutBucketCors), arg0)
-}
-
-// PutBucketCorsRequest mocks base method.
-func (m *MockS3API) PutBucketCorsRequest(arg0 *s3.PutBucketCorsInput) (*request.Request, *s3.PutBucketCorsOutput) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "PutBucketCorsRequest", arg0)
- ret0, _ := ret[0].(*request.Request)
- ret1, _ := ret[1].(*s3.PutBucketCorsOutput)
- return ret0, ret1
-}
-
-// PutBucketCorsRequest indicates an expected call of PutBucketCorsRequest.
-func (mr *MockS3APIMockRecorder) PutBucketCorsRequest(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutBucketCorsRequest", reflect.TypeOf((*MockS3API)(nil).PutBucketCorsRequest), arg0)
-}
-
-// PutBucketCorsWithContext mocks base method.
-func (m *MockS3API) PutBucketCorsWithContext(arg0 context.Context, arg1 *s3.PutBucketCorsInput, arg2 ...request.Option) (*s3.PutBucketCorsOutput, error) {
- m.ctrl.T.Helper()
- varargs := []interface{}{arg0, arg1}
- for _, a := range arg2 {
- varargs = append(varargs, a)
- }
- ret := m.ctrl.Call(m, "PutBucketCorsWithContext", varargs...)
- ret0, _ := ret[0].(*s3.PutBucketCorsOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// PutBucketCorsWithContext indicates an expected call of PutBucketCorsWithContext.
-func (mr *MockS3APIMockRecorder) PutBucketCorsWithContext(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, "PutBucketCorsWithContext", reflect.TypeOf((*MockS3API)(nil).PutBucketCorsWithContext), varargs...)
-}
-
-// PutBucketEncryption mocks base method.
-func (m *MockS3API) PutBucketEncryption(arg0 *s3.PutBucketEncryptionInput) (*s3.PutBucketEncryptionOutput, error) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "PutBucketEncryption", arg0)
- ret0, _ := ret[0].(*s3.PutBucketEncryptionOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// PutBucketEncryption indicates an expected call of PutBucketEncryption.
-func (mr *MockS3APIMockRecorder) PutBucketEncryption(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutBucketEncryption", reflect.TypeOf((*MockS3API)(nil).PutBucketEncryption), arg0)
-}
-
-// PutBucketEncryptionRequest mocks base method.
-func (m *MockS3API) PutBucketEncryptionRequest(arg0 *s3.PutBucketEncryptionInput) (*request.Request, *s3.PutBucketEncryptionOutput) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "PutBucketEncryptionRequest", arg0)
- ret0, _ := ret[0].(*request.Request)
- ret1, _ := ret[1].(*s3.PutBucketEncryptionOutput)
- return ret0, ret1
-}
-
-// PutBucketEncryptionRequest indicates an expected call of PutBucketEncryptionRequest.
-func (mr *MockS3APIMockRecorder) PutBucketEncryptionRequest(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutBucketEncryptionRequest", reflect.TypeOf((*MockS3API)(nil).PutBucketEncryptionRequest), arg0)
-}
-
-// PutBucketEncryptionWithContext mocks base method.
-func (m *MockS3API) PutBucketEncryptionWithContext(arg0 context.Context, arg1 *s3.PutBucketEncryptionInput, arg2 ...request.Option) (*s3.PutBucketEncryptionOutput, error) {
- m.ctrl.T.Helper()
- varargs := []interface{}{arg0, arg1}
- for _, a := range arg2 {
- varargs = append(varargs, a)
- }
- ret := m.ctrl.Call(m, "PutBucketEncryptionWithContext", varargs...)
- ret0, _ := ret[0].(*s3.PutBucketEncryptionOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// PutBucketEncryptionWithContext indicates an expected call of PutBucketEncryptionWithContext.
-func (mr *MockS3APIMockRecorder) PutBucketEncryptionWithContext(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, "PutBucketEncryptionWithContext", reflect.TypeOf((*MockS3API)(nil).PutBucketEncryptionWithContext), varargs...)
-}
-
-// PutBucketIntelligentTieringConfiguration mocks base method.
-func (m *MockS3API) PutBucketIntelligentTieringConfiguration(arg0 *s3.PutBucketIntelligentTieringConfigurationInput) (*s3.PutBucketIntelligentTieringConfigurationOutput, error) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "PutBucketIntelligentTieringConfiguration", arg0)
- ret0, _ := ret[0].(*s3.PutBucketIntelligentTieringConfigurationOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// PutBucketIntelligentTieringConfiguration indicates an expected call of PutBucketIntelligentTieringConfiguration.
-func (mr *MockS3APIMockRecorder) PutBucketIntelligentTieringConfiguration(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutBucketIntelligentTieringConfiguration", reflect.TypeOf((*MockS3API)(nil).PutBucketIntelligentTieringConfiguration), arg0)
-}
-
-// PutBucketIntelligentTieringConfigurationRequest mocks base method.
-func (m *MockS3API) PutBucketIntelligentTieringConfigurationRequest(arg0 *s3.PutBucketIntelligentTieringConfigurationInput) (*request.Request, *s3.PutBucketIntelligentTieringConfigurationOutput) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "PutBucketIntelligentTieringConfigurationRequest", arg0)
- ret0, _ := ret[0].(*request.Request)
- ret1, _ := ret[1].(*s3.PutBucketIntelligentTieringConfigurationOutput)
- return ret0, ret1
-}
-
-// PutBucketIntelligentTieringConfigurationRequest indicates an expected call of PutBucketIntelligentTieringConfigurationRequest.
-func (mr *MockS3APIMockRecorder) PutBucketIntelligentTieringConfigurationRequest(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutBucketIntelligentTieringConfigurationRequest", reflect.TypeOf((*MockS3API)(nil).PutBucketIntelligentTieringConfigurationRequest), arg0)
-}
-
-// PutBucketIntelligentTieringConfigurationWithContext mocks base method.
-func (m *MockS3API) PutBucketIntelligentTieringConfigurationWithContext(arg0 context.Context, arg1 *s3.PutBucketIntelligentTieringConfigurationInput, arg2 ...request.Option) (*s3.PutBucketIntelligentTieringConfigurationOutput, error) {
- m.ctrl.T.Helper()
- varargs := []interface{}{arg0, arg1}
- for _, a := range arg2 {
- varargs = append(varargs, a)
- }
- ret := m.ctrl.Call(m, "PutBucketIntelligentTieringConfigurationWithContext", varargs...)
- ret0, _ := ret[0].(*s3.PutBucketIntelligentTieringConfigurationOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// PutBucketIntelligentTieringConfigurationWithContext indicates an expected call of PutBucketIntelligentTieringConfigurationWithContext.
-func (mr *MockS3APIMockRecorder) PutBucketIntelligentTieringConfigurationWithContext(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, "PutBucketIntelligentTieringConfigurationWithContext", reflect.TypeOf((*MockS3API)(nil).PutBucketIntelligentTieringConfigurationWithContext), varargs...)
-}
-
-// PutBucketInventoryConfiguration mocks base method.
-func (m *MockS3API) PutBucketInventoryConfiguration(arg0 *s3.PutBucketInventoryConfigurationInput) (*s3.PutBucketInventoryConfigurationOutput, error) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "PutBucketInventoryConfiguration", arg0)
- ret0, _ := ret[0].(*s3.PutBucketInventoryConfigurationOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// PutBucketInventoryConfiguration indicates an expected call of PutBucketInventoryConfiguration.
-func (mr *MockS3APIMockRecorder) PutBucketInventoryConfiguration(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutBucketInventoryConfiguration", reflect.TypeOf((*MockS3API)(nil).PutBucketInventoryConfiguration), arg0)
-}
-
-// PutBucketInventoryConfigurationRequest mocks base method.
-func (m *MockS3API) PutBucketInventoryConfigurationRequest(arg0 *s3.PutBucketInventoryConfigurationInput) (*request.Request, *s3.PutBucketInventoryConfigurationOutput) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "PutBucketInventoryConfigurationRequest", arg0)
- ret0, _ := ret[0].(*request.Request)
- ret1, _ := ret[1].(*s3.PutBucketInventoryConfigurationOutput)
- return ret0, ret1
-}
-
-// PutBucketInventoryConfigurationRequest indicates an expected call of PutBucketInventoryConfigurationRequest.
-func (mr *MockS3APIMockRecorder) PutBucketInventoryConfigurationRequest(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutBucketInventoryConfigurationRequest", reflect.TypeOf((*MockS3API)(nil).PutBucketInventoryConfigurationRequest), arg0)
-}
-
-// PutBucketInventoryConfigurationWithContext mocks base method.
-func (m *MockS3API) PutBucketInventoryConfigurationWithContext(arg0 context.Context, arg1 *s3.PutBucketInventoryConfigurationInput, arg2 ...request.Option) (*s3.PutBucketInventoryConfigurationOutput, error) {
- m.ctrl.T.Helper()
- varargs := []interface{}{arg0, arg1}
- for _, a := range arg2 {
- varargs = append(varargs, a)
- }
- ret := m.ctrl.Call(m, "PutBucketInventoryConfigurationWithContext", varargs...)
- ret0, _ := ret[0].(*s3.PutBucketInventoryConfigurationOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// PutBucketInventoryConfigurationWithContext indicates an expected call of PutBucketInventoryConfigurationWithContext.
-func (mr *MockS3APIMockRecorder) PutBucketInventoryConfigurationWithContext(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, "PutBucketInventoryConfigurationWithContext", reflect.TypeOf((*MockS3API)(nil).PutBucketInventoryConfigurationWithContext), varargs...)
-}
-
-// PutBucketLifecycle mocks base method.
-func (m *MockS3API) PutBucketLifecycle(arg0 *s3.PutBucketLifecycleInput) (*s3.PutBucketLifecycleOutput, error) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "PutBucketLifecycle", arg0)
- ret0, _ := ret[0].(*s3.PutBucketLifecycleOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// PutBucketLifecycle indicates an expected call of PutBucketLifecycle.
-func (mr *MockS3APIMockRecorder) PutBucketLifecycle(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutBucketLifecycle", reflect.TypeOf((*MockS3API)(nil).PutBucketLifecycle), arg0)
-}
-
-// PutBucketLifecycleConfiguration mocks base method.
-func (m *MockS3API) PutBucketLifecycleConfiguration(arg0 *s3.PutBucketLifecycleConfigurationInput) (*s3.PutBucketLifecycleConfigurationOutput, error) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "PutBucketLifecycleConfiguration", arg0)
- ret0, _ := ret[0].(*s3.PutBucketLifecycleConfigurationOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// PutBucketLifecycleConfiguration indicates an expected call of PutBucketLifecycleConfiguration.
-func (mr *MockS3APIMockRecorder) PutBucketLifecycleConfiguration(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutBucketLifecycleConfiguration", reflect.TypeOf((*MockS3API)(nil).PutBucketLifecycleConfiguration), arg0)
-}
-
-// PutBucketLifecycleConfigurationRequest mocks base method.
-func (m *MockS3API) PutBucketLifecycleConfigurationRequest(arg0 *s3.PutBucketLifecycleConfigurationInput) (*request.Request, *s3.PutBucketLifecycleConfigurationOutput) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "PutBucketLifecycleConfigurationRequest", arg0)
- ret0, _ := ret[0].(*request.Request)
- ret1, _ := ret[1].(*s3.PutBucketLifecycleConfigurationOutput)
- return ret0, ret1
-}
-
-// PutBucketLifecycleConfigurationRequest indicates an expected call of PutBucketLifecycleConfigurationRequest.
-func (mr *MockS3APIMockRecorder) PutBucketLifecycleConfigurationRequest(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutBucketLifecycleConfigurationRequest", reflect.TypeOf((*MockS3API)(nil).PutBucketLifecycleConfigurationRequest), arg0)
-}
-
-// PutBucketLifecycleConfigurationWithContext mocks base method.
-func (m *MockS3API) PutBucketLifecycleConfigurationWithContext(arg0 context.Context, arg1 *s3.PutBucketLifecycleConfigurationInput, arg2 ...request.Option) (*s3.PutBucketLifecycleConfigurationOutput, error) {
- m.ctrl.T.Helper()
- varargs := []interface{}{arg0, arg1}
- for _, a := range arg2 {
- varargs = append(varargs, a)
- }
- ret := m.ctrl.Call(m, "PutBucketLifecycleConfigurationWithContext", varargs...)
- ret0, _ := ret[0].(*s3.PutBucketLifecycleConfigurationOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// PutBucketLifecycleConfigurationWithContext indicates an expected call of PutBucketLifecycleConfigurationWithContext.
-func (mr *MockS3APIMockRecorder) PutBucketLifecycleConfigurationWithContext(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, "PutBucketLifecycleConfigurationWithContext", reflect.TypeOf((*MockS3API)(nil).PutBucketLifecycleConfigurationWithContext), varargs...)
-}
-
-// PutBucketLifecycleRequest mocks base method.
-func (m *MockS3API) PutBucketLifecycleRequest(arg0 *s3.PutBucketLifecycleInput) (*request.Request, *s3.PutBucketLifecycleOutput) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "PutBucketLifecycleRequest", arg0)
- ret0, _ := ret[0].(*request.Request)
- ret1, _ := ret[1].(*s3.PutBucketLifecycleOutput)
- return ret0, ret1
-}
-
-// PutBucketLifecycleRequest indicates an expected call of PutBucketLifecycleRequest.
-func (mr *MockS3APIMockRecorder) PutBucketLifecycleRequest(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutBucketLifecycleRequest", reflect.TypeOf((*MockS3API)(nil).PutBucketLifecycleRequest), arg0)
-}
-
-// PutBucketLifecycleWithContext mocks base method.
-func (m *MockS3API) PutBucketLifecycleWithContext(arg0 context.Context, arg1 *s3.PutBucketLifecycleInput, arg2 ...request.Option) (*s3.PutBucketLifecycleOutput, error) {
- m.ctrl.T.Helper()
- varargs := []interface{}{arg0, arg1}
- for _, a := range arg2 {
- varargs = append(varargs, a)
- }
- ret := m.ctrl.Call(m, "PutBucketLifecycleWithContext", varargs...)
- ret0, _ := ret[0].(*s3.PutBucketLifecycleOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// PutBucketLifecycleWithContext indicates an expected call of PutBucketLifecycleWithContext.
-func (mr *MockS3APIMockRecorder) PutBucketLifecycleWithContext(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, "PutBucketLifecycleWithContext", reflect.TypeOf((*MockS3API)(nil).PutBucketLifecycleWithContext), varargs...)
-}
-
-// PutBucketLogging mocks base method.
-func (m *MockS3API) PutBucketLogging(arg0 *s3.PutBucketLoggingInput) (*s3.PutBucketLoggingOutput, error) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "PutBucketLogging", arg0)
- ret0, _ := ret[0].(*s3.PutBucketLoggingOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// PutBucketLogging indicates an expected call of PutBucketLogging.
-func (mr *MockS3APIMockRecorder) PutBucketLogging(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutBucketLogging", reflect.TypeOf((*MockS3API)(nil).PutBucketLogging), arg0)
-}
-
-// PutBucketLoggingRequest mocks base method.
-func (m *MockS3API) PutBucketLoggingRequest(arg0 *s3.PutBucketLoggingInput) (*request.Request, *s3.PutBucketLoggingOutput) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "PutBucketLoggingRequest", arg0)
- ret0, _ := ret[0].(*request.Request)
- ret1, _ := ret[1].(*s3.PutBucketLoggingOutput)
- return ret0, ret1
-}
-
-// PutBucketLoggingRequest indicates an expected call of PutBucketLoggingRequest.
-func (mr *MockS3APIMockRecorder) PutBucketLoggingRequest(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutBucketLoggingRequest", reflect.TypeOf((*MockS3API)(nil).PutBucketLoggingRequest), arg0)
-}
-
-// PutBucketLoggingWithContext mocks base method.
-func (m *MockS3API) PutBucketLoggingWithContext(arg0 context.Context, arg1 *s3.PutBucketLoggingInput, arg2 ...request.Option) (*s3.PutBucketLoggingOutput, error) {
- m.ctrl.T.Helper()
- varargs := []interface{}{arg0, arg1}
- for _, a := range arg2 {
- varargs = append(varargs, a)
- }
- ret := m.ctrl.Call(m, "PutBucketLoggingWithContext", varargs...)
- ret0, _ := ret[0].(*s3.PutBucketLoggingOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// PutBucketLoggingWithContext indicates an expected call of PutBucketLoggingWithContext.
-func (mr *MockS3APIMockRecorder) PutBucketLoggingWithContext(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, "PutBucketLoggingWithContext", reflect.TypeOf((*MockS3API)(nil).PutBucketLoggingWithContext), varargs...)
-}
-
-// PutBucketMetricsConfiguration mocks base method.
-func (m *MockS3API) PutBucketMetricsConfiguration(arg0 *s3.PutBucketMetricsConfigurationInput) (*s3.PutBucketMetricsConfigurationOutput, error) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "PutBucketMetricsConfiguration", arg0)
- ret0, _ := ret[0].(*s3.PutBucketMetricsConfigurationOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// PutBucketMetricsConfiguration indicates an expected call of PutBucketMetricsConfiguration.
-func (mr *MockS3APIMockRecorder) PutBucketMetricsConfiguration(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutBucketMetricsConfiguration", reflect.TypeOf((*MockS3API)(nil).PutBucketMetricsConfiguration), arg0)
-}
-
-// PutBucketMetricsConfigurationRequest mocks base method.
-func (m *MockS3API) PutBucketMetricsConfigurationRequest(arg0 *s3.PutBucketMetricsConfigurationInput) (*request.Request, *s3.PutBucketMetricsConfigurationOutput) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "PutBucketMetricsConfigurationRequest", arg0)
- ret0, _ := ret[0].(*request.Request)
- ret1, _ := ret[1].(*s3.PutBucketMetricsConfigurationOutput)
- return ret0, ret1
-}
-
-// PutBucketMetricsConfigurationRequest indicates an expected call of PutBucketMetricsConfigurationRequest.
-func (mr *MockS3APIMockRecorder) PutBucketMetricsConfigurationRequest(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutBucketMetricsConfigurationRequest", reflect.TypeOf((*MockS3API)(nil).PutBucketMetricsConfigurationRequest), arg0)
-}
-
-// PutBucketMetricsConfigurationWithContext mocks base method.
-func (m *MockS3API) PutBucketMetricsConfigurationWithContext(arg0 context.Context, arg1 *s3.PutBucketMetricsConfigurationInput, arg2 ...request.Option) (*s3.PutBucketMetricsConfigurationOutput, error) {
- m.ctrl.T.Helper()
- varargs := []interface{}{arg0, arg1}
- for _, a := range arg2 {
- varargs = append(varargs, a)
- }
- ret := m.ctrl.Call(m, "PutBucketMetricsConfigurationWithContext", varargs...)
- ret0, _ := ret[0].(*s3.PutBucketMetricsConfigurationOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// PutBucketMetricsConfigurationWithContext indicates an expected call of PutBucketMetricsConfigurationWithContext.
-func (mr *MockS3APIMockRecorder) PutBucketMetricsConfigurationWithContext(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, "PutBucketMetricsConfigurationWithContext", reflect.TypeOf((*MockS3API)(nil).PutBucketMetricsConfigurationWithContext), varargs...)
-}
-
-// PutBucketNotification mocks base method.
-func (m *MockS3API) PutBucketNotification(arg0 *s3.PutBucketNotificationInput) (*s3.PutBucketNotificationOutput, error) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "PutBucketNotification", arg0)
- ret0, _ := ret[0].(*s3.PutBucketNotificationOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// PutBucketNotification indicates an expected call of PutBucketNotification.
-func (mr *MockS3APIMockRecorder) PutBucketNotification(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutBucketNotification", reflect.TypeOf((*MockS3API)(nil).PutBucketNotification), arg0)
-}
-
-// PutBucketNotificationConfiguration mocks base method.
-func (m *MockS3API) PutBucketNotificationConfiguration(arg0 *s3.PutBucketNotificationConfigurationInput) (*s3.PutBucketNotificationConfigurationOutput, error) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "PutBucketNotificationConfiguration", arg0)
- ret0, _ := ret[0].(*s3.PutBucketNotificationConfigurationOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// PutBucketNotificationConfiguration indicates an expected call of PutBucketNotificationConfiguration.
-func (mr *MockS3APIMockRecorder) PutBucketNotificationConfiguration(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutBucketNotificationConfiguration", reflect.TypeOf((*MockS3API)(nil).PutBucketNotificationConfiguration), arg0)
-}
-
-// PutBucketNotificationConfigurationRequest mocks base method.
-func (m *MockS3API) PutBucketNotificationConfigurationRequest(arg0 *s3.PutBucketNotificationConfigurationInput) (*request.Request, *s3.PutBucketNotificationConfigurationOutput) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "PutBucketNotificationConfigurationRequest", arg0)
- ret0, _ := ret[0].(*request.Request)
- ret1, _ := ret[1].(*s3.PutBucketNotificationConfigurationOutput)
- return ret0, ret1
-}
-
-// PutBucketNotificationConfigurationRequest indicates an expected call of PutBucketNotificationConfigurationRequest.
-func (mr *MockS3APIMockRecorder) PutBucketNotificationConfigurationRequest(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutBucketNotificationConfigurationRequest", reflect.TypeOf((*MockS3API)(nil).PutBucketNotificationConfigurationRequest), arg0)
-}
-
-// PutBucketNotificationConfigurationWithContext mocks base method.
-func (m *MockS3API) PutBucketNotificationConfigurationWithContext(arg0 context.Context, arg1 *s3.PutBucketNotificationConfigurationInput, arg2 ...request.Option) (*s3.PutBucketNotificationConfigurationOutput, error) {
- m.ctrl.T.Helper()
- varargs := []interface{}{arg0, arg1}
- for _, a := range arg2 {
- varargs = append(varargs, a)
- }
- ret := m.ctrl.Call(m, "PutBucketNotificationConfigurationWithContext", varargs...)
- ret0, _ := ret[0].(*s3.PutBucketNotificationConfigurationOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// PutBucketNotificationConfigurationWithContext indicates an expected call of PutBucketNotificationConfigurationWithContext.
-func (mr *MockS3APIMockRecorder) PutBucketNotificationConfigurationWithContext(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, "PutBucketNotificationConfigurationWithContext", reflect.TypeOf((*MockS3API)(nil).PutBucketNotificationConfigurationWithContext), varargs...)
-}
-
-// PutBucketNotificationRequest mocks base method.
-func (m *MockS3API) PutBucketNotificationRequest(arg0 *s3.PutBucketNotificationInput) (*request.Request, *s3.PutBucketNotificationOutput) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "PutBucketNotificationRequest", arg0)
- ret0, _ := ret[0].(*request.Request)
- ret1, _ := ret[1].(*s3.PutBucketNotificationOutput)
- return ret0, ret1
-}
-
-// PutBucketNotificationRequest indicates an expected call of PutBucketNotificationRequest.
-func (mr *MockS3APIMockRecorder) PutBucketNotificationRequest(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutBucketNotificationRequest", reflect.TypeOf((*MockS3API)(nil).PutBucketNotificationRequest), arg0)
-}
-
-// PutBucketNotificationWithContext mocks base method.
-func (m *MockS3API) PutBucketNotificationWithContext(arg0 context.Context, arg1 *s3.PutBucketNotificationInput, arg2 ...request.Option) (*s3.PutBucketNotificationOutput, error) {
- m.ctrl.T.Helper()
- varargs := []interface{}{arg0, arg1}
- for _, a := range arg2 {
- varargs = append(varargs, a)
- }
- ret := m.ctrl.Call(m, "PutBucketNotificationWithContext", varargs...)
- ret0, _ := ret[0].(*s3.PutBucketNotificationOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// PutBucketNotificationWithContext indicates an expected call of PutBucketNotificationWithContext.
-func (mr *MockS3APIMockRecorder) PutBucketNotificationWithContext(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, "PutBucketNotificationWithContext", reflect.TypeOf((*MockS3API)(nil).PutBucketNotificationWithContext), varargs...)
-}
-
-// PutBucketOwnershipControls mocks base method.
-func (m *MockS3API) PutBucketOwnershipControls(arg0 *s3.PutBucketOwnershipControlsInput) (*s3.PutBucketOwnershipControlsOutput, error) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "PutBucketOwnershipControls", arg0)
- ret0, _ := ret[0].(*s3.PutBucketOwnershipControlsOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// PutBucketOwnershipControls indicates an expected call of PutBucketOwnershipControls.
-func (mr *MockS3APIMockRecorder) PutBucketOwnershipControls(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutBucketOwnershipControls", reflect.TypeOf((*MockS3API)(nil).PutBucketOwnershipControls), arg0)
-}
-
-// PutBucketOwnershipControlsRequest mocks base method.
-func (m *MockS3API) PutBucketOwnershipControlsRequest(arg0 *s3.PutBucketOwnershipControlsInput) (*request.Request, *s3.PutBucketOwnershipControlsOutput) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "PutBucketOwnershipControlsRequest", arg0)
- ret0, _ := ret[0].(*request.Request)
- ret1, _ := ret[1].(*s3.PutBucketOwnershipControlsOutput)
- return ret0, ret1
-}
-
-// PutBucketOwnershipControlsRequest indicates an expected call of PutBucketOwnershipControlsRequest.
-func (mr *MockS3APIMockRecorder) PutBucketOwnershipControlsRequest(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutBucketOwnershipControlsRequest", reflect.TypeOf((*MockS3API)(nil).PutBucketOwnershipControlsRequest), arg0)
-}
-
-// PutBucketOwnershipControlsWithContext mocks base method.
-func (m *MockS3API) PutBucketOwnershipControlsWithContext(arg0 context.Context, arg1 *s3.PutBucketOwnershipControlsInput, arg2 ...request.Option) (*s3.PutBucketOwnershipControlsOutput, error) {
- m.ctrl.T.Helper()
- varargs := []interface{}{arg0, arg1}
- for _, a := range arg2 {
- varargs = append(varargs, a)
- }
- ret := m.ctrl.Call(m, "PutBucketOwnershipControlsWithContext", varargs...)
- ret0, _ := ret[0].(*s3.PutBucketOwnershipControlsOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// PutBucketOwnershipControlsWithContext indicates an expected call of PutBucketOwnershipControlsWithContext.
-func (mr *MockS3APIMockRecorder) PutBucketOwnershipControlsWithContext(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, "PutBucketOwnershipControlsWithContext", reflect.TypeOf((*MockS3API)(nil).PutBucketOwnershipControlsWithContext), varargs...)
-}
-
-// PutBucketPolicy mocks base method.
-func (m *MockS3API) PutBucketPolicy(arg0 *s3.PutBucketPolicyInput) (*s3.PutBucketPolicyOutput, error) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "PutBucketPolicy", arg0)
- ret0, _ := ret[0].(*s3.PutBucketPolicyOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// PutBucketPolicy indicates an expected call of PutBucketPolicy.
-func (mr *MockS3APIMockRecorder) PutBucketPolicy(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutBucketPolicy", reflect.TypeOf((*MockS3API)(nil).PutBucketPolicy), arg0)
-}
-
-// PutBucketPolicyRequest mocks base method.
-func (m *MockS3API) PutBucketPolicyRequest(arg0 *s3.PutBucketPolicyInput) (*request.Request, *s3.PutBucketPolicyOutput) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "PutBucketPolicyRequest", arg0)
- ret0, _ := ret[0].(*request.Request)
- ret1, _ := ret[1].(*s3.PutBucketPolicyOutput)
- return ret0, ret1
-}
-
-// PutBucketPolicyRequest indicates an expected call of PutBucketPolicyRequest.
-func (mr *MockS3APIMockRecorder) PutBucketPolicyRequest(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutBucketPolicyRequest", reflect.TypeOf((*MockS3API)(nil).PutBucketPolicyRequest), arg0)
-}
-
-// PutBucketPolicyWithContext mocks base method.
-func (m *MockS3API) PutBucketPolicyWithContext(arg0 context.Context, arg1 *s3.PutBucketPolicyInput, arg2 ...request.Option) (*s3.PutBucketPolicyOutput, error) {
- m.ctrl.T.Helper()
- varargs := []interface{}{arg0, arg1}
- for _, a := range arg2 {
- varargs = append(varargs, a)
- }
- ret := m.ctrl.Call(m, "PutBucketPolicyWithContext", varargs...)
- ret0, _ := ret[0].(*s3.PutBucketPolicyOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// PutBucketPolicyWithContext indicates an expected call of PutBucketPolicyWithContext.
-func (mr *MockS3APIMockRecorder) PutBucketPolicyWithContext(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, "PutBucketPolicyWithContext", reflect.TypeOf((*MockS3API)(nil).PutBucketPolicyWithContext), varargs...)
-}
-
-// PutBucketReplication mocks base method.
-func (m *MockS3API) PutBucketReplication(arg0 *s3.PutBucketReplicationInput) (*s3.PutBucketReplicationOutput, error) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "PutBucketReplication", arg0)
- ret0, _ := ret[0].(*s3.PutBucketReplicationOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// PutBucketReplication indicates an expected call of PutBucketReplication.
-func (mr *MockS3APIMockRecorder) PutBucketReplication(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutBucketReplication", reflect.TypeOf((*MockS3API)(nil).PutBucketReplication), arg0)
-}
-
-// PutBucketReplicationRequest mocks base method.
-func (m *MockS3API) PutBucketReplicationRequest(arg0 *s3.PutBucketReplicationInput) (*request.Request, *s3.PutBucketReplicationOutput) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "PutBucketReplicationRequest", arg0)
- ret0, _ := ret[0].(*request.Request)
- ret1, _ := ret[1].(*s3.PutBucketReplicationOutput)
- return ret0, ret1
-}
-
-// PutBucketReplicationRequest indicates an expected call of PutBucketReplicationRequest.
-func (mr *MockS3APIMockRecorder) PutBucketReplicationRequest(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutBucketReplicationRequest", reflect.TypeOf((*MockS3API)(nil).PutBucketReplicationRequest), arg0)
-}
-
-// PutBucketReplicationWithContext mocks base method.
-func (m *MockS3API) PutBucketReplicationWithContext(arg0 context.Context, arg1 *s3.PutBucketReplicationInput, arg2 ...request.Option) (*s3.PutBucketReplicationOutput, error) {
- m.ctrl.T.Helper()
- varargs := []interface{}{arg0, arg1}
- for _, a := range arg2 {
- varargs = append(varargs, a)
- }
- ret := m.ctrl.Call(m, "PutBucketReplicationWithContext", varargs...)
- ret0, _ := ret[0].(*s3.PutBucketReplicationOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// PutBucketReplicationWithContext indicates an expected call of PutBucketReplicationWithContext.
-func (mr *MockS3APIMockRecorder) PutBucketReplicationWithContext(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, "PutBucketReplicationWithContext", reflect.TypeOf((*MockS3API)(nil).PutBucketReplicationWithContext), varargs...)
-}
-
-// PutBucketRequestPayment mocks base method.
-func (m *MockS3API) PutBucketRequestPayment(arg0 *s3.PutBucketRequestPaymentInput) (*s3.PutBucketRequestPaymentOutput, error) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "PutBucketRequestPayment", arg0)
- ret0, _ := ret[0].(*s3.PutBucketRequestPaymentOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// PutBucketRequestPayment indicates an expected call of PutBucketRequestPayment.
-func (mr *MockS3APIMockRecorder) PutBucketRequestPayment(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutBucketRequestPayment", reflect.TypeOf((*MockS3API)(nil).PutBucketRequestPayment), arg0)
-}
-
-// PutBucketRequestPaymentRequest mocks base method.
-func (m *MockS3API) PutBucketRequestPaymentRequest(arg0 *s3.PutBucketRequestPaymentInput) (*request.Request, *s3.PutBucketRequestPaymentOutput) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "PutBucketRequestPaymentRequest", arg0)
- ret0, _ := ret[0].(*request.Request)
- ret1, _ := ret[1].(*s3.PutBucketRequestPaymentOutput)
- return ret0, ret1
-}
-
-// PutBucketRequestPaymentRequest indicates an expected call of PutBucketRequestPaymentRequest.
-func (mr *MockS3APIMockRecorder) PutBucketRequestPaymentRequest(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutBucketRequestPaymentRequest", reflect.TypeOf((*MockS3API)(nil).PutBucketRequestPaymentRequest), arg0)
-}
-
-// PutBucketRequestPaymentWithContext mocks base method.
-func (m *MockS3API) PutBucketRequestPaymentWithContext(arg0 context.Context, arg1 *s3.PutBucketRequestPaymentInput, arg2 ...request.Option) (*s3.PutBucketRequestPaymentOutput, error) {
- m.ctrl.T.Helper()
- varargs := []interface{}{arg0, arg1}
- for _, a := range arg2 {
- varargs = append(varargs, a)
- }
- ret := m.ctrl.Call(m, "PutBucketRequestPaymentWithContext", varargs...)
- ret0, _ := ret[0].(*s3.PutBucketRequestPaymentOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// PutBucketRequestPaymentWithContext indicates an expected call of PutBucketRequestPaymentWithContext.
-func (mr *MockS3APIMockRecorder) PutBucketRequestPaymentWithContext(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, "PutBucketRequestPaymentWithContext", reflect.TypeOf((*MockS3API)(nil).PutBucketRequestPaymentWithContext), varargs...)
-}
-
-// PutBucketTagging mocks base method.
-func (m *MockS3API) PutBucketTagging(arg0 *s3.PutBucketTaggingInput) (*s3.PutBucketTaggingOutput, error) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "PutBucketTagging", arg0)
- ret0, _ := ret[0].(*s3.PutBucketTaggingOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// PutBucketTagging indicates an expected call of PutBucketTagging.
-func (mr *MockS3APIMockRecorder) PutBucketTagging(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutBucketTagging", reflect.TypeOf((*MockS3API)(nil).PutBucketTagging), arg0)
-}
-
-// PutBucketTaggingRequest mocks base method.
-func (m *MockS3API) PutBucketTaggingRequest(arg0 *s3.PutBucketTaggingInput) (*request.Request, *s3.PutBucketTaggingOutput) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "PutBucketTaggingRequest", arg0)
- ret0, _ := ret[0].(*request.Request)
- ret1, _ := ret[1].(*s3.PutBucketTaggingOutput)
- return ret0, ret1
-}
-
-// PutBucketTaggingRequest indicates an expected call of PutBucketTaggingRequest.
-func (mr *MockS3APIMockRecorder) PutBucketTaggingRequest(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutBucketTaggingRequest", reflect.TypeOf((*MockS3API)(nil).PutBucketTaggingRequest), arg0)
-}
-
-// PutBucketTaggingWithContext mocks base method.
-func (m *MockS3API) PutBucketTaggingWithContext(arg0 context.Context, arg1 *s3.PutBucketTaggingInput, arg2 ...request.Option) (*s3.PutBucketTaggingOutput, error) {
- m.ctrl.T.Helper()
- varargs := []interface{}{arg0, arg1}
- for _, a := range arg2 {
- varargs = append(varargs, a)
- }
- ret := m.ctrl.Call(m, "PutBucketTaggingWithContext", varargs...)
- ret0, _ := ret[0].(*s3.PutBucketTaggingOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// PutBucketTaggingWithContext indicates an expected call of PutBucketTaggingWithContext.
-func (mr *MockS3APIMockRecorder) PutBucketTaggingWithContext(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, "PutBucketTaggingWithContext", reflect.TypeOf((*MockS3API)(nil).PutBucketTaggingWithContext), varargs...)
-}
-
-// PutBucketVersioning mocks base method.
-func (m *MockS3API) PutBucketVersioning(arg0 *s3.PutBucketVersioningInput) (*s3.PutBucketVersioningOutput, error) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "PutBucketVersioning", arg0)
- ret0, _ := ret[0].(*s3.PutBucketVersioningOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// PutBucketVersioning indicates an expected call of PutBucketVersioning.
-func (mr *MockS3APIMockRecorder) PutBucketVersioning(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutBucketVersioning", reflect.TypeOf((*MockS3API)(nil).PutBucketVersioning), arg0)
-}
-
-// PutBucketVersioningRequest mocks base method.
-func (m *MockS3API) PutBucketVersioningRequest(arg0 *s3.PutBucketVersioningInput) (*request.Request, *s3.PutBucketVersioningOutput) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "PutBucketVersioningRequest", arg0)
- ret0, _ := ret[0].(*request.Request)
- ret1, _ := ret[1].(*s3.PutBucketVersioningOutput)
- return ret0, ret1
-}
-
-// PutBucketVersioningRequest indicates an expected call of PutBucketVersioningRequest.
-func (mr *MockS3APIMockRecorder) PutBucketVersioningRequest(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutBucketVersioningRequest", reflect.TypeOf((*MockS3API)(nil).PutBucketVersioningRequest), arg0)
-}
-
-// PutBucketVersioningWithContext mocks base method.
-func (m *MockS3API) PutBucketVersioningWithContext(arg0 context.Context, arg1 *s3.PutBucketVersioningInput, arg2 ...request.Option) (*s3.PutBucketVersioningOutput, error) {
- m.ctrl.T.Helper()
- varargs := []interface{}{arg0, arg1}
- for _, a := range arg2 {
- varargs = append(varargs, a)
- }
- ret := m.ctrl.Call(m, "PutBucketVersioningWithContext", varargs...)
- ret0, _ := ret[0].(*s3.PutBucketVersioningOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// PutBucketVersioningWithContext indicates an expected call of PutBucketVersioningWithContext.
-func (mr *MockS3APIMockRecorder) PutBucketVersioningWithContext(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, "PutBucketVersioningWithContext", reflect.TypeOf((*MockS3API)(nil).PutBucketVersioningWithContext), varargs...)
-}
-
-// PutBucketWebsite mocks base method.
-func (m *MockS3API) PutBucketWebsite(arg0 *s3.PutBucketWebsiteInput) (*s3.PutBucketWebsiteOutput, error) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "PutBucketWebsite", arg0)
- ret0, _ := ret[0].(*s3.PutBucketWebsiteOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// PutBucketWebsite indicates an expected call of PutBucketWebsite.
-func (mr *MockS3APIMockRecorder) PutBucketWebsite(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutBucketWebsite", reflect.TypeOf((*MockS3API)(nil).PutBucketWebsite), arg0)
-}
-
-// PutBucketWebsiteRequest mocks base method.
-func (m *MockS3API) PutBucketWebsiteRequest(arg0 *s3.PutBucketWebsiteInput) (*request.Request, *s3.PutBucketWebsiteOutput) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "PutBucketWebsiteRequest", arg0)
- ret0, _ := ret[0].(*request.Request)
- ret1, _ := ret[1].(*s3.PutBucketWebsiteOutput)
- return ret0, ret1
-}
-
-// PutBucketWebsiteRequest indicates an expected call of PutBucketWebsiteRequest.
-func (mr *MockS3APIMockRecorder) PutBucketWebsiteRequest(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutBucketWebsiteRequest", reflect.TypeOf((*MockS3API)(nil).PutBucketWebsiteRequest), arg0)
-}
-
-// PutBucketWebsiteWithContext mocks base method.
-func (m *MockS3API) PutBucketWebsiteWithContext(arg0 context.Context, arg1 *s3.PutBucketWebsiteInput, arg2 ...request.Option) (*s3.PutBucketWebsiteOutput, error) {
- m.ctrl.T.Helper()
- varargs := []interface{}{arg0, arg1}
- for _, a := range arg2 {
- varargs = append(varargs, a)
- }
- ret := m.ctrl.Call(m, "PutBucketWebsiteWithContext", varargs...)
- ret0, _ := ret[0].(*s3.PutBucketWebsiteOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// PutBucketWebsiteWithContext indicates an expected call of PutBucketWebsiteWithContext.
-func (mr *MockS3APIMockRecorder) PutBucketWebsiteWithContext(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, "PutBucketWebsiteWithContext", reflect.TypeOf((*MockS3API)(nil).PutBucketWebsiteWithContext), varargs...)
-}
-
-// PutObject mocks base method.
-func (m *MockS3API) PutObject(arg0 *s3.PutObjectInput) (*s3.PutObjectOutput, error) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "PutObject", arg0)
- ret0, _ := ret[0].(*s3.PutObjectOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// PutObject indicates an expected call of PutObject.
-func (mr *MockS3APIMockRecorder) PutObject(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutObject", reflect.TypeOf((*MockS3API)(nil).PutObject), arg0)
-}
-
-// PutObjectAcl mocks base method.
-func (m *MockS3API) PutObjectAcl(arg0 *s3.PutObjectAclInput) (*s3.PutObjectAclOutput, error) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "PutObjectAcl", arg0)
- ret0, _ := ret[0].(*s3.PutObjectAclOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// PutObjectAcl indicates an expected call of PutObjectAcl.
-func (mr *MockS3APIMockRecorder) PutObjectAcl(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutObjectAcl", reflect.TypeOf((*MockS3API)(nil).PutObjectAcl), arg0)
-}
-
-// PutObjectAclRequest mocks base method.
-func (m *MockS3API) PutObjectAclRequest(arg0 *s3.PutObjectAclInput) (*request.Request, *s3.PutObjectAclOutput) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "PutObjectAclRequest", arg0)
- ret0, _ := ret[0].(*request.Request)
- ret1, _ := ret[1].(*s3.PutObjectAclOutput)
- return ret0, ret1
-}
-
-// PutObjectAclRequest indicates an expected call of PutObjectAclRequest.
-func (mr *MockS3APIMockRecorder) PutObjectAclRequest(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutObjectAclRequest", reflect.TypeOf((*MockS3API)(nil).PutObjectAclRequest), arg0)
-}
-
-// PutObjectAclWithContext mocks base method.
-func (m *MockS3API) PutObjectAclWithContext(arg0 context.Context, arg1 *s3.PutObjectAclInput, arg2 ...request.Option) (*s3.PutObjectAclOutput, error) {
- m.ctrl.T.Helper()
- varargs := []interface{}{arg0, arg1}
- for _, a := range arg2 {
- varargs = append(varargs, a)
- }
- ret := m.ctrl.Call(m, "PutObjectAclWithContext", varargs...)
- ret0, _ := ret[0].(*s3.PutObjectAclOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// PutObjectAclWithContext indicates an expected call of PutObjectAclWithContext.
-func (mr *MockS3APIMockRecorder) PutObjectAclWithContext(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, "PutObjectAclWithContext", reflect.TypeOf((*MockS3API)(nil).PutObjectAclWithContext), varargs...)
-}
-
-// PutObjectLegalHold mocks base method.
-func (m *MockS3API) PutObjectLegalHold(arg0 *s3.PutObjectLegalHoldInput) (*s3.PutObjectLegalHoldOutput, error) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "PutObjectLegalHold", arg0)
- ret0, _ := ret[0].(*s3.PutObjectLegalHoldOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// PutObjectLegalHold indicates an expected call of PutObjectLegalHold.
-func (mr *MockS3APIMockRecorder) PutObjectLegalHold(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutObjectLegalHold", reflect.TypeOf((*MockS3API)(nil).PutObjectLegalHold), arg0)
-}
-
-// PutObjectLegalHoldRequest mocks base method.
-func (m *MockS3API) PutObjectLegalHoldRequest(arg0 *s3.PutObjectLegalHoldInput) (*request.Request, *s3.PutObjectLegalHoldOutput) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "PutObjectLegalHoldRequest", arg0)
- ret0, _ := ret[0].(*request.Request)
- ret1, _ := ret[1].(*s3.PutObjectLegalHoldOutput)
- return ret0, ret1
-}
-
-// PutObjectLegalHoldRequest indicates an expected call of PutObjectLegalHoldRequest.
-func (mr *MockS3APIMockRecorder) PutObjectLegalHoldRequest(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutObjectLegalHoldRequest", reflect.TypeOf((*MockS3API)(nil).PutObjectLegalHoldRequest), arg0)
-}
-
-// PutObjectLegalHoldWithContext mocks base method.
-func (m *MockS3API) PutObjectLegalHoldWithContext(arg0 context.Context, arg1 *s3.PutObjectLegalHoldInput, arg2 ...request.Option) (*s3.PutObjectLegalHoldOutput, error) {
- m.ctrl.T.Helper()
- varargs := []interface{}{arg0, arg1}
- for _, a := range arg2 {
- varargs = append(varargs, a)
- }
- ret := m.ctrl.Call(m, "PutObjectLegalHoldWithContext", varargs...)
- ret0, _ := ret[0].(*s3.PutObjectLegalHoldOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// PutObjectLegalHoldWithContext indicates an expected call of PutObjectLegalHoldWithContext.
-func (mr *MockS3APIMockRecorder) PutObjectLegalHoldWithContext(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, "PutObjectLegalHoldWithContext", reflect.TypeOf((*MockS3API)(nil).PutObjectLegalHoldWithContext), varargs...)
-}
-
-// PutObjectLockConfiguration mocks base method.
-func (m *MockS3API) PutObjectLockConfiguration(arg0 *s3.PutObjectLockConfigurationInput) (*s3.PutObjectLockConfigurationOutput, error) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "PutObjectLockConfiguration", arg0)
- ret0, _ := ret[0].(*s3.PutObjectLockConfigurationOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// PutObjectLockConfiguration indicates an expected call of PutObjectLockConfiguration.
-func (mr *MockS3APIMockRecorder) PutObjectLockConfiguration(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutObjectLockConfiguration", reflect.TypeOf((*MockS3API)(nil).PutObjectLockConfiguration), arg0)
-}
-
-// PutObjectLockConfigurationRequest mocks base method.
-func (m *MockS3API) PutObjectLockConfigurationRequest(arg0 *s3.PutObjectLockConfigurationInput) (*request.Request, *s3.PutObjectLockConfigurationOutput) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "PutObjectLockConfigurationRequest", arg0)
- ret0, _ := ret[0].(*request.Request)
- ret1, _ := ret[1].(*s3.PutObjectLockConfigurationOutput)
- return ret0, ret1
-}
-
-// PutObjectLockConfigurationRequest indicates an expected call of PutObjectLockConfigurationRequest.
-func (mr *MockS3APIMockRecorder) PutObjectLockConfigurationRequest(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutObjectLockConfigurationRequest", reflect.TypeOf((*MockS3API)(nil).PutObjectLockConfigurationRequest), arg0)
-}
-
-// PutObjectLockConfigurationWithContext mocks base method.
-func (m *MockS3API) PutObjectLockConfigurationWithContext(arg0 context.Context, arg1 *s3.PutObjectLockConfigurationInput, arg2 ...request.Option) (*s3.PutObjectLockConfigurationOutput, error) {
- m.ctrl.T.Helper()
- varargs := []interface{}{arg0, arg1}
- for _, a := range arg2 {
- varargs = append(varargs, a)
- }
- ret := m.ctrl.Call(m, "PutObjectLockConfigurationWithContext", varargs...)
- ret0, _ := ret[0].(*s3.PutObjectLockConfigurationOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// PutObjectLockConfigurationWithContext indicates an expected call of PutObjectLockConfigurationWithContext.
-func (mr *MockS3APIMockRecorder) PutObjectLockConfigurationWithContext(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, "PutObjectLockConfigurationWithContext", reflect.TypeOf((*MockS3API)(nil).PutObjectLockConfigurationWithContext), varargs...)
-}
-
-// PutObjectRequest mocks base method.
-func (m *MockS3API) PutObjectRequest(arg0 *s3.PutObjectInput) (*request.Request, *s3.PutObjectOutput) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "PutObjectRequest", arg0)
- ret0, _ := ret[0].(*request.Request)
- ret1, _ := ret[1].(*s3.PutObjectOutput)
- return ret0, ret1
-}
-
-// PutObjectRequest indicates an expected call of PutObjectRequest.
-func (mr *MockS3APIMockRecorder) PutObjectRequest(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutObjectRequest", reflect.TypeOf((*MockS3API)(nil).PutObjectRequest), arg0)
-}
-
-// PutObjectRetention mocks base method.
-func (m *MockS3API) PutObjectRetention(arg0 *s3.PutObjectRetentionInput) (*s3.PutObjectRetentionOutput, error) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "PutObjectRetention", arg0)
- ret0, _ := ret[0].(*s3.PutObjectRetentionOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// PutObjectRetention indicates an expected call of PutObjectRetention.
-func (mr *MockS3APIMockRecorder) PutObjectRetention(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutObjectRetention", reflect.TypeOf((*MockS3API)(nil).PutObjectRetention), arg0)
-}
-
-// PutObjectRetentionRequest mocks base method.
-func (m *MockS3API) PutObjectRetentionRequest(arg0 *s3.PutObjectRetentionInput) (*request.Request, *s3.PutObjectRetentionOutput) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "PutObjectRetentionRequest", arg0)
- ret0, _ := ret[0].(*request.Request)
- ret1, _ := ret[1].(*s3.PutObjectRetentionOutput)
- return ret0, ret1
-}
-
-// PutObjectRetentionRequest indicates an expected call of PutObjectRetentionRequest.
-func (mr *MockS3APIMockRecorder) PutObjectRetentionRequest(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutObjectRetentionRequest", reflect.TypeOf((*MockS3API)(nil).PutObjectRetentionRequest), arg0)
-}
-
-// PutObjectRetentionWithContext mocks base method.
-func (m *MockS3API) PutObjectRetentionWithContext(arg0 context.Context, arg1 *s3.PutObjectRetentionInput, arg2 ...request.Option) (*s3.PutObjectRetentionOutput, error) {
- m.ctrl.T.Helper()
- varargs := []interface{}{arg0, arg1}
- for _, a := range arg2 {
- varargs = append(varargs, a)
- }
- ret := m.ctrl.Call(m, "PutObjectRetentionWithContext", varargs...)
- ret0, _ := ret[0].(*s3.PutObjectRetentionOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// PutObjectRetentionWithContext indicates an expected call of PutObjectRetentionWithContext.
-func (mr *MockS3APIMockRecorder) PutObjectRetentionWithContext(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, "PutObjectRetentionWithContext", reflect.TypeOf((*MockS3API)(nil).PutObjectRetentionWithContext), varargs...)
-}
-
-// PutObjectTagging mocks base method.
-func (m *MockS3API) PutObjectTagging(arg0 *s3.PutObjectTaggingInput) (*s3.PutObjectTaggingOutput, error) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "PutObjectTagging", arg0)
- ret0, _ := ret[0].(*s3.PutObjectTaggingOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// PutObjectTagging indicates an expected call of PutObjectTagging.
-func (mr *MockS3APIMockRecorder) PutObjectTagging(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutObjectTagging", reflect.TypeOf((*MockS3API)(nil).PutObjectTagging), arg0)
-}
-
-// PutObjectTaggingRequest mocks base method.
-func (m *MockS3API) PutObjectTaggingRequest(arg0 *s3.PutObjectTaggingInput) (*request.Request, *s3.PutObjectTaggingOutput) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "PutObjectTaggingRequest", arg0)
- ret0, _ := ret[0].(*request.Request)
- ret1, _ := ret[1].(*s3.PutObjectTaggingOutput)
- return ret0, ret1
-}
-
-// PutObjectTaggingRequest indicates an expected call of PutObjectTaggingRequest.
-func (mr *MockS3APIMockRecorder) PutObjectTaggingRequest(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutObjectTaggingRequest", reflect.TypeOf((*MockS3API)(nil).PutObjectTaggingRequest), arg0)
-}
-
-// PutObjectTaggingWithContext mocks base method.
-func (m *MockS3API) PutObjectTaggingWithContext(arg0 context.Context, arg1 *s3.PutObjectTaggingInput, arg2 ...request.Option) (*s3.PutObjectTaggingOutput, error) {
- m.ctrl.T.Helper()
- varargs := []interface{}{arg0, arg1}
- for _, a := range arg2 {
- varargs = append(varargs, a)
- }
- ret := m.ctrl.Call(m, "PutObjectTaggingWithContext", varargs...)
- ret0, _ := ret[0].(*s3.PutObjectTaggingOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// PutObjectTaggingWithContext indicates an expected call of PutObjectTaggingWithContext.
-func (mr *MockS3APIMockRecorder) PutObjectTaggingWithContext(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, "PutObjectTaggingWithContext", reflect.TypeOf((*MockS3API)(nil).PutObjectTaggingWithContext), varargs...)
-}
-
-// PutObjectWithContext mocks base method.
-func (m *MockS3API) PutObjectWithContext(arg0 context.Context, arg1 *s3.PutObjectInput, arg2 ...request.Option) (*s3.PutObjectOutput, error) {
- m.ctrl.T.Helper()
- varargs := []interface{}{arg0, arg1}
- for _, a := range arg2 {
- varargs = append(varargs, a)
- }
- ret := m.ctrl.Call(m, "PutObjectWithContext", varargs...)
- ret0, _ := ret[0].(*s3.PutObjectOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// PutObjectWithContext indicates an expected call of PutObjectWithContext.
-func (mr *MockS3APIMockRecorder) PutObjectWithContext(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, "PutObjectWithContext", reflect.TypeOf((*MockS3API)(nil).PutObjectWithContext), varargs...)
-}
-
-// PutPublicAccessBlock mocks base method.
-func (m *MockS3API) PutPublicAccessBlock(arg0 *s3.PutPublicAccessBlockInput) (*s3.PutPublicAccessBlockOutput, error) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "PutPublicAccessBlock", arg0)
- ret0, _ := ret[0].(*s3.PutPublicAccessBlockOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// PutPublicAccessBlock indicates an expected call of PutPublicAccessBlock.
-func (mr *MockS3APIMockRecorder) PutPublicAccessBlock(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutPublicAccessBlock", reflect.TypeOf((*MockS3API)(nil).PutPublicAccessBlock), arg0)
-}
-
-// PutPublicAccessBlockRequest mocks base method.
-func (m *MockS3API) PutPublicAccessBlockRequest(arg0 *s3.PutPublicAccessBlockInput) (*request.Request, *s3.PutPublicAccessBlockOutput) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "PutPublicAccessBlockRequest", arg0)
- ret0, _ := ret[0].(*request.Request)
- ret1, _ := ret[1].(*s3.PutPublicAccessBlockOutput)
- return ret0, ret1
-}
-
-// PutPublicAccessBlockRequest indicates an expected call of PutPublicAccessBlockRequest.
-func (mr *MockS3APIMockRecorder) PutPublicAccessBlockRequest(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutPublicAccessBlockRequest", reflect.TypeOf((*MockS3API)(nil).PutPublicAccessBlockRequest), arg0)
-}
-
-// PutPublicAccessBlockWithContext mocks base method.
-func (m *MockS3API) PutPublicAccessBlockWithContext(arg0 context.Context, arg1 *s3.PutPublicAccessBlockInput, arg2 ...request.Option) (*s3.PutPublicAccessBlockOutput, error) {
- m.ctrl.T.Helper()
- varargs := []interface{}{arg0, arg1}
- for _, a := range arg2 {
- varargs = append(varargs, a)
- }
- ret := m.ctrl.Call(m, "PutPublicAccessBlockWithContext", varargs...)
- ret0, _ := ret[0].(*s3.PutPublicAccessBlockOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// PutPublicAccessBlockWithContext indicates an expected call of PutPublicAccessBlockWithContext.
-func (mr *MockS3APIMockRecorder) PutPublicAccessBlockWithContext(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, "PutPublicAccessBlockWithContext", reflect.TypeOf((*MockS3API)(nil).PutPublicAccessBlockWithContext), varargs...)
-}
-
-// RestoreObject mocks base method.
-func (m *MockS3API) RestoreObject(arg0 *s3.RestoreObjectInput) (*s3.RestoreObjectOutput, error) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "RestoreObject", arg0)
- ret0, _ := ret[0].(*s3.RestoreObjectOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// RestoreObject indicates an expected call of RestoreObject.
-func (mr *MockS3APIMockRecorder) RestoreObject(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RestoreObject", reflect.TypeOf((*MockS3API)(nil).RestoreObject), arg0)
-}
-
-// RestoreObjectRequest mocks base method.
-func (m *MockS3API) RestoreObjectRequest(arg0 *s3.RestoreObjectInput) (*request.Request, *s3.RestoreObjectOutput) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "RestoreObjectRequest", arg0)
- ret0, _ := ret[0].(*request.Request)
- ret1, _ := ret[1].(*s3.RestoreObjectOutput)
- return ret0, ret1
-}
-
-// RestoreObjectRequest indicates an expected call of RestoreObjectRequest.
-func (mr *MockS3APIMockRecorder) RestoreObjectRequest(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RestoreObjectRequest", reflect.TypeOf((*MockS3API)(nil).RestoreObjectRequest), arg0)
-}
-
-// RestoreObjectWithContext mocks base method.
-func (m *MockS3API) RestoreObjectWithContext(arg0 context.Context, arg1 *s3.RestoreObjectInput, arg2 ...request.Option) (*s3.RestoreObjectOutput, error) {
- m.ctrl.T.Helper()
- varargs := []interface{}{arg0, arg1}
- for _, a := range arg2 {
- varargs = append(varargs, a)
- }
- ret := m.ctrl.Call(m, "RestoreObjectWithContext", varargs...)
- ret0, _ := ret[0].(*s3.RestoreObjectOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// RestoreObjectWithContext indicates an expected call of RestoreObjectWithContext.
-func (mr *MockS3APIMockRecorder) RestoreObjectWithContext(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, "RestoreObjectWithContext", reflect.TypeOf((*MockS3API)(nil).RestoreObjectWithContext), varargs...)
-}
-
-// SelectObjectContent mocks base method.
-func (m *MockS3API) SelectObjectContent(arg0 *s3.SelectObjectContentInput) (*s3.SelectObjectContentOutput, error) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "SelectObjectContent", arg0)
- ret0, _ := ret[0].(*s3.SelectObjectContentOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// SelectObjectContent indicates an expected call of SelectObjectContent.
-func (mr *MockS3APIMockRecorder) SelectObjectContent(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SelectObjectContent", reflect.TypeOf((*MockS3API)(nil).SelectObjectContent), arg0)
-}
-
-// SelectObjectContentRequest mocks base method.
-func (m *MockS3API) SelectObjectContentRequest(arg0 *s3.SelectObjectContentInput) (*request.Request, *s3.SelectObjectContentOutput) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "SelectObjectContentRequest", arg0)
- ret0, _ := ret[0].(*request.Request)
- ret1, _ := ret[1].(*s3.SelectObjectContentOutput)
- return ret0, ret1
-}
-
-// SelectObjectContentRequest indicates an expected call of SelectObjectContentRequest.
-func (mr *MockS3APIMockRecorder) SelectObjectContentRequest(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SelectObjectContentRequest", reflect.TypeOf((*MockS3API)(nil).SelectObjectContentRequest), arg0)
-}
-
-// SelectObjectContentWithContext mocks base method.
-func (m *MockS3API) SelectObjectContentWithContext(arg0 context.Context, arg1 *s3.SelectObjectContentInput, arg2 ...request.Option) (*s3.SelectObjectContentOutput, error) {
- m.ctrl.T.Helper()
- varargs := []interface{}{arg0, arg1}
- for _, a := range arg2 {
- varargs = append(varargs, a)
- }
- ret := m.ctrl.Call(m, "SelectObjectContentWithContext", varargs...)
- ret0, _ := ret[0].(*s3.SelectObjectContentOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// SelectObjectContentWithContext indicates an expected call of SelectObjectContentWithContext.
-func (mr *MockS3APIMockRecorder) SelectObjectContentWithContext(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, "SelectObjectContentWithContext", reflect.TypeOf((*MockS3API)(nil).SelectObjectContentWithContext), varargs...)
-}
-
-// UploadPart mocks base method.
-func (m *MockS3API) UploadPart(arg0 *s3.UploadPartInput) (*s3.UploadPartOutput, error) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "UploadPart", arg0)
- ret0, _ := ret[0].(*s3.UploadPartOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// UploadPart indicates an expected call of UploadPart.
-func (mr *MockS3APIMockRecorder) UploadPart(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UploadPart", reflect.TypeOf((*MockS3API)(nil).UploadPart), arg0)
-}
-
-// UploadPartCopy mocks base method.
-func (m *MockS3API) UploadPartCopy(arg0 *s3.UploadPartCopyInput) (*s3.UploadPartCopyOutput, error) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "UploadPartCopy", arg0)
- ret0, _ := ret[0].(*s3.UploadPartCopyOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// UploadPartCopy indicates an expected call of UploadPartCopy.
-func (mr *MockS3APIMockRecorder) UploadPartCopy(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UploadPartCopy", reflect.TypeOf((*MockS3API)(nil).UploadPartCopy), arg0)
-}
-
-// UploadPartCopyRequest mocks base method.
-func (m *MockS3API) UploadPartCopyRequest(arg0 *s3.UploadPartCopyInput) (*request.Request, *s3.UploadPartCopyOutput) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "UploadPartCopyRequest", arg0)
- ret0, _ := ret[0].(*request.Request)
- ret1, _ := ret[1].(*s3.UploadPartCopyOutput)
- return ret0, ret1
-}
-
-// UploadPartCopyRequest indicates an expected call of UploadPartCopyRequest.
-func (mr *MockS3APIMockRecorder) UploadPartCopyRequest(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UploadPartCopyRequest", reflect.TypeOf((*MockS3API)(nil).UploadPartCopyRequest), arg0)
-}
-
-// UploadPartCopyWithContext mocks base method.
-func (m *MockS3API) UploadPartCopyWithContext(arg0 context.Context, arg1 *s3.UploadPartCopyInput, arg2 ...request.Option) (*s3.UploadPartCopyOutput, error) {
- m.ctrl.T.Helper()
- varargs := []interface{}{arg0, arg1}
- for _, a := range arg2 {
- varargs = append(varargs, a)
- }
- ret := m.ctrl.Call(m, "UploadPartCopyWithContext", varargs...)
- ret0, _ := ret[0].(*s3.UploadPartCopyOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// UploadPartCopyWithContext indicates an expected call of UploadPartCopyWithContext.
-func (mr *MockS3APIMockRecorder) UploadPartCopyWithContext(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, "UploadPartCopyWithContext", reflect.TypeOf((*MockS3API)(nil).UploadPartCopyWithContext), varargs...)
-}
-
-// UploadPartRequest mocks base method.
-func (m *MockS3API) UploadPartRequest(arg0 *s3.UploadPartInput) (*request.Request, *s3.UploadPartOutput) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "UploadPartRequest", arg0)
- ret0, _ := ret[0].(*request.Request)
- ret1, _ := ret[1].(*s3.UploadPartOutput)
- return ret0, ret1
-}
-
-// UploadPartRequest indicates an expected call of UploadPartRequest.
-func (mr *MockS3APIMockRecorder) UploadPartRequest(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UploadPartRequest", reflect.TypeOf((*MockS3API)(nil).UploadPartRequest), arg0)
-}
-
-// UploadPartWithContext mocks base method.
-func (m *MockS3API) UploadPartWithContext(arg0 context.Context, arg1 *s3.UploadPartInput, arg2 ...request.Option) (*s3.UploadPartOutput, error) {
- m.ctrl.T.Helper()
- varargs := []interface{}{arg0, arg1}
- for _, a := range arg2 {
- varargs = append(varargs, a)
- }
- ret := m.ctrl.Call(m, "UploadPartWithContext", varargs...)
- ret0, _ := ret[0].(*s3.UploadPartOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// UploadPartWithContext indicates an expected call of UploadPartWithContext.
-func (mr *MockS3APIMockRecorder) UploadPartWithContext(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, "UploadPartWithContext", reflect.TypeOf((*MockS3API)(nil).UploadPartWithContext), varargs...)
-}
-
-// WaitUntilBucketExists mocks base method.
-func (m *MockS3API) WaitUntilBucketExists(arg0 *s3.HeadBucketInput) error {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "WaitUntilBucketExists", arg0)
- ret0, _ := ret[0].(error)
- return ret0
-}
-
-// WaitUntilBucketExists indicates an expected call of WaitUntilBucketExists.
-func (mr *MockS3APIMockRecorder) WaitUntilBucketExists(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilBucketExists", reflect.TypeOf((*MockS3API)(nil).WaitUntilBucketExists), arg0)
-}
-
-// WaitUntilBucketExistsWithContext mocks base method.
-func (m *MockS3API) WaitUntilBucketExistsWithContext(arg0 context.Context, arg1 *s3.HeadBucketInput, arg2 ...request.WaiterOption) error {
- m.ctrl.T.Helper()
- varargs := []interface{}{arg0, arg1}
- for _, a := range arg2 {
- varargs = append(varargs, a)
- }
- ret := m.ctrl.Call(m, "WaitUntilBucketExistsWithContext", varargs...)
- ret0, _ := ret[0].(error)
- return ret0
-}
-
-// WaitUntilBucketExistsWithContext indicates an expected call of WaitUntilBucketExistsWithContext.
-func (mr *MockS3APIMockRecorder) WaitUntilBucketExistsWithContext(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, "WaitUntilBucketExistsWithContext", reflect.TypeOf((*MockS3API)(nil).WaitUntilBucketExistsWithContext), varargs...)
-}
-
-// WaitUntilBucketNotExists mocks base method.
-func (m *MockS3API) WaitUntilBucketNotExists(arg0 *s3.HeadBucketInput) error {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "WaitUntilBucketNotExists", arg0)
- ret0, _ := ret[0].(error)
- return ret0
-}
-
-// WaitUntilBucketNotExists indicates an expected call of WaitUntilBucketNotExists.
-func (mr *MockS3APIMockRecorder) WaitUntilBucketNotExists(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilBucketNotExists", reflect.TypeOf((*MockS3API)(nil).WaitUntilBucketNotExists), arg0)
-}
-
-// WaitUntilBucketNotExistsWithContext mocks base method.
-func (m *MockS3API) WaitUntilBucketNotExistsWithContext(arg0 context.Context, arg1 *s3.HeadBucketInput, arg2 ...request.WaiterOption) error {
- m.ctrl.T.Helper()
- varargs := []interface{}{arg0, arg1}
- for _, a := range arg2 {
- varargs = append(varargs, a)
- }
- ret := m.ctrl.Call(m, "WaitUntilBucketNotExistsWithContext", varargs...)
- ret0, _ := ret[0].(error)
- return ret0
-}
-
-// WaitUntilBucketNotExistsWithContext indicates an expected call of WaitUntilBucketNotExistsWithContext.
-func (mr *MockS3APIMockRecorder) WaitUntilBucketNotExistsWithContext(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, "WaitUntilBucketNotExistsWithContext", reflect.TypeOf((*MockS3API)(nil).WaitUntilBucketNotExistsWithContext), varargs...)
-}
-
-// WaitUntilObjectExists mocks base method.
-func (m *MockS3API) WaitUntilObjectExists(arg0 *s3.HeadObjectInput) error {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "WaitUntilObjectExists", arg0)
- ret0, _ := ret[0].(error)
- return ret0
-}
-
-// WaitUntilObjectExists indicates an expected call of WaitUntilObjectExists.
-func (mr *MockS3APIMockRecorder) WaitUntilObjectExists(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilObjectExists", reflect.TypeOf((*MockS3API)(nil).WaitUntilObjectExists), arg0)
-}
-
-// WaitUntilObjectExistsWithContext mocks base method.
-func (m *MockS3API) WaitUntilObjectExistsWithContext(arg0 context.Context, arg1 *s3.HeadObjectInput, arg2 ...request.WaiterOption) error {
- m.ctrl.T.Helper()
- varargs := []interface{}{arg0, arg1}
- for _, a := range arg2 {
- varargs = append(varargs, a)
- }
- ret := m.ctrl.Call(m, "WaitUntilObjectExistsWithContext", varargs...)
- ret0, _ := ret[0].(error)
- return ret0
-}
-
-// WaitUntilObjectExistsWithContext indicates an expected call of WaitUntilObjectExistsWithContext.
-func (mr *MockS3APIMockRecorder) WaitUntilObjectExistsWithContext(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, "WaitUntilObjectExistsWithContext", reflect.TypeOf((*MockS3API)(nil).WaitUntilObjectExistsWithContext), varargs...)
-}
-
-// WaitUntilObjectNotExists mocks base method.
-func (m *MockS3API) WaitUntilObjectNotExists(arg0 *s3.HeadObjectInput) error {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "WaitUntilObjectNotExists", arg0)
- ret0, _ := ret[0].(error)
- return ret0
-}
-
-// WaitUntilObjectNotExists indicates an expected call of WaitUntilObjectNotExists.
-func (mr *MockS3APIMockRecorder) WaitUntilObjectNotExists(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilObjectNotExists", reflect.TypeOf((*MockS3API)(nil).WaitUntilObjectNotExists), arg0)
-}
-
-// WaitUntilObjectNotExistsWithContext mocks base method.
-func (m *MockS3API) WaitUntilObjectNotExistsWithContext(arg0 context.Context, arg1 *s3.HeadObjectInput, arg2 ...request.WaiterOption) error {
- m.ctrl.T.Helper()
- varargs := []interface{}{arg0, arg1}
- for _, a := range arg2 {
- varargs = append(varargs, a)
- }
- ret := m.ctrl.Call(m, "WaitUntilObjectNotExistsWithContext", varargs...)
- ret0, _ := ret[0].(error)
- return ret0
-}
-
-// WaitUntilObjectNotExistsWithContext indicates an expected call of WaitUntilObjectNotExistsWithContext.
-func (mr *MockS3APIMockRecorder) WaitUntilObjectNotExistsWithContext(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, "WaitUntilObjectNotExistsWithContext", reflect.TypeOf((*MockS3API)(nil).WaitUntilObjectNotExistsWithContext), varargs...)
-}
-
-// WriteGetObjectResponse mocks base method.
-func (m *MockS3API) WriteGetObjectResponse(arg0 *s3.WriteGetObjectResponseInput) (*s3.WriteGetObjectResponseOutput, error) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "WriteGetObjectResponse", arg0)
- ret0, _ := ret[0].(*s3.WriteGetObjectResponseOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// WriteGetObjectResponse indicates an expected call of WriteGetObjectResponse.
-func (mr *MockS3APIMockRecorder) WriteGetObjectResponse(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WriteGetObjectResponse", reflect.TypeOf((*MockS3API)(nil).WriteGetObjectResponse), arg0)
-}
-
-// WriteGetObjectResponseRequest mocks base method.
-func (m *MockS3API) WriteGetObjectResponseRequest(arg0 *s3.WriteGetObjectResponseInput) (*request.Request, *s3.WriteGetObjectResponseOutput) {
- m.ctrl.T.Helper()
- ret := m.ctrl.Call(m, "WriteGetObjectResponseRequest", arg0)
- ret0, _ := ret[0].(*request.Request)
- ret1, _ := ret[1].(*s3.WriteGetObjectResponseOutput)
- return ret0, ret1
-}
-
-// WriteGetObjectResponseRequest indicates an expected call of WriteGetObjectResponseRequest.
-func (mr *MockS3APIMockRecorder) WriteGetObjectResponseRequest(arg0 interface{}) *gomock.Call {
- mr.mock.ctrl.T.Helper()
- return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WriteGetObjectResponseRequest", reflect.TypeOf((*MockS3API)(nil).WriteGetObjectResponseRequest), arg0)
-}
-
-// WriteGetObjectResponseWithContext mocks base method.
-func (m *MockS3API) WriteGetObjectResponseWithContext(arg0 context.Context, arg1 *s3.WriteGetObjectResponseInput, arg2 ...request.Option) (*s3.WriteGetObjectResponseOutput, error) {
- m.ctrl.T.Helper()
- varargs := []interface{}{arg0, arg1}
- for _, a := range arg2 {
- varargs = append(varargs, a)
- }
- ret := m.ctrl.Call(m, "WriteGetObjectResponseWithContext", varargs...)
- ret0, _ := ret[0].(*s3.WriteGetObjectResponseOutput)
- ret1, _ := ret[1].(error)
- return ret0, ret1
-}
-
-// WriteGetObjectResponseWithContext indicates an expected call of WriteGetObjectResponseWithContext.
-func (mr *MockS3APIMockRecorder) WriteGetObjectResponseWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+// PutObject indicates an expected call of PutObject.
+func (mr *MockS3APIMockRecorder) PutObject(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, "WriteGetObjectResponseWithContext", reflect.TypeOf((*MockS3API)(nil).WriteGetObjectResponseWithContext), varargs...)
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutObject", reflect.TypeOf((*MockS3API)(nil).PutObject), varargs...)
}
diff --git a/pkg/cloud/services/s3/s3.go b/pkg/cloud/services/s3/s3.go
index 6eb8582585..259feb7000 100644
--- a/pkg/cloud/services/s3/s3.go
+++ b/pkg/cloud/services/s3/s3.go
@@ -19,18 +19,19 @@ package s3
import (
"bytes"
+ "context"
"encoding/json"
"fmt"
"net/url"
"path"
"sort"
+ "github.com/aws/aws-sdk-go-v2/service/s3"
+ "github.com/aws/aws-sdk-go-v2/service/s3/types"
"github.com/aws/aws-sdk-go/aws"
- "github.com/aws/aws-sdk-go/aws/awserr"
- "github.com/aws/aws-sdk-go/service/s3"
- "github.com/aws/aws-sdk-go/service/s3/s3iface"
"github.com/aws/aws-sdk-go/service/sts"
"github.com/aws/aws-sdk-go/service/sts/stsiface"
+ "github.com/aws/smithy-go"
"github.com/pkg/errors"
"k8s.io/utils/ptr"
@@ -47,40 +48,54 @@ const AWSDefaultRegion string = "us-east-1"
// The interfaces are broken down like this to group functions together.
// One alternative is to have a large list of functions from the ec2 client.
type Service struct {
- scope scope.S3Scope
- S3Client s3iface.S3API
- STSClient stsiface.STSAPI
+ scope scope.S3Scope
+ S3Client S3API
+ S3PresignClient *s3.PresignClient
+ STSClient stsiface.STSAPI
+}
+
+// S3API is the subset of the AWS S3 API that is used by CAPA.
+type S3API interface {
+ CreateBucket(ctx context.Context, params *s3.CreateBucketInput, optFns ...func(*s3.Options)) (*s3.CreateBucketOutput, error)
+ DeleteBucket(ctx context.Context, params *s3.DeleteBucketInput, optFns ...func(*s3.Options)) (*s3.DeleteBucketOutput, error)
+ DeleteObject(ctx context.Context, params *s3.DeleteObjectInput, optFns ...func(*s3.Options)) (*s3.DeleteObjectOutput, error)
+ HeadObject(ctx context.Context, params *s3.HeadObjectInput, optFns ...func(*s3.Options)) (*s3.HeadObjectOutput, error)
+ PutBucketPolicy(ctx context.Context, params *s3.PutBucketPolicyInput, optFns ...func(*s3.Options)) (*s3.PutBucketPolicyOutput, error)
+ PutBucketTagging(ctx context.Context, params *s3.PutBucketTaggingInput, optFns ...func(*s3.Options)) (*s3.PutBucketTaggingOutput, error)
+ PutObject(ctx context.Context, params *s3.PutObjectInput, optFns ...func(*s3.Options)) (*s3.PutObjectOutput, error)
}
// NewService returns a new service given the api clients.
func NewService(s3Scope scope.S3Scope) *Service {
s3Client := scope.NewS3Client(s3Scope, s3Scope, s3Scope, s3Scope.InfraCluster())
+ s3PresignClient := s3.NewPresignClient(s3Client)
STSClient := scope.NewSTSClient(s3Scope, s3Scope, s3Scope, s3Scope.InfraCluster())
return &Service{
- scope: s3Scope,
- S3Client: s3Client,
- STSClient: STSClient,
+ scope: s3Scope,
+ S3Client: s3Client,
+ S3PresignClient: s3PresignClient,
+ STSClient: STSClient,
}
}
// ReconcileBucket reconciles the S3 bucket.
-func (s *Service) ReconcileBucket() error {
+func (s *Service) ReconcileBucket(ctx context.Context) error {
if !s.bucketManagementEnabled() {
return nil
}
bucketName := s.bucketName()
- if err := s.createBucketIfNotExist(bucketName); err != nil {
+ if err := s.createBucketIfNotExist(ctx, bucketName); err != nil {
return errors.Wrap(err, "ensuring bucket exists")
}
- if err := s.tagBucket(bucketName); err != nil {
+ if err := s.tagBucket(ctx, bucketName); err != nil {
return errors.Wrap(err, "tagging bucket")
}
- if err := s.ensureBucketPolicy(bucketName); err != nil {
+ if err := s.ensureBucketPolicy(ctx, bucketName); err != nil {
return errors.Wrap(err, "ensuring bucket policy")
}
@@ -88,7 +103,7 @@ func (s *Service) ReconcileBucket() error {
}
// DeleteBucket deletes the S3 bucket.
-func (s *Service) DeleteBucket() error {
+func (s *Service) DeleteBucket(ctx context.Context) error {
if !s.bucketManagementEnabled() {
return nil
}
@@ -99,32 +114,32 @@ func (s *Service) DeleteBucket() error {
log.Info("Deleting S3 Bucket")
- _, err := s.S3Client.DeleteBucket(&s3.DeleteBucketInput{
+ _, err := s.S3Client.DeleteBucket(ctx, &s3.DeleteBucketInput{
Bucket: aws.String(bucketName),
})
- if err == nil {
- return nil
- }
+ if err != nil {
+ var aerr smithy.APIError
+ if errors.As(err, &aerr) {
+ switch aerr.ErrorCode() {
+ case (&types.NoSuchBucket{}).ErrorCode():
+ log.Info("Bucket already removed")
+ case "BucketNotEmpty":
+ log.Info("Bucket not empty, skipping removal")
+ default:
+ return errors.Wrap(aerr, "deleting S3 bucket")
+ }
- aerr, ok := err.(awserr.Error)
- if !ok {
- return errors.Wrap(err, "deleting S3 bucket")
- }
+ return nil
+ }
- switch aerr.Code() {
- case s3.ErrCodeNoSuchBucket:
- log.Info("Bucket already removed")
- case "BucketNotEmpty":
- log.Info("Bucket not empty, skipping removal")
- default:
- return errors.Wrap(aerr, "deleting S3 bucket")
+ return errors.Wrap(err, "deleting S3 bucket")
}
return nil
}
// Create creates an object in the S3 bucket.
-func (s *Service) Create(m *scope.MachineScope, data []byte) (string, error) {
+func (s *Service) Create(ctx context.Context, m *scope.MachineScope, data []byte) (string, error) {
if !s.bucketManagementEnabled() {
return "", errors.New("requested object creation but bucket management is not enabled")
}
@@ -142,22 +157,27 @@ func (s *Service) Create(m *scope.MachineScope, data []byte) (string, error) {
s.scope.Info("Creating object", "bucket_name", bucket, "key", key)
- if _, err := s.S3Client.PutObject(&s3.PutObjectInput{
+ if _, err := s.S3Client.PutObject(ctx, &s3.PutObjectInput{
Body: aws.ReadSeekCloser(bytes.NewReader(data)),
Bucket: aws.String(bucket),
Key: aws.String(key),
- ServerSideEncryption: aws.String("aws:kms"),
+ ServerSideEncryption: types.ServerSideEncryptionAwsKms,
}); err != nil {
return "", errors.Wrap(err, "putting object")
}
if exp := s.scope.Bucket().PresignedURLDuration; exp != nil {
s.scope.Info("Generating presigned URL", "bucket_name", bucket, "key", key)
- req, _ := s.S3Client.GetObjectRequest(&s3.GetObjectInput{
+ req, err := s.S3PresignClient.PresignGetObject(ctx, &s3.GetObjectInput{
Bucket: aws.String(bucket),
Key: aws.String(key),
+ }, func(opts *s3.PresignOptions) {
+ opts.Expires = exp.Duration
})
- return req.Presign(exp.Duration)
+ if err != nil {
+ return "", errors.Wrap(err, "generating presigned object request")
+ }
+ return req.URL, nil
}
objectURL := &url.URL{
@@ -170,7 +190,7 @@ func (s *Service) Create(m *scope.MachineScope, data []byte) (string, error) {
}
// Delete deletes the object from the S3 bucket.
-func (s *Service) Delete(m *scope.MachineScope) error {
+func (s *Service) Delete(ctx context.Context, m *scope.MachineScope) error {
if !s.bucketManagementEnabled() {
return errors.New("requested object creation but bucket management is not enabled")
}
@@ -182,20 +202,21 @@ func (s *Service) Delete(m *scope.MachineScope) error {
bucket := s.bucketName()
key := s.bootstrapDataKey(m)
- _, err := s.S3Client.HeadObject(&s3.HeadObjectInput{
+ _, err := s.S3Client.HeadObject(ctx, &s3.HeadObjectInput{
Bucket: aws.String(bucket),
Key: aws.String(key),
})
if err != nil {
- if aerr, ok := err.(awserr.Error); ok {
- switch aerr.Code() {
+ var aerr smithy.APIError
+ if errors.As(err, &aerr) {
+ switch aerr.ErrorCode() {
case "Forbidden":
// In the case that the IAM policy does not have sufficient
// permissions to get the object, we will attempt to delete it
// anyway for backwards compatibility reasons.
s.scope.Debug("Received 403 forbidden from S3 HeadObject call. If GetObject permission has been granted to the controller but not ListBucket, object is already deleted. Attempting deletion anyway in case GetObject permission hasn't been granted to the controller but DeleteObject has.", "bucket", bucket, "key", key)
- if err := s.deleteObject(bucket, key); err != nil {
+ if err := s.deleteObject(ctx, bucket, key); err != nil {
return err
}
@@ -205,10 +226,10 @@ func (s *Service) Delete(m *scope.MachineScope) error {
case "NotFound":
s.scope.Debug("Either bucket or object does not exist", "bucket", bucket, "key", key)
return nil
- case s3.ErrCodeNoSuchKey:
+ case (&types.NoSuchKey{}).ErrorCode():
s.scope.Debug("Object already deleted", "bucket", bucket, "key", key)
return nil
- case s3.ErrCodeNoSuchBucket:
+ case (&types.NoSuchBucket{}).ErrorCode():
s.scope.Debug("Bucket does not exist", "bucket", bucket)
return nil
}
@@ -218,19 +239,20 @@ func (s *Service) Delete(m *scope.MachineScope) error {
s.scope.Info("Deleting S3 object", "bucket", bucket, "key", key)
- return s.deleteObject(bucket, key)
+ return s.deleteObject(ctx, bucket, key)
}
-func (s *Service) deleteObject(bucket, key string) error {
- if _, err := s.S3Client.DeleteObject(&s3.DeleteObjectInput{
+func (s *Service) deleteObject(ctx context.Context, bucket, key string) error {
+ if _, err := s.S3Client.DeleteObject(ctx, &s3.DeleteObjectInput{
Bucket: aws.String(bucket),
Key: aws.String(key),
}); err != nil {
if ptr.Deref(s.scope.Bucket().BestEffortDeleteObjects, false) {
- if aerr, ok := err.(awserr.Error); ok {
- switch aerr.Code() {
+ var aerr smithy.APIError
+ if errors.As(err, &aerr) {
+ switch aerr.ErrorCode() {
case "Forbidden", "AccessDenied":
- s.scope.Debug("Ignoring deletion error", "bucket", bucket, "key", key, "error", aerr.Message())
+ s.scope.Debug("Ignoring deletion error", "bucket", bucket, "key", key, "error", aerr.ErrorMessage())
return nil
}
}
@@ -241,40 +263,40 @@ func (s *Service) deleteObject(bucket, key string) error {
return nil
}
-func (s *Service) createBucketIfNotExist(bucketName string) error {
+func (s *Service) createBucketIfNotExist(ctx context.Context, bucketName string) error {
input := &s3.CreateBucketInput{Bucket: aws.String(bucketName)}
// See https://docs.aws.amazon.com/AmazonS3/latest/API/API_CreateBucket.html#AmazonS3-CreateBucket-request-LocationConstraint.
if s.scope.Region() != AWSDefaultRegion {
- input.CreateBucketConfiguration = &s3.CreateBucketConfiguration{
- LocationConstraint: aws.String(s.scope.Region()),
+ input.CreateBucketConfiguration = &types.CreateBucketConfiguration{
+ LocationConstraint: types.BucketLocationConstraint(s.scope.Region()),
}
}
- _, err := s.S3Client.CreateBucket(input)
+ _, err := s.S3Client.CreateBucket(ctx, input)
if err == nil {
s.scope.Info("Created bucket", "bucket_name", bucketName)
return nil
}
- aerr, ok := err.(awserr.Error)
- if !ok {
- return errors.Wrap(err, "creating S3 bucket")
+ var aerr smithy.APIError
+ if errors.As(err, &aerr) {
+ switch aerr.ErrorCode() {
+ // If bucket already exists, all good.
+ //
+ // TODO: This will fail if bucket is shared with other cluster.
+ case (&types.BucketAlreadyOwnedByYou{}).ErrorCode():
+ return nil
+ default:
+ return errors.Wrap(aerr, "creating S3 bucket")
+ }
}
- switch aerr.Code() {
- // If bucket already exists, all good.
- //
- // TODO: This will fail if bucket is shared with other cluster.
- case s3.ErrCodeBucketAlreadyOwnedByYou:
- return nil
- default:
- return errors.Wrap(aerr, "creating S3 bucket")
- }
+ return errors.Wrap(err, "creating S3 bucket")
}
-func (s *Service) ensureBucketPolicy(bucketName string) error {
+func (s *Service) ensureBucketPolicy(ctx context.Context, bucketName string) error {
bucketPolicy, err := s.bucketPolicy(bucketName)
if err != nil {
return errors.Wrap(err, "generating Bucket policy")
@@ -285,7 +307,7 @@ func (s *Service) ensureBucketPolicy(bucketName string) error {
Policy: aws.String(bucketPolicy),
}
- if _, err := s.S3Client.PutBucketPolicy(input); err != nil {
+ if _, err := s.S3Client.PutBucketPolicy(ctx, input); err != nil {
return errors.Wrap(err, "creating S3 bucket policy")
}
@@ -294,10 +316,10 @@ func (s *Service) ensureBucketPolicy(bucketName string) error {
return nil
}
-func (s *Service) tagBucket(bucketName string) error {
+func (s *Service) tagBucket(ctx context.Context, bucketName string) error {
taggingInput := &s3.PutBucketTaggingInput{
Bucket: aws.String(bucketName),
- Tagging: &s3.Tagging{
+ Tagging: &types.Tagging{
TagSet: nil,
},
}
@@ -311,7 +333,7 @@ func (s *Service) tagBucket(bucketName string) error {
})
for key, value := range tags {
- taggingInput.Tagging.TagSet = append(taggingInput.Tagging.TagSet, &s3.Tag{
+ taggingInput.Tagging.TagSet = append(taggingInput.Tagging.TagSet, types.Tag{
Key: aws.String(key),
Value: aws.String(value),
})
@@ -321,7 +343,7 @@ func (s *Service) tagBucket(bucketName string) error {
return *taggingInput.Tagging.TagSet[i].Key < *taggingInput.Tagging.TagSet[j].Key
})
- _, err := s.S3Client.PutBucketTagging(taggingInput)
+ _, err := s.S3Client.PutBucketTagging(ctx, taggingInput)
if err != nil {
return err
}
diff --git a/pkg/cloud/services/s3/s3_test.go b/pkg/cloud/services/s3/s3_test.go
index 3db7abfca7..d3e9883029 100644
--- a/pkg/cloud/services/s3/s3_test.go
+++ b/pkg/cloud/services/s3/s3_test.go
@@ -17,6 +17,7 @@ limitations under the License.
package s3_test
import (
+ "context"
"errors"
"fmt"
"io"
@@ -25,9 +26,9 @@ import (
"strings"
"testing"
- "github.com/aws/aws-sdk-go/aws"
- "github.com/aws/aws-sdk-go/aws/awserr"
- s3svc "github.com/aws/aws-sdk-go/service/s3"
+ "github.com/aws/aws-sdk-go-v2/aws"
+ s3svc "github.com/aws/aws-sdk-go-v2/service/s3"
+ "github.com/aws/aws-sdk-go-v2/service/s3/types"
"github.com/aws/aws-sdk-go/service/sts"
"github.com/golang/mock/gomock"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
@@ -56,7 +57,7 @@ func TestReconcileBucket(t *testing.T) {
svc, _ := testService(t, nil)
- if err := svc.ReconcileBucket(); err != nil {
+ if err := svc.ReconcileBucket(context.TODO()); err != nil {
t.Fatalf("Unexpected error: %v", err)
}
})
@@ -74,17 +75,17 @@ func TestReconcileBucket(t *testing.T) {
input := &s3svc.CreateBucketInput{
Bucket: aws.String(expectedBucketName),
- CreateBucketConfiguration: &s3svc.CreateBucketConfiguration{
- LocationConstraint: aws.String("us-west-2"),
+ CreateBucketConfiguration: &types.CreateBucketConfiguration{
+ LocationConstraint: types.BucketLocationConstraintUsWest2,
},
}
- s3Mock.EXPECT().CreateBucket(gomock.Eq(input)).Return(nil, nil).Times(1)
+ s3Mock.EXPECT().CreateBucket(gomock.Any(), gomock.Eq(input)).Return(nil, nil).Times(1)
taggingInput := &s3svc.PutBucketTaggingInput{
Bucket: aws.String(expectedBucketName),
- Tagging: &s3svc.Tagging{
- TagSet: []*s3svc.Tag{
+ Tagging: &types.Tagging{
+ TagSet: []types.Tag{
{
Key: aws.String("additional"),
Value: aws.String("from-aws-cluster"),
@@ -101,11 +102,11 @@ func TestReconcileBucket(t *testing.T) {
},
}
- s3Mock.EXPECT().PutBucketTagging(gomock.Eq(taggingInput)).Return(nil, nil).Times(1)
+ s3Mock.EXPECT().PutBucketTagging(gomock.Any(), gomock.Eq(taggingInput)).Return(nil, nil).Times(1)
- s3Mock.EXPECT().PutBucketPolicy(gomock.Any()).Return(nil, nil).Times(1)
+ s3Mock.EXPECT().PutBucketPolicy(gomock.Any(), gomock.Any()).Return(nil, nil).Times(1)
- if err := svc.ReconcileBucket(); err != nil {
+ if err := svc.ReconcileBucket(context.TODO()); err != nil {
t.Fatalf("Unexpected error: %v", err)
}
})
@@ -147,7 +148,7 @@ func TestReconcileBucket(t *testing.T) {
svc.S3Client = s3Mock
svc.STSClient = stsMock
- s3Mock.EXPECT().CreateBucket(gomock.Any()).Do(func(input *s3svc.CreateBucketInput) {
+ s3Mock.EXPECT().CreateBucket(gomock.Any(), gomock.Any()).Do(func(ctx context.Context, input *s3svc.CreateBucketInput, optFns ...func(*s3svc.Options)) {
if input.Bucket == nil {
t.Fatalf("CreateBucket request must have Bucket specified")
}
@@ -157,10 +158,10 @@ func TestReconcileBucket(t *testing.T) {
}
}).Return(nil, nil).Times(1)
- s3Mock.EXPECT().PutBucketTagging(gomock.Any()).Return(nil, nil).Times(1)
- s3Mock.EXPECT().PutBucketPolicy(gomock.Any()).Return(nil, nil).Times(1)
+ s3Mock.EXPECT().PutBucketTagging(gomock.Any(), gomock.Any()).Return(nil, nil).Times(1)
+ s3Mock.EXPECT().PutBucketPolicy(gomock.Any(), gomock.Any()).Return(nil, nil).Times(1)
- if err := svc.ReconcileBucket(); err != nil {
+ if err := svc.ReconcileBucket(context.TODO()); err != nil {
t.Fatalf("Unexpected error: %v", err)
}
})
@@ -180,9 +181,9 @@ func TestReconcileBucket(t *testing.T) {
},
})
- s3Mock.EXPECT().CreateBucket(gomock.Any()).Return(nil, nil).Times(1)
- s3Mock.EXPECT().PutBucketTagging(gomock.Any()).Return(nil, nil).Times(1)
- s3Mock.EXPECT().PutBucketPolicy(gomock.Any()).Do(func(input *s3svc.PutBucketPolicyInput) {
+ s3Mock.EXPECT().CreateBucket(gomock.Any(), gomock.Any()).Return(nil, nil).Times(1)
+ s3Mock.EXPECT().PutBucketTagging(gomock.Any(), gomock.Any()).Return(nil, nil).Times(1)
+ s3Mock.EXPECT().PutBucketPolicy(gomock.Any(), gomock.Any()).Do(func(ctx context.Context, input *s3svc.PutBucketPolicyInput, optFns ...func(*s3svc.Options)) {
if input.Policy == nil {
t.Fatalf("Policy must be defined")
}
@@ -214,7 +215,7 @@ func TestReconcileBucket(t *testing.T) {
}
}).Return(nil, nil).Times(1)
- if err := svc.ReconcileBucket(); err != nil {
+ if err := svc.ReconcileBucket(context.TODO()); err != nil {
t.Fatalf("Unexpected error: %v", err)
}
})
@@ -224,15 +225,15 @@ func TestReconcileBucket(t *testing.T) {
svc, s3Mock := testService(t, &testServiceInput{Bucket: &infrav1.S3Bucket{}})
- s3Mock.EXPECT().CreateBucket(gomock.Any()).Return(nil, nil).Times(2)
- s3Mock.EXPECT().PutBucketTagging(gomock.Any()).Return(nil, nil).Times(2)
- s3Mock.EXPECT().PutBucketPolicy(gomock.Any()).Return(nil, nil).Times(2)
+ s3Mock.EXPECT().CreateBucket(gomock.Any(), gomock.Any()).Return(nil, nil).Times(2)
+ s3Mock.EXPECT().PutBucketTagging(gomock.Any(), gomock.Any()).Return(nil, nil).Times(2)
+ s3Mock.EXPECT().PutBucketPolicy(gomock.Any(), gomock.Any()).Return(nil, nil).Times(2)
- if err := svc.ReconcileBucket(); err != nil {
+ if err := svc.ReconcileBucket(context.TODO()); err != nil {
t.Fatalf("Unexpected error: %v", err)
}
- if err := svc.ReconcileBucket(); err != nil {
+ if err := svc.ReconcileBucket(context.TODO()); err != nil {
t.Fatalf("Unexpected error: %v", err)
}
})
@@ -242,13 +243,13 @@ func TestReconcileBucket(t *testing.T) {
svc, s3Mock := testService(t, &testServiceInput{Bucket: &infrav1.S3Bucket{}})
- err := awserr.New(s3svc.ErrCodeBucketAlreadyOwnedByYou, "err", errors.New("err"))
+ err := &types.BucketAlreadyOwnedByYou{Message: aws.String("err")}
- s3Mock.EXPECT().CreateBucket(gomock.Any()).Return(nil, err).Times(1)
- s3Mock.EXPECT().PutBucketTagging(gomock.Any()).Return(nil, nil).Times(1)
- s3Mock.EXPECT().PutBucketPolicy(gomock.Any()).Return(nil, nil).Times(1)
+ s3Mock.EXPECT().CreateBucket(gomock.Any(), gomock.Any()).Return(nil, err).Times(1)
+ s3Mock.EXPECT().PutBucketTagging(gomock.Any(), gomock.Any()).Return(nil, nil).Times(1)
+ s3Mock.EXPECT().PutBucketPolicy(gomock.Any(), gomock.Any()).Return(nil, nil).Times(1)
- if err := svc.ReconcileBucket(); err != nil {
+ if err := svc.ReconcileBucket(context.TODO()); err != nil {
t.Fatalf("Unexpected error, got: %v", err)
}
})
@@ -261,9 +262,9 @@ func TestReconcileBucket(t *testing.T) {
svc, s3Mock := testService(t, &testServiceInput{Bucket: &infrav1.S3Bucket{}})
- s3Mock.EXPECT().CreateBucket(gomock.Any()).Return(nil, errors.New("error")).Times(1)
+ s3Mock.EXPECT().CreateBucket(gomock.Any(), gomock.Any()).Return(nil, errors.New("error")).Times(1)
- if err := svc.ReconcileBucket(); err == nil {
+ if err := svc.ReconcileBucket(context.TODO()); err == nil {
t.Fatalf("Expected error")
}
})
@@ -273,9 +274,12 @@ func TestReconcileBucket(t *testing.T) {
svc, s3Mock := testService(t, &testServiceInput{Bucket: &infrav1.S3Bucket{}})
- s3Mock.EXPECT().CreateBucket(gomock.Any()).Return(nil, awserr.New("foo", "", nil)).Times(1)
+ s3Mock.EXPECT().CreateBucket(gomock.Any(), gomock.Any()).Return(nil, &types.NoSuchBucket{
+ Message: aws.String(""),
+ ErrorCodeOverride: aws.String("foo"),
+ }).Times(1)
- if err := svc.ReconcileBucket(); err == nil {
+ if err := svc.ReconcileBucket(context.TODO()); err == nil {
t.Fatalf("Expected error")
}
})
@@ -285,15 +289,15 @@ func TestReconcileBucket(t *testing.T) {
svc, s3Mock := testService(t, &testServiceInput{Bucket: &infrav1.S3Bucket{}})
- s3Mock.EXPECT().CreateBucket(gomock.Any()).Return(nil, nil).Times(1)
- s3Mock.EXPECT().PutBucketTagging(gomock.Any()).Return(nil, nil).Times(1)
+ s3Mock.EXPECT().CreateBucket(gomock.Any(), gomock.Any()).Return(nil, nil).Times(1)
+ s3Mock.EXPECT().PutBucketTagging(gomock.Any(), gomock.Any()).Return(nil, nil).Times(1)
mockCtrl := gomock.NewController(t)
stsMock := mock_stsiface.NewMockSTSAPI(mockCtrl)
stsMock.EXPECT().GetCallerIdentity(gomock.Any()).Return(nil, errors.New(t.Name())).AnyTimes()
svc.STSClient = stsMock
- if err := svc.ReconcileBucket(); err == nil {
+ if err := svc.ReconcileBucket(context.TODO()); err == nil {
t.Fatalf("Expected error")
}
})
@@ -303,11 +307,11 @@ func TestReconcileBucket(t *testing.T) {
svc, s3Mock := testService(t, &testServiceInput{Bucket: &infrav1.S3Bucket{}})
- s3Mock.EXPECT().CreateBucket(gomock.Any()).Return(nil, nil).Times(1)
- s3Mock.EXPECT().PutBucketTagging(gomock.Any()).Return(nil, nil).Times(1)
- s3Mock.EXPECT().PutBucketPolicy(gomock.Any()).Return(nil, errors.New("error")).Times(1)
+ s3Mock.EXPECT().CreateBucket(gomock.Any(), gomock.Any()).Return(nil, nil).Times(1)
+ s3Mock.EXPECT().PutBucketTagging(gomock.Any(), gomock.Any()).Return(nil, nil).Times(1)
+ s3Mock.EXPECT().PutBucketPolicy(gomock.Any(), gomock.Any()).Return(nil, errors.New("error")).Times(1)
- if err := svc.ReconcileBucket(); err == nil {
+ if err := svc.ReconcileBucket(context.TODO()); err == nil {
t.Fatalf("Expected error")
}
})
@@ -324,11 +328,11 @@ func TestReconcileBucket(t *testing.T) {
Bucket: aws.String(bucketName),
}
- s3Mock.EXPECT().CreateBucket(gomock.Eq(input)).Return(nil, nil).Times(1)
- s3Mock.EXPECT().PutBucketTagging(gomock.Any()).Return(nil, nil).Times(1)
- s3Mock.EXPECT().PutBucketPolicy(gomock.Any()).Return(nil, nil).Times(1)
+ s3Mock.EXPECT().CreateBucket(gomock.Any(), gomock.Eq(input)).Return(nil, nil).Times(1)
+ s3Mock.EXPECT().PutBucketTagging(gomock.Any(), gomock.Any()).Return(nil, nil).Times(1)
+ s3Mock.EXPECT().PutBucketPolicy(gomock.Any(), gomock.Any()).Return(nil, nil).Times(1)
- if err := svc.ReconcileBucket(); err != nil {
+ if err := svc.ReconcileBucket(context.TODO()); err != nil {
t.Fatalf("Unexpected error: %v", err)
}
})
@@ -345,7 +349,7 @@ func TestDeleteBucket(t *testing.T) {
svc, _ := testService(t, nil)
- if err := svc.DeleteBucket(); err != nil {
+ if err := svc.DeleteBucket(context.TODO()); err != nil {
t.Fatalf("Unexpected error, got: %v", err)
}
})
@@ -363,9 +367,9 @@ func TestDeleteBucket(t *testing.T) {
Bucket: aws.String(bucketName),
}
- s3Mock.EXPECT().DeleteBucket(input).Return(nil, nil).Times(1)
+ s3Mock.EXPECT().DeleteBucket(gomock.Any(), input).Return(nil, nil).Times(1)
- if err := svc.DeleteBucket(); err != nil {
+ if err := svc.DeleteBucket(context.TODO()); err != nil {
t.Fatalf("Unexpected error, got: %v", err)
}
})
@@ -377,9 +381,9 @@ func TestDeleteBucket(t *testing.T) {
svc, s3Mock := testService(t, &testServiceInput{Bucket: &infrav1.S3Bucket{}})
- s3Mock.EXPECT().DeleteBucket(gomock.Any()).Return(nil, errors.New("err")).Times(1)
+ s3Mock.EXPECT().DeleteBucket(gomock.Any(), gomock.Any()).Return(nil, errors.New("err")).Times(1)
- if err := svc.DeleteBucket(); err == nil {
+ if err := svc.DeleteBucket(context.TODO()); err == nil {
t.Fatalf("Expected error")
}
})
@@ -389,9 +393,12 @@ func TestDeleteBucket(t *testing.T) {
svc, s3Mock := testService(t, &testServiceInput{Bucket: &infrav1.S3Bucket{}})
- s3Mock.EXPECT().DeleteBucket(gomock.Any()).Return(nil, awserr.New("foo", "", nil)).Times(1)
+ s3Mock.EXPECT().DeleteBucket(gomock.Any(), gomock.Any()).Return(nil, &types.NoSuchBucket{
+ Message: aws.String(""),
+ ErrorCodeOverride: aws.String("foo"),
+ }).Times(1)
- if err := svc.DeleteBucket(); err == nil {
+ if err := svc.DeleteBucket(context.TODO()); err == nil {
t.Fatalf("Expected error")
}
})
@@ -402,9 +409,9 @@ func TestDeleteBucket(t *testing.T) {
svc, s3Mock := testService(t, &testServiceInput{Bucket: &infrav1.S3Bucket{}})
- s3Mock.EXPECT().DeleteBucket(gomock.Any()).Return(nil, awserr.New(s3svc.ErrCodeNoSuchBucket, "", nil)).Times(1)
+ s3Mock.EXPECT().DeleteBucket(gomock.Any(), gomock.Any()).Return(nil, &types.NoSuchBucket{}).Times(1)
- if err := svc.DeleteBucket(); err != nil {
+ if err := svc.DeleteBucket(context.TODO()); err != nil {
t.Fatalf("Unexpected error: %v", err)
}
})
@@ -414,9 +421,12 @@ func TestDeleteBucket(t *testing.T) {
svc, s3Mock := testService(t, &testServiceInput{Bucket: &infrav1.S3Bucket{}})
- s3Mock.EXPECT().DeleteBucket(gomock.Any()).Return(nil, awserr.New("BucketNotEmpty", "", nil)).Times(1)
+ s3Mock.EXPECT().DeleteBucket(gomock.Any(), gomock.Any()).Return(nil, &types.NoSuchBucket{
+ Message: aws.String(""),
+ ErrorCodeOverride: aws.String("BucketNotEmpty"),
+ }).Times(1)
- if err := svc.DeleteBucket(); err != nil {
+ if err := svc.DeleteBucket(context.TODO()); err != nil {
t.Fatalf("Unexpected error: %v", err)
}
})
@@ -450,7 +460,7 @@ func TestCreateObject(t *testing.T) {
bootstrapData := []byte("foobar")
- s3Mock.EXPECT().PutObject(gomock.Any()).Do(func(putObjectInput *s3svc.PutObjectInput) {
+ s3Mock.EXPECT().PutObject(gomock.Any(), gomock.Any()).Do(func(ctx context.Context, putObjectInput *s3svc.PutObjectInput, optFns ...func(*s3svc.Options)) {
t.Run("use_configured_bucket_name_on_cluster_level", func(t *testing.T) {
t.Parallel()
@@ -485,7 +495,7 @@ func TestCreateObject(t *testing.T) {
})
}).Return(nil, nil).Times(1)
- bootstrapDataURL, err := svc.Create(machineScope, bootstrapData)
+ bootstrapDataURL, err := svc.Create(context.TODO(), machineScope, bootstrapData)
if err != nil {
t.Fatalf("Unexpected error, got: %v", err)
}
@@ -527,14 +537,14 @@ func TestCreateObject(t *testing.T) {
},
}
- s3Mock.EXPECT().PutObject(gomock.Any()).Return(nil, nil).Times(2)
+ s3Mock.EXPECT().PutObject(gomock.Any(), gomock.Any()).Return(nil, nil).Times(2)
boostrapData := []byte("foo")
- if _, err := svc.Create(machineScope, boostrapData); err != nil {
+ if _, err := svc.Create(context.TODO(), machineScope, boostrapData); err != nil {
t.Fatalf("Unexpected error: %v", err)
}
- if _, err := svc.Create(machineScope, boostrapData); err != nil {
+ if _, err := svc.Create(context.TODO(), machineScope, boostrapData); err != nil {
t.Fatalf("Unexpected error: %v", err)
}
})
@@ -556,9 +566,9 @@ func TestCreateObject(t *testing.T) {
},
}
- s3Mock.EXPECT().PutObject(gomock.Any()).Return(nil, errors.New("foo")).Times(1)
+ s3Mock.EXPECT().PutObject(gomock.Any(), gomock.Any()).Return(nil, errors.New("foo")).Times(1)
- bootstrapDataURL, err := svc.Create(machineScope, []byte("foo"))
+ bootstrapDataURL, err := svc.Create(context.TODO(), machineScope, []byte("foo"))
if err == nil {
t.Fatalf("Expected error")
}
@@ -573,7 +583,7 @@ func TestCreateObject(t *testing.T) {
svc, _ := testService(t, &testServiceInput{Bucket: &infrav1.S3Bucket{}})
- bootstrapDataURL, err := svc.Create(nil, []byte("foo"))
+ bootstrapDataURL, err := svc.Create(context.TODO(), nil, []byte("foo"))
if err == nil {
t.Fatalf("Expected error")
}
@@ -598,7 +608,7 @@ func TestCreateObject(t *testing.T) {
},
}
- bootstrapDataURL, err := svc.Create(machineScope, []byte{})
+ bootstrapDataURL, err := svc.Create(context.TODO(), machineScope, []byte{})
if err == nil {
t.Fatalf("Expected error")
}
@@ -622,7 +632,7 @@ func TestCreateObject(t *testing.T) {
},
}
- bootstrapDataURL, err := svc.Create(machineScope, []byte("foo"))
+ bootstrapDataURL, err := svc.Create(context.TODO(), machineScope, []byte("foo"))
if err == nil {
t.Fatalf("Expected error")
}
@@ -665,9 +675,9 @@ func TestDeleteObject(t *testing.T) {
},
}
- s3Mock.EXPECT().HeadObject(gomock.Any())
+ s3Mock.EXPECT().HeadObject(gomock.Any(), gomock.Any())
- s3Mock.EXPECT().DeleteObject(gomock.Any()).Do(func(deleteObjectInput *s3svc.DeleteObjectInput) {
+ s3Mock.EXPECT().DeleteObject(gomock.Any(), gomock.Any()).Do(func(ctx context.Context, deleteObjectInput *s3svc.DeleteObjectInput, optFns ...func(*s3svc.Options)) {
t.Run("use_configured_bucket_name_on_cluster_level", func(t *testing.T) {
t.Parallel()
@@ -689,7 +699,7 @@ func TestDeleteObject(t *testing.T) {
})
}).Return(nil, nil).Times(1)
- if err := svc.Delete(machineScope); err != nil {
+ if err := svc.Delete(context.TODO(), machineScope); err != nil {
t.Fatalf("Unexpected error, got: %v", err)
}
})
@@ -710,9 +720,9 @@ func TestDeleteObject(t *testing.T) {
t.Parallel()
svc, s3Mock := testService(t, &testServiceInput{Bucket: &infrav1.S3Bucket{}})
- s3Mock.EXPECT().HeadObject(gomock.Any()).Return(nil, awserr.New(s3svc.ErrCodeNoSuchBucket, "", nil))
+ s3Mock.EXPECT().HeadObject(gomock.Any(), gomock.Any()).Return(nil, &types.NoSuchBucket{})
- if err := svc.Delete(machineScope); err != nil {
+ if err := svc.Delete(context.TODO(), machineScope); err != nil {
t.Fatalf("Unexpected error, got: %v", err)
}
})
@@ -721,9 +731,9 @@ func TestDeleteObject(t *testing.T) {
t.Parallel()
svc, s3Mock := testService(t, &testServiceInput{Bucket: &infrav1.S3Bucket{}})
- s3Mock.EXPECT().HeadObject(gomock.Any()).Return(nil, awserr.New(s3svc.ErrCodeNoSuchKey, "", nil))
+ s3Mock.EXPECT().HeadObject(gomock.Any(), gomock.Any()).Return(nil, &types.NoSuchKey{})
- if err := svc.Delete(machineScope); err != nil {
+ if err := svc.Delete(context.TODO(), machineScope); err != nil {
t.Fatalf("Unexpected error, got: %v", err)
}
})
@@ -732,9 +742,12 @@ func TestDeleteObject(t *testing.T) {
t.Parallel()
svc, s3Mock := testService(t, &testServiceInput{Bucket: &infrav1.S3Bucket{}})
- s3Mock.EXPECT().HeadObject(gomock.Any()).Return(nil, awserr.New("NotFound", "Not found", nil))
+ s3Mock.EXPECT().HeadObject(gomock.Any(), gomock.Any()).Return(nil, &types.NoSuchBucket{
+ Message: aws.String("Not found"),
+ ErrorCodeOverride: aws.String("NotFound"),
+ })
- if err := svc.Delete(machineScope); err != nil {
+ if err := svc.Delete(context.TODO(), machineScope); err != nil {
t.Fatalf("Unexpected error, got: %v", err)
}
})
@@ -743,10 +756,13 @@ func TestDeleteObject(t *testing.T) {
t.Parallel()
svc, s3Mock := testService(t, &testServiceInput{Bucket: &infrav1.S3Bucket{BestEffortDeleteObjects: aws.Bool(true)}})
- s3Mock.EXPECT().HeadObject(gomock.Any()).Return(nil, nil)
- s3Mock.EXPECT().DeleteObject(gomock.Any()).Return(nil, awserr.New("AccessDenied", "Access Denied", nil))
+ s3Mock.EXPECT().HeadObject(gomock.Any(), gomock.Any()).Return(nil, nil)
+ s3Mock.EXPECT().DeleteObject(gomock.Any(), gomock.Any()).Return(nil, &types.NoSuchBucket{
+ Message: aws.String("Access Denied"),
+ ErrorCodeOverride: aws.String("AccessDenied"),
+ })
- if err := svc.Delete(machineScope); err != nil {
+ if err := svc.Delete(context.TODO(), machineScope); err != nil {
t.Fatalf("Unexpected error, got: %v", err)
}
})
@@ -769,10 +785,10 @@ func TestDeleteObject(t *testing.T) {
},
}
- s3Mock.EXPECT().HeadObject(gomock.Any())
- s3Mock.EXPECT().DeleteObject(gomock.Any()).Return(nil, errors.New("foo")).Times(1)
+ s3Mock.EXPECT().HeadObject(gomock.Any(), gomock.Any())
+ s3Mock.EXPECT().DeleteObject(gomock.Any(), gomock.Any()).Return(nil, errors.New("foo")).Times(1)
- if err := svc.Delete(machineScope); err == nil {
+ if err := svc.Delete(context.TODO(), machineScope); err == nil {
t.Fatalf("Expected error")
}
})
@@ -782,7 +798,7 @@ func TestDeleteObject(t *testing.T) {
svc, _ := testService(t, nil)
- if err := svc.Delete(nil); err == nil {
+ if err := svc.Delete(context.TODO(), nil); err == nil {
t.Fatalf("Expected error")
}
})
@@ -801,7 +817,7 @@ func TestDeleteObject(t *testing.T) {
},
}
- if err := svc.Delete(machineScope); err == nil {
+ if err := svc.Delete(context.TODO(), machineScope); err == nil {
t.Fatalf("Expected error")
}
})
@@ -810,8 +826,11 @@ func TestDeleteObject(t *testing.T) {
t.Parallel()
svc, s3Mock := testService(t, &testServiceInput{Bucket: &infrav1.S3Bucket{}})
- s3Mock.EXPECT().HeadObject(gomock.Any()).Return(nil, nil)
- s3Mock.EXPECT().DeleteObject(gomock.Any()).Return(nil, awserr.New("AccessDenied", "Access Denied", nil))
+ s3Mock.EXPECT().HeadObject(gomock.Any(), gomock.Any()).Return(nil, nil)
+ s3Mock.EXPECT().DeleteObject(gomock.Any(), gomock.Any()).Return(nil, &types.NoSuchBucket{
+ Message: aws.String("Access Denied"),
+ ErrorCodeOverride: aws.String("AccessDenied"),
+ })
machineScope := &scope.MachineScope{
Machine: &clusterv1.Machine{},
@@ -822,7 +841,7 @@ func TestDeleteObject(t *testing.T) {
},
}
- if err := svc.Delete(machineScope); err == nil {
+ if err := svc.Delete(context.TODO(), machineScope); err == nil {
t.Fatalf("Expected error")
}
})
@@ -842,14 +861,14 @@ func TestDeleteObject(t *testing.T) {
},
}
- s3Mock.EXPECT().HeadObject(gomock.Any()).Times(2)
- s3Mock.EXPECT().DeleteObject(gomock.Any()).Return(nil, nil).Times(2)
+ s3Mock.EXPECT().HeadObject(gomock.Any(), gomock.Any()).Times(2)
+ s3Mock.EXPECT().DeleteObject(gomock.Any(), gomock.Any()).Return(nil, nil).Times(2)
- if err := svc.Delete(machineScope); err != nil {
+ if err := svc.Delete(context.TODO(), machineScope); err != nil {
t.Fatalf("Unexpected error: %v", err)
}
- if err := svc.Delete(machineScope); err != nil {
+ if err := svc.Delete(context.TODO(), machineScope); err != nil {
t.Fatalf("Unexpected error: %v", err)
}
})
diff --git a/pkg/logger/logger.go b/pkg/logger/logger.go
index fa05ff5427..0ee7b190c5 100644
--- a/pkg/logger/logger.go
+++ b/pkg/logger/logger.go
@@ -19,7 +19,9 @@ package logger
import (
"context"
+ "fmt"
+ smithylogging "github.com/aws/smithy-go/logging"
"github.com/go-logr/logr"
)
@@ -41,6 +43,7 @@ type Wrapper interface {
WithValues(keysAndValues ...any) *Logger
WithName(name string) *Logger
GetLogger() logr.Logger
+ GetAWSLogger() smithylogging.Logger
}
// Logger is a concrete logger using logr underneath.
@@ -104,6 +107,11 @@ func (c *Logger) GetLogger() logr.Logger {
return c.logger
}
+// GetAWSLogger returns a compatible aws-sdk-go-v2 logger.
+func (c Logger) GetAWSLogger() smithylogging.Logger {
+ return c
+}
+
// WithValues adds some key-value pairs of context to a logger.
func (c *Logger) WithValues(keysAndValues ...any) *Logger {
return &Logger{
@@ -119,3 +127,14 @@ func (c *Logger) WithName(name string) *Logger {
logger: c.logger.WithName(name),
}
}
+
+// Logf allows Logger to satisfy the smithylogging.Logger interface.
+func (c Logger) Logf(classification smithylogging.Classification, format string, v ...interface{}) {
+ switch classification {
+ // The only two classification levels are WARN and DEBUG
+ case smithylogging.Debug:
+ c.logger.V(logLevelDebug).Info(fmt.Sprintf(format, v...))
+ default:
+ c.logger.V(logLevelWarn).Info(fmt.Sprintf(format, v...))
+ }
+}
diff --git a/test/mocks/capa_clusterscoper_mock.go b/test/mocks/capa_clusterscoper_mock.go
index 54b9ee81eb..42e916a9af 100644
--- a/test/mocks/capa_clusterscoper_mock.go
+++ b/test/mocks/capa_clusterscoper_mock.go
@@ -23,7 +23,9 @@ package mocks
import (
reflect "reflect"
+ 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"
unstructured "k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
@@ -162,6 +164,20 @@ func (mr *MockClusterScoperMockRecorder) Error(arg0, arg1 interface{}, arg2 ...i
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Error", reflect.TypeOf((*MockClusterScoper)(nil).Error), varargs...)
}
+// GetAWSLogger mocks base method.
+func (m *MockClusterScoper) GetAWSLogger() logging.Logger {
+ m.ctrl.T.Helper()
+ ret := m.ctrl.Call(m, "GetAWSLogger")
+ ret0, _ := ret[0].(logging.Logger)
+ return ret0
+}
+
+// GetAWSLogger indicates an expected call of GetAWSLogger.
+func (mr *MockClusterScoperMockRecorder) GetAWSLogger() *gomock.Call {
+ mr.mock.ctrl.T.Helper()
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAWSLogger", reflect.TypeOf((*MockClusterScoper)(nil).GetAWSLogger))
+}
+
// GetLogger mocks base method.
func (m *MockClusterScoper) GetLogger() logr.Logger {
m.ctrl.T.Helper()
@@ -347,6 +363,20 @@ func (mr *MockClusterScoperMockRecorder) Session() *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Session", reflect.TypeOf((*MockClusterScoper)(nil).Session))
}
+// SessionV2 mocks base method.
+func (m *MockClusterScoper) SessionV2() aws.Config {
+ m.ctrl.T.Helper()
+ ret := m.ctrl.Call(m, "SessionV2")
+ ret0, _ := ret[0].(aws.Config)
+ return ret0
+}
+
+// SessionV2 indicates an expected call of SessionV2.
+func (mr *MockClusterScoperMockRecorder) SessionV2() *gomock.Call {
+ mr.mock.ctrl.T.Helper()
+ return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SessionV2", reflect.TypeOf((*MockClusterScoper)(nil).SessionV2))
+}
+
// SetFailureDomain mocks base method.
func (m *MockClusterScoper) SetFailureDomain(arg0 string, arg1 v1beta1.FailureDomainSpec) {
m.ctrl.T.Helper()