diff --git a/controllers/crds/cninode_controller.go b/controllers/crds/cninode_controller.go index 18d03978..af5950fe 100644 --- a/controllers/crds/cninode_controller.go +++ b/controllers/crds/cninode_controller.go @@ -25,9 +25,8 @@ import ( "github.com/aws/amazon-vpc-resource-controller-k8s/pkg/utils" "github.com/go-logr/logr" "github.com/prometheus/client_golang/prometheus" - "golang.org/x/sync/semaphore" v1 "k8s.io/api/core/v1" - apierrors "k8s.io/apimachinery/pkg/api/errors" + "k8s.io/apimachinery/pkg/api/errors" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/apimachinery/pkg/runtime" "k8s.io/apimachinery/pkg/types" @@ -36,7 +35,6 @@ import ( ctrl "sigs.k8s.io/controller-runtime" "sigs.k8s.io/controller-runtime/pkg/client" "sigs.k8s.io/controller-runtime/pkg/controller" - "sigs.k8s.io/controller-runtime/pkg/controller/controllerutil" "sigs.k8s.io/controller-runtime/pkg/metrics" ) @@ -77,8 +75,7 @@ type CNINodeReconciler struct { clusterName string vpcId string finalizerManager k8s.FinalizerManager - deletePool *semaphore.Weighted - newResourceCleaner func(nodeID string, eC2Wrapper ec2API.EC2Wrapper, vpcID string, log logr.Logger) cleanup.ResourceCleaner + newResourceCleaner func(nodeID string, eC2Wrapper ec2API.EC2Wrapper, vpcID string) cleanup.ResourceCleaner } func NewCNINodeReconciler( @@ -91,8 +88,7 @@ func NewCNINodeReconciler( clusterName string, vpcId string, finalizerManager k8s.FinalizerManager, - maxConcurrentWorkers int, - newResourceCleaner func(nodeID string, eC2Wrapper ec2API.EC2Wrapper, vpcID string, log logr.Logger) cleanup.ResourceCleaner, + newResourceCleaner func(nodeID string, eC2Wrapper ec2API.EC2Wrapper, vpcID string) cleanup.ResourceCleaner, ) *CNINodeReconciler { return &CNINodeReconciler{ Client: client, @@ -104,7 +100,6 @@ func NewCNINodeReconciler( clusterName: clusterName, vpcId: vpcId, finalizerManager: finalizerManager, - deletePool: semaphore.NewWeighted(int64(maxConcurrentWorkers)), newResourceCleaner: newResourceCleaner, } } @@ -123,7 +118,7 @@ func (r *CNINodeReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ct nodeFound := true node := &v1.Node{} if err := r.Client.Get(ctx, req.NamespacedName, node); err != nil { - if apierrors.IsNotFound(err) { + if errors.IsNotFound(err) { nodeFound = false } else { r.log.Error(err, "failed to get the node object in CNINode reconciliation, will retry") @@ -133,50 +128,66 @@ func (r *CNINodeReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ct } if cniNode.GetDeletionTimestamp().IsZero() { + shouldPatch := false cniNodeCopy := cniNode.DeepCopy() - shouldPatch, err := r.ensureTagsAndLabels(cniNodeCopy, node) - shouldPatch = controllerutil.AddFinalizer(cniNodeCopy, config.NodeTerminationFinalizer) || shouldPatch - - if shouldPatch { - r.log.Info("patching CNINode to add fields Tags, Labels and finalizer", "cninode", cniNode.Name) - if err := r.Client.Patch(ctx, cniNodeCopy, client.MergeFromWithOptions(cniNode, client.MergeFromWithOptimisticLock{})); err != nil { - if apierrors.IsConflict(err) { - r.log.Info("failed to update cninode", "cninode", cniNode.Name, "error", err) - return ctrl.Result{Requeue: true}, nil + // Add cluster name tag if it does not exist + val, ok := cniNode.Spec.Tags[config.VPCCNIClusterNameKey] + if !ok || val != r.clusterName { + if len(cniNodeCopy.Spec.Tags) != 0 { + cniNodeCopy.Spec.Tags[config.VPCCNIClusterNameKey] = r.clusterName + } else { + cniNodeCopy.Spec.Tags = map[string]string{ + config.VPCCNIClusterNameKey: r.clusterName, } - return ctrl.Result{}, err } + shouldPatch = true } - return ctrl.Result{}, err + // if node exists, get & add OS label if it does not exist on CNINode + if nodeFound { + nodeLabelOS := node.ObjectMeta.Labels[config.NodeLabelOS] + val, ok = cniNode.ObjectMeta.Labels[config.NodeLabelOS] + if !ok || val != nodeLabelOS { + if len(cniNodeCopy.ObjectMeta.Labels) != 0 { + cniNodeCopy.ObjectMeta.Labels[config.NodeLabelOS] = nodeLabelOS + } else { + cniNodeCopy.ObjectMeta.Labels = map[string]string{ + config.NodeLabelOS: nodeLabelOS, + } + } + shouldPatch = true + } + } + + if shouldPatch { + r.log.Info("patching CNINode to add required fields Tags and Labels", "cninode", cniNode.Name) + return ctrl.Result{}, r.Client.Patch(ctx, cniNodeCopy, client.MergeFromWithOptions(cniNode, client.MergeFromWithOptimisticLock{})) + } + + // Add finalizer if it does not exist + if err := r.finalizerManager.AddFinalizers(ctx, cniNode, config.NodeTerminationFinalizer); err != nil { + r.log.Error(err, "failed to add finalizer on CNINode, will retry", "cniNode", cniNode.Name, "finalizer", config.NodeTerminationFinalizer) + return ctrl.Result{}, err + } + return ctrl.Result{}, nil + } else { // CNINode is marked for deletion if !nodeFound { // node is also deleted, proceed with running the cleanup routine and remove the finalizer + // run cleanup for Linux nodes only if val, ok := cniNode.ObjectMeta.Labels[config.NodeLabelOS]; ok && val == config.OSLinux { r.log.Info("running the finalizer routine on cniNode", "cniNode", cniNode.Name) // run cleanup when node id is present if nodeID, ok := cniNode.Spec.Tags[config.NetworkInterfaceNodeIDKey]; ok && nodeID != "" { - if !r.deletePool.TryAcquire(1) { - r.log.Info("d, will requeue request") - return ctrl.Result{RequeueAfter: 10 * time.Second}, nil + if err := r.newResourceCleaner(nodeID, r.eC2Wrapper, r.vpcId).DeleteLeakedResources(); err != nil { + r.log.Error(err, "failed to cleanup resources during node termination") + ec2API.NodeTerminationENICleanupFailure.Inc() } - go func(nodeID string) { - defer r.deletePool.Release(1) - childCtx, cancel := context.WithTimeout(ctx, config.NodeTerminationTimeout) - defer cancel() - if err := r.newResourceCleaner(nodeID, r.eC2Wrapper, r.vpcId, r.log).DeleteLeakedResources(childCtx); err != nil { - r.log.Error(err, "failed to cleanup resources during node termination") - ec2API.NodeTerminationENICleanupFailure.Inc() - } - }(nodeID) } } - if err := r.removeFinalizer(ctx, cniNode, config.NodeTerminationFinalizer); err != nil { + if err := r.finalizerManager.RemoveFinalizers(ctx, cniNode, config.NodeTerminationFinalizer); err != nil { r.log.Error(err, "failed to remove finalizer on CNINode, will retry", "cniNode", cniNode.Name, "finalizer", config.NodeTerminationFinalizer) - if apierrors.IsConflict(err) { - return ctrl.Result{Requeue: true}, nil - } return ctrl.Result{}, err } return ctrl.Result{}, nil @@ -196,7 +207,7 @@ func (r *CNINodeReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ct Spec: cniNode.Spec, } - if err := r.removeFinalizer(ctx, cniNode, config.NodeTerminationFinalizer); err != nil { + if err := r.finalizerManager.RemoveFinalizers(ctx, cniNode, config.NodeTerminationFinalizer); err != nil { r.log.Error(err, "failed to remove finalizer on CNINode, will retry") return ctrl.Result{}, err } @@ -241,7 +252,7 @@ func (r *CNINodeReconciler) waitTillCNINodeDeleted(nameSpacedCNINode types.Names oldCNINode := &v1alpha1.CNINode{} return wait.PollUntilContextTimeout(context.TODO(), 500*time.Millisecond, time.Second*3, true, func(ctx context.Context) (bool, error) { - if err := r.Client.Get(ctx, nameSpacedCNINode, oldCNINode); err != nil && apierrors.IsNotFound(err) { + if err := r.Client.Get(ctx, nameSpacedCNINode, oldCNINode); err != nil && errors.IsNotFound(err) { return true, nil } return false, nil @@ -255,45 +266,3 @@ func (r *CNINodeReconciler) createCNINodeFromObj(ctx context.Context, newCNINode return r.Client.Create(ctx, newCNINode) }) } - -func (r *CNINodeReconciler) ensureTagsAndLabels(cniNode *v1alpha1.CNINode, node *v1.Node) (bool, error) { - shouldPatch := false - var err error - if cniNode.Spec.Tags == nil { - cniNode.Spec.Tags = make(map[string]string) - } - // add cluster name tag if it does not exist - if cniNode.Spec.Tags[config.VPCCNIClusterNameKey] != r.clusterName { - cniNode.Spec.Tags[config.VPCCNIClusterNameKey] = r.clusterName - shouldPatch = true - } - if node != nil { - var nodeID string - nodeID, err = utils.GetNodeID(node) - - if nodeID != "" && cniNode.Spec.Tags[config.NetworkInterfaceNodeIDKey] != nodeID { - cniNode.Spec.Tags[config.NetworkInterfaceNodeIDKey] = nodeID - shouldPatch = true - } - - // add node label if it does not exist - if cniNode.ObjectMeta.Labels == nil { - cniNode.ObjectMeta.Labels = make(map[string]string) - } - if cniNode.ObjectMeta.Labels[config.NodeLabelOS] != node.ObjectMeta.Labels[config.NodeLabelOS] { - cniNode.ObjectMeta.Labels[config.NodeLabelOS] = node.ObjectMeta.Labels[config.NodeLabelOS] - shouldPatch = true - } - } - return shouldPatch, err -} - -func (r *CNINodeReconciler) removeFinalizer(ctx context.Context, cniNode *v1alpha1.CNINode, finalizer string) error { - cniNodeCopy := cniNode.DeepCopy() - - if controllerutil.RemoveFinalizer(cniNodeCopy, finalizer) { - r.log.Info("removing finalizer for cninode", "name", cniNode.GetName(), "finalizer", finalizer) - return r.Client.Patch(ctx, cniNodeCopy, client.MergeFromWithOptions(cniNode, client.MergeFromWithOptimisticLock{})) - } - return nil -} diff --git a/controllers/crds/cninode_controller_test.go b/controllers/crds/cninode_controller_test.go index 3d54e32d..96021290 100644 --- a/controllers/crds/cninode_controller_test.go +++ b/controllers/crds/cninode_controller_test.go @@ -11,10 +11,8 @@ import ( ec2API "github.com/aws/amazon-vpc-resource-controller-k8s/pkg/aws/ec2/api" "github.com/aws/amazon-vpc-resource-controller-k8s/pkg/aws/ec2/api/cleanup" "github.com/aws/amazon-vpc-resource-controller-k8s/pkg/config" - "github.com/go-logr/logr" "github.com/golang/mock/gomock" "github.com/stretchr/testify/assert" - "golang.org/x/sync/semaphore" corev1 "k8s.io/api/core/v1" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/apimachinery/pkg/runtime" @@ -39,9 +37,6 @@ var ( config.NodeLabelOS: "linux", }, }, - Spec: corev1.NodeSpec{ - ProviderID: "aws:///us-west-2a/i-0123456789abcdef0", - }, } reconcileRequest = reconcile.Request{ NamespacedName: types.NamespacedName{ @@ -62,7 +57,6 @@ func NewCNINodeMock(ctrl *gomock.Controller, mockObjects ...client.Object) *CNIN log: zap.New(), clusterName: mockClusterName, vpcId: "vpc-000000000000", - deletePool: semaphore.NewWeighted(10), }, } } @@ -86,7 +80,7 @@ func TestCNINodeReconcile(t *testing.T) { asserts func(reconcile.Result, error, *v1alpha1.CNINode) }{ { - name: "verify clusterName, instanceID, os label are added if missing", + name: "verify clusterName tag and labels are added if missing", args: args{ mockNode: mockNodeWithLabel, mockCNINode: &v1alpha1.CNINode{ @@ -100,7 +94,7 @@ func TestCNINodeReconcile(t *testing.T) { assert.NoError(t, err) assert.Equal(t, res, reconcile.Result{}) assert.Equal(t, cniNode.Labels, map[string]string{config.NodeLabelOS: "linux"}) - assert.Equal(t, cniNode.Spec.Tags, map[string]string{config.VPCCNIClusterNameKey: mockClusterName, config.NetworkInterfaceNodeIDKey: "i-0123456789abcdef0"}) + assert.Equal(t, cniNode.Spec.Tags, map[string]string{config.VPCCNIClusterNameKey: mockClusterName}) }, }, { @@ -119,10 +113,14 @@ func TestCNINodeReconcile(t *testing.T) { }, }, prepare: func(f *fields) { - f.mockCNINode.Reconciler.newResourceCleaner = func(nodeID string, eC2Wrapper ec2API.EC2Wrapper, vpcID string, log logr.Logger) cleanup.ResourceCleaner { + f.mockCNINode.Reconciler.newResourceCleaner = func(nodeID string, eC2Wrapper ec2API.EC2Wrapper, vpcID string) cleanup.ResourceCleaner { return f.mockResourceCleaner } - f.mockResourceCleaner.EXPECT().DeleteLeakedResources(gomock.Any()).Times(0) + f.mockResourceCleaner.EXPECT().DeleteLeakedResources().Times(0) + + f.mockFinalizerManager.EXPECT(). + RemoveFinalizers(gomock.Any(), gomock.Any(), config.NodeTerminationFinalizer). + Return(nil) }, asserts: func(res reconcile.Result, err error, cniNode *v1alpha1.CNINode) { assert.NoError(t, err) @@ -144,17 +142,20 @@ func TestCNINodeReconcile(t *testing.T) { }, Spec: v1alpha1.CNINodeSpec{ Tags: map[string]string{ - config.NetworkInterfaceNodeIDKey: "i-0123456789abcdef0", + config.NetworkInterfaceNodeIDKey: "i-1234567890", }, }, }, }, prepare: func(f *fields) { - f.mockCNINode.Reconciler.newResourceCleaner = func(nodeID string, eC2Wrapper ec2API.EC2Wrapper, vpcID string, log logr.Logger) cleanup.ResourceCleaner { - assert.Equal(t, "i-0123456789abcdef0", nodeID) + f.mockCNINode.Reconciler.newResourceCleaner = func(nodeID string, eC2Wrapper ec2API.EC2Wrapper, vpcID string) cleanup.ResourceCleaner { + assert.Equal(t, "i-1234567890", nodeID) return f.mockResourceCleaner } - f.mockResourceCleaner.EXPECT().DeleteLeakedResources(gomock.Any()).Times(1).Return(nil) + f.mockResourceCleaner.EXPECT().DeleteLeakedResources().Times(1).Return(nil) + f.mockFinalizerManager.EXPECT(). + RemoveFinalizers(gomock.Any(), gomock.Any(), config.NodeTerminationFinalizer). + Return(nil) }, asserts: func(res reconcile.Result, err error, cniNode *v1alpha1.CNINode) { @@ -162,32 +163,6 @@ func TestCNINodeReconcile(t *testing.T) { assert.Equal(t, res, reconcile.Result{}) }, }, - { - name: "verify finalizer is added when labels and tags are present", - args: args{ - mockNode: mockNodeWithLabel, - mockCNINode: &v1alpha1.CNINode{ - ObjectMeta: metav1.ObjectMeta{ - Name: mockName, - Labels: map[string]string{ - config.NodeLabelOS: "linux", - }, - }, - Spec: v1alpha1.CNINodeSpec{ - Tags: map[string]string{ - config.VPCCNIClusterNameKey: mockClusterName, - config.NetworkInterfaceNodeIDKey: "i-0123456789abcdef0", - }, - }, - }, - }, - prepare: nil, - asserts: func(res reconcile.Result, err error, cniNode *v1alpha1.CNINode) { - assert.NoError(t, err) - assert.Equal(t, res, reconcile.Result{}) - assert.Contains(t, cniNode.Finalizers, config.NodeTerminationFinalizer) - }, - }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { @@ -213,10 +188,8 @@ func TestCNINodeReconcile(t *testing.T) { res, err := mock.Reconciler.Reconcile(context.Background(), reconcileRequest) cniNode := &v1alpha1.CNINode{} - if tt.args.mockCNINode.GetDeletionTimestamp() == nil { - getErr := mock.Reconciler.Client.Get(context.Background(), reconcileRequest.NamespacedName, cniNode) - assert.NoError(t, getErr) - } + getErr := mock.Reconciler.Client.Get(context.Background(), reconcileRequest.NamespacedName, cniNode) + assert.NoError(t, getErr) if tt.asserts != nil { tt.asserts(res, err, cniNode) diff --git a/go.mod b/go.mod index d88e68a3..e84aad87 100644 --- a/go.mod +++ b/go.mod @@ -24,7 +24,6 @@ require ( github.com/prometheus/common v0.62.0 github.com/stretchr/testify v1.10.0 go.uber.org/zap v1.27.0 - golang.org/x/sync v0.13.0 golang.org/x/time v0.11.0 gomodules.xyz/jsonpatch/v2 v2.5.0 k8s.io/api v0.33.0 @@ -48,6 +47,7 @@ require ( github.com/gorilla/websocket v1.5.4-0.20250319132907-e064f32e3674 // indirect github.com/mxk/go-flowrate v0.0.0-20140419014527-cca7078d478f // indirect github.com/x448/float16 v0.8.4 // indirect + golang.org/x/sync v0.13.0 // indirect gopkg.in/evanphx/json-patch.v4 v4.12.0 // indirect sigs.k8s.io/randfill v1.0.0 // indirect ) diff --git a/main.go b/main.go index 7d152bf3..f18a0fbd 100644 --- a/main.go +++ b/main.go @@ -439,7 +439,6 @@ func main() { clusterName, vpcID, finalizerManager, - maxNodeConcurrentReconciles, cleanup.NewNodeResourceCleaner, ).SetupWithManager(mgr, maxNodeConcurrentReconciles)); err != nil { setupLog.Error(err, "unable to create controller", "controller", "CNINode") diff --git a/mocks/amazon-vcp-resource-controller-k8s/pkg/aws/ec2/api/cleanup/mock_resource_cleaner.go b/mocks/amazon-vcp-resource-controller-k8s/pkg/aws/ec2/api/cleanup/mock_resource_cleaner.go index 0031259c..4ed17141 100644 --- a/mocks/amazon-vcp-resource-controller-k8s/pkg/aws/ec2/api/cleanup/mock_resource_cleaner.go +++ b/mocks/amazon-vcp-resource-controller-k8s/pkg/aws/ec2/api/cleanup/mock_resource_cleaner.go @@ -18,7 +18,6 @@ package mock_cleanup import ( - context "context" reflect "reflect" gomock "github.com/golang/mock/gomock" @@ -48,15 +47,15 @@ func (m *MockResourceCleaner) EXPECT() *MockResourceCleanerMockRecorder { } // DeleteLeakedResources mocks base method. -func (m *MockResourceCleaner) DeleteLeakedResources(arg0 context.Context) error { +func (m *MockResourceCleaner) DeleteLeakedResources() error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteLeakedResources", arg0) + ret := m.ctrl.Call(m, "DeleteLeakedResources") ret0, _ := ret[0].(error) return ret0 } // DeleteLeakedResources indicates an expected call of DeleteLeakedResources. -func (mr *MockResourceCleanerMockRecorder) DeleteLeakedResources(arg0 interface{}) *gomock.Call { +func (mr *MockResourceCleanerMockRecorder) DeleteLeakedResources() *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLeakedResources", reflect.TypeOf((*MockResourceCleaner)(nil).DeleteLeakedResources), arg0) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLeakedResources", reflect.TypeOf((*MockResourceCleaner)(nil).DeleteLeakedResources)) } diff --git a/mocks/amazon-vcp-resource-controller-k8s/pkg/aws/ec2/api/mock_ec2_wrapper.go b/mocks/amazon-vcp-resource-controller-k8s/pkg/aws/ec2/api/mock_ec2_wrapper.go index 35971b6c..a49f1d43 100644 --- a/mocks/amazon-vcp-resource-controller-k8s/pkg/aws/ec2/api/mock_ec2_wrapper.go +++ b/mocks/amazon-vcp-resource-controller-k8s/pkg/aws/ec2/api/mock_ec2_wrapper.go @@ -18,7 +18,6 @@ package mock_api import ( - context "context" reflect "reflect" ec2 "github.com/aws/aws-sdk-go-v2/service/ec2" @@ -50,240 +49,240 @@ func (m *MockEC2Wrapper) EXPECT() *MockEC2WrapperMockRecorder { } // AssignPrivateIPAddresses mocks base method. -func (m *MockEC2Wrapper) AssignPrivateIPAddresses(input *ec2.AssignPrivateIpAddressesInput) (*ec2.AssignPrivateIpAddressesOutput, error) { +func (m *MockEC2Wrapper) AssignPrivateIPAddresses(arg0 *ec2.AssignPrivateIpAddressesInput) (*ec2.AssignPrivateIpAddressesOutput, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "AssignPrivateIPAddresses", input) + ret := m.ctrl.Call(m, "AssignPrivateIPAddresses", arg0) ret0, _ := ret[0].(*ec2.AssignPrivateIpAddressesOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // AssignPrivateIPAddresses indicates an expected call of AssignPrivateIPAddresses. -func (mr *MockEC2WrapperMockRecorder) AssignPrivateIPAddresses(input interface{}) *gomock.Call { +func (mr *MockEC2WrapperMockRecorder) AssignPrivateIPAddresses(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssignPrivateIPAddresses", reflect.TypeOf((*MockEC2Wrapper)(nil).AssignPrivateIPAddresses), input) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssignPrivateIPAddresses", reflect.TypeOf((*MockEC2Wrapper)(nil).AssignPrivateIPAddresses), arg0) } // AssociateTrunkInterface mocks base method. -func (m *MockEC2Wrapper) AssociateTrunkInterface(input *ec2.AssociateTrunkInterfaceInput) (*ec2.AssociateTrunkInterfaceOutput, error) { +func (m *MockEC2Wrapper) AssociateTrunkInterface(arg0 *ec2.AssociateTrunkInterfaceInput) (*ec2.AssociateTrunkInterfaceOutput, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "AssociateTrunkInterface", input) + ret := m.ctrl.Call(m, "AssociateTrunkInterface", arg0) ret0, _ := ret[0].(*ec2.AssociateTrunkInterfaceOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // AssociateTrunkInterface indicates an expected call of AssociateTrunkInterface. -func (mr *MockEC2WrapperMockRecorder) AssociateTrunkInterface(input interface{}) *gomock.Call { +func (mr *MockEC2WrapperMockRecorder) AssociateTrunkInterface(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateTrunkInterface", reflect.TypeOf((*MockEC2Wrapper)(nil).AssociateTrunkInterface), input) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateTrunkInterface", reflect.TypeOf((*MockEC2Wrapper)(nil).AssociateTrunkInterface), arg0) } // AttachNetworkInterface mocks base method. -func (m *MockEC2Wrapper) AttachNetworkInterface(input *ec2.AttachNetworkInterfaceInput) (*ec2.AttachNetworkInterfaceOutput, error) { +func (m *MockEC2Wrapper) AttachNetworkInterface(arg0 *ec2.AttachNetworkInterfaceInput) (*ec2.AttachNetworkInterfaceOutput, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "AttachNetworkInterface", input) + ret := m.ctrl.Call(m, "AttachNetworkInterface", arg0) ret0, _ := ret[0].(*ec2.AttachNetworkInterfaceOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // AttachNetworkInterface indicates an expected call of AttachNetworkInterface. -func (mr *MockEC2WrapperMockRecorder) AttachNetworkInterface(input interface{}) *gomock.Call { +func (mr *MockEC2WrapperMockRecorder) AttachNetworkInterface(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AttachNetworkInterface", reflect.TypeOf((*MockEC2Wrapper)(nil).AttachNetworkInterface), input) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AttachNetworkInterface", reflect.TypeOf((*MockEC2Wrapper)(nil).AttachNetworkInterface), arg0) } // CreateNetworkInterface mocks base method. -func (m *MockEC2Wrapper) CreateNetworkInterface(input *ec2.CreateNetworkInterfaceInput) (*ec2.CreateNetworkInterfaceOutput, error) { +func (m *MockEC2Wrapper) CreateNetworkInterface(arg0 *ec2.CreateNetworkInterfaceInput) (*ec2.CreateNetworkInterfaceOutput, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateNetworkInterface", input) + ret := m.ctrl.Call(m, "CreateNetworkInterface", arg0) ret0, _ := ret[0].(*ec2.CreateNetworkInterfaceOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // CreateNetworkInterface indicates an expected call of CreateNetworkInterface. -func (mr *MockEC2WrapperMockRecorder) CreateNetworkInterface(input interface{}) *gomock.Call { +func (mr *MockEC2WrapperMockRecorder) CreateNetworkInterface(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateNetworkInterface", reflect.TypeOf((*MockEC2Wrapper)(nil).CreateNetworkInterface), input) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateNetworkInterface", reflect.TypeOf((*MockEC2Wrapper)(nil).CreateNetworkInterface), arg0) } // CreateNetworkInterfacePermission mocks base method. -func (m *MockEC2Wrapper) CreateNetworkInterfacePermission(input *ec2.CreateNetworkInterfacePermissionInput) (*ec2.CreateNetworkInterfacePermissionOutput, error) { +func (m *MockEC2Wrapper) CreateNetworkInterfacePermission(arg0 *ec2.CreateNetworkInterfacePermissionInput) (*ec2.CreateNetworkInterfacePermissionOutput, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateNetworkInterfacePermission", input) + ret := m.ctrl.Call(m, "CreateNetworkInterfacePermission", arg0) ret0, _ := ret[0].(*ec2.CreateNetworkInterfacePermissionOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // CreateNetworkInterfacePermission indicates an expected call of CreateNetworkInterfacePermission. -func (mr *MockEC2WrapperMockRecorder) CreateNetworkInterfacePermission(input interface{}) *gomock.Call { +func (mr *MockEC2WrapperMockRecorder) CreateNetworkInterfacePermission(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateNetworkInterfacePermission", reflect.TypeOf((*MockEC2Wrapper)(nil).CreateNetworkInterfacePermission), input) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateNetworkInterfacePermission", reflect.TypeOf((*MockEC2Wrapper)(nil).CreateNetworkInterfacePermission), arg0) } // CreateTags mocks base method. -func (m *MockEC2Wrapper) CreateTags(input *ec2.CreateTagsInput) (*ec2.CreateTagsOutput, error) { +func (m *MockEC2Wrapper) CreateTags(arg0 *ec2.CreateTagsInput) (*ec2.CreateTagsOutput, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateTags", input) + ret := m.ctrl.Call(m, "CreateTags", arg0) ret0, _ := ret[0].(*ec2.CreateTagsOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // CreateTags indicates an expected call of CreateTags. -func (mr *MockEC2WrapperMockRecorder) CreateTags(input interface{}) *gomock.Call { +func (mr *MockEC2WrapperMockRecorder) CreateTags(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTags", reflect.TypeOf((*MockEC2Wrapper)(nil).CreateTags), input) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTags", reflect.TypeOf((*MockEC2Wrapper)(nil).CreateTags), arg0) } // DeleteNetworkInterface mocks base method. -func (m *MockEC2Wrapper) DeleteNetworkInterface(ctx context.Context, input *ec2.DeleteNetworkInterfaceInput) (*ec2.DeleteNetworkInterfaceOutput, error) { +func (m *MockEC2Wrapper) DeleteNetworkInterface(arg0 *ec2.DeleteNetworkInterfaceInput) (*ec2.DeleteNetworkInterfaceOutput, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteNetworkInterface", ctx, input) + ret := m.ctrl.Call(m, "DeleteNetworkInterface", arg0) ret0, _ := ret[0].(*ec2.DeleteNetworkInterfaceOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // DeleteNetworkInterface indicates an expected call of DeleteNetworkInterface. -func (mr *MockEC2WrapperMockRecorder) DeleteNetworkInterface(ctx, input interface{}) *gomock.Call { +func (mr *MockEC2WrapperMockRecorder) DeleteNetworkInterface(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteNetworkInterface", reflect.TypeOf((*MockEC2Wrapper)(nil).DeleteNetworkInterface), ctx, input) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteNetworkInterface", reflect.TypeOf((*MockEC2Wrapper)(nil).DeleteNetworkInterface), arg0) } // DescribeInstances mocks base method. -func (m *MockEC2Wrapper) DescribeInstances(input *ec2.DescribeInstancesInput) (*ec2.DescribeInstancesOutput, error) { +func (m *MockEC2Wrapper) DescribeInstances(arg0 *ec2.DescribeInstancesInput) (*ec2.DescribeInstancesOutput, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeInstances", input) + ret := m.ctrl.Call(m, "DescribeInstances", arg0) ret0, _ := ret[0].(*ec2.DescribeInstancesOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // DescribeInstances indicates an expected call of DescribeInstances. -func (mr *MockEC2WrapperMockRecorder) DescribeInstances(input interface{}) *gomock.Call { +func (mr *MockEC2WrapperMockRecorder) DescribeInstances(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstances", reflect.TypeOf((*MockEC2Wrapper)(nil).DescribeInstances), input) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstances", reflect.TypeOf((*MockEC2Wrapper)(nil).DescribeInstances), arg0) } // DescribeNetworkInterfaces mocks base method. -func (m *MockEC2Wrapper) DescribeNetworkInterfaces(input *ec2.DescribeNetworkInterfacesInput) (*ec2.DescribeNetworkInterfacesOutput, error) { +func (m *MockEC2Wrapper) DescribeNetworkInterfaces(arg0 *ec2.DescribeNetworkInterfacesInput) (*ec2.DescribeNetworkInterfacesOutput, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeNetworkInterfaces", input) + ret := m.ctrl.Call(m, "DescribeNetworkInterfaces", arg0) ret0, _ := ret[0].(*ec2.DescribeNetworkInterfacesOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // DescribeNetworkInterfaces indicates an expected call of DescribeNetworkInterfaces. -func (mr *MockEC2WrapperMockRecorder) DescribeNetworkInterfaces(input interface{}) *gomock.Call { +func (mr *MockEC2WrapperMockRecorder) DescribeNetworkInterfaces(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNetworkInterfaces", reflect.TypeOf((*MockEC2Wrapper)(nil).DescribeNetworkInterfaces), input) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNetworkInterfaces", reflect.TypeOf((*MockEC2Wrapper)(nil).DescribeNetworkInterfaces), arg0) } -// DescribeNetworkInterfacesPages mocks base method. -func (m *MockEC2Wrapper) DescribeNetworkInterfacesPages(ctx context.Context, input *ec2.DescribeNetworkInterfacesInput) ([]*types.NetworkInterface, error) { +// DescribeNetworkInterfacesPagesWithRetry mocks base method. +func (m *MockEC2Wrapper) DescribeNetworkInterfacesPagesWithRetry(arg0 *ec2.DescribeNetworkInterfacesInput) ([]*types.NetworkInterface, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeNetworkInterfacesPages", ctx, input) + ret := m.ctrl.Call(m, "DescribeNetworkInterfacesPagesWithRetry", arg0) ret0, _ := ret[0].([]*types.NetworkInterface) ret1, _ := ret[1].(error) return ret0, ret1 } -// DescribeNetworkInterfacesPages indicates an expected call of DescribeNetworkInterfacesPages. -func (mr *MockEC2WrapperMockRecorder) DescribeNetworkInterfacesPages(ctx, input interface{}) *gomock.Call { +// DescribeNetworkInterfacesPagesWithRetry indicates an expected call of DescribeNetworkInterfacesPagesWithRetry. +func (mr *MockEC2WrapperMockRecorder) DescribeNetworkInterfacesPagesWithRetry(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNetworkInterfacesPages", reflect.TypeOf((*MockEC2Wrapper)(nil).DescribeNetworkInterfacesPages), ctx, input) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNetworkInterfacesPagesWithRetry", reflect.TypeOf((*MockEC2Wrapper)(nil).DescribeNetworkInterfacesPagesWithRetry), arg0) } // DescribeSubnets mocks base method. -func (m *MockEC2Wrapper) DescribeSubnets(input *ec2.DescribeSubnetsInput) (*ec2.DescribeSubnetsOutput, error) { +func (m *MockEC2Wrapper) DescribeSubnets(arg0 *ec2.DescribeSubnetsInput) (*ec2.DescribeSubnetsOutput, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeSubnets", input) + ret := m.ctrl.Call(m, "DescribeSubnets", arg0) ret0, _ := ret[0].(*ec2.DescribeSubnetsOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // DescribeSubnets indicates an expected call of DescribeSubnets. -func (mr *MockEC2WrapperMockRecorder) DescribeSubnets(input interface{}) *gomock.Call { +func (mr *MockEC2WrapperMockRecorder) DescribeSubnets(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSubnets", reflect.TypeOf((*MockEC2Wrapper)(nil).DescribeSubnets), input) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSubnets", reflect.TypeOf((*MockEC2Wrapper)(nil).DescribeSubnets), arg0) } // DescribeTrunkInterfaceAssociations mocks base method. -func (m *MockEC2Wrapper) DescribeTrunkInterfaceAssociations(input *ec2.DescribeTrunkInterfaceAssociationsInput) (*ec2.DescribeTrunkInterfaceAssociationsOutput, error) { +func (m *MockEC2Wrapper) DescribeTrunkInterfaceAssociations(arg0 *ec2.DescribeTrunkInterfaceAssociationsInput) (*ec2.DescribeTrunkInterfaceAssociationsOutput, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeTrunkInterfaceAssociations", input) + ret := m.ctrl.Call(m, "DescribeTrunkInterfaceAssociations", arg0) ret0, _ := ret[0].(*ec2.DescribeTrunkInterfaceAssociationsOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // DescribeTrunkInterfaceAssociations indicates an expected call of DescribeTrunkInterfaceAssociations. -func (mr *MockEC2WrapperMockRecorder) DescribeTrunkInterfaceAssociations(input interface{}) *gomock.Call { +func (mr *MockEC2WrapperMockRecorder) DescribeTrunkInterfaceAssociations(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTrunkInterfaceAssociations", reflect.TypeOf((*MockEC2Wrapper)(nil).DescribeTrunkInterfaceAssociations), input) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTrunkInterfaceAssociations", reflect.TypeOf((*MockEC2Wrapper)(nil).DescribeTrunkInterfaceAssociations), arg0) } // DetachNetworkInterface mocks base method. -func (m *MockEC2Wrapper) DetachNetworkInterface(input *ec2.DetachNetworkInterfaceInput) (*ec2.DetachNetworkInterfaceOutput, error) { +func (m *MockEC2Wrapper) DetachNetworkInterface(arg0 *ec2.DetachNetworkInterfaceInput) (*ec2.DetachNetworkInterfaceOutput, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DetachNetworkInterface", input) + ret := m.ctrl.Call(m, "DetachNetworkInterface", arg0) ret0, _ := ret[0].(*ec2.DetachNetworkInterfaceOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // DetachNetworkInterface indicates an expected call of DetachNetworkInterface. -func (mr *MockEC2WrapperMockRecorder) DetachNetworkInterface(input interface{}) *gomock.Call { +func (mr *MockEC2WrapperMockRecorder) DetachNetworkInterface(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DetachNetworkInterface", reflect.TypeOf((*MockEC2Wrapper)(nil).DetachNetworkInterface), input) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DetachNetworkInterface", reflect.TypeOf((*MockEC2Wrapper)(nil).DetachNetworkInterface), arg0) } // DisassociateTrunkInterface mocks base method. -func (m *MockEC2Wrapper) DisassociateTrunkInterface(input *ec2.DisassociateTrunkInterfaceInput) error { +func (m *MockEC2Wrapper) DisassociateTrunkInterface(arg0 *ec2.DisassociateTrunkInterfaceInput) error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DisassociateTrunkInterface", input) + ret := m.ctrl.Call(m, "DisassociateTrunkInterface", arg0) ret0, _ := ret[0].(error) return ret0 } // DisassociateTrunkInterface indicates an expected call of DisassociateTrunkInterface. -func (mr *MockEC2WrapperMockRecorder) DisassociateTrunkInterface(input interface{}) *gomock.Call { +func (mr *MockEC2WrapperMockRecorder) DisassociateTrunkInterface(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateTrunkInterface", reflect.TypeOf((*MockEC2Wrapper)(nil).DisassociateTrunkInterface), input) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateTrunkInterface", reflect.TypeOf((*MockEC2Wrapper)(nil).DisassociateTrunkInterface), arg0) } // ModifyNetworkInterfaceAttribute mocks base method. -func (m *MockEC2Wrapper) ModifyNetworkInterfaceAttribute(input *ec2.ModifyNetworkInterfaceAttributeInput) (*ec2.ModifyNetworkInterfaceAttributeOutput, error) { +func (m *MockEC2Wrapper) ModifyNetworkInterfaceAttribute(arg0 *ec2.ModifyNetworkInterfaceAttributeInput) (*ec2.ModifyNetworkInterfaceAttributeOutput, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ModifyNetworkInterfaceAttribute", input) + ret := m.ctrl.Call(m, "ModifyNetworkInterfaceAttribute", arg0) ret0, _ := ret[0].(*ec2.ModifyNetworkInterfaceAttributeOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // ModifyNetworkInterfaceAttribute indicates an expected call of ModifyNetworkInterfaceAttribute. -func (mr *MockEC2WrapperMockRecorder) ModifyNetworkInterfaceAttribute(input interface{}) *gomock.Call { +func (mr *MockEC2WrapperMockRecorder) ModifyNetworkInterfaceAttribute(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyNetworkInterfaceAttribute", reflect.TypeOf((*MockEC2Wrapper)(nil).ModifyNetworkInterfaceAttribute), input) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyNetworkInterfaceAttribute", reflect.TypeOf((*MockEC2Wrapper)(nil).ModifyNetworkInterfaceAttribute), arg0) } // UnassignPrivateIPAddresses mocks base method. -func (m *MockEC2Wrapper) UnassignPrivateIPAddresses(input *ec2.UnassignPrivateIpAddressesInput) (*ec2.UnassignPrivateIpAddressesOutput, error) { +func (m *MockEC2Wrapper) UnassignPrivateIPAddresses(arg0 *ec2.UnassignPrivateIpAddressesInput) (*ec2.UnassignPrivateIpAddressesOutput, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "UnassignPrivateIPAddresses", input) + ret := m.ctrl.Call(m, "UnassignPrivateIPAddresses", arg0) ret0, _ := ret[0].(*ec2.UnassignPrivateIpAddressesOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // UnassignPrivateIPAddresses indicates an expected call of UnassignPrivateIPAddresses. -func (mr *MockEC2WrapperMockRecorder) UnassignPrivateIPAddresses(input interface{}) *gomock.Call { +func (mr *MockEC2WrapperMockRecorder) UnassignPrivateIPAddresses(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnassignPrivateIPAddresses", reflect.TypeOf((*MockEC2Wrapper)(nil).UnassignPrivateIPAddresses), input) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnassignPrivateIPAddresses", reflect.TypeOf((*MockEC2Wrapper)(nil).UnassignPrivateIPAddresses), arg0) } diff --git a/mocks/amazon-vcp-resource-controller-k8s/pkg/k8s/mock_k8swrapper.go b/mocks/amazon-vcp-resource-controller-k8s/pkg/k8s/mock_k8swrapper.go index 9a8000f5..8fab3025 100644 --- a/mocks/amazon-vcp-resource-controller-k8s/pkg/k8s/mock_k8swrapper.go +++ b/mocks/amazon-vcp-resource-controller-k8s/pkg/k8s/mock_k8swrapper.go @@ -12,7 +12,7 @@ // permissions and limitations under the License. // Code generated by MockGen. DO NOT EDIT. -// Source: github.com/aws/amazon-vpc-resource-controller-k8s/pkg/k8s/wrapper.go +// Source: github.com/aws/amazon-vpc-resource-controller-k8s/pkg/k8s (interfaces: K8sWrapper) // Package mock_k8s is a generated GoMock package. package mock_k8s @@ -55,162 +55,162 @@ func (m *MockK8sWrapper) EXPECT() *MockK8sWrapperMockRecorder { } // AddLabelToManageNode mocks base method. -func (m *MockK8sWrapper) AddLabelToManageNode(node *v10.Node, labelKey, labelValue string) (bool, error) { +func (m *MockK8sWrapper) AddLabelToManageNode(arg0 *v10.Node, arg1, arg2 string) (bool, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "AddLabelToManageNode", node, labelKey, labelValue) + ret := m.ctrl.Call(m, "AddLabelToManageNode", arg0, arg1, arg2) ret0, _ := ret[0].(bool) ret1, _ := ret[1].(error) return ret0, ret1 } // AddLabelToManageNode indicates an expected call of AddLabelToManageNode. -func (mr *MockK8sWrapperMockRecorder) AddLabelToManageNode(node, labelKey, labelValue interface{}) *gomock.Call { +func (mr *MockK8sWrapperMockRecorder) AddLabelToManageNode(arg0, arg1, arg2 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddLabelToManageNode", reflect.TypeOf((*MockK8sWrapper)(nil).AddLabelToManageNode), node, labelKey, labelValue) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddLabelToManageNode", reflect.TypeOf((*MockK8sWrapper)(nil).AddLabelToManageNode), arg0, arg1, arg2) } // AdvertiseCapacityIfNotSet mocks base method. -func (m *MockK8sWrapper) AdvertiseCapacityIfNotSet(nodeName, resourceName string, capacity int) error { +func (m *MockK8sWrapper) AdvertiseCapacityIfNotSet(arg0, arg1 string, arg2 int) error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "AdvertiseCapacityIfNotSet", nodeName, resourceName, capacity) + ret := m.ctrl.Call(m, "AdvertiseCapacityIfNotSet", arg0, arg1, arg2) ret0, _ := ret[0].(error) return ret0 } // AdvertiseCapacityIfNotSet indicates an expected call of AdvertiseCapacityIfNotSet. -func (mr *MockK8sWrapperMockRecorder) AdvertiseCapacityIfNotSet(nodeName, resourceName, capacity interface{}) *gomock.Call { +func (mr *MockK8sWrapperMockRecorder) AdvertiseCapacityIfNotSet(arg0, arg1, arg2 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AdvertiseCapacityIfNotSet", reflect.TypeOf((*MockK8sWrapper)(nil).AdvertiseCapacityIfNotSet), nodeName, resourceName, capacity) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AdvertiseCapacityIfNotSet", reflect.TypeOf((*MockK8sWrapper)(nil).AdvertiseCapacityIfNotSet), arg0, arg1, arg2) } // BroadcastEvent mocks base method. -func (m *MockK8sWrapper) BroadcastEvent(obj runtime.Object, reason, message, eventType string) { +func (m *MockK8sWrapper) BroadcastEvent(arg0 runtime.Object, arg1, arg2, arg3 string) { m.ctrl.T.Helper() - m.ctrl.Call(m, "BroadcastEvent", obj, reason, message, eventType) + m.ctrl.Call(m, "BroadcastEvent", arg0, arg1, arg2, arg3) } // BroadcastEvent indicates an expected call of BroadcastEvent. -func (mr *MockK8sWrapperMockRecorder) BroadcastEvent(obj, reason, message, eventType interface{}) *gomock.Call { +func (mr *MockK8sWrapperMockRecorder) BroadcastEvent(arg0, arg1, arg2, arg3 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BroadcastEvent", reflect.TypeOf((*MockK8sWrapper)(nil).BroadcastEvent), obj, reason, message, eventType) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BroadcastEvent", reflect.TypeOf((*MockK8sWrapper)(nil).BroadcastEvent), arg0, arg1, arg2, arg3) } // CreateCNINode mocks base method. -func (m *MockK8sWrapper) CreateCNINode(node *v10.Node, clusterName, nodeID string) error { +func (m *MockK8sWrapper) CreateCNINode(arg0 *v10.Node, arg1 string) error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateCNINode", node, clusterName, nodeID) + ret := m.ctrl.Call(m, "CreateCNINode", arg0, arg1) ret0, _ := ret[0].(error) return ret0 } // CreateCNINode indicates an expected call of CreateCNINode. -func (mr *MockK8sWrapperMockRecorder) CreateCNINode(node, clusterName, nodeID interface{}) *gomock.Call { +func (mr *MockK8sWrapperMockRecorder) CreateCNINode(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateCNINode", reflect.TypeOf((*MockK8sWrapper)(nil).CreateCNINode), node, clusterName, nodeID) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateCNINode", reflect.TypeOf((*MockK8sWrapper)(nil).CreateCNINode), arg0, arg1) } // DeleteCNINode mocks base method. -func (m *MockK8sWrapper) DeleteCNINode(cniNode *v1alpha10.CNINode) error { +func (m *MockK8sWrapper) DeleteCNINode(arg0 *v1alpha10.CNINode) error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteCNINode", cniNode) + ret := m.ctrl.Call(m, "DeleteCNINode", arg0) ret0, _ := ret[0].(error) return ret0 } // DeleteCNINode indicates an expected call of DeleteCNINode. -func (mr *MockK8sWrapperMockRecorder) DeleteCNINode(cniNode interface{}) *gomock.Call { +func (mr *MockK8sWrapperMockRecorder) DeleteCNINode(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteCNINode", reflect.TypeOf((*MockK8sWrapper)(nil).DeleteCNINode), cniNode) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteCNINode", reflect.TypeOf((*MockK8sWrapper)(nil).DeleteCNINode), arg0) } // GetCNINode mocks base method. -func (m *MockK8sWrapper) GetCNINode(namespacedName types.NamespacedName) (*v1alpha10.CNINode, error) { +func (m *MockK8sWrapper) GetCNINode(arg0 types.NamespacedName) (*v1alpha10.CNINode, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetCNINode", namespacedName) + ret := m.ctrl.Call(m, "GetCNINode", arg0) ret0, _ := ret[0].(*v1alpha10.CNINode) ret1, _ := ret[1].(error) return ret0, ret1 } // GetCNINode indicates an expected call of GetCNINode. -func (mr *MockK8sWrapperMockRecorder) GetCNINode(namespacedName interface{}) *gomock.Call { +func (mr *MockK8sWrapperMockRecorder) GetCNINode(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCNINode", reflect.TypeOf((*MockK8sWrapper)(nil).GetCNINode), namespacedName) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCNINode", reflect.TypeOf((*MockK8sWrapper)(nil).GetCNINode), arg0) } // GetConfigMap mocks base method. -func (m *MockK8sWrapper) GetConfigMap(configMapName, configMapNamespace string) (*v10.ConfigMap, error) { +func (m *MockK8sWrapper) GetConfigMap(arg0, arg1 string) (*v10.ConfigMap, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetConfigMap", configMapName, configMapNamespace) + ret := m.ctrl.Call(m, "GetConfigMap", arg0, arg1) ret0, _ := ret[0].(*v10.ConfigMap) ret1, _ := ret[1].(error) return ret0, ret1 } // GetConfigMap indicates an expected call of GetConfigMap. -func (mr *MockK8sWrapperMockRecorder) GetConfigMap(configMapName, configMapNamespace interface{}) *gomock.Call { +func (mr *MockK8sWrapperMockRecorder) GetConfigMap(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetConfigMap", reflect.TypeOf((*MockK8sWrapper)(nil).GetConfigMap), configMapName, configMapNamespace) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetConfigMap", reflect.TypeOf((*MockK8sWrapper)(nil).GetConfigMap), arg0, arg1) } // GetDaemonSet mocks base method. -func (m *MockK8sWrapper) GetDaemonSet(namespace, name string) (*v1.DaemonSet, error) { +func (m *MockK8sWrapper) GetDaemonSet(arg0, arg1 string) (*v1.DaemonSet, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetDaemonSet", namespace, name) + ret := m.ctrl.Call(m, "GetDaemonSet", arg0, arg1) ret0, _ := ret[0].(*v1.DaemonSet) ret1, _ := ret[1].(error) return ret0, ret1 } // GetDaemonSet indicates an expected call of GetDaemonSet. -func (mr *MockK8sWrapperMockRecorder) GetDaemonSet(namespace, name interface{}) *gomock.Call { +func (mr *MockK8sWrapperMockRecorder) GetDaemonSet(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDaemonSet", reflect.TypeOf((*MockK8sWrapper)(nil).GetDaemonSet), namespace, name) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDaemonSet", reflect.TypeOf((*MockK8sWrapper)(nil).GetDaemonSet), arg0, arg1) } // GetDeployment mocks base method. -func (m *MockK8sWrapper) GetDeployment(namespace, name string) (*v1.Deployment, error) { +func (m *MockK8sWrapper) GetDeployment(arg0, arg1 string) (*v1.Deployment, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetDeployment", namespace, name) + ret := m.ctrl.Call(m, "GetDeployment", arg0, arg1) ret0, _ := ret[0].(*v1.Deployment) ret1, _ := ret[1].(error) return ret0, ret1 } // GetDeployment indicates an expected call of GetDeployment. -func (mr *MockK8sWrapperMockRecorder) GetDeployment(namespace, name interface{}) *gomock.Call { +func (mr *MockK8sWrapperMockRecorder) GetDeployment(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDeployment", reflect.TypeOf((*MockK8sWrapper)(nil).GetDeployment), namespace, name) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDeployment", reflect.TypeOf((*MockK8sWrapper)(nil).GetDeployment), arg0, arg1) } // GetENIConfig mocks base method. -func (m *MockK8sWrapper) GetENIConfig(eniConfigName string) (*v1alpha1.ENIConfig, error) { +func (m *MockK8sWrapper) GetENIConfig(arg0 string) (*v1alpha1.ENIConfig, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetENIConfig", eniConfigName) + ret := m.ctrl.Call(m, "GetENIConfig", arg0) ret0, _ := ret[0].(*v1alpha1.ENIConfig) ret1, _ := ret[1].(error) return ret0, ret1 } // GetENIConfig indicates an expected call of GetENIConfig. -func (mr *MockK8sWrapperMockRecorder) GetENIConfig(eniConfigName interface{}) *gomock.Call { +func (mr *MockK8sWrapperMockRecorder) GetENIConfig(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetENIConfig", reflect.TypeOf((*MockK8sWrapper)(nil).GetENIConfig), eniConfigName) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetENIConfig", reflect.TypeOf((*MockK8sWrapper)(nil).GetENIConfig), arg0) } // GetNode mocks base method. -func (m *MockK8sWrapper) GetNode(nodeName string) (*v10.Node, error) { +func (m *MockK8sWrapper) GetNode(arg0 string) (*v10.Node, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetNode", nodeName) + ret := m.ctrl.Call(m, "GetNode", arg0) ret0, _ := ret[0].(*v10.Node) ret1, _ := ret[1].(error) return ret0, ret1 } // GetNode indicates an expected call of GetNode. -func (mr *MockK8sWrapperMockRecorder) GetNode(nodeName interface{}) *gomock.Call { +func (mr *MockK8sWrapperMockRecorder) GetNode(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNode", reflect.TypeOf((*MockK8sWrapper)(nil).GetNode), nodeName) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNode", reflect.TypeOf((*MockK8sWrapper)(nil).GetNode), arg0) } // ListCNINodes mocks base method. @@ -229,18 +229,18 @@ func (mr *MockK8sWrapperMockRecorder) ListCNINodes() *gomock.Call { } // ListEvents mocks base method. -func (m *MockK8sWrapper) ListEvents(ops []client.ListOption) (*v11.EventList, error) { +func (m *MockK8sWrapper) ListEvents(arg0 []client.ListOption) (*v11.EventList, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ListEvents", ops) + ret := m.ctrl.Call(m, "ListEvents", arg0) ret0, _ := ret[0].(*v11.EventList) ret1, _ := ret[1].(error) return ret0, ret1 } // ListEvents indicates an expected call of ListEvents. -func (mr *MockK8sWrapperMockRecorder) ListEvents(ops interface{}) *gomock.Call { +func (mr *MockK8sWrapperMockRecorder) ListEvents(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListEvents", reflect.TypeOf((*MockK8sWrapper)(nil).ListEvents), ops) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListEvents", reflect.TypeOf((*MockK8sWrapper)(nil).ListEvents), arg0) } // ListNodes mocks base method. @@ -259,15 +259,15 @@ func (mr *MockK8sWrapperMockRecorder) ListNodes() *gomock.Call { } // PatchCNINode mocks base method. -func (m *MockK8sWrapper) PatchCNINode(oldCNINode, newCNINode *v1alpha10.CNINode) error { +func (m *MockK8sWrapper) PatchCNINode(arg0, arg1 *v1alpha10.CNINode) error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "PatchCNINode", oldCNINode, newCNINode) + ret := m.ctrl.Call(m, "PatchCNINode", arg0, arg1) ret0, _ := ret[0].(error) return ret0 } // PatchCNINode indicates an expected call of PatchCNINode. -func (mr *MockK8sWrapperMockRecorder) PatchCNINode(oldCNINode, newCNINode interface{}) *gomock.Call { +func (mr *MockK8sWrapperMockRecorder) PatchCNINode(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PatchCNINode", reflect.TypeOf((*MockK8sWrapper)(nil).PatchCNINode), oldCNINode, newCNINode) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PatchCNINode", reflect.TypeOf((*MockK8sWrapper)(nil).PatchCNINode), arg0, arg1) } diff --git a/pkg/aws/ec2/api/cleanup/eni_cleanup.go b/pkg/aws/ec2/api/cleanup/eni_cleanup.go index b80088d7..19047c81 100644 --- a/pkg/aws/ec2/api/cleanup/eni_cleanup.go +++ b/pkg/aws/ec2/api/cleanup/eni_cleanup.go @@ -99,7 +99,7 @@ func (e *ClusterENICleaner) Start(ctx context.Context) error { // Perform ENI cleanup after fixed time intervals till shut down variable is set to true on receiving the shutdown // signal for !e.shutdown { - e.DeleteLeakedResources(ctx) + e.DeleteLeakedResources() time.Sleep(config.ENICleanUpInterval) } @@ -110,7 +110,7 @@ func (e *ClusterENICleaner) Start(ctx context.Context) error { // This is called by periodically by ClusterENICleaner which deletes available ENIs cluster-wide, and by the NodeTermination cleaner on node termination // The available ENIs are deleted if ShouldDeleteENI is true, defined in the respective cleaners // The function also updates metrics for the periodic cleanup routine and the node termination cleanup -func (e *ENICleaner) DeleteLeakedResources(ctx context.Context) error { +func (e *ENICleaner) DeleteLeakedResources() error { var errors []error availableENIs := make(map[string]struct{}) vpcrcAvailableCount := 0 @@ -140,7 +140,7 @@ func (e *ENICleaner) DeleteLeakedResources(ctx context.Context) error { Filters: filterCopy, } - tempNetworkInterfaces, err := e.EC2Wrapper.DescribeNetworkInterfacesPages(ctx, describeNetworkInterfaceIp) + tempNetworkInterfaces, err := e.EC2Wrapper.DescribeNetworkInterfacesPagesWithRetry(describeNetworkInterfaceIp) if err != nil { e.Log.Error(err, "failed to describe network interfaces, cleanup will be retried in next cycle") return err @@ -151,7 +151,7 @@ func (e *ENICleaner) DeleteLeakedResources(ctx context.Context) error { describeNetworkInterfaceIp := &ec2.DescribeNetworkInterfacesInput{ Filters: filters, } - networkInterfaces, err = e.EC2Wrapper.DescribeNetworkInterfacesPages(ctx, describeNetworkInterfaceIp) + networkInterfaces, err = e.EC2Wrapper.DescribeNetworkInterfacesPagesWithRetry(describeNetworkInterfaceIp) if err != nil { e.Log.Error(err, "failed to describe network interfaces, cleanup will be retried in next cycle") return err @@ -174,7 +174,7 @@ func (e *ENICleaner) DeleteLeakedResources(ctx context.Context) error { continue } } - _, err := e.EC2Wrapper.DeleteNetworkInterface(ctx, &ec2.DeleteNetworkInterfaceInput{ + _, err := e.EC2Wrapper.DeleteNetworkInterface(&ec2.DeleteNetworkInterfaceInput{ NetworkInterfaceId: nwInterface.NetworkInterfaceId, }) if err != nil { diff --git a/pkg/aws/ec2/api/cleanup/eni_cleanup_test.go b/pkg/aws/ec2/api/cleanup/eni_cleanup_test.go index 6904099a..5c02ff46 100644 --- a/pkg/aws/ec2/api/cleanup/eni_cleanup_test.go +++ b/pkg/aws/ec2/api/cleanup/eni_cleanup_test.go @@ -163,37 +163,32 @@ func TestENICleaner_DeleteLeakedResources(t *testing.T) { filtersWithFirstTag := append(append(commonFilters, vpcFilter), firstOrFilter) filtersWithSecondTag := append(append(commonFilters, vpcFilter), secondOrFilter) gomock.InOrder( - f.mockEC2Wrapper.EXPECT().DescribeNetworkInterfacesPages( - context.TODO(), + f.mockEC2Wrapper.EXPECT().DescribeNetworkInterfacesPagesWithRetry( &ec2.DescribeNetworkInterfacesInput{ Filters: filtersWithFirstTag, }, ).Return(NetworkInterfacesWith1And2, nil), - f.mockEC2Wrapper.EXPECT().DescribeNetworkInterfacesPages( - context.TODO(), + f.mockEC2Wrapper.EXPECT().DescribeNetworkInterfacesPagesWithRetry( &ec2.DescribeNetworkInterfacesInput{ Filters: filtersWithSecondTag, }, ).Return([]*ec2types.NetworkInterface{}, nil), // Return network interface 1 and 3 in the second cycle - f.mockEC2Wrapper.EXPECT().DescribeNetworkInterfacesPages( - context.TODO(), + f.mockEC2Wrapper.EXPECT().DescribeNetworkInterfacesPagesWithRetry( &ec2.DescribeNetworkInterfacesInput{ Filters: filtersWithFirstTag, }, ).Return(NetworkInterfacesWith1And3, nil), - f.mockEC2Wrapper.EXPECT().DescribeNetworkInterfacesPages( - context.TODO(), + f.mockEC2Wrapper.EXPECT().DescribeNetworkInterfacesPagesWithRetry( &ec2.DescribeNetworkInterfacesInput{ Filters: filtersWithSecondTag, }, ).Return([]*ec2types.NetworkInterface{}, nil), f.mockEC2Wrapper.EXPECT().DeleteNetworkInterface( - context.TODO(), &ec2.DeleteNetworkInterfaceInput{NetworkInterfaceId: &mockNetworkInterfaceId1}, ).Return(nil, nil), ) @@ -226,22 +221,18 @@ func TestENICleaner_DeleteLeakedResources(t *testing.T) { gomock.InOrder( // Return network interface 1 and 2 in first cycle, expect to call delete on both - f.mockEC2Wrapper.EXPECT().DescribeNetworkInterfacesPages(context.TODO(), mockNodeIDTagInput). + f.mockEC2Wrapper.EXPECT().DescribeNetworkInterfacesPagesWithRetry(mockNodeIDTagInput). Return(NetworkInterfacesWith1And2, nil), f.mockEC2Wrapper.EXPECT().DeleteNetworkInterface( - context.TODO(), &ec2.DeleteNetworkInterfaceInput{NetworkInterfaceId: &mockNetworkInterfaceId1}).Return(nil, nil), f.mockEC2Wrapper.EXPECT().DeleteNetworkInterface( - context.TODO(), &ec2.DeleteNetworkInterfaceInput{NetworkInterfaceId: &mockNetworkInterfaceId2}).Return(nil, nil), // Return network interface 1 and 3 in the second cycle, again expect to call delete on both - f.mockEC2Wrapper.EXPECT().DescribeNetworkInterfacesPages(context.TODO(), mockNodeIDTagInput). + f.mockEC2Wrapper.EXPECT().DescribeNetworkInterfacesPagesWithRetry(mockNodeIDTagInput). Return(NetworkInterfacesWith1And3, nil), f.mockEC2Wrapper.EXPECT().DeleteNetworkInterface( - context.TODO(), &ec2.DeleteNetworkInterfaceInput{NetworkInterfaceId: &mockNetworkInterfaceId1}).Return(nil, nil), f.mockEC2Wrapper.EXPECT().DeleteNetworkInterface( - context.TODO(), &ec2.DeleteNetworkInterfaceInput{NetworkInterfaceId: &mockNetworkInterfaceId3}).Return(nil, nil), ) }, @@ -266,13 +257,13 @@ func TestENICleaner_DeleteLeakedResources(t *testing.T) { tt.prepare(&f) } - err := mockENICleaner.DeleteLeakedResources(context.TODO()) + err := mockENICleaner.DeleteLeakedResources() assert.NoError(t, err) if tt.assertFirstCall != nil { tt.assertFirstCall(&f) } - err = mockENICleaner.DeleteLeakedResources(context.TODO()) + err = mockENICleaner.DeleteLeakedResources() assert.NoError(t, err) if tt.assertSecondCall != nil { tt.assertSecondCall(&f) diff --git a/pkg/aws/ec2/api/cleanup/node_cleanup.go b/pkg/aws/ec2/api/cleanup/node_cleanup.go index 0fb40d78..4c16a33d 100644 --- a/pkg/aws/ec2/api/cleanup/node_cleanup.go +++ b/pkg/aws/ec2/api/cleanup/node_cleanup.go @@ -18,7 +18,7 @@ import ( "github.com/aws/amazon-vpc-resource-controller-k8s/pkg/config" "github.com/aws/aws-sdk-go-v2/aws" ec2types "github.com/aws/aws-sdk-go-v2/service/ec2/types" - "github.com/go-logr/logr" + ctrl "sigs.k8s.io/controller-runtime" ) // NodeTerminationCleanerto handle resource cleanup at node termination @@ -51,7 +51,7 @@ func (n *NodeTerminationCleaner) UpdateCleanupMetrics(vpcrcAvailableCount *int, return } -func NewNodeResourceCleaner(nodeID string, eC2Wrapper ec2API.EC2Wrapper, vpcID string, log logr.Logger) ResourceCleaner { +func NewNodeResourceCleaner(nodeID string, eC2Wrapper ec2API.EC2Wrapper, vpcID string) ResourceCleaner { cleaner := &NodeTerminationCleaner{ NodeID: nodeID, } @@ -59,7 +59,7 @@ func NewNodeResourceCleaner(nodeID string, eC2Wrapper ec2API.EC2Wrapper, vpcID s EC2Wrapper: eC2Wrapper, Manager: cleaner, VpcId: vpcID, - Log: log.WithName("eniCleaner").WithName("node"), + Log: ctrl.Log.WithName("eniCleaner").WithName("node"), } return cleaner.ENICleaner } diff --git a/pkg/aws/ec2/api/cleanup/resource_cleaner.go b/pkg/aws/ec2/api/cleanup/resource_cleaner.go index 58c60f06..d5c7e6d1 100644 --- a/pkg/aws/ec2/api/cleanup/resource_cleaner.go +++ b/pkg/aws/ec2/api/cleanup/resource_cleaner.go @@ -13,9 +13,7 @@ package cleanup -import "context" - // ResourceCleaner interface should be implemented by components that need to delete leaked AWS resources type ResourceCleaner interface { - DeleteLeakedResources(ctx context.Context) error + DeleteLeakedResources() error } diff --git a/pkg/aws/ec2/api/helper.go b/pkg/aws/ec2/api/helper.go index 442c93a7..ddc02b48 100644 --- a/pkg/aws/ec2/api/helper.go +++ b/pkg/aws/ec2/api/helper.go @@ -14,7 +14,6 @@ package api import ( - "context" "fmt" "time" @@ -209,7 +208,7 @@ func (h *ec2APIHelper) DeleteNetworkInterface(interfaceId *string) error { } err := retry.OnError(defaultBackOff, func(err error) bool { return true }, func() error { - _, err := h.ec2Wrapper.DeleteNetworkInterface(context.TODO(), deleteNetworkInterface) + _, err := h.ec2Wrapper.DeleteNetworkInterface(deleteNetworkInterface) return err }) diff --git a/pkg/aws/ec2/api/helper_test.go b/pkg/aws/ec2/api/helper_test.go index c2376ed0..d3dfd8f8 100644 --- a/pkg/aws/ec2/api/helper_test.go +++ b/pkg/aws/ec2/api/helper_test.go @@ -14,7 +14,6 @@ package api import ( - "context" "fmt" "testing" "time" @@ -553,7 +552,7 @@ func TestEc2APIHelper_DeleteNetworkInterface(t *testing.T) { ec2ApiHelper, mockWrapper := getMockWrapper(ctrl) - mockWrapper.EXPECT().DeleteNetworkInterface(context.TODO(), deleteNetworkInterfaceInput).Return(nil, nil) + mockWrapper.EXPECT().DeleteNetworkInterface(deleteNetworkInterfaceInput).Return(nil, nil) err := ec2ApiHelper.DeleteNetworkInterface(&branchInterfaceId) assert.NoError(t, err) @@ -567,7 +566,7 @@ func TestEc2APIHelper_DeleteNetworkInterface_Error(t *testing.T) { ec2ApiHelper, mockWrapper := getMockWrapper(ctrl) - mockWrapper.EXPECT().DeleteNetworkInterface(context.TODO(), deleteNetworkInterfaceInput).Return(nil, errMock).Times(maxRetryOnError) + mockWrapper.EXPECT().DeleteNetworkInterface(deleteNetworkInterfaceInput).Return(nil, errMock).Times(maxRetryOnError) err := ec2ApiHelper.DeleteNetworkInterface(&branchInterfaceId) assert.Error(t, errMock, err) @@ -582,8 +581,8 @@ func TestEc2APIHelper_DeleteNetworkInterface_ErrorThenSuccess(t *testing.T) { ec2ApiHelper, mockWrapper := getMockWrapper(ctrl) gomock.InOrder( - mockWrapper.EXPECT().DeleteNetworkInterface(context.TODO(), deleteNetworkInterfaceInput).Return(nil, errMock).Times(2), - mockWrapper.EXPECT().DeleteNetworkInterface(context.TODO(), deleteNetworkInterfaceInput).Return(nil, nil).Times(1), + mockWrapper.EXPECT().DeleteNetworkInterface(deleteNetworkInterfaceInput).Return(nil, errMock).Times(2), + mockWrapper.EXPECT().DeleteNetworkInterface(deleteNetworkInterfaceInput).Return(nil, nil).Times(1), ) err := ec2ApiHelper.DeleteNetworkInterface(&branchInterfaceId) @@ -772,7 +771,7 @@ func TestEc2APIHelper_CreateAndAttachNetworkInterface_DeleteOnAttachFailed(t *te mockWrapper.EXPECT().AttachNetworkInterface(attachNetworkInterfaceInput).Return(attachNetworkInterfaceOutput, errMock) // Test delete is called - mockWrapper.EXPECT().DeleteNetworkInterface(context.TODO(), deleteNetworkInterfaceInput).Return(nil, nil) + mockWrapper.EXPECT().DeleteNetworkInterface(deleteNetworkInterfaceInput).Return(nil, nil) nwInterface, err := ec2ApiHelper.CreateAndAttachNetworkInterface(&instanceId, &subnetId, securityGroups, tags, &deviceIndex, &eniDescription, nil, nil) @@ -797,7 +796,7 @@ func TestEc2APIHelper_CreateAndAttachNetworkInterface_DeleteOnSetTerminationFail mockWrapper.EXPECT().DetachNetworkInterface(detachNetworkInterfaceInput).Return(nil, nil) mockWrapper.EXPECT().DescribeNetworkInterfaces(describeNetworkInterfaceInputUsingOneInterfaceId). Return(describeNetworkInterfaceOutputUsingOneInterfaceId, nil) - mockWrapper.EXPECT().DeleteNetworkInterface(context.TODO(), deleteNetworkInterfaceInput).Return(nil, nil) + mockWrapper.EXPECT().DeleteNetworkInterface(deleteNetworkInterfaceInput).Return(nil, nil) nwInterface, err := ec2ApiHelper.CreateAndAttachNetworkInterface(&instanceId, &subnetId, securityGroups, tags, &deviceIndex, &eniDescription, nil, nil) @@ -945,7 +944,7 @@ func TestEc2APIHelper_DetachAndDeleteNetworkInterface(t *testing.T) { mockWrapper.EXPECT().DetachNetworkInterface(detachNetworkInterfaceInput).Return(nil, nil) mockWrapper.EXPECT().DescribeNetworkInterfaces(describeNetworkInterfaceInputUsingOneInterfaceId). Return(describeNetworkInterfaceOutputUsingOneInterfaceId, nil) - mockWrapper.EXPECT().DeleteNetworkInterface(context.TODO(), deleteNetworkInterfaceInput).Return(nil, nil) + mockWrapper.EXPECT().DeleteNetworkInterface(deleteNetworkInterfaceInput).Return(nil, nil) err := ec2ApiHelper.DetachAndDeleteNetworkInterface(&attachmentId, &branchInterfaceId) assert.NoError(t, err) diff --git a/pkg/aws/ec2/api/wrapper.go b/pkg/aws/ec2/api/wrapper.go index ee00fe9d..45377b2f 100644 --- a/pkg/aws/ec2/api/wrapper.go +++ b/pkg/aws/ec2/api/wrapper.go @@ -15,6 +15,7 @@ package api import ( "context" + "errors" "fmt" "net/http" "strings" @@ -22,6 +23,7 @@ import ( vpc_rc_config "github.com/aws/amazon-vpc-resource-controller-k8s/pkg/config" "github.com/aws/amazon-vpc-resource-controller-k8s/pkg/utils" + "k8s.io/apimachinery/pkg/util/wait" "github.com/aws/amazon-vpc-resource-controller-k8s/pkg/version" smithymiddleware "github.com/aws/smithy-go/middleware" @@ -33,6 +35,7 @@ import ( "github.com/aws/aws-sdk-go-v2/config" "github.com/aws/aws-sdk-go-v2/credentials/stscreds" "github.com/aws/aws-sdk-go-v2/feature/ec2/imds" + "github.com/aws/smithy-go" "github.com/aws/aws-sdk-go-v2/service/ec2" ec2types "github.com/aws/aws-sdk-go-v2/service/ec2/types" @@ -55,11 +58,11 @@ type EC2Wrapper interface { CreateNetworkInterface(input *ec2.CreateNetworkInterfaceInput) (*ec2.CreateNetworkInterfaceOutput, error) AttachNetworkInterface(input *ec2.AttachNetworkInterfaceInput) (*ec2.AttachNetworkInterfaceOutput, error) DetachNetworkInterface(input *ec2.DetachNetworkInterfaceInput) (*ec2.DetachNetworkInterfaceOutput, error) - DeleteNetworkInterface(ctx context.Context, input *ec2.DeleteNetworkInterfaceInput) (*ec2.DeleteNetworkInterfaceOutput, error) + DeleteNetworkInterface(input *ec2.DeleteNetworkInterfaceInput) (*ec2.DeleteNetworkInterfaceOutput, error) AssignPrivateIPAddresses(input *ec2.AssignPrivateIpAddressesInput) (*ec2.AssignPrivateIpAddressesOutput, error) UnassignPrivateIPAddresses(input *ec2.UnassignPrivateIpAddressesInput) (*ec2.UnassignPrivateIpAddressesOutput, error) DescribeNetworkInterfaces(input *ec2.DescribeNetworkInterfacesInput) (*ec2.DescribeNetworkInterfacesOutput, error) - DescribeNetworkInterfacesPages(ctx context.Context, input *ec2.DescribeNetworkInterfacesInput) ([]*ec2types.NetworkInterface, error) + DescribeNetworkInterfacesPagesWithRetry(input *ec2.DescribeNetworkInterfacesInput) ([]*ec2types.NetworkInterface, error) CreateTags(input *ec2.CreateTagsInput) (*ec2.CreateTagsOutput, error) DescribeSubnets(input *ec2.DescribeSubnetsInput) (*ec2.DescribeSubnetsOutput, error) AssociateTrunkInterface(input *ec2.AssociateTrunkInterfaceInput) (*ec2.AssociateTrunkInterfaceOutput, error) @@ -664,9 +667,9 @@ func (e *ec2Wrapper) AttachNetworkInterface(input *ec2.AttachNetworkInterfaceInp return attachNetworkInterfaceOutput, err } -func (e *ec2Wrapper) DeleteNetworkInterface(ctx context.Context, input *ec2.DeleteNetworkInterfaceInput) (*ec2.DeleteNetworkInterfaceOutput, error) { +func (e *ec2Wrapper) DeleteNetworkInterface(input *ec2.DeleteNetworkInterfaceInput) (*ec2.DeleteNetworkInterfaceOutput, error) { start := time.Now() - deleteNetworkInterfaceOutput, err := e.userServiceClient.DeleteNetworkInterface(ctx, input) + deleteNetworkInterfaceOutput, err := e.userServiceClient.DeleteNetworkInterface(context.TODO(), input) ec2APICallLatencies.WithLabelValues("delete_network_interface").Observe(timeSinceMs(start)) // Metric updates @@ -717,7 +720,7 @@ func (e *ec2Wrapper) DescribeNetworkInterfaces(input *ec2.DescribeNetworkInterfa // DescribeNetworkInterfacesPagesWithRetry returns network interfaces that match the filters specified in the input // with retry mechanism for handling API throttling -func (e *ec2Wrapper) DescribeNetworkInterfacesPages(ctx context.Context, input *ec2.DescribeNetworkInterfacesInput) ([]*ec2types.NetworkInterface, error) { +func (e *ec2Wrapper) DescribeNetworkInterfacesPagesWithRetry(input *ec2.DescribeNetworkInterfacesInput) ([]*ec2types.NetworkInterface, error) { if input.MaxResults == nil { input.MaxResults = aws.Int32(int32(vpc_rc_config.DescribeNetworkInterfacesMaxResults)) } @@ -727,29 +730,50 @@ func (e *ec2Wrapper) DescribeNetworkInterfacesPages(ctx context.Context, input * ec2APICallLatencies.WithLabelValues("describe_network_interfaces_pages").Observe(timeSinceMs(start)) }() - nwInterfaces := make([]*ec2types.NetworkInterface, 0, vpc_rc_config.DescribeNetworkInterfacesMaxResults) + var apiError error + for attempt := 1; attempt <= MaxRetries; attempt++ { + attemptInterfaces := make([]*ec2types.NetworkInterface, 0, vpc_rc_config.DescribeNetworkInterfacesMaxResults) + + paginator := ec2.NewDescribeNetworkInterfacesPaginator(e.userServiceClient, input) + + for paginator.HasMorePages() { + output, err := paginator.NextPage(context.TODO()) + if err != nil { + ec2APIErrCnt.Inc() + ec2DescribeNetworkInterfacesPagesAPIErrCnt.Inc() + apiError = err + + var ae smithy.APIError + if errors.As(err, &ae) && ae.ErrorCode() == "Throttling" && attempt < MaxRetries { + e.log.Info("Throttling error, will retry", "attempt", attempt) + backoff := time.Duration(attempt) * 500 * time.Millisecond + time.Sleep(wait.Jitter(backoff, 0.1)) + goto Retry + } + return nil, err + } + + ec2APICallCnt.Inc() + ec2DescribeNetworkInterfacesPagesAPICallCnt.Inc() + + for _, nwInterface := range output.NetworkInterfaces { + attemptInterfaces = append(attemptInterfaces, &ec2types.NetworkInterface{ + NetworkInterfaceId: nwInterface.NetworkInterfaceId, + TagSet: nwInterface.TagSet, + Attachment: nwInterface.Attachment, + }) + } + + time.Sleep(wait.Jitter(100*time.Millisecond, 0.2)) + } - paginator := ec2.NewDescribeNetworkInterfacesPaginator(e.userServiceClient, input) + return attemptInterfaces, nil - for paginator.HasMorePages() { - output, err := paginator.NextPage(ctx) - if err != nil { - ec2APIErrCnt.Inc() - ec2DescribeNetworkInterfacesPagesAPIErrCnt.Inc() - return nil, err - } - ec2APICallCnt.Inc() - ec2DescribeNetworkInterfacesPagesAPICallCnt.Inc() - - for _, nwInterface := range output.NetworkInterfaces { - nwInterfaces = append(nwInterfaces, &ec2types.NetworkInterface{ - NetworkInterfaceId: nwInterface.NetworkInterfaceId, - TagSet: nwInterface.TagSet, - Attachment: nwInterface.Attachment, - }) - } + Retry: + continue } - return nwInterfaces, nil + + return nil, apiError } func (e *ec2Wrapper) AssignPrivateIPAddresses(input *ec2.AssignPrivateIpAddressesInput) (*ec2.AssignPrivateIpAddressesOutput, error) { diff --git a/pkg/config/type.go b/pkg/config/type.go index b14e2130..f658fc49 100644 --- a/pkg/config/type.go +++ b/pkg/config/type.go @@ -118,10 +118,9 @@ const ( // customized configurations for BigCache const ( - InstancesCacheTTL = 30 * time.Minute // scaling < 1k nodes should be under 20 minutes - InstancesCacheShards = 32 // must be power of 2 - InstancesCacheMaxSize = 2 // in MB - NodeTerminationTimeout = 3 * time.Minute + InstancesCacheTTL = 30 * time.Minute // scaling < 1k nodes should be under 20 minutes + InstancesCacheShards = 32 // must be power of 2 + InstancesCacheMaxSize = 2 // in MB ) var ( diff --git a/pkg/k8s/wrapper.go b/pkg/k8s/wrapper.go index 9acf7e5b..ffd46662 100644 --- a/pkg/k8s/wrapper.go +++ b/pkg/k8s/wrapper.go @@ -15,6 +15,7 @@ package k8s import ( "context" + "fmt" "strconv" "github.com/aws/amazon-vpc-cni-k8s/pkg/apis/crd/v1alpha1" @@ -80,7 +81,7 @@ type K8sWrapper interface { AddLabelToManageNode(node *v1.Node, labelKey string, labelValue string) (bool, error) ListEvents(ops []client.ListOption) (*eventsv1.EventList, error) GetCNINode(namespacedName types.NamespacedName) (*rcv1alpha1.CNINode, error) - CreateCNINode(node *v1.Node, clusterName string, nodeID string) error + CreateCNINode(node *v1.Node, clusterName string) error ListCNINodes() ([]*rcv1alpha1.CNINode, error) PatchCNINode(oldCNINode, newCNINode *rcv1alpha1.CNINode) error DeleteCNINode(cniNode *rcv1alpha1.CNINode) error @@ -236,7 +237,7 @@ func (k *k8sWrapper) GetCNINode(namespacedName types.NamespacedName) (*rcv1alpha return cninode, nil } -func (k *k8sWrapper) CreateCNINode(node *v1.Node, clusterName string, nodeID string) error { +func (k *k8sWrapper) CreateCNINode(node *v1.Node, clusterName string) error { cniNode := &rcv1alpha1.CNINode{ ObjectMeta: metav1.ObjectMeta{ Name: node.Name, @@ -259,8 +260,7 @@ func (k *k8sWrapper) CreateCNINode(node *v1.Node, clusterName string, nodeID str }, Spec: rcv1alpha1.CNINodeSpec{ Tags: map[string]string{ - config.VPCCNIClusterNameKey: clusterName, - config.NetworkInterfaceNodeIDKey: nodeID, + fmt.Sprintf(config.VPCCNIClusterNameKey): clusterName, }, }, } diff --git a/pkg/k8s/wrapper_test.go b/pkg/k8s/wrapper_test.go index addc1c5c..00c63fc2 100644 --- a/pkg/k8s/wrapper_test.go +++ b/pkg/k8s/wrapper_test.go @@ -38,7 +38,6 @@ import ( var ( nodeName = "node-name" mockClusterName = "cluster-name" - mockNodeID = "i-123456789" mockResourceName = config.ResourceNamePodENI existingResource = "extended-resource" @@ -201,25 +200,22 @@ func TestK8sWrapper_CreateCNINodeWithExistedObject_NoError(t *testing.T) { ctrl := gomock.NewController(t) wrapper, _, _ := getMockK8sWrapperWithClient(ctrl, []runtime.Object{mockCNINode}) - err := wrapper.CreateCNINode(mockNode, mockClusterName, mockNodeID) + err := wrapper.CreateCNINode(mockNode, mockClusterName) assert.NoError(t, err) cniNode, err := wrapper.GetCNINode(types.NamespacedName{Name: mockNode.Name}) assert.NoError(t, err) assert.Equal(t, mockNode.Name, cniNode.Name) - err = wrapper.CreateCNINode(mockNode, mockClusterName, mockNodeID) + err = wrapper.CreateCNINode(mockNode, mockClusterName) assert.NoError(t, err) } func TestK8sWrapper_CreateCNINode_NoError(t *testing.T) { ctrl := gomock.NewController(t) - wrapper, _, _ := getMockK8sWrapperWithClient(ctrl, []runtime.Object{}) + wrapper, _, _ := getMockK8sWrapperWithClient(ctrl, []runtime.Object{mockCNINode}) - err := wrapper.CreateCNINode(mockNode, mockClusterName, mockNodeID) + err := wrapper.CreateCNINode(mockNode, mockClusterName) assert.NoError(t, err) cniNode, err := wrapper.GetCNINode(types.NamespacedName{Name: mockNode.Name}) assert.NoError(t, err) assert.Equal(t, mockNode.Name, cniNode.Name) - assert.Equal(t, mockNodeID, cniNode.Spec.Tags[config.NetworkInterfaceNodeIDKey]) - assert.Equal(t, mockClusterName, cniNode.Spec.Tags[config.VPCCNIClusterNameKey]) - assert.Contains(t, cniNode.Finalizers, config.NodeTerminationFinalizer) } diff --git a/pkg/node/manager/manager.go b/pkg/node/manager/manager.go index 560e4c41..d9d14b1a 100644 --- a/pkg/node/manager/manager.go +++ b/pkg/node/manager/manager.go @@ -229,12 +229,8 @@ func (m *manager) CreateCNINodeIfNotExisting(node *v1.Node) error { types.NamespacedName{Name: node.Name}, ); err != nil { if apierrors.IsNotFound(err) { - nodeID, err := utils.GetNodeID(node) - if err != nil { - m.Log.Error(err, "failed to get node ID") - } m.Log.Info("Will create a new CNINode", "CNINodeName", node.Name) - return m.wrapper.K8sAPI.CreateCNINode(node, m.clusterName, nodeID) + return m.wrapper.K8sAPI.CreateCNINode(node, m.clusterName) } return err } else { diff --git a/pkg/node/manager/manager_test.go b/pkg/node/manager/manager_test.go index fd6c917c..bab5db98 100644 --- a/pkg/node/manager/manager_test.go +++ b/pkg/node/manager/manager_test.go @@ -204,7 +204,7 @@ func Test_AddNode_CNINode_Existing(t *testing.T) { mock.MockK8sAPI.EXPECT().GetNode(nodeName).Return(v1Node, nil).Times(1) mock.MockWorker.EXPECT().SubmitJob(gomock.All(NewAsyncOperationMatcher(expectedJob))) - mock.MockK8sAPI.EXPECT().CreateCNINode(v1Node, mockClusterName, instanceID).Return(nil).Times(0) + mock.MockK8sAPI.EXPECT().CreateCNINode(v1Node, mockClusterName).Return(nil).Times(0) mock.MockK8sAPI.EXPECT().GetCNINode(types.NamespacedName{Name: v1Node.Name}).Return(&rcV1alpha1.CNINode{}, nil).Times(2) err := mock.Manager.AddNode(nodeName) @@ -227,7 +227,7 @@ func Test_AddNode_CNINode_Not_Existing(t *testing.T) { mock.MockK8sAPI.EXPECT().GetNode(nodeName).Return(v1Node, nil).Times(1) mock.MockWorker.EXPECT().SubmitJob(gomock.All(NewAsyncOperationMatcher(expectedJob))) - mock.MockK8sAPI.EXPECT().CreateCNINode(v1Node, mock.Manager.clusterName, instanceID).Return(nil).Times(1) + mock.MockK8sAPI.EXPECT().CreateCNINode(v1Node, mock.Manager.clusterName).Return(nil).Times(1) mock.MockK8sAPI.EXPECT().GetCNINode(types.NamespacedName{Name: v1Node.Name}).Return( &rcV1alpha1.CNINode{}, apierrors.NewNotFound(schema.GroupResource{Group: "vpcresources.k8s.aws", Resource: "1"}, "test")). Times(2) @@ -248,7 +248,7 @@ func Test_AddNode_UnManaged(t *testing.T) { nodeWithoutLabel.Labels = map[string]string{} mock.MockK8sAPI.EXPECT().GetNode(nodeName).Return(nodeWithoutLabel, nil).Times(1) - mock.MockK8sAPI.EXPECT().CreateCNINode(nodeWithoutLabel, mock.Manager.clusterName, instanceID).Return(nil).Times(1) + mock.MockK8sAPI.EXPECT().CreateCNINode(nodeWithoutLabel, mock.Manager.clusterName).Return(nil).Times(1) mock.MockK8sAPI.EXPECT().GetCNINode(types.NamespacedName{Name: nodeWithoutLabel.Name}).Return( &rcV1alpha1.CNINode{}, apierrors.NewNotFound(schema.GroupResource{Group: "vpcresources.k8s.aws", Resource: "1"}, "test")). Times(1) // unmanaged node won't check custom networking subnets and call GetCNINode only once @@ -290,7 +290,7 @@ func Test_AddNode_CustomNetworking_CNINode(t *testing.T) { mock.MockK8sAPI.EXPECT().GetNode(nodeName).Return(nodeWithENIConfig, nil) mock.MockK8sAPI.EXPECT().GetENIConfig(eniConfigName).Return(eniConfig, nil).Times(1) mock.MockWorker.EXPECT().SubmitJob(gomock.All(NewAsyncOperationMatcher(job))) - mock.MockK8sAPI.EXPECT().CreateCNINode(nodeWithENIConfig, mock.Manager.clusterName, instanceID).Return(nil).Times(1) + mock.MockK8sAPI.EXPECT().CreateCNINode(nodeWithENIConfig, mock.Manager.clusterName).Return(nil).Times(1) mock.MockK8sAPI.EXPECT().GetCNINode(types.NamespacedName{Name: nodeWithENIConfig.Name}).Return(&rcV1alpha1.CNINode{ Spec: rcV1alpha1.CNINodeSpec{ Features: []rcV1alpha1.Feature{{Name: rcV1alpha1.CustomNetworking, Value: eniConfigName}}, @@ -330,7 +330,7 @@ func Test_AddNode_CustomNetworking_CNINode_No_EniConfigName(t *testing.T) { mock.MockK8sAPI.EXPECT().BroadcastEvent(nodeWithENIConfig, utils.EniConfigNameNotFoundReason, msg, v1.EventTypeWarning).Times(1) mock.MockK8sAPI.EXPECT().GetENIConfig(eniConfigName).Return(eniConfig, nil).Times(0) mock.MockWorker.EXPECT().SubmitJob(gomock.All(NewAsyncOperationMatcher(job))).Times(0) - mock.MockK8sAPI.EXPECT().CreateCNINode(nodeWithENIConfig, mock.Manager.clusterName, instanceID).Return(nil).Times(1) + mock.MockK8sAPI.EXPECT().CreateCNINode(nodeWithENIConfig, mock.Manager.clusterName).Return(nil).Times(1) mock.MockK8sAPI.EXPECT().GetCNINode(types.NamespacedName{Name: nodeWithENIConfig.Name}).Return(&rcV1alpha1.CNINode{ Spec: rcV1alpha1.CNINodeSpec{ Features: []rcV1alpha1.Feature{{Name: rcV1alpha1.CustomNetworking}}, @@ -367,7 +367,7 @@ func Test_AddNode_CustomNetworking_NodeLabel(t *testing.T) { mock.MockK8sAPI.EXPECT().GetNode(nodeName).Return(nodeWithENIConfig, nil) mock.MockK8sAPI.EXPECT().GetENIConfig(eniConfigName).Return(eniConfig, nil).Times(1) mock.MockWorker.EXPECT().SubmitJob(gomock.All(NewAsyncOperationMatcher(job))) - mock.MockK8sAPI.EXPECT().CreateCNINode(nodeWithENIConfig, mock.Manager.clusterName, instanceID).Return(nil).Times(1) + mock.MockK8sAPI.EXPECT().CreateCNINode(nodeWithENIConfig, mock.Manager.clusterName).Return(nil).Times(1) mock.MockK8sAPI.EXPECT().GetCNINode(types.NamespacedName{Name: nodeWithENIConfig.Name}).Return(&rcV1alpha1.CNINode{ Spec: rcV1alpha1.CNINodeSpec{ Features: []rcV1alpha1.Feature{{Name: rcV1alpha1.CustomNetworking}}, @@ -400,7 +400,7 @@ func Test_AddNode_CustomNetworking_Incorrect_ENIConfig(t *testing.T) { mock.MockK8sAPI.EXPECT().GetNode(nodeName).Return(nodeWithENIConfig, nil) mock.MockK8sAPI.EXPECT().GetENIConfig(eniConfigName).Return(eniConfig_empty_sg, nil) mock.MockWorker.EXPECT().SubmitJob(gomock.All(NewAsyncOperationMatcher(job))) - mock.MockK8sAPI.EXPECT().CreateCNINode(nodeWithENIConfig, mockClusterName, instanceID).Return(nil).Times(1) + mock.MockK8sAPI.EXPECT().CreateCNINode(nodeWithENIConfig, mockClusterName).Return(nil).Times(1) mock.MockK8sAPI.EXPECT().GetCNINode(types.NamespacedName{Name: nodeWithENIConfig.Name}).Return(&rcV1alpha1.CNINode{ Spec: rcV1alpha1.CNINodeSpec{ Features: []rcV1alpha1.Feature{{Name: rcV1alpha1.CustomNetworking}}, @@ -424,7 +424,7 @@ func Test_AddNode_CustomNetworking_NoENIConfig(t *testing.T) { nodeWithENIConfig.Labels[config.CustomNetworkingLabel] = eniConfigName mock.MockK8sAPI.EXPECT().GetNode(nodeName).Return(nodeWithENIConfig, nil) - mock.MockK8sAPI.EXPECT().CreateCNINode(nodeWithENIConfig, mock.Manager.clusterName, instanceID).Return(nil).Times(1) + mock.MockK8sAPI.EXPECT().CreateCNINode(nodeWithENIConfig, mock.Manager.clusterName).Return(nil).Times(1) mock.MockK8sAPI.EXPECT().GetENIConfig(eniConfigName).Return(nil, mockError) mock.MockK8sAPI.EXPECT().GetCNINode(types.NamespacedName{Name: nodeWithENIConfig.Name}).Return(&rcV1alpha1.CNINode{}, apierrors.NewNotFound(schema.GroupResource{Group: "vpcresources.k8s.aws", Resource: "1"}, "test")) diff --git a/pkg/utils/helper.go b/pkg/utils/helper.go index ed6d8871..b460f98e 100644 --- a/pkg/utils/helper.go +++ b/pkg/utils/helper.go @@ -17,7 +17,6 @@ import ( "context" "errors" "fmt" - "regexp" "strconv" "strings" @@ -41,8 +40,6 @@ const ( AccountIndex = 4 ) -var instanceIDRegex = regexp.MustCompile(`^i-(?:[a-f0-9]{8}|[a-f0-9]{17})$`) - // RemoveDuplicatedSg removes duplicated items from a string slice. // It returns a no duplicates string slice. func RemoveDuplicatedSg(list []string) []string { @@ -264,18 +261,3 @@ func IntToInt32(value int) (int32, error) { return int32(value), nil } - -func GetNodeID(node *corev1.Node) (string, error) { - if node.Spec.ProviderID == "" { - return "", fmt.Errorf("provider ID is not set for node %s", node.Name) - } - idx := strings.LastIndex(node.Spec.ProviderID, "/") - if idx == -1 || idx >= len(node.Spec.ProviderID)-1 { - return "", fmt.Errorf("invalid provider ID format for node %s, with providerId %s", node.Name, node.Spec.ProviderID) - } - instanceID := node.Spec.ProviderID[idx+1:] - if !instanceIDRegex.MatchString(instanceID) { - return "", fmt.Errorf("provider ID for node %s does not match AWS EC2 instance ID format: %s", node.Name, instanceID) - } - return instanceID, nil -} diff --git a/pkg/utils/helper_test.go b/pkg/utils/helper_test.go index 820bc67f..2a603b75 100644 --- a/pkg/utils/helper_test.go +++ b/pkg/utils/helper_test.go @@ -18,7 +18,6 @@ import ( "github.com/samber/lo" "github.com/stretchr/testify/assert" - corev1 "k8s.io/api/core/v1" v1 "k8s.io/api/core/v1" "k8s.io/apimachinery/pkg/api/resource" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" @@ -680,69 +679,3 @@ func TestPodHasENIRequest(t *testing.T) { }) } } - -func TestGetNodeID(t *testing.T) { - tests := []struct { - name string - providerID string - want string - wantErr bool - }{ - { - name: "valid 8char id", - providerID: "aws:///us-west-2a/i-1234abcd", - want: "i-1234abcd", - wantErr: false, - }, - { - name: "valid 17char id", - providerID: "aws:///us-west-2a/i-0123456789abcdef0", - want: "i-0123456789abcdef0", - wantErr: false, - }, - { - name: "missing provider id", - providerID: "", - want: "", - wantErr: true, - }, - { - name: "invalid format - no slash", - providerID: "i-1234abcd", - want: "", - wantErr: true, - }, - { - name: "invalid id - not hex", - providerID: "aws:///us-west-2a/i-1234abcg", - want: "", - wantErr: true, - }, - { - name: "invalid id - too short", - providerID: "aws:///us-west-2a/i-1234abc", - want: "", - wantErr: true, - }, - { - name: "invalid id - too long", - providerID: "aws:///us-west-2a/i-0123456789abcdef01", - want: "", - wantErr: true, - }, - } - - for _, tt := range tests { - t.Run(tt.name, func(t *testing.T) { - node := &corev1.Node{} - node.Spec.ProviderID = tt.providerID - got, err := GetNodeID(node) - if (err != nil) != tt.wantErr { - t.Errorf("GetNodeID() error = %v, wantErr %v", err, tt.wantErr) - } - if got != tt.want { - t.Errorf("GetNodeID() = %v, want %v", got, tt.want) - } - }) - } -} diff --git a/test/framework/resource/aws/autoscaling/manager.go b/test/framework/resource/aws/autoscaling/manager.go index e2e9e858..7fa9d827 100644 --- a/test/framework/resource/aws/autoscaling/manager.go +++ b/test/framework/resource/aws/autoscaling/manager.go @@ -25,8 +25,6 @@ import ( type Manager interface { DescribeAutoScalingGroup(autoScalingGroupName string) ([]autoscalingtypes.AutoScalingGroup, error) UpdateAutoScalingGroup(asgName string, desiredSize, minSize, maxSize int32) error - StartInstanceRefresh(asgName string) (string, error) - DescribeInstanceRefresh(asgName string, instanceRefreshId string) (autoscalingtypes.InstanceRefresh, error) } type defaultManager struct { @@ -64,19 +62,3 @@ func (d defaultManager) UpdateAutoScalingGroup(asgName string, desiredSize, minS _, err := d.AutoScalingAPI.UpdateAutoScalingGroup(context.TODO(), updateASGInput) return err } - -func (d defaultManager) StartInstanceRefresh(asgName string) (string, error) { - in := &autoscaling.StartInstanceRefreshInput{ - AutoScalingGroupName: aws.String(asgName), - } - out, err := d.AutoScalingAPI.StartInstanceRefresh(context.TODO(), in) - return *out.InstanceRefreshId, err -} - -func (d defaultManager) DescribeInstanceRefresh(asgName, instanceRefreshId string) (autoscalingtypes.InstanceRefresh, error) { - out, err := d.AutoScalingAPI.DescribeInstanceRefreshes(context.TODO(), &autoscaling.DescribeInstanceRefreshesInput{ - AutoScalingGroupName: aws.String(asgName), - InstanceRefreshIds: []string{instanceRefreshId}, - }) - return out.InstanceRefreshes[0], err -} diff --git a/test/framework/resource/aws/ec2/manager.go b/test/framework/resource/aws/ec2/manager.go index 8cd9da6e..d246f732 100644 --- a/test/framework/resource/aws/ec2/manager.go +++ b/test/framework/resource/aws/ec2/manager.go @@ -308,25 +308,3 @@ func (d *Manager) ReCreateSG(securityGroupName string, ctx context.Context) (str } return groupID, nil } - -func (d *Manager) DetachNetworkInterface(ctx context.Context, attachmentID string, force bool) error { - _, err := d.ec2Client.DetachNetworkInterface(ctx, &ec2.DetachNetworkInterfaceInput{ - AttachmentId: aws.String(attachmentID), - Force: aws.Bool(force), - }) - return err -} - -func (d *Manager) GetInstances(ctx context.Context, instanceIds []string) ([]ec2types.Instance, error) { - out, err := d.ec2Client.DescribeInstances(ctx, &ec2.DescribeInstancesInput{ - InstanceIds: instanceIds, - }) - if err != nil { - return nil, err - } - var instances []ec2types.Instance - for _, res := range out.Reservations { - instances = append(instances, res.Instances...) - } - return instances, nil -} diff --git a/test/framework/resource/k8s/deployment/manager.go b/test/framework/resource/k8s/deployment/manager.go index 92aba8c7..99c5fb72 100644 --- a/test/framework/resource/k8s/deployment/manager.go +++ b/test/framework/resource/k8s/deployment/manager.go @@ -48,7 +48,7 @@ func (m *defaultManager) CreateAndWaitUntilDeploymentReady(ctx context.Context, } observedDP := &appsv1.Deployment{} - return observedDP, wait.PollUntilContextTimeout(ctx, utils.PollIntervalMedium, utils.ResourceOperationTimeout, false, func(ctx context.Context) (bool, error) { + return observedDP, wait.PollUntil(utils.PollIntervalShort, func() (bool, error) { if err := m.k8sClient.Get(ctx, utils.NamespacedName(dp), observedDP); err != nil { return false, err } @@ -59,7 +59,7 @@ func (m *defaultManager) CreateAndWaitUntilDeploymentReady(ctx context.Context, return true, nil } return false, nil - }) + }, ctx.Done()) } func (m *defaultManager) DeleteAndWaitUntilDeploymentDeleted(ctx context.Context, dp *appsv1.Deployment) error { @@ -67,7 +67,7 @@ func (m *defaultManager) DeleteAndWaitUntilDeploymentDeleted(ctx context.Context if err != nil { return err } - return wait.PollUntilContextTimeout(ctx, utils.PollIntervalMedium, utils.ResourceOperationTimeout, false, func(ctx context.Context) (bool, error) { + return wait.PollUntil(utils.PollIntervalShort, func() (bool, error) { observedDP := &appsv1.Deployment{} if err := m.k8sClient.Get(ctx, utils.NamespacedName(dp), observedDP); err != nil { if errors.IsNotFound(err) { @@ -76,7 +76,7 @@ func (m *defaultManager) DeleteAndWaitUntilDeploymentDeleted(ctx context.Context return false, err } return false, nil - }) + }, ctx.Done()) } func (m *defaultManager) ScaleDeploymentAndWaitTillReady(ctx context.Context, namespace string, name string, replicas int32) error { diff --git a/test/framework/resource/k8s/node/wrapper.go b/test/framework/resource/k8s/node/wrapper.go index 231c3433..a486d63a 100644 --- a/test/framework/resource/k8s/node/wrapper.go +++ b/test/framework/resource/k8s/node/wrapper.go @@ -29,7 +29,7 @@ import ( func GetNodeAndWaitTillCapacityPresent(manager Manager, os string, expectedResource string) *v1.NodeList { observedNodeList := &v1.NodeList{} var err error - err = wait.PollUntilContextTimeout(context.Background(), utils.PollIntervalShort, utils.ResourceOperationTimeout, true, + err = wait.PollUntilContextTimeout(context.Background(), utils.PollIntervalShort, utils.ResourceCreationTimeout, true, func(ctx context.Context) (bool, error) { By("checking nodes have capacity present") observedNodeList, err = manager.GetNodesWithOS(os) diff --git a/test/framework/resource/k8s/pod/wrapper.go b/test/framework/resource/k8s/pod/wrapper.go index 36ccb3fe..4e27c2c5 100644 --- a/test/framework/resource/k8s/pod/wrapper.go +++ b/test/framework/resource/k8s/pod/wrapper.go @@ -25,7 +25,7 @@ import ( func CreateAndWaitForPodToStart(podManager Manager, ctx context.Context, pod *v1.Pod) *v1.Pod { By("create the pod") - pod, err := podManager.CreateAndWaitTillPodIsRunning(ctx, pod, utils.ResourceOperationTimeout) + pod, err := podManager.CreateAndWaitTillPodIsRunning(ctx, pod, utils.ResourceCreationTimeout) Expect(err).NotTo(HaveOccurred()) return pod diff --git a/test/framework/utils/poll.go b/test/framework/utils/poll.go index aaa02bd9..ec62f251 100644 --- a/test/framework/utils/poll.go +++ b/test/framework/utils/poll.go @@ -20,9 +20,9 @@ const ( PollIntervalMedium = 10 * time.Second PollIntervalLong = 20 * time.Second PollTimeout = 30 * time.Second - // ResourceOperationTimeout is the number of seconds till the controller waits + // ResourceCreationTimeout is the number of seconds till the controller waits // for the resource creation to complete - ResourceOperationTimeout = 180 * time.Second + ResourceCreationTimeout = 180 * time.Second // Windows Container Images are much larger in size and pulling them the first // time takes much longer, so have higher timeout for Windows Pod to be Ready WindowsPodsCreationTimeout = 240 * time.Second diff --git a/test/integration/cninode/cninode_test.go b/test/integration/cninode/cninode_test.go index 1d23ded3..1cbf269e 100644 --- a/test/integration/cninode/cninode_test.go +++ b/test/integration/cninode/cninode_test.go @@ -41,7 +41,7 @@ var _ = Describe("[CANARY]CNINode test", func() { var asgName string BeforeEach(func() { By("getting autoscaling group name") - asgName = GetAutoScalingGroupName(config.OSLinux) + asgName = ListNodesAndGetAutoScalingGroupName() asg, err := frameWork.AutoScalingManager.DescribeAutoScalingGroup(asgName) Expect(err).ToNot(HaveOccurred()) oldDesiredSize = *asg[0].DesiredCapacity @@ -151,9 +151,9 @@ var _ = Describe("[CANARY]CNINode test", func() { }) -func GetAutoScalingGroupName(os string) string { +func ListNodesAndGetAutoScalingGroupName() string { By("getting instance details") - nodeList, err := frameWork.NodeManager.GetNodesWithOS(os) + nodeList, err := frameWork.NodeManager.GetNodesWithOS(config.OSLinux) Expect(err).ToNot(HaveOccurred()) Expect(nodeList.Items).ToNot(BeEmpty()) instanceID := frameWork.NodeManager.GetInstanceID(&nodeList.Items[0]) @@ -169,7 +169,7 @@ func GetAutoScalingGroupName(os string) string { // Verifies (linux) node size is updated after ASG is updated func WaitTillNodeSizeUpdated(desiredSize int) error { By("waiting till node list is updated") - err := wait.PollUntilContextTimeout(context.Background(), testUtils.PollIntervalShort, testUtils.ResourceOperationTimeout, true, + err := wait.PollUntilContextTimeout(context.Background(), testUtils.PollIntervalShort, testUtils.ResourceCreationTimeout, true, func(ctx context.Context) (bool, error) { nodes, err := frameWork.NodeManager.GetNodesWithOS(config.OSLinux) // since we are only updating the linux ASG in the test if err != nil { diff --git a/test/integration/ec2api/ec2api_test.go b/test/integration/ec2api/ec2api_test.go index f18c51b4..fca49b28 100644 --- a/test/integration/ec2api/ec2api_test.go +++ b/test/integration/ec2api/ec2api_test.go @@ -62,7 +62,7 @@ var _ = Describe("[LOCAL] Test IAM permissions for EC2 API calls", func() { err = frameWork.EC2Manager.TerminateInstances(instanceID) Expect(err).ToNot(HaveOccurred()) // allow time for instance to be deleted and ENI to be available, new node to be ready - time.Sleep(utils.ResourceOperationTimeout) + time.Sleep(utils.ResourceCreationTimeout) By("verifying ENI is not deleted by controller") err = frameWork.EC2Manager.DescribeNetworkInterface(nwInterfaceID) Expect(err).ToNot(HaveOccurred()) diff --git a/test/integration/metrics/metrics_suite_test.go b/test/integration/metrics/metrics_suite_test.go index 8174efc0..ac09f16c 100644 --- a/test/integration/metrics/metrics_suite_test.go +++ b/test/integration/metrics/metrics_suite_test.go @@ -80,7 +80,7 @@ func createCurlPod() (*v1.Pod, error) { if err != nil { return nil, err } - return frameWork.PodManager.CreateAndWaitTillPodIsRunning(ctx, pod, utils.ResourceOperationTimeout) + return frameWork.PodManager.CreateAndWaitTillPodIsRunning(ctx, pod, utils.ResourceCreationTimeout) } func ensureControllerReadyTobeScraped() error { diff --git a/test/integration/perpodsg/job_test.go b/test/integration/perpodsg/job_test.go index 32d473cb..2382f954 100644 --- a/test/integration/perpodsg/job_test.go +++ b/test/integration/perpodsg/job_test.go @@ -130,7 +130,7 @@ var _ = Describe("Security Group Per Pod", func() { By("creating the server pod") serverPod, err = frameWork.PodManager. - CreateAndWaitTillPodIsRunning(ctx, serverPod, utils.ResourceOperationTimeout) + CreateAndWaitTillPodIsRunning(ctx, serverPod, utils.ResourceCreationTimeout) Expect(err).ToNot(HaveOccurred()) for i := 0; i < testNodeCount; i++ { diff --git a/test/integration/perpodsg/perpodsg_test.go b/test/integration/perpodsg/perpodsg_test.go index e7f767af..ef8f51e4 100644 --- a/test/integration/perpodsg/perpodsg_test.go +++ b/test/integration/perpodsg/perpodsg_test.go @@ -451,7 +451,7 @@ var _ = Describe("Branch ENI Pods", func() { firstPod := podTemplate.DeepCopy() By("creating a Pod on the un-managed node and verifying it fails") - _, err = frameWork.PodManager.CreateAndWaitTillPodIsRunning(ctx, firstPod, utils.ResourceOperationTimeout) + _, err = frameWork.PodManager.CreateAndWaitTillPodIsRunning(ctx, firstPod, utils.ResourceCreationTimeout) Expect(err).To(HaveOccurred()) By("deleting the pod") @@ -471,7 +471,7 @@ var _ = Describe("Branch ENI Pods", func() { By("creating the Pod on now managed node and verify it runs") secondPod := podTemplate.DeepCopy() - secondPod, err = frameWork.PodManager.CreateAndWaitTillPodIsRunning(ctx, secondPod, utils.ResourceOperationTimeout) + secondPod, err = frameWork.PodManager.CreateAndWaitTillPodIsRunning(ctx, secondPod, utils.ResourceCreationTimeout) Expect(err).ToNot(HaveOccurred()) verify.VerifyNetworkingOfPodUsingENI(*secondPod, []string{securityGroupID1}) diff --git a/test/integration/scale/node_termination_scale_test.go b/test/integration/scale/node_termination_scale_test.go deleted file mode 100644 index cd9c0103..00000000 --- a/test/integration/scale/node_termination_scale_test.go +++ /dev/null @@ -1,139 +0,0 @@ -package scale_test - -import ( - "fmt" - "time" - - "github.com/aws/amazon-vpc-resource-controller-k8s/pkg/config" - utils_vpc_rc "github.com/aws/amazon-vpc-resource-controller-k8s/pkg/utils" - "github.com/aws/amazon-vpc-resource-controller-k8s/test/framework/manifest" - "github.com/aws/amazon-vpc-resource-controller-k8s/test/framework/utils" - utils_test "github.com/aws/amazon-vpc-resource-controller-k8s/test/utils" - . "github.com/onsi/ginkgo/v2" - . "github.com/onsi/gomega" - v1 "k8s.io/api/apps/v1" -) - -var ns = "node-termination-cleaner-scale" -var _ = Describe("Node termination ENI Cleaner Scale test", Ordered, func() { - var ( - asgName string - oldDesiredSize int32 - oldMinSize int32 - oldMaxSize int32 - deployment *v1.Deployment - eniDetached []string - ) - - BeforeAll(func() { - Expect(nodes).To(BeNumerically(">", 0)) - Expect(deletePerMin).To(BeNumerically(">", 0)) - asgName = utils_test.GetAutoScalingGroupName(frameWork, config.OSLinux) - asg, err := frameWork.AutoScalingManager.DescribeAutoScalingGroup(asgName) - Expect(err).NotTo(HaveOccurred()) - oldDesiredSize = *asg[0].DesiredCapacity - oldMinSize = *asg[0].MinSize - oldMaxSize = *asg[0].MaxSize - - By(fmt.Sprintf("scaling the cluster to %d nodes", nodes)) - Expect(frameWork.AutoScalingManager.UpdateAutoScalingGroup(asgName, int32(nodes), 0, int32(nodes))).To(Succeed()) - Eventually(func() int { - list, err := frameWork.NodeManager.GetCNINodeList() - Expect(err).NotTo(HaveOccurred()) - return len(list.Items) - }, utils.ResourceOperationTimeout, utils.PollIntervalMedium).Should(BeNumerically("==", nodes)) - - By("Creating name space") - Expect(frameWork.NSManager.CreateNamespace(ctx, ns)).To(Succeed()) - - By("deploying pods to 70% capacity") - nodeList, err := frameWork.NodeManager.GetNodesWithOS(config.OSLinux) - Expect(err).NotTo(HaveOccurred()) - podCap, ok := nodeList.Items[0].Status.Allocatable.Pods().AsInt64() - Expect(ok).To(BeTrue()) - replicas := int(podCap * int64(len(nodeList.Items)) * 7 / 10) - fmt.Println("replicas", replicas) - deployment = manifest.NewDefaultDeploymentBuilder().Namespace(ns).Replicas(replicas).PodLabel("node-scale", "1").Build() - _, err = frameWork.DeploymentManager.CreateAndWaitUntilDeploymentReady(ctx, deployment) - Expect(err).NotTo(HaveOccurred()) - }) - AfterAll(func() { - - By("deleting deployment") - if deployment != nil { - Expect(frameWork.DeploymentManager.DeleteAndWaitUntilDeploymentDeleted(ctx, deployment)).To(Succeed()) - } - - By("cleaning up all old nodes") - Expect(frameWork.AutoScalingManager.UpdateAutoScalingGroup(asgName, 0, oldMinSize, oldMaxSize)).To(Succeed()) - - By("waiting for 3 minutes to take clean up all nodes", func() { - time.Sleep(3 * time.Minute) - }) - - By(fmt.Sprintf("oldDesiredSize %v, oldMinSize %v oldMaxSize %v", oldDesiredSize, oldMinSize, oldMaxSize)) - Expect(frameWork.AutoScalingManager.UpdateAutoScalingGroup(asgName, oldDesiredSize, oldMinSize, oldMaxSize)).To(Succeed()) - Eventually(func() int { - list, err := frameWork.NodeManager.GetCNINodeList() - Expect(err).NotTo(HaveOccurred()) - return len(list.Items) - }, utils.ResourceOperationTimeout, utils.PollIntervalMedium).Should(BeNumerically("==", oldDesiredSize)) - - By("deleting namespace") - Expect(frameWork.NSManager.DeleteAndWaitTillNamespaceDeleted(ctx, ns)).To(Succeed()) - - }) - - It("detaching Secondary ENI from worker nodes", func() { - nodeList, err := frameWork.NodeManager.GetNodeList() - Expect(err).NotTo(HaveOccurred()) - var instanceIDs []string - fmt.Println("no of nodes in list for detachment ", len(nodeList.Items)) - for _, node := range nodeList.Items { - id, err := utils_vpc_rc.GetNodeID(&node) - Expect(err).NotTo(HaveOccurred()) - instanceIDs = append(instanceIDs, id) - } - instances, err := frameWork.EC2Manager.GetInstances(ctx, instanceIDs) - Expect(err).NotTo(HaveOccurred()) - fmt.Println("no of instance objects we have", len(instances)) - var zero = int32(0) - for _, instance := range instances { - for _, nw := range instance.NetworkInterfaces { - if *nw.Attachment.DeviceIndex > zero { - //fmt.Println("eniID", *nw.NetworkInterfaceId) - eniDetached = append(eniDetached, *nw.NetworkInterfaceId) - Expect(frameWork.EC2Manager.DetachNetworkInterface(ctx, *nw.Attachment.AttachmentId, true)).To(Succeed()) - } - } - } - fmt.Println("total ENI's detached", len(eniDetached)) - }) - - It("waiting for 2 minutes to let eni state sync", func() { - time.Sleep(2 * time.Minute) - }) - - It(fmt.Sprintf("deleting node at rate of %d per minute", deletePerMin), func() { - nl, err := frameWork.NodeManager.GetNodeList() - Expect(err).NotTo(HaveOccurred()) - utils_test.DeleteNodesWithThrottle(frameWork, nl, deletePerMin) - Eventually(func() int { - list, err := frameWork.NodeManager.GetCNINodeList() - Expect(err).NotTo(HaveOccurred()) - return len(list.Items) - }, utils.ResourceOperationTimeout, utils.PollIntervalMedium).Should(BeNumerically("==", 1)) - }) - - It("waiting for 2 minutes for vpc-rc to clean up all ENI", func() { - time.Sleep(2 * time.Minute) - }) - - It("verifying all detached interfaces are deleted", func() { - for _, eniId := range eniDetached { - err := frameWork.EC2Manager.DescribeNetworkInterface(eniId) - Expect(err).To(HaveOccurred(), fmt.Sprintf("ENI with ID %s was not deleted. with error %s", eniId, err)) - } - }) - -}) diff --git a/test/integration/scale/scale_suite_test.go b/test/integration/scale/scale_suite_test.go index 7e6d0ced..4c0e528c 100644 --- a/test/integration/scale/scale_suite_test.go +++ b/test/integration/scale/scale_suite_test.go @@ -15,7 +15,6 @@ package scale_test import ( "context" - "flag" "testing" "github.com/aws/amazon-vpc-resource-controller-k8s/test/framework" @@ -25,21 +24,12 @@ import ( . "github.com/onsi/gomega" ) -var ( - frameWork *framework.Framework - verify *verifier.PodVerification - ctx context.Context - securityGroupID string - err error - namespace = "podsg-scale-" + utils.TestNameSpace - nodes int - deletePerMin int -) - -func init() { - flag.IntVar(&nodes, "nodes", 20, "Number nodes to scale cluster to") - flag.IntVar(&deletePerMin, "deletePerMin", 5, "Number of nodes to delete per min") -} +var frameWork *framework.Framework +var verify *verifier.PodVerification +var ctx context.Context +var securityGroupID string +var err error +var namespace = "podsg-scale-" + utils.TestNameSpace func TestScale(t *testing.T) { RegisterFailHandler(Fail) diff --git a/test/integration/webhook/validating_webhook_suite_test.go b/test/integration/webhook/validating_webhook_suite_test.go index 17af8a15..21fe152b 100644 --- a/test/integration/webhook/validating_webhook_suite_test.go +++ b/test/integration/webhook/validating_webhook_suite_test.go @@ -91,7 +91,7 @@ var _ = BeforeSuite(func() { Build() Expect(err).ToNot(HaveOccurred()) - pod, err = frameWork.PodManager.CreateAndWaitTillPodIsRunning(ctx, pod, utils.ResourceOperationTimeout) + pod, err = frameWork.PodManager.CreateAndWaitTillPodIsRunning(ctx, pod, utils.ResourceCreationTimeout) Expect(err).ToNot(HaveOccurred()) By("verifying the pod eni annotation is present on branch pod") diff --git a/test/integration/webhook/validating_webhook_test.go b/test/integration/webhook/validating_webhook_test.go index c8f509e2..6224d7a3 100644 --- a/test/integration/webhook/validating_webhook_test.go +++ b/test/integration/webhook/validating_webhook_test.go @@ -69,7 +69,7 @@ var _ = Describe("validating webhook test cases", func() { Build() Expect(err).ToNot(HaveOccurred()) - _, err = frameWork.PodManager.CreateAndWaitTillPodIsRunning(ctx, newPod, utils.ResourceOperationTimeout) + _, err = frameWork.PodManager.CreateAndWaitTillPodIsRunning(ctx, newPod, utils.ResourceCreationTimeout) Expect(err).To(HaveOccurred()) }) @@ -81,7 +81,7 @@ var _ = Describe("validating webhook test cases", func() { Build() Expect(err).ToNot(HaveOccurred()) - _, err = frameWork.PodManager.CreateAndWaitTillPodIsRunning(ctx, newPod, utils.ResourceOperationTimeout) + _, err = frameWork.PodManager.CreateAndWaitTillPodIsRunning(ctx, newPod, utils.ResourceCreationTimeout) Expect(err).ToNot(HaveOccurred()) // Allow the cache to sync diff --git a/test/utils/utils.go b/test/utils/utils.go deleted file mode 100644 index e1759c49..00000000 --- a/test/utils/utils.go +++ /dev/null @@ -1,37 +0,0 @@ -package utils_test - -import ( - "context" - "time" - - "github.com/aws/amazon-vpc-resource-controller-k8s/pkg/utils" - "github.com/aws/amazon-vpc-resource-controller-k8s/test/framework" - . "github.com/onsi/ginkgo/v2" - . "github.com/onsi/gomega" - v1 "k8s.io/api/core/v1" -) - -func GetAutoScalingGroupName(frameWork *framework.Framework, os string) string { - By("getting instance details") - nodeList, err := frameWork.NodeManager.GetNodesWithOS(os) - Expect(err).ToNot(HaveOccurred()) - Expect(nodeList.Items).ToNot(BeEmpty()) - instanceID := frameWork.NodeManager.GetInstanceID(&nodeList.Items[0]) - Expect(instanceID).ToNot(BeEmpty()) - instance, err := frameWork.EC2Manager.GetInstanceDetails(instanceID) - Expect(err).ToNot(HaveOccurred()) - tags := utils.GetTagKeyValueMap(instance.Tags) - val, ok := tags["aws:autoscaling:groupName"] - Expect(ok).To(BeTrue()) - return val -} - -func DeleteNodesWithThrottle(frameWork *framework.Framework, nodeList *v1.NodeList, deletePerMin int) { - rate := time.Minute / time.Duration(deletePerMin) - ticker := time.NewTicker(rate) - defer ticker.Stop() - for _, node := range nodeList.Items { - <-ticker.C - Expect(frameWork.K8sClient.Delete(context.TODO(), &node)).To(Succeed()) - } -}