github/kubernetes
1
0
Fork 0
mirror of https://github.com/k3s-io/kubernetes.git synced 2025-08-04 09:49:50 +00:00
Code Issues Projects Releases Wiki Activity

Merge pull request #123777 from linxiulei/nc

Browse Source 
Remove setting NoRouteCreated condition
This commit is contained in:
Kubernetes Prow Robot 2024-04-25 01:20:42 -07:00 committed by GitHub
commit e19ff7771d
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
2 changed files with 3 additions and 209 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

22
staging/src/k8s.io/cloud-provider/controllers/node/node_controller.go
View File

@ -446,32 +446,10 @@ func (cnc *CloudNodeController) syncNode(ctx context.Context, nodeName string) e
}) })
err = clientretry.RetryOnConflict(UpdateNodeSpecBackoff, func() error { err = clientretry.RetryOnConflict(UpdateNodeSpecBackoff, func() error {
var curNode *v1.Node
if cnc.cloud.ProviderName() == "gce" {
// TODO(wlan0): Move this logic to the route controller using the node taint instead of condition
// Since there are node taints, do we still need this?
// This condition marks the node as unusable until routes are initialized in the cloud provider
if err := nodeutil.SetNodeCondition(cnc.kubeClient, types.NodeName(nodeName), v1.NodeCondition{
Type: v1.NodeNetworkUnavailable,
Status: v1.ConditionTrue,
Reason: "NoRouteCreated",
Message: "Node created without a route",
LastTransitionTime: metav1.Now(),
}); err != nil {
return err
}
// fetch latest node from API server since GCE-specific condition was set and informer cache may be stale
curNode, err = cnc.kubeClient.CoreV1().Nodes().Get(context.TODO(), nodeName, metav1.GetOptions{})
if err != nil {
return err
}
} else {
curNode, err = cnc.nodeInformer.Lister().Get(nodeName) curNode, err = cnc.nodeInformer.Lister().Get(nodeName)
if err != nil { if err != nil {
return err return err
} }
}
newNode := curNode.DeepCopy() newNode := curNode.DeepCopy()
for _, modify := range nodeModifiers { for _, modify := range nodeModifiers {

184
staging/src/k8s.io/cloud-provider/controllers/node/node_controller_test.go
View File

@ -1816,190 +1816,6 @@ func Test_syncNode(t *testing.T) {
} }
} }
// test syncNode with instanceV2, same test case with TestGCECondition.
func TestGCEConditionV2(t *testing.T) {
existingNode := &v1.Node{
ObjectMeta: metav1.ObjectMeta{
Name: "node0",
CreationTimestamp: metav1.Date(2012, 1, 1, 0, 0, 0, 0, time.UTC),
},
Status: v1.NodeStatus{
Conditions: []v1.NodeCondition{
{
Type: v1.NodeReady,
Status: v1.ConditionUnknown,
LastHeartbeatTime: metav1.Date(2015, 1, 1, 12, 0, 0, 0, time.UTC),
LastTransitionTime: metav1.Date(2015, 1, 1, 12, 0, 0, 0, time.UTC),
},
},
},
Spec: v1.NodeSpec{
Taints: []v1.Taint{
{
Key: cloudproviderapi.TaintExternalCloudProvider,
Value: "true",
Effect: v1.TaintEffectNoSchedule,
},
},
},
}
fakeCloud := &fakecloud.Cloud{
EnableInstancesV2: true,
InstanceTypes: map[types.NodeName]string{
types.NodeName("node0"): "t1.micro",
},
ProviderID: map[types.NodeName]string{
types.NodeName("node0"): "fake://12334",
},
Addresses: []v1.NodeAddress{
{
Type: v1.NodeHostName,
Address: "node0.cloud.internal",
},
{
Type: v1.NodeInternalIP,
Address: "10.0.0.1",
},
{
Type: v1.NodeExternalIP,
Address: "132.143.154.163",
},
},
Provider: "gce",
Err: nil,
}
clientset := fake.NewSimpleClientset(existingNode)
factory := informers.NewSharedInformerFactory(clientset, 0)
eventBroadcaster := record.NewBroadcaster()
cloudNodeController := &CloudNodeController{
kubeClient: clientset,
nodeInformer: factory.Core().V1().Nodes(),
nodesLister: factory.Core().V1().Nodes().Lister(),
cloud: fakeCloud,
recorder: eventBroadcaster.NewRecorder(scheme.Scheme, v1.EventSource{Component: "cloud-node-controller"}),
nodeStatusUpdateFrequency: 1 * time.Second,
}
stopCh := make(chan struct{})
defer close(stopCh)
factory.Start(stopCh)
factory.WaitForCacheSync(stopCh)
w := eventBroadcaster.StartLogging(klog.Infof)
defer w.Stop()
cloudNodeController.syncNode(context.TODO(), existingNode.Name)
updatedNode, err := clientset.CoreV1().Nodes().Get(context.TODO(), existingNode.Name, metav1.GetOptions{})
if err != nil {
t.Fatalf("error getting updated nodes: %v", err)
}
conditionAdded := false
for _, cond := range updatedNode.Status.Conditions {
if cond.Status == "True" && cond.Type == "NetworkUnavailable" && cond.Reason == "NoRouteCreated" {
conditionAdded = true
}
}
assert.True(t, conditionAdded, "Network Route Condition for GCE not added by external cloud initializer")
}
// This test checks that a node with the external cloud provider taint is cloudprovider initialized and
// the GCE route condition is added if cloudprovider is GCE
func TestGCECondition(t *testing.T) {
existingNode := &v1.Node{
ObjectMeta: metav1.ObjectMeta{
Name: "node0",
CreationTimestamp: metav1.Date(2012, 1, 1, 0, 0, 0, 0, time.UTC),
},
Status: v1.NodeStatus{
Conditions: []v1.NodeCondition{
{
Type: v1.NodeReady,
Status: v1.ConditionUnknown,
LastHeartbeatTime: metav1.Date(2015, 1, 1, 12, 0, 0, 0, time.UTC),
LastTransitionTime: metav1.Date(2015, 1, 1, 12, 0, 0, 0, time.UTC),
},
},
},
Spec: v1.NodeSpec{
Taints: []v1.Taint{
{
Key: cloudproviderapi.TaintExternalCloudProvider,
Value: "true",
Effect: v1.TaintEffectNoSchedule,
},
},
},
}
fakeCloud := &fakecloud.Cloud{
EnableInstancesV2: false,
InstanceTypes: map[types.NodeName]string{
types.NodeName("node0"): "t1.micro",
},
Addresses: []v1.NodeAddress{
{
Type: v1.NodeHostName,
Address: "node0.cloud.internal",
},
{
Type: v1.NodeInternalIP,
Address: "10.0.0.1",
},
{
Type: v1.NodeExternalIP,
Address: "132.143.154.163",
},
},
Provider: "gce",
Err: nil,
}
clientset := fake.NewSimpleClientset(existingNode)
factory := informers.NewSharedInformerFactory(clientset, 0)
eventBroadcaster := record.NewBroadcaster()
cloudNodeController := &CloudNodeController{
kubeClient: clientset,
nodeInformer: factory.Core().V1().Nodes(),
nodesLister: factory.Core().V1().Nodes().Lister(),
cloud: fakeCloud,
recorder: eventBroadcaster.NewRecorder(scheme.Scheme, v1.EventSource{Component: "cloud-node-controller"}),
nodeStatusUpdateFrequency: 1 * time.Second,
}
stopCh := make(chan struct{})
defer close(stopCh)
factory.Start(stopCh)
factory.WaitForCacheSync(stopCh)
w := eventBroadcaster.StartLogging(klog.Infof)
defer w.Stop()
cloudNodeController.syncNode(context.TODO(), existingNode.Name)
updatedNode, err := clientset.CoreV1().Nodes().Get(context.TODO(), existingNode.Name, metav1.GetOptions{})
if err != nil {
t.Fatalf("error getting updated nodes: %v", err)
}
conditionAdded := false
for _, cond := range updatedNode.Status.Conditions {
if cond.Status == "True" && cond.Type == "NetworkUnavailable" && cond.Reason == "NoRouteCreated" {
conditionAdded = true
}
}
assert.True(t, conditionAdded, "Network Route Condition for GCE not added by external cloud initializer")
}
func Test_reconcileNodeLabels(t *testing.T) { func Test_reconcileNodeLabels(t *testing.T) {
testcases := []struct { testcases := []struct {
name string name string