Add falg to report node internal IP address in ingress status

pkg/ingress/controller/controller.go

@@ -135,9 +135,11 @@ type Configuration struct {
 	Backend ingress.Controller
 
 	UpdateStatus           bool
+	UseNodeInternalIP      bool
 	ElectionID             string
 	UpdateStatusOnShutdown bool
-	SortBackends           bool
+
+	SortBackends bool
 }
 
 // newIngressController creates an Ingress controller
@@ -174,6 +176,7 @@ func newIngressController(config *Configuration) *GenericController {
 			DefaultIngressClass:    config.DefaultIngressClass,
 			UpdateStatusOnShutdown: config.UpdateStatusOnShutdown,
 			CustomIngressStatus:    ic.cfg.Backend.UpdateIngressStatus,
+			UseNodeInternalIP:      ic.cfg.UseNodeInternalIP,
 		})
 	} else {
 		glog.Warning("Update of ingress status is disabled (flag --update-status=false was specified)")

pkg/ingress/controller/launch.go

@@ -101,6 +101,9 @@ func NewIngressController(backend ingress.Controller) *GenericController {
 
 		sortBackends = flags.Bool("sort-backends", false,
 			`Defines if backends and it's endpoints should be sorted`)
+
+		useNodeInternalIP = flags.Bool("report-node-internal-ip-address", false,
+			`Defines if the nodes IP address to be returned in the ingress status should be the internal instead of the external IP address`)
 	)
 
 	flags.AddGoFlagSet(flag.CommandLine)
@@ -198,6 +201,7 @@ func NewIngressController(backend ingress.Controller) *GenericController {
 		DisableNodeList:         *disableNodeList,
 		UpdateStatusOnShutdown:  *updateStatusOnShutdown,
 		SortBackends:            *sortBackends,
+		UseNodeInternalIP:       *useNodeInternalIP,
 	}
 
 	ic := newIngressController(config)

pkg/ingress/status/status.go

@@ -66,6 +66,8 @@ type Config struct {
 
 	UpdateStatusOnShutdown bool
 
+	UseNodeInternalIP bool
+
 	IngressLister store.IngressLister
 
 	DefaultIngressClass string
@@ -267,7 +269,7 @@ func (s *statusSync) runningAddresses() ([]string, error) {
 
 	addrs := []string{}
 	for _, pod := range pods.Items {
-		name := k8s.GetNodeIP(s.Client, pod.Spec.NodeName)
+		name := k8s.GetNodeIP(s.Client, pod.Spec.NodeName, s.UseNodeInternalIP)
 		if !sliceutils.StringInSlice(name, addrs) {
 			addrs = append(addrs, name)
 		}

pkg/k8s/main.go

@@ -37,26 +37,30 @@ func ParseNameNS(input string) (string, string, error) {
 }
 
 // GetNodeIP returns the IP address of a node in the cluster
-func GetNodeIP(kubeClient clientset.Interface, name string) string {
+func GetNodeIP(kubeClient clientset.Interface, name string, useInternalIP bool) string {
-	var externalIP string
 	node, err := kubeClient.Core().Nodes().Get(name, metav1.GetOptions{})
 	if err != nil {
-		return externalIP
+		return ""
 	}
 
 	for _, address := range node.Status.Addresses {
-		if address.Type == apiv1.NodeExternalIP {
+		if useInternalIP {
-			if address.Address != "" {
+			if address.Type == apiv1.NodeInternalIP {
-				externalIP = address.Address
+				if address.Address != "" {
-				break
+					return address.Address
+				}
 			}
+			continue
 		}
 
-		if externalIP == "" && address.Type == apiv1.NodeInternalIP {
+		if address.Type == apiv1.NodeExternalIP {
-			externalIP = address.Address
+			if address.Address != "" {
+				return address.Address
+			}
 		}
 	}
-	return externalIP
+
+	return ""
 }
 
 // PodInfo contains runtime information about the pod running the Ingres controller
@@ -87,7 +91,7 @@ func GetPodDetails(kubeClient clientset.Interface) (*PodInfo, error) {
 	return &PodInfo{
 		Name:      podName,
 		Namespace: podNs,
-		NodeIP:    GetNodeIP(kubeClient, pod.Spec.NodeName),
+		NodeIP:    GetNodeIP(kubeClient, pod.Spec.NodeName, true),
 		Labels:    pod.GetLabels(),
 	}, nil
 }

pkg/k8s/main_test.go

@@ -61,9 +61,10 @@ func TestGetNodeIP(t *testing.T) {
 		cs *testclient.Clientset
 		n  string
 		ea string
+		i  bool
 	}{
 		// empty node list
-		{testclient.NewSimpleClientset(), "demo", ""},
+		{testclient.NewSimpleClientset(), "demo", "", true},
 
 		// node not exist
 		{testclient.NewSimpleClientset(&apiv1.NodeList{Items: []apiv1.Node{{
@@ -78,7 +79,7 @@ func TestGetNodeIP(t *testing.T) {
 					},
 				},
 			},
-		}}}), "notexistnode", ""},
+		}}}), "notexistnode", "", true},
 
 		// node  exist
 		{testclient.NewSimpleClientset(&apiv1.NodeList{Items: []apiv1.Node{{
@@ -93,7 +94,7 @@ func TestGetNodeIP(t *testing.T) {
 					},
 				},
 			},
-		}}}), "demo", "10.0.0.1"},
+		}}}), "demo", "10.0.0.1", true},
 
 		// search the correct node
 		{testclient.NewSimpleClientset(&apiv1.NodeList{Items: []apiv1.Node{
@@ -123,7 +124,7 @@ func TestGetNodeIP(t *testing.T) {
 					},
 				},
 			},
-		}}), "demo2", "10.0.0.2"},
+		}}), "demo2", "10.0.0.2", true},
 
 		// get NodeExternalIP
 		{testclient.NewSimpleClientset(&apiv1.NodeList{Items: []apiv1.Node{{
@@ -141,7 +142,7 @@ func TestGetNodeIP(t *testing.T) {
 					},
 				},
 			},
-		}}}), "demo", "10.0.0.2"},
+		}}}), "demo", "10.0.0.2", false},
 
 		// get NodeInternalIP
 		{testclient.NewSimpleClientset(&apiv1.NodeList{Items: []apiv1.Node{{
@@ -159,11 +160,11 @@ func TestGetNodeIP(t *testing.T) {
 					},
 				},
 			},
-		}}}), "demo", "10.0.0.2"},
+		}}}), "demo", "10.0.0.2", true},
 	}
 
 	for _, fk := range fKNodes {
-		address := GetNodeIP(fk.cs, fk.n)
+		address := GetNodeIP(fk.cs, fk.n, fk.i)
 		if address != fk.ea {
 			t.Errorf("expected %s, but returned %s", fk.ea, address)
 		}