Merge pull request #7966 from pmendelski/htnap-events-for-tpu

Emit event on successful async scale-up

Author: k8s-ci-robot

cluster-autoscaler/core/scaleup/orchestrator/async_initializer.go

@@ -155,9 +155,17 @@ func (s *AsyncNodeGroupInitializer) InitializeNodeGroup(result nodegroups.AsyncN
 		return
 	}
 	klog.Infof("Initial scale-up succeeded. Scale ups: %v", scaleUpInfos)
+	s.emitScaleUpStatus(&status.ScaleUpStatus{
+		Result:                 status.ScaleUpSuccessful,
+		ScaleUpInfos:           scaleUpInfos,
+		CreateNodeGroupResults: []nodegroups.CreateNodeGroupResult{result.CreationResult},
+		PodsTriggeredScaleUp:   s.triggeringPods,
+	}, nil)
 }
 
 func (s *AsyncNodeGroupInitializer) emitScaleUpStatus(scaleUpStatus *status.ScaleUpStatus, err errors.AutoscalerError) {
-	status.UpdateScaleUpError(scaleUpStatus, err)
+	if err != nil {
+		status.UpdateScaleUpError(scaleUpStatus, err)
+	}
 	s.scaleUpStatusProcessor.Process(s.context, scaleUpStatus)
 }

cluster-autoscaler/core/scaleup/orchestrator/async_initializer_test.go

@@ -30,6 +30,7 @@ import (
 	"k8s.io/autoscaler/cluster-autoscaler/expander"
 	"k8s.io/autoscaler/cluster-autoscaler/processors/nodegroups"
 	"k8s.io/autoscaler/cluster-autoscaler/processors/nodegroups/asyncnodegroups"
+	"k8s.io/autoscaler/cluster-autoscaler/processors/nodegroupset"
 	"k8s.io/autoscaler/cluster-autoscaler/processors/status"
 	processorstest "k8s.io/autoscaler/cluster-autoscaler/processors/test"
 	"k8s.io/autoscaler/cluster-autoscaler/simulator/framework"
@@ -41,72 +42,80 @@ import (
 )
 
 func TestNodePoolAsyncInitialization(t *testing.T) {
+	scaleUpSize := 3
+	failingNodeGroupName := "failing-ng"
+	provider := testprovider.NewTestCloudProvider(
+		func(nodeGroup string, increase int) error {
+			if nodeGroup == failingNodeGroupName {
+				return fmt.Errorf("Simulated error")
+			}
+			return nil
+		}, nil)
+	pod := BuildTestPod("p1", 2, 1000)
+	failingNodeGroup := provider.BuildNodeGroup(failingNodeGroupName, 0, 100, 0, false, true, "T1", nil)
+	successfulNodeGroup := provider.BuildNodeGroup("async-ng", 0, 100, 0, false, true, "T1", nil)
+	failedScaleUpErr := errors.ToAutoscalerError(errors.CloudProviderError, fmt.Errorf("Simulated error")).AddPrefix("failed to increase node group size: ")
 	testCases := []struct {
-		name             string
-		failingScaleUps  map[string]bool
-		expectedScaleUps map[string]int
+		name       string
+		nodeGroup  *testprovider.TestNodeGroup
+		wantStatus status.ScaleUpStatus
 	}{
 		{
-			name:             "scale up upcoming node group",
-			expectedScaleUps: map[string]int{"async-ng": 3},
+			name:      "scale up upcoming node group",
+			nodeGroup: successfulNodeGroup,
+			wantStatus: status.ScaleUpStatus{
+				Result: status.ScaleUpSuccessful,
+				ScaleUpInfos: []nodegroupset.ScaleUpInfo{
+					{
+						Group:       successfulNodeGroup,
+						CurrentSize: 0,
+						NewSize:     scaleUpSize,
+						MaxSize:     successfulNodeGroup.MaxSize(),
+					},
+				},
+				CreateNodeGroupResults: []nodegroups.CreateNodeGroupResult{
+					{MainCreatedNodeGroup: successfulNodeGroup},
+				},
+				PodsTriggeredScaleUp: []*apiv1.Pod{pod},
+			},
 		},
 		{
-			name:            "failing initial scale up",
-			failingScaleUps: map[string]bool{"async-ng": true},
+			name:      "failing initial scale up",
+			nodeGroup: failingNodeGroup,
+			wantStatus: status.ScaleUpStatus{
+				Result:       status.ScaleUpError,
+				ScaleUpError: &failedScaleUpErr,
+				CreateNodeGroupResults: []nodegroups.CreateNodeGroupResult{
+					{MainCreatedNodeGroup: failingNodeGroup},
+				},
+				FailedResizeNodeGroups: []cloudprovider.NodeGroup{failingNodeGroup},
+				PodsTriggeredScaleUp:   []*apiv1.Pod{pod},
+			},
 		},
 	}
+	listers := kube_util.NewListerRegistry(nil, nil, nil, nil, nil, nil, nil, nil, nil)
+	upcomingNodeGroup := provider.BuildNodeGroup("upcoming-ng", 0, 100, 0, false, true, "T1", nil)
+	options := config.AutoscalingOptions{AsyncNodeGroupsEnabled: true}
+	context, err := NewScaleTestAutoscalingContext(options, &fake.Clientset{}, listers, provider, nil, nil)
+	assert.NoError(t, err)
+	option := expander.Option{NodeGroup: upcomingNodeGroup, Pods: []*apiv1.Pod{pod}}
+	processors := processorstest.NewTestProcessors(&context)
+	processors.AsyncNodeGroupStateChecker = &asyncnodegroups.MockAsyncNodeGroupStateChecker{IsUpcomingNodeGroup: map[string]bool{upcomingNodeGroup.Id(): true}}
+	nodeInfo := framework.NewTestNodeInfo(BuildTestNode("t1", 100, 0))
+	executor := newScaleUpExecutor(&context, processors.ScaleStateNotifier, processors.AsyncNodeGroupStateChecker)
 	for _, tc := range testCases {
 		t.Run(tc.name, func(t *testing.T) {
-			scaledUpGroups := make(map[string]int)
-			provider := testprovider.NewTestCloudProvider(
-				func(nodeGroup string, increase int) error {
-					if tc.failingScaleUps[nodeGroup] {
-						return fmt.Errorf("Simulated error")
-					}
-					scaledUpGroups[nodeGroup] += increase
-					return nil
-				}, nil)
-			options := config.AutoscalingOptions{
-				AsyncNodeGroupsEnabled: true,
-			}
-			listers := kube_util.NewListerRegistry(nil, nil, nil, nil, nil, nil, nil, nil, nil)
-			context, err := NewScaleTestAutoscalingContext(options, &fake.Clientset{}, listers, provider, nil, nil)
-			assert.NoError(t, err)
-			p1 := BuildTestPod("p1", 2, 1000)
-			upcomingNodeGroup := provider.BuildNodeGroup("upcoming-ng", 0, 100, 0, false, true, "T1", nil)
-			createdNodeGroup := provider.BuildNodeGroup("async-ng", 0, 100, 0, false, true, "T1", nil)
-			option := expander.Option{
-				NodeGroup: upcomingNodeGroup,
-				Pods:      []*apiv1.Pod{p1},
-			}
-			processors := processorstest.NewTestProcessors(&context)
-			processors.AsyncNodeGroupStateChecker = &asyncnodegroups.MockAsyncNodeGroupStateChecker{IsUpcomingNodeGroup: map[string]bool{upcomingNodeGroup.Id(): true}}
-			nodeInfo := framework.NewTestNodeInfo(BuildTestNode("t1", 100, 0))
-			executor := newScaleUpExecutor(&context, processors.ScaleStateNotifier, processors.AsyncNodeGroupStateChecker)
 			scaleUpStatusProcessor := &fakeScaleUpStatusProcessor{}
 			initializer := NewAsyncNodeGroupInitializer(&option, nodeInfo, executor, taints.TaintConfig{}, nil, scaleUpStatusProcessor, &context, false)
-			initializer.SetTargetSize(upcomingNodeGroup.Id(), 3)
+			initializer.SetTargetSize(upcomingNodeGroup.Id(), int64(scaleUpSize))
 			asyncResult := nodegroups.AsyncNodeGroupCreationResult{
-				CreationResult: nodegroups.CreateNodeGroupResult{MainCreatedNodeGroup: createdNodeGroup},
+				CreationResult: nodegroups.CreateNodeGroupResult{MainCreatedNodeGroup: tc.nodeGroup},
 				CreatedToUpcomingMapping: map[string]string{
-					createdNodeGroup.Id(): upcomingNodeGroup.Id(),
+					tc.nodeGroup.Id(): upcomingNodeGroup.Id(),
 				},
 			}
 			initializer.InitializeNodeGroup(asyncResult)
-			assert.Equal(t, len(scaledUpGroups), len(tc.expectedScaleUps))
-			for groupName, increase := range tc.expectedScaleUps {
-				assert.Equal(t, increase, scaledUpGroups[groupName])
-			}
-			if len(tc.failingScaleUps) > 0 {
-				expectedErr := errors.ToAutoscalerError(errors.CloudProviderError, fmt.Errorf("Simulated error")).AddPrefix("failed to increase node group size: ")
-				assert.Equal(t, scaleUpStatusProcessor.lastStatus, &status.ScaleUpStatus{
-					Result:                 status.ScaleUpError,
-					ScaleUpError:           &expectedErr,
-					CreateNodeGroupResults: []nodegroups.CreateNodeGroupResult{asyncResult.CreationResult},
-					FailedResizeNodeGroups: []cloudprovider.NodeGroup{createdNodeGroup},
-					PodsTriggeredScaleUp:   option.Pods,
-				})
-			}
+			assert.Equal(t, *scaleUpStatusProcessor.lastStatus, tc.wantStatus)
 		})
 	}
 }