From 72c4296f1fdff2914293079fdeb59dc72f10dfa6 Mon Sep 17 00:00:00 2001 From: David Cheung Date: Fri, 17 Feb 2023 09:28:34 +0000 Subject: [PATCH] Add metrics for sync result Added metrics to collect the cumulative count of sync results. --- pkg/neg/controller.go | 1 + pkg/neg/metrics/neg_metrics_collector.go | 3 + pkg/neg/syncers/transaction.go | 104 +++++++++++++++-------- pkg/neg/syncers/transaction_test.go | 50 +++++------ pkg/neg/syncers/utils.go | 13 +-- 5 files changed, 99 insertions(+), 72 deletions(-) diff --git a/pkg/neg/controller.go b/pkg/neg/controller.go index c1666c4c6c..41997ea33b 100644 --- a/pkg/neg/controller.go +++ b/pkg/neg/controller.go @@ -340,6 +340,7 @@ func (c *Controller) Run(stopCh <-chan struct{}) { wait.Until(c.gc, c.gcPeriod, stopCh) }() go c.reflector.Run(stopCh) + go c.syncerMetrics.Run(stopCh) <-stopCh } diff --git a/pkg/neg/metrics/neg_metrics_collector.go b/pkg/neg/metrics/neg_metrics_collector.go index b18a7f1e80..285c971122 100644 --- a/pkg/neg/metrics/neg_metrics_collector.go +++ b/pkg/neg/metrics/neg_metrics_collector.go @@ -91,6 +91,9 @@ func (sm *SyncerMetrics) export() { // UpdateSyncer update the status of corresponding syncer based on the syncResult. func (sm *SyncerMetrics) UpdateSyncer(key negtypes.NegSyncerKey, syncResult *negtypes.NegSyncResult) { + if syncResult.Result == negtypes.ResultInProgress { + return + } syncerSyncResult.WithLabelValues(syncResult.Result).Inc() sm.mu.Lock() diff --git a/pkg/neg/syncers/transaction.go b/pkg/neg/syncers/transaction.go index fbc1078927..39ec2705f8 100644 --- a/pkg/neg/syncers/transaction.go +++ b/pkg/neg/syncers/transaction.go @@ -193,14 +193,17 @@ func (s *transactionSyncer) syncInternal() error { defer s.syncLock.Unlock() start := time.Now() - err := s.syncInternalImpl() + result := s.syncInternalImpl() - s.updateStatus(err) - metrics.PublishNegSyncMetrics(string(s.NegSyncerKey.NegType), string(s.endpointsCalculator.Mode()), err, start) - return err + s.updateStatus(result.Error) + metrics.PublishNegSyncMetrics(string(s.NegSyncerKey.NegType), string(s.endpointsCalculator.Mode()), result.Error, start) + if s.enableEndpointSlices && result.Error != nil { + s.syncCollector.UpdateSyncer(s.NegSyncerKey, result) + } + return result.Error } -func (s *transactionSyncer) syncInternalImpl() error { +func (s *transactionSyncer) syncInternalImpl() *negtypes.NegSyncResult { // TODO(cheungdavid): for now we reset the boolean so it is a no-op, but // in the future, it will be used to trigger degraded mode if the syncer is in error state. if s.inErrorState() { @@ -209,20 +212,20 @@ func (s *transactionSyncer) syncInternalImpl() error { if s.needInit || s.isZoneChange() { if err := s.ensureNetworkEndpointGroups(); err != nil { - return err + return negtypes.NewNegSyncResult(err, negtypes.ResultNegNotFound) } s.needInit = false } if s.syncer.IsStopped() || s.syncer.IsShuttingDown() { s.logger.V(3).Info("Skip syncing NEG", "negSyncerKey", s.NegSyncerKey.String()) - return nil + return negtypes.NewNegSyncResult(nil, negtypes.ResultSuccess) } s.logger.V(2).Info("Sync NEG", "negSyncerKey", s.NegSyncerKey.String(), "endpointsCalculatorMode", s.endpointsCalculator.Mode()) currentMap, err := retrieveExistingZoneNetworkEndpointMap(s.NegSyncerKey.NegName, s.zoneGetter, s.cloud, s.NegSyncerKey.GetAPIVersion(), s.endpointsCalculator.Mode()) if err != nil { - return err + return negtypes.NewNegSyncResult(err, negtypes.ResultCurrentEPNotFound) } s.logStats(currentMap, "current NEG endpoints") @@ -238,11 +241,11 @@ func (s *transactionSyncer) syncInternalImpl() error { if s.enableEndpointSlices { slices, err := s.endpointSliceLister.ByIndex(endpointslices.EndpointSlicesByServiceIndex, endpointslices.FormatEndpointSlicesServiceKey(s.Namespace, s.Name)) if err != nil { - return err + return negtypes.NewNegSyncResult(err, negtypes.ResultEPSNotFound) } if len(slices) < 1 { s.logger.Error(nil, "Endpoint slices for the service doesn't exist. Skipping NEG sync") - return nil + return negtypes.NewNegSyncResult(nil, negtypes.ResultSuccess) } endpointSlices := make([]*discovery.EndpointSlice, len(slices)) negCR, err := getNegFromStore(s.svcNegLister, s.Namespace, s.NegSyncerKey.NegName) @@ -267,14 +270,16 @@ func (s *transactionSyncer) syncInternalImpl() error { } endpointsData := negtypes.EndpointsDataFromEndpointSlices(endpointSlices) targetMap, endpointPodMap, dupCount, err = s.endpointsCalculator.CalculateEndpoints(endpointsData, currentMap) - if valid, reason := s.isValidEPField(err); !valid { - s.setErrorState(reason) + if valid, result := s.CheckEPField(err); !valid { + s.setErrorState(result.Result) + return result } - if valid, reason := s.isValidEndpointInfo(endpointsData, endpointPodMap, dupCount); !valid { - s.setErrorState(reason) + if valid, result := s.CheckEndpointInfo(endpointsData, endpointPodMap, dupCount); !valid { + s.setErrorState(result.Result) + return result } if err != nil { - return fmt.Errorf("endpoints calculation error in mode %q, err: %w", s.endpointsCalculator.Mode(), err) + return negtypes.NewNegSyncResult(fmt.Errorf("endpoints calculation error in mode %q, err: %w", s.endpointsCalculator.Mode(), err), negtypes.ResultOtherError) } } else { ep, exists, err := s.endpointLister.Get( @@ -286,16 +291,16 @@ func (s *transactionSyncer) syncInternalImpl() error { }, ) if err != nil { - return err + return negtypes.NewNegSyncResult(err, negtypes.ResultOtherError) } if !exists { s.logger.Info("Endpoint does not exist. Skipping NEG sync", "endpoint", klog.KRef(s.Namespace, s.Name)) - return nil + return negtypes.NewNegSyncResult(nil, negtypes.ResultSuccess) } endpointsData := negtypes.EndpointsDataFromEndpoints(ep.(*apiv1.Endpoints)) targetMap, endpointPodMap, _, err = s.endpointsCalculator.CalculateEndpoints(endpointsData, currentMap) if err != nil { - return fmt.Errorf("endpoints calculation error in mode %q, err: %w", s.endpointsCalculator.Mode(), err) + return negtypes.NewNegSyncResult(fmt.Errorf("endpoints calculation error in mode %q, err: %w", s.endpointsCalculator.Mode(), err), negtypes.ResultOtherError) } } @@ -320,7 +325,7 @@ func (s *transactionSyncer) syncInternalImpl() error { if len(addEndpoints) == 0 && len(removeEndpoints) == 0 { s.logger.V(3).Info("No endpoint change. Skip syncing NEG. ", s.Namespace, s.Name) - return nil + return negtypes.NewNegSyncResult(nil, negtypes.ResultSuccess) } s.logEndpoints(addEndpoints, "adding endpoint") s.logEndpoints(removeEndpoints, "removing endpoint") @@ -384,19 +389,19 @@ func (s *transactionSyncer) ensureNetworkEndpointGroups() error { return utilerrors.NewAggregate(errList) } -// isValidEndpointInfo checks if endpoint information is correct. -// It returns false and the corresponding reason if one of the two checks fails: +// CheckEndpointInfo checks if endpoint information is correct. +// It returns false with the corresponding reason if one of the two checks fails: // // 1. The endpoint count from endpointData doesn't equal to the one from endpointPodMap: // endpiontPodMap removes the duplicated endpoints, and dupCount stores the number of duplicated it removed // and we compare the endpoint counts with duplicates // 2. The endpoint count from endpointData or the one from endpointPodMap is 0 -func (s *transactionSyncer) isValidEndpointInfo(eds []negtypes.EndpointsData, endpointPodMap negtypes.EndpointPodMap, dupCount int) (bool, string) { +func (s *transactionSyncer) CheckEndpointInfo(eds []negtypes.EndpointsData, endpointPodMap negtypes.EndpointPodMap, dupCount int) (bool, *negtypes.NegSyncResult) { // Endpoint count from EndpointPodMap countFromPodMap := len(endpointPodMap) + dupCount if countFromPodMap == 0 { s.logger.Info("Detected endpoint count from endpointPodMap going to zero", "endpointPodMap", endpointPodMap) - return false, negtypes.ResultEPCalculationCountZero + return false, negtypes.NewNegSyncResult(negtypes.ErrEPCalculationCountZero, negtypes.ResultEPCalculationCountZero) } // Endpoint count from EndpointData @@ -406,27 +411,35 @@ func (s *transactionSyncer) isValidEndpointInfo(eds []negtypes.EndpointsData, en } if countFromEndpointData == 0 { s.logger.Info("Detected endpoint count from endpointData going to zero", "endpointData", eds) - return false, negtypes.ResultEPSEndpointCountZero + return false, negtypes.NewNegSyncResult(negtypes.ErrEPSEndpointCountZero, negtypes.ResultEPSEndpointCountZero) } if countFromEndpointData != countFromPodMap { s.logger.Info("Detected error when comparing endpoint counts", "endpointData", eds, "endpointPodMap", endpointPodMap, "dupCount", dupCount) - return false, negtypes.ResultEPCountsDiffer + return false, negtypes.NewNegSyncResult(negtypes.ErrEPCountsDiffer, negtypes.ResultEPCountsDiffer) } - return true, negtypes.ResultSuccess + return true, negtypes.NewNegSyncResult(nil, negtypes.ResultSuccess) } -// isValidEPField returns false and the corresponding reason if there is endpoint with missing zone or nodeName -func (s *transactionSyncer) isValidEPField(err error) (bool, string) { - if errors.Is(err, ErrEPMissingNodeName) { +// CheckEPField checks if endpoints have valid field +// It return the result boolean with the corresponding reason +func (s *transactionSyncer) CheckEPField(err error) (bool, *negtypes.NegSyncResult) { + if errors.Is(err, negtypes.ErrEPMissingNodeName) { s.logger.Info("Detected unexpected error when checking missing nodeName", "error", err) - return false, negtypes.ResultEPMissingNodeName + return false, negtypes.NewNegSyncResult(err, negtypes.ResultEPMissingNodeName) } - if errors.Is(err, ErrEPMissingZone) { + if errors.Is(err, negtypes.ErrEPMissingZone) { s.logger.Info("Detected unexpected error when checking missing zone", "error", err) - return false, negtypes.ResultEPMissingZone + return false, negtypes.NewNegSyncResult(err, negtypes.ResultEPMissingZone) + } + if errors.Is(err, negtypes.ErrNodeNotFound) { + return true, negtypes.NewNegSyncResult(err, negtypes.ResultNodeNotFound) + } + if err != nil { + return true, negtypes.NewNegSyncResult(nil, negtypes.ResultOtherError) + } else { + return true, negtypes.NewNegSyncResult(nil, negtypes.ResultSuccess) } - return true, negtypes.ResultSuccess } // isValidEPBatch returns false and the corresponding reason if the error from endpoint batch response is due to bad request @@ -450,7 +463,7 @@ func (s *transactionSyncer) isValidEPBatch(err error, operation transactionOp, n } // syncNetworkEndpoints spins off go routines to execute NEG operations -func (s *transactionSyncer) syncNetworkEndpoints(addEndpoints, removeEndpoints map[string]negtypes.NetworkEndpointSet) error { +func (s *transactionSyncer) syncNetworkEndpoints(addEndpoints, removeEndpoints map[string]negtypes.NetworkEndpointSet) *negtypes.NegSyncResult { var wg sync.WaitGroup syncFunc := func(endpointMap map[string]negtypes.NetworkEndpointSet, operation transactionOp) error { @@ -486,19 +499,36 @@ func (s *transactionSyncer) syncNetworkEndpoints(addEndpoints, removeEndpoints m } if err := syncFunc(addEndpoints, attachOp); err != nil { - return err + return negtypes.NewNegSyncResult(err, negtypes.ResultOtherError) } if err := syncFunc(removeEndpoints, detachOp); err != nil { - return err + return negtypes.NewNegSyncResult(err, negtypes.ResultOtherError) } go s.collectSyncResult(&wg) - return nil + return negtypes.NewNegSyncResult(nil, negtypes.ResultInProgress) } // collectSyncResult collects the result of the sync and emits the metrics for sync result func (s *transactionSyncer) collectSyncResult(wg *sync.WaitGroup) { wg.Wait() + s.syncLock.Lock() + defer s.syncLock.Unlock() + + var syncResult *negtypes.NegSyncResult + if s.inErrorState() { + switch s.errorState { + case negtypes.ResultInvalidAPIResponse: + syncResult = negtypes.NewNegSyncResult(negtypes.ErrInvalidAPIResponse, s.errorState) + case negtypes.ResultInvalidEPAttach: + syncResult = negtypes.NewNegSyncResult(negtypes.ErrInvalidEPAttach, s.errorState) + default: + syncResult = negtypes.NewNegSyncResult(negtypes.ErrInvalidEPDetach, s.errorState) + } + } else { + syncResult = negtypes.NewNegSyncResult(nil, negtypes.ResultSuccess) + } + s.syncCollector.UpdateSyncer(s.NegSyncerKey, syncResult) } // attachNetworkEndpoints creates go routine to run operations for attaching network endpoints diff --git a/pkg/neg/syncers/transaction_test.go b/pkg/neg/syncers/transaction_test.go index bf58e56ce9..7f63fe36eb 100644 --- a/pkg/neg/syncers/transaction_test.go +++ b/pkg/neg/syncers/transaction_test.go @@ -206,9 +206,9 @@ func TestTransactionSyncNetworkEndpoints(t *testing.T) { } for _, tc := range testCases { - err := transactionSyncer.syncNetworkEndpoints(tc.addEndpoints, tc.removeEndpoints) - if err != nil { - t.Errorf("For case %q, syncNetworkEndpoints() got %v, want nil", tc.desc, err) + syncResult := transactionSyncer.syncNetworkEndpoints(tc.addEndpoints, tc.removeEndpoints) + if syncResult.Error != nil { + t.Errorf("For case %q, syncNetworkEndpoints() got %v, want nil", tc.desc, syncResult.Error) } if err := waitForTransactions(transactionSyncer); err != nil { @@ -1414,7 +1414,7 @@ func TestUnknownNodes(t *testing.T) { } } -func TestIsValidEndpointInfo(t *testing.T) { +func TestCheckEndpointInfo(t *testing.T) { t.Parallel() _, transactionSyncer := newTestTransactionSyncer(negtypes.NewAdapter(gce.NewFakeGCECloud(gce.DefaultTestClusterValues())), negtypes.VmIpPortEndpointType, false, true) @@ -1475,7 +1475,7 @@ func TestIsValidEndpointInfo(t *testing.T) { endpointPodMap map[negtypes.NetworkEndpoint]types.NamespacedName dupCount int expect bool - expectedReason string + expectedResult *negtypes.NegSyncResult }{ { desc: "counts equal, endpointData has no duplicated endpoints", @@ -1548,7 +1548,7 @@ func TestIsValidEndpointInfo(t *testing.T) { endpointPodMap: testEndpointPodMap, dupCount: 0, expect: true, - expectedReason: negtypes.ResultSuccess, + expectedResult: negtypes.NewNegSyncResult(nil, negtypes.ResultSuccess), }, { desc: "counts equal, endpointData has duplicated endpoints", @@ -1630,7 +1630,7 @@ func TestIsValidEndpointInfo(t *testing.T) { endpointPodMap: testEndpointPodMap, dupCount: 1, expect: true, - expectedReason: negtypes.ResultSuccess, + expectedResult: negtypes.NewNegSyncResult(nil, negtypes.ResultSuccess), }, { desc: "counts not equal, endpointData has no duplicated endpoints", @@ -1694,7 +1694,7 @@ func TestIsValidEndpointInfo(t *testing.T) { endpointPodMap: testEndpointPodMap, dupCount: 0, expect: false, - expectedReason: negtypes.ResultEPCountsDiffer, + expectedResult: negtypes.NewNegSyncResult(negtypes.ErrEPCountsDiffer, negtypes.ResultEPCountsDiffer), }, { desc: "counts not equal, endpointData has duplicated endpoints", @@ -1767,7 +1767,7 @@ func TestIsValidEndpointInfo(t *testing.T) { endpointPodMap: testEndpointPodMap, dupCount: 1, expect: false, - expectedReason: negtypes.ResultEPCountsDiffer, + expectedResult: negtypes.NewNegSyncResult(negtypes.ErrEPCountsDiffer, negtypes.ResultEPCountsDiffer), }, { desc: "endpointData has zero endpoint", @@ -1802,7 +1802,7 @@ func TestIsValidEndpointInfo(t *testing.T) { endpointPodMap: testEndpointPodMap, dupCount: 0, expect: false, - expectedReason: negtypes.ResultEPSEndpointCountZero, + expectedResult: negtypes.NewNegSyncResult(negtypes.ErrEPSEndpointCountZero, negtypes.ResultEPSEndpointCountZero), }, { desc: "endpointPodMap has zero endpoint", @@ -1875,7 +1875,7 @@ func TestIsValidEndpointInfo(t *testing.T) { endpointPodMap: map[negtypes.NetworkEndpoint]types.NamespacedName{}, dupCount: 0, expect: false, - expectedReason: negtypes.ResultEPCalculationCountZero, + expectedResult: negtypes.NewNegSyncResult(negtypes.ErrEPCalculationCountZero, negtypes.ResultEPCalculationCountZero), }, { desc: "endpointData and endpointPodMap both have zero endpoint", @@ -1910,7 +1910,7 @@ func TestIsValidEndpointInfo(t *testing.T) { endpointPodMap: map[negtypes.NetworkEndpoint]types.NamespacedName{}, dupCount: 0, expect: false, - expectedReason: negtypes.ResultEPCalculationCountZero, + expectedResult: negtypes.NewNegSyncResult(negtypes.ErrEPCalculationCountZero, negtypes.ResultEPCalculationCountZero), // PodMap count is check and returned first, }, { desc: "endpointData and endpointPodMap both have non-zero endpoints", @@ -1983,20 +1983,20 @@ func TestIsValidEndpointInfo(t *testing.T) { endpointPodMap: testEndpointPodMap, dupCount: 0, expect: true, - expectedReason: negtypes.ResultSuccess, + expectedResult: negtypes.NewNegSyncResult(nil, negtypes.ResultSuccess), }, } for _, tc := range testCases { t.Run(tc.desc, func(t *testing.T) { - if got, reason := transactionSyncer.isValidEndpointInfo(tc.endpointsData, tc.endpointPodMap, tc.dupCount); got != tc.expect && reason != tc.expectedReason { - t.Errorf("invalidEndpointInfo() = %t, expected %t", got, tc.expect) + if got, result := transactionSyncer.CheckEndpointInfo(tc.endpointsData, tc.endpointPodMap, tc.dupCount); got != tc.expect || result.Result != tc.expectedResult.Result || !errors.Is(result.Error, tc.expectedResult.Error) { + t.Errorf("CheckEndpointInfo() = %t|%s|%t, expected %t|%s|%t", got, result.Result, result.Error, tc.expect, tc.expectedResult.Result, tc.expectedResult.Error) } }) } } -func TestIsValidEPField(t *testing.T) { +func TestCheckEPField(t *testing.T) { t.Parallel() _, transactionSyncer := newTestTransactionSyncer(negtypes.NewAdapter(gce.NewFakeGCECloud(gce.DefaultTestClusterValues())), negtypes.VmIpPortEndpointType, false, true) @@ -2026,7 +2026,7 @@ func TestIsValidEPField(t *testing.T) { desc string endpointsData []negtypes.EndpointsData expect bool - expectedReason string + expectedResult *negtypes.NegSyncResult }{ { desc: "no missing zone or nodeName", @@ -2097,7 +2097,7 @@ func TestIsValidEPField(t *testing.T) { }, }, expect: true, - expectedReason: negtypes.ResultSuccess, + expectedResult: negtypes.NewNegSyncResult(nil, negtypes.ResultSuccess), }, { desc: "contains one missing nodeName", @@ -2168,7 +2168,7 @@ func TestIsValidEPField(t *testing.T) { }, }, expect: false, - expectedReason: negtypes.ResultEPMissingNodeName, + expectedResult: negtypes.NewNegSyncResult(negtypes.ErrEPMissingNodeName, negtypes.ResultEPMissingNodeName), }, { desc: "contains one empty nodeName", @@ -2239,7 +2239,7 @@ func TestIsValidEPField(t *testing.T) { }, }, expect: false, - expectedReason: negtypes.ResultEPMissingNodeName, + expectedResult: negtypes.NewNegSyncResult(negtypes.ErrEPMissingNodeName, negtypes.ResultEPMissingNodeName), }, { desc: "contains one missing zone", @@ -2310,20 +2310,20 @@ func TestIsValidEPField(t *testing.T) { }, }, expect: false, - expectedReason: negtypes.ResultEPMissingZone, + expectedResult: negtypes.NewNegSyncResult(negtypes.ErrEPMissingZone, negtypes.ResultEPMissingZone), }, } for _, tc := range testCases { t.Run(tc.desc, func(t *testing.T) { _, _, _, err := transactionSyncer.endpointsCalculator.CalculateEndpoints(tc.endpointsData, nil) - if got, reason := transactionSyncer.isValidEPField(err); got != tc.expect && reason != tc.expectedReason { - t.Errorf("isValidEPField() = %t, expected %t, err: %v, ", got, tc.expect, err) + if got, result := transactionSyncer.CheckEPField(err); got != tc.expect || !errors.Is(result.Error, tc.expectedResult.Error) || result.Result != tc.expectedResult.Result { + t.Errorf("CheckEPField() = %t|%s|%t, expected %t|%s|%t, err: %v, ", got, result.Result, result.Error, tc.expect, tc.expectedResult.Result, tc.expectedResult.Error, err) } }) } } -func TestIsValidEPBatch(t *testing.T) { +func TestCheckValidEPBatch(t *testing.T) { fakeGCE := gce.NewFakeGCECloud(gce.DefaultTestClusterValues()) fakeCloud := negtypes.NewAdapter(fakeGCE) zone := "us-central1-a" @@ -2368,7 +2368,7 @@ func TestIsValidEPBatch(t *testing.T) { _, transactionSyncer := newTestTransactionSyncer(fakeCloud, negtypes.VmIpPortEndpointType, false, true) err := transactionSyncer.cloud.AttachNetworkEndpoints(transactionSyncer.NegSyncerKey.NegName, zone, networkEndpoints, transactionSyncer.NegSyncerKey.GetAPIVersion()) - if got, reason := transactionSyncer.isValidEPBatch(err, attachOp, networkEndpoints); got != tc.expect && reason != tc.expectedReason { + if got, reason := transactionSyncer.isValidEPBatch(err, attachOp, networkEndpoints); got != tc.expect || reason != tc.expectedReason { t.Errorf("isInvalidEPBatch() = %t, expected %t", got, tc.expect) } }) diff --git a/pkg/neg/syncers/utils.go b/pkg/neg/syncers/utils.go index 4c2b0b2dc3..5c65a4c108 100644 --- a/pkg/neg/syncers/utils.go +++ b/pkg/neg/syncers/utils.go @@ -17,7 +17,6 @@ limitations under the License. package syncers import ( - "errors" "fmt" "strconv" "strings" @@ -47,12 +46,6 @@ const ( separator = "||" ) -var ( - ErrEPMissingNodeName = errors.New("endpoint has empty nodeName field") - ErrNodeNotFound = errors.New("failed to retrieve associated zone of node") - ErrEPMissingZone = errors.New("endpoint has empty zone field") -) - // encodeEndpoint encodes ip and instance into a single string func encodeEndpoint(ip, instance, port string) string { return strings.Join([]string{ip, instance, port}, separator) @@ -254,7 +247,7 @@ func toZoneNetworkEndpointMap(eds []negtypes.EndpointsData, zoneGetter negtypes. for _, endpointAddress := range ed.Addresses { if endpointAddress.NodeName == nil || len(*endpointAddress.NodeName) == 0 { klog.V(2).Infof("Endpoint %q in Endpoints %s/%s does not have an associated node. Skipping", endpointAddress.Addresses, ed.Meta.Namespace, ed.Meta.Name) - return nil, nil, dupCount, ErrEPMissingNodeName + return nil, nil, dupCount, negtypes.ErrEPMissingNodeName } if endpointAddress.TargetRef == nil { klog.V(2).Infof("Endpoint %q in Endpoints %s/%s does not have an associated pod. Skipping", endpointAddress.Addresses, ed.Meta.Namespace, ed.Meta.Name) @@ -262,10 +255,10 @@ func toZoneNetworkEndpointMap(eds []negtypes.EndpointsData, zoneGetter negtypes. } zone, err := zoneGetter.GetZoneForNode(*endpointAddress.NodeName) if err != nil { - return nil, nil, dupCount, ErrNodeNotFound + return nil, nil, dupCount, negtypes.ErrNodeNotFound } if zone == "" { - return nil, nil, dupCount, ErrEPMissingZone + return nil, nil, dupCount, negtypes.ErrEPMissingZone } if zoneNetworkEndpointMap[zone] == nil { zoneNetworkEndpointMap[zone] = negtypes.NewNetworkEndpointSet()