diff --git a/pkg/neg/controller.go b/pkg/neg/controller.go index 665a4589d7..62e2613c0b 100644 --- a/pkg/neg/controller.go +++ b/pkg/neg/controller.go @@ -44,6 +44,7 @@ import ( "k8s.io/ingress-gce/pkg/neg/readiness" "k8s.io/ingress-gce/pkg/neg/syncers/labels" negtypes "k8s.io/ingress-gce/pkg/neg/types" + "k8s.io/ingress-gce/pkg/network" svcnegclient "k8s.io/ingress-gce/pkg/svcneg/client/clientset/versioned" "k8s.io/ingress-gce/pkg/utils" "k8s.io/ingress-gce/pkg/utils/endpointslices" @@ -67,6 +68,7 @@ type Controller struct { namer negtypes.NetworkEndpointGroupNamer l4Namer namer2.L4ResourcesNamer zoneGetter negtypes.ZoneGetter + cloud negtypes.NetworkEndpointGroupCloud hasSynced func() bool ingressLister cache.Indexer @@ -196,6 +198,7 @@ func NewController( gcPeriod: gcPeriod, recorder: recorder, zoneGetter: zoneGetter, + cloud: cloud, namer: namer, l4Namer: l4Namer, defaultBackendService: defaultBackendService, @@ -444,21 +447,25 @@ func (c *Controller) processService(key string) error { } negUsage := usageMetrics.NegServiceState{} svcPortInfoMap := make(negtypes.PortInfoMap) - if err := c.mergeDefaultBackendServicePortInfoMap(key, service, svcPortInfoMap); err != nil { + networkInfo, err := network.ServiceNetwork(service, c.cloud) + if err != nil { + return err + } + if err := c.mergeDefaultBackendServicePortInfoMap(key, service, svcPortInfoMap, networkInfo); err != nil { return err } negUsage.IngressNeg = len(svcPortInfoMap) - if err := c.mergeIngressPortInfo(service, types.NamespacedName{Namespace: namespace, Name: name}, svcPortInfoMap); err != nil { + if err := c.mergeIngressPortInfo(service, types.NamespacedName{Namespace: namespace, Name: name}, svcPortInfoMap, networkInfo); err != nil { return err } negUsage.IngressNeg = len(svcPortInfoMap) - if err := c.mergeStandaloneNEGsPortInfo(service, types.NamespacedName{Namespace: namespace, Name: name}, svcPortInfoMap, &negUsage); err != nil { + if err := c.mergeStandaloneNEGsPortInfo(service, types.NamespacedName{Namespace: namespace, Name: name}, svcPortInfoMap, &negUsage, networkInfo); err != nil { return err } negUsage.StandaloneNeg = len(svcPortInfoMap) - negUsage.IngressNeg if c.enableASM { - csmSVCPortInfoMap, err := c.getCSMPortInfoMap(namespace, name, service) + csmSVCPortInfoMap, err := c.getCSMPortInfoMap(namespace, name, service, networkInfo) if err != nil { return err } @@ -471,7 +478,7 @@ func (c *Controller) processService(key string) error { } if c.runL4 { - if err := c.mergeVmIpNEGsPortInfo(service, types.NamespacedName{Namespace: namespace, Name: name}, svcPortInfoMap, &negUsage); err != nil { + if err := c.mergeVmIpNEGsPortInfo(service, types.NamespacedName{Namespace: namespace, Name: name}, svcPortInfoMap, &negUsage, networkInfo); err != nil { return err } } @@ -495,7 +502,7 @@ func (c *Controller) processService(key string) error { } // mergeIngressPortInfo merges Ingress PortInfo into portInfoMap if the service has Enable Ingress annotation. -func (c *Controller) mergeIngressPortInfo(service *apiv1.Service, name types.NamespacedName, portInfoMap negtypes.PortInfoMap) error { +func (c *Controller) mergeIngressPortInfo(service *apiv1.Service, name types.NamespacedName, portInfoMap negtypes.PortInfoMap, networkInfo *network.NetworkInfo) error { negAnnotation, foundNEGAnnotation, err := annotations.FromService(service).NEGAnnotation() if err != nil { return err @@ -509,7 +516,7 @@ func (c *Controller) mergeIngressPortInfo(service *apiv1.Service, name types.Nam // Only service ports referenced by ingress are synced for NEG ings := getIngressServicesFromStore(c.ingressLister, service) ingressSvcPortTuples := gatherPortMappingUsedByIngress(ings, service, c.logger) - ingressPortInfoMap := negtypes.NewPortInfoMap(name.Namespace, name.Name, ingressSvcPortTuples, c.namer, true, nil) + ingressPortInfoMap := negtypes.NewPortInfoMap(name.Namespace, name.Name, ingressSvcPortTuples, c.namer, true, nil, networkInfo) if err := portInfoMap.Merge(ingressPortInfoMap); err != nil { return fmt.Errorf("failed to merge service ports referenced by ingress (%v): %w", ingressPortInfoMap, err) } @@ -518,7 +525,7 @@ func (c *Controller) mergeIngressPortInfo(service *apiv1.Service, name types.Nam } // mergeStandaloneNEGsPortInfo merge Standalone NEG PortInfo into portInfoMap -func (c *Controller) mergeStandaloneNEGsPortInfo(service *apiv1.Service, name types.NamespacedName, portInfoMap negtypes.PortInfoMap, negUsage *usageMetrics.NegServiceState) error { +func (c *Controller) mergeStandaloneNEGsPortInfo(service *apiv1.Service, name types.NamespacedName, portInfoMap negtypes.PortInfoMap, negUsage *usageMetrics.NegServiceState, networkInfo *network.NetworkInfo) error { negAnnotation, foundNEGAnnotation, err := annotations.FromService(service).NEGAnnotation() if err != nil { return err @@ -549,7 +556,7 @@ func (c *Controller) mergeStandaloneNEGsPortInfo(service *apiv1.Service, name ty } negUsage.CustomNamedNeg = len(customNames) - if err := portInfoMap.Merge(negtypes.NewPortInfoMap(name.Namespace, name.Name, exposedNegSvcPort, c.namer /*readinessGate*/, true, customNames)); err != nil { + if err := portInfoMap.Merge(negtypes.NewPortInfoMap(name.Namespace, name.Name, exposedNegSvcPort, c.namer, true, customNames, networkInfo)); err != nil { return fmt.Errorf("failed to merge service ports exposed as standalone NEGs (%v) into ingress referenced service ports (%v): %w", exposedNegSvcPort, portInfoMap, err) } } @@ -558,7 +565,7 @@ func (c *Controller) mergeStandaloneNEGsPortInfo(service *apiv1.Service, name ty } // mergeVmIpNEGsPortInfo merges the PortInfo for ILB services using GCE_VM_IP NEGs into portInfoMap -func (c *Controller) mergeVmIpNEGsPortInfo(service *apiv1.Service, name types.NamespacedName, portInfoMap negtypes.PortInfoMap, negUsage *usageMetrics.NegServiceState) error { +func (c *Controller) mergeVmIpNEGsPortInfo(service *apiv1.Service, name types.NamespacedName, portInfoMap negtypes.PortInfoMap, negUsage *usageMetrics.NegServiceState, networkInfo *network.NetworkInfo) error { if wantsILB, _ := annotations.WantsL4ILB(service); !wantsILB { return nil } @@ -574,7 +581,7 @@ func (c *Controller) mergeVmIpNEGsPortInfo(service *apiv1.Service, name types.Na // Update usage metrics. negUsage.VmIpNeg = usageMetrics.NewVmIpNegType(onlyLocal) - return portInfoMap.Merge(negtypes.NewPortInfoMapForVMIPNEG(name.Namespace, name.Name, c.l4Namer, onlyLocal)) + return portInfoMap.Merge(negtypes.NewPortInfoMapForVMIPNEG(name.Namespace, name.Name, c.l4Namer, onlyLocal, networkInfo)) } // mergeDefaultBackendServicePortInfoMap merge the PortInfoMap for the default backend service into portInfoMap @@ -582,7 +589,7 @@ func (c *Controller) mergeVmIpNEGsPortInfo(service *apiv1.Service, name types.Na // in the ingress spec. It is either inferred and then managed by the controller, or // it is passed to the controller via a command line flag. // Additionally, supporting NEGs for default backends is only for L7-ILB -func (c *Controller) mergeDefaultBackendServicePortInfoMap(key string, service *apiv1.Service, portInfoMap negtypes.PortInfoMap) error { +func (c *Controller) mergeDefaultBackendServicePortInfoMap(key string, service *apiv1.Service, portInfoMap negtypes.PortInfoMap, networkInfo *network.NetworkInfo) error { if c.defaultBackendService.ID.Service.String() != key { return nil } @@ -597,7 +604,7 @@ func (c *Controller) mergeDefaultBackendServicePortInfoMap(key string, service * Port: c.defaultBackendService.Port, TargetPort: c.defaultBackendService.TargetPort.String(), }) - defaultServicePortInfoMap := negtypes.NewPortInfoMap(c.defaultBackendService.ID.Service.Namespace, c.defaultBackendService.ID.Service.Name, svcPortTupleSet, c.namer, false, nil) + defaultServicePortInfoMap := negtypes.NewPortInfoMap(c.defaultBackendService.ID.Service.Namespace, c.defaultBackendService.ID.Service.Name, svcPortTupleSet, c.namer, false, nil, networkInfo) return portInfoMap.Merge(defaultServicePortInfoMap) } } @@ -624,7 +631,7 @@ func (c *Controller) mergeDefaultBackendServicePortInfoMap(key string, service * // getCSMPortInfoMap returns the PortInfoMap used when ASM is enabled. The controller will create NEGs for every port of the service // NOTE: The output of this function should only be used when enableASM = true. -func (c *Controller) getCSMPortInfoMap(namespace, name string, service *apiv1.Service) (negtypes.PortInfoMap, error) { +func (c *Controller) getCSMPortInfoMap(namespace, name string, service *apiv1.Service, networkInfo *network.NetworkInfo) (negtypes.PortInfoMap, error) { servicePortInfoMap := make(negtypes.PortInfoMap) // Fill all service ports into portinfomap servicePorts := gatherPortMappingFromService(service) @@ -635,7 +642,7 @@ func (c *Controller) getCSMPortInfoMap(namespace, name string, service *apiv1.Se } else if contains(c.asmServiceNEGSkipNamespaces, namespace) { c.logger.Info("Skip NEG creation for services in namespace", "namespace", namespace) } else { - servicePortInfoMap = negtypes.NewPortInfoMap(namespace, name, servicePorts, c.namer, false, nil) + servicePortInfoMap = negtypes.NewPortInfoMap(namespace, name, servicePorts, c.namer, false, nil, networkInfo) } return servicePortInfoMap, nil } diff --git a/pkg/neg/controller_test.go b/pkg/neg/controller_test.go index 5a6e672134..d901d5c740 100644 --- a/pkg/neg/controller_test.go +++ b/pkg/neg/controller_test.go @@ -43,6 +43,7 @@ import ( "k8s.io/ingress-gce/pkg/metrics" "k8s.io/ingress-gce/pkg/neg/syncers/labels" negtypes "k8s.io/ingress-gce/pkg/neg/types" + "k8s.io/ingress-gce/pkg/network" svcnegclient "k8s.io/ingress-gce/pkg/svcneg/client/clientset/versioned" "k8s.io/ingress-gce/pkg/utils" "k8s.io/klog/v2" @@ -108,6 +109,10 @@ var ( }, }, } + + defaultNetwork = &network.NetworkInfo{ + K8sNetwork: "default", + } ) func newTestControllerWithParamsAndContext(kubeClient kubernetes.Interface, testContext *negtypes.TestContext, runL4 bool, enableASM bool) *Controller { @@ -372,8 +377,7 @@ func TestEnableNEGServiceWithL4ILB(t *testing.T) { if err != nil { t.Fatalf("Service was not created.(*apiv1.Service) successfully, err: %v", err) } - expectedPortInfoMap := negtypes.NewPortInfoMapForVMIPNEG(testServiceNamespace, testServiceName, - controller.l4Namer, false) + expectedPortInfoMap := negtypes.NewPortInfoMapForVMIPNEG(testServiceNamespace, testServiceName, controller.l4Namer, false, defaultNetwork) // There will be only one entry in the map for key, val := range expectedPortInfoMap { prevSyncerKey = manager.getSyncerKey(testServiceNamespace, testServiceName, key, val) @@ -394,8 +398,7 @@ func TestEnableNEGServiceWithL4ILB(t *testing.T) { if err = controller.processService(svcKey); err != nil { t.Fatalf("Failed to process updated L4 ILB service: %v", err) } - expectedPortInfoMap = negtypes.NewPortInfoMapForVMIPNEG(testServiceNamespace, testServiceName, - controller.l4Namer, true) + expectedPortInfoMap = negtypes.NewPortInfoMapForVMIPNEG(testServiceNamespace, testServiceName, controller.l4Namer, true, defaultNetwork) // There will be only one entry in the map for key, val := range expectedPortInfoMap { updatedSyncerKey = manager.getSyncerKey(testServiceNamespace, testServiceName, key, val) @@ -687,39 +690,39 @@ func TestSyncNegAnnotation(t *testing.T) { }{ { desc: "apply new annotation with no previous annotation", - portMap: negtypes.NewPortInfoMap(namespace, name, negtypes.NewSvcPortTupleSet(negtypes.SvcPortTuple{Port: 80, TargetPort: "named_port"}, negtypes.SvcPortTuple{Port: 443, TargetPort: "other_port"}), namer, false, nil), + portMap: negtypes.NewPortInfoMap(namespace, name, negtypes.NewSvcPortTupleSet(negtypes.SvcPortTuple{Port: 80, TargetPort: "named_port"}, negtypes.SvcPortTuple{Port: 443, TargetPort: "other_port"}), namer, false, nil, defaultNetwork), }, { desc: "same annotation applied twice", - previousPortMap: negtypes.NewPortInfoMap(namespace, name, negtypes.NewSvcPortTupleSet(negtypes.SvcPortTuple{Port: 80, TargetPort: "named_port"}, negtypes.SvcPortTuple{Port: 4040, TargetPort: "other_port"}), namer, false, nil), - portMap: negtypes.NewPortInfoMap(namespace, name, negtypes.NewSvcPortTupleSet(negtypes.SvcPortTuple{Port: 80, TargetPort: "named_port"}, negtypes.SvcPortTuple{Port: 4040, TargetPort: "other_port"}), namer, false, nil), + previousPortMap: negtypes.NewPortInfoMap(namespace, name, negtypes.NewSvcPortTupleSet(negtypes.SvcPortTuple{Port: 80, TargetPort: "named_port"}, negtypes.SvcPortTuple{Port: 4040, TargetPort: "other_port"}), namer, false, nil, defaultNetwork), + portMap: negtypes.NewPortInfoMap(namespace, name, negtypes.NewSvcPortTupleSet(negtypes.SvcPortTuple{Port: 80, TargetPort: "named_port"}, negtypes.SvcPortTuple{Port: 4040, TargetPort: "other_port"}), namer, false, nil, defaultNetwork), }, { desc: "apply new annotation and override previous annotation", - previousPortMap: negtypes.NewPortInfoMap(namespace, name, negtypes.NewSvcPortTupleSet(negtypes.SvcPortTuple{Port: 80, TargetPort: "named_port"}, negtypes.SvcPortTuple{Port: 4040, TargetPort: "other_port"}), namer, false, nil), - portMap: negtypes.NewPortInfoMap(namespace, name, negtypes.NewSvcPortTupleSet(negtypes.SvcPortTuple{Port: 3000, TargetPort: "6000"}, negtypes.SvcPortTuple{Port: 4000, TargetPort: "8000"}), namer, false, nil), + previousPortMap: negtypes.NewPortInfoMap(namespace, name, negtypes.NewSvcPortTupleSet(negtypes.SvcPortTuple{Port: 80, TargetPort: "named_port"}, negtypes.SvcPortTuple{Port: 4040, TargetPort: "other_port"}), namer, false, nil, defaultNetwork), + portMap: negtypes.NewPortInfoMap(namespace, name, negtypes.NewSvcPortTupleSet(negtypes.SvcPortTuple{Port: 3000, TargetPort: "6000"}, negtypes.SvcPortTuple{Port: 4000, TargetPort: "8000"}), namer, false, nil, defaultNetwork), }, { desc: "remove previous annotation", - previousPortMap: negtypes.NewPortInfoMap(namespace, name, negtypes.NewSvcPortTupleSet(negtypes.SvcPortTuple{Port: 80, TargetPort: "named_port"}, negtypes.SvcPortTuple{Port: 4040, TargetPort: "other_port"}), namer, false, nil), + previousPortMap: negtypes.NewPortInfoMap(namespace, name, negtypes.NewSvcPortTupleSet(negtypes.SvcPortTuple{Port: 80, TargetPort: "named_port"}, negtypes.SvcPortTuple{Port: 4040, TargetPort: "other_port"}), namer, false, nil, defaultNetwork), }, { desc: "remove annotation with no previous annotation", }, { desc: "readiness gate makes no difference 1", - previousPortMap: negtypes.NewPortInfoMap(namespace, name, negtypes.NewSvcPortTupleSet(negtypes.SvcPortTuple{Port: 80, TargetPort: "named_port"}, negtypes.SvcPortTuple{Port: 4040, TargetPort: "other_port"}), namer, false, nil), - portMap: negtypes.NewPortInfoMap(namespace, name, negtypes.NewSvcPortTupleSet(negtypes.SvcPortTuple{Port: 3000, TargetPort: "6000"}, negtypes.SvcPortTuple{Port: 4000, TargetPort: "8000"}), namer, true, nil), + previousPortMap: negtypes.NewPortInfoMap(namespace, name, negtypes.NewSvcPortTupleSet(negtypes.SvcPortTuple{Port: 80, TargetPort: "named_port"}, negtypes.SvcPortTuple{Port: 4040, TargetPort: "other_port"}), namer, false, nil, defaultNetwork), + portMap: negtypes.NewPortInfoMap(namespace, name, negtypes.NewSvcPortTupleSet(negtypes.SvcPortTuple{Port: 3000, TargetPort: "6000"}, negtypes.SvcPortTuple{Port: 4000, TargetPort: "8000"}), namer, true, nil, defaultNetwork), }, { desc: "readiness gate makes no difference 2", - previousPortMap: negtypes.NewPortInfoMap(namespace, name, negtypes.NewSvcPortTupleSet(negtypes.SvcPortTuple{Port: 80, TargetPort: "named_port"}, negtypes.SvcPortTuple{Port: 4040, TargetPort: "other_port"}), namer, true, nil), - portMap: negtypes.NewPortInfoMap(namespace, name, negtypes.NewSvcPortTupleSet(negtypes.SvcPortTuple{Port: 80, TargetPort: "named_port"}, negtypes.SvcPortTuple{Port: 4040, TargetPort: "other_port"}), namer, false, nil), + previousPortMap: negtypes.NewPortInfoMap(namespace, name, negtypes.NewSvcPortTupleSet(negtypes.SvcPortTuple{Port: 80, TargetPort: "named_port"}, negtypes.SvcPortTuple{Port: 4040, TargetPort: "other_port"}), namer, true, nil, defaultNetwork), + portMap: negtypes.NewPortInfoMap(namespace, name, negtypes.NewSvcPortTupleSet(negtypes.SvcPortTuple{Port: 80, TargetPort: "named_port"}, negtypes.SvcPortTuple{Port: 4040, TargetPort: "other_port"}), namer, false, nil, defaultNetwork), }, { desc: "no difference with port name", - previousPortMap: negtypes.NewPortInfoMap(namespace, name, negtypes.NewSvcPortTupleSet(negtypes.SvcPortTuple{Port: 80, TargetPort: "named_port"}, negtypes.SvcPortTuple{Port: 4040, TargetPort: "other_port"}), namer, true, nil), - portMap: negtypes.NewPortInfoMap(namespace, name, negtypes.NewSvcPortTupleSet(negtypes.SvcPortTuple{Port: 80, Name: "foo", TargetPort: "named_port"}, negtypes.SvcPortTuple{Port: 4040, Name: "bar", TargetPort: "other_port"}), namer, false, nil), + previousPortMap: negtypes.NewPortInfoMap(namespace, name, negtypes.NewSvcPortTupleSet(negtypes.SvcPortTuple{Port: 80, TargetPort: "named_port"}, negtypes.SvcPortTuple{Port: 4040, TargetPort: "other_port"}), namer, true, nil, defaultNetwork), + portMap: negtypes.NewPortInfoMap(namespace, name, negtypes.NewSvcPortTupleSet(negtypes.SvcPortTuple{Port: 80, Name: "foo", TargetPort: "named_port"}, negtypes.SvcPortTuple{Port: 4040, Name: "bar", TargetPort: "other_port"}), namer, false, nil, defaultNetwork), }, } @@ -798,14 +801,7 @@ func TestDefaultBackendServicePortInfoMapForL7ILB(t *testing.T) { forIlb: true, defaultOverride: true, defaultBackendServiceServicePort: defaultBackend, - want: negtypes.NewPortInfoMap( - defaultBackend.ID.Service.Namespace, - defaultBackend.ID.Service.Name, - negtypes.NewSvcPortTupleSet(negtypes.SvcPortTuple{Name: "http", Port: 80, TargetPort: defaultBackend.TargetPort.String()}), - controller.namer, - false, - nil, - ), + want: negtypes.NewPortInfoMap(defaultBackend.ID.Service.Namespace, defaultBackend.ID.Service.Name, negtypes.NewSvcPortTupleSet(negtypes.SvcPortTuple{Name: "http", Port: 80, TargetPort: defaultBackend.TargetPort.String()}), controller.namer, false, nil, defaultNetwork), }, { desc: "User default backend with different port", @@ -823,14 +819,7 @@ func TestDefaultBackendServicePortInfoMapForL7ILB(t *testing.T) { Port: 80, TargetPort: intstr.FromInt(8888), }, - want: negtypes.NewPortInfoMap( - testServiceNamespace, - "newDefaultBackend", - negtypes.NewSvcPortTupleSet(negtypes.SvcPortTuple{Name: "80", Port: 80, TargetPort: "8888"}), - controller.namer, - false, - nil, - ), + want: negtypes.NewPortInfoMap(testServiceNamespace, "newDefaultBackend", negtypes.NewSvcPortTupleSet(negtypes.SvcPortTuple{Name: "80", Port: 80, TargetPort: "8888"}), controller.namer, false, nil, defaultNetwork), }, } for _, tc := range testCases { @@ -857,7 +846,7 @@ func TestDefaultBackendServicePortInfoMapForL7ILB(t *testing.T) { t.Fatal(err) } result := make(negtypes.PortInfoMap) - controller.mergeDefaultBackendServicePortInfoMap(controller.defaultBackendService.ID.Service.String(), defaultBackendService, result) + controller.mergeDefaultBackendServicePortInfoMap(controller.defaultBackendService.ID.Service.String(), defaultBackendService, result, defaultNetwork) if !reflect.DeepEqual(tc.want, result) { t.Fatalf("got %+v, want %+v", result, tc.want) } @@ -870,14 +859,7 @@ func TestMergeDefaultBackendServicePortInfoMap(t *testing.T) { controller.defaultBackendService = defaultBackend newTestService(controller, false, []int32{}) defaultBackendServiceKey := defaultBackend.ID.Service.String() - expectPortMap := negtypes.NewPortInfoMap( - defaultBackend.ID.Service.Namespace, - defaultBackend.ID.Service.Name, - negtypes.NewSvcPortTupleSet(negtypes.SvcPortTuple{Name: "http", Port: 80, TargetPort: defaultBackend.TargetPort.String()}), - controller.namer, - false, - nil, - ) + expectPortMap := negtypes.NewPortInfoMap(defaultBackend.ID.Service.Namespace, defaultBackend.ID.Service.Name, negtypes.NewSvcPortTupleSet(negtypes.SvcPortTuple{Name: "http", Port: 80, TargetPort: defaultBackend.TargetPort.String()}), controller.namer, false, nil, defaultNetwork) expectEmptyPortmap := make(negtypes.PortInfoMap) for _, tc := range []struct { @@ -971,7 +953,7 @@ func TestMergeDefaultBackendServicePortInfoMap(t *testing.T) { } portMap := make(negtypes.PortInfoMap) - if err := controller.mergeDefaultBackendServicePortInfoMap(defaultBackendServiceKey, tc.defaultService, portMap); err != nil { + if err := controller.mergeDefaultBackendServicePortInfoMap(defaultBackendServiceKey, tc.defaultService, portMap, defaultNetwork); err != nil { t.Errorf("for test case %q, expect err == nil; but got %v", tc.desc, err) } @@ -992,14 +974,7 @@ func TestEnableASM(t *testing.T) { controller := newTestControllerWithASM(fake.NewSimpleClientset()) defer controller.stop() testSvc := newTestServiceCus(t, controller, "namespace1", "service1", []int32{80, 90}) - wantSvcPortMap := negtypes.NewPortInfoMap( - "namespace1", - "service1", - negtypes.NewSvcPortTupleSet(negtypes.SvcPortTuple{Name: "port80", Port: 80, TargetPort: "80"}, negtypes.SvcPortTuple{Name: "port90", Port: 90, TargetPort: "90"}), - controller.namer, - false, - nil, - ) + wantSvcPortMap := negtypes.NewPortInfoMap("namespace1", "service1", negtypes.NewSvcPortTupleSet(negtypes.SvcPortTuple{Name: "port80", Port: 80, TargetPort: "80"}, negtypes.SvcPortTuple{Name: "port90", Port: 90, TargetPort: "90"}), controller.namer, false, nil, defaultNetwork) svcKey := utils.ServiceKeyFunc(testSvc.GetNamespace(), testSvc.GetName()) @@ -1039,39 +1014,25 @@ func TestMergeCSMPortInfoMap(t *testing.T) { wantSvcPortMap negtypes.PortInfoMap }{ { - desc: "controller should create NEGs for services and destinationrules", - srvNamespace: "namespace1", - srvName: "service1", - service: n1s1, - wantSvcPortMap: negtypes.NewPortInfoMap( - "namespace1", - "service1", - negtypes.NewSvcPortTupleSet(negtypes.SvcPortTuple{Name: "port80", Port: 80, TargetPort: "80"}, negtypes.SvcPortTuple{Name: "port90", Port: 90, TargetPort: "90"}), - controller.namer, - false, - nil, - ), + desc: "controller should create NEGs for services and destinationrules", + srvNamespace: "namespace1", + srvName: "service1", + service: n1s1, + wantSvcPortMap: negtypes.NewPortInfoMap("namespace1", "service1", negtypes.NewSvcPortTupleSet(negtypes.SvcPortTuple{Name: "port80", Port: 80, TargetPort: "80"}, negtypes.SvcPortTuple{Name: "port90", Port: 90, TargetPort: "90"}), controller.namer, false, nil, defaultNetwork), }, { - desc: "controller should create NEGs for services", - srvNamespace: "namespace2", - srvName: "service1", - service: n2s1, - wantSvcPortMap: negtypes.NewPortInfoMap( - "namespace2", - "service1", - negtypes.NewSvcPortTupleSet(negtypes.SvcPortTuple{Name: "port90", Port: 90, TargetPort: "90"}), - controller.namer, - false, - nil, - ), + desc: "controller should create NEGs for services", + srvNamespace: "namespace2", + srvName: "service1", + service: n2s1, + wantSvcPortMap: negtypes.NewPortInfoMap("namespace2", "service1", negtypes.NewSvcPortTupleSet(negtypes.SvcPortTuple{Name: "port90", Port: 90, TargetPort: "90"}), controller.namer, false, nil, defaultNetwork), }, } for _, tc := range testcases { t.Run(tc.desc, func(t *testing.T) { portInfoMap := make(negtypes.PortInfoMap) - portInfoMap, err := controller.getCSMPortInfoMap(tc.srvNamespace, tc.srvName, tc.service) + portInfoMap, err := controller.getCSMPortInfoMap(tc.srvNamespace, tc.srvName, tc.service, defaultNetwork) if err != nil { t.Fatalf("Failed to run mergeCSMPortInfoMap: %v", err) } diff --git a/pkg/neg/manager.go b/pkg/neg/manager.go index d136cfe443..c948b283e0 100644 --- a/pkg/neg/manager.go +++ b/pkg/neg/manager.go @@ -255,6 +255,7 @@ func (manager *syncerManager) EnsureSyncers(namespace, name string, newPorts neg manager.logger, manager.lpConfig, manager.enableDualStackNEG, + portInfo.NetworkInfo, ) manager.syncerMap[syncerKey] = syncer } diff --git a/pkg/neg/manager_test.go b/pkg/neg/manager_test.go index c86eb976a5..ca9959a9a8 100644 --- a/pkg/neg/manager_test.go +++ b/pkg/neg/manager_test.go @@ -128,7 +128,7 @@ func TestEnsureAndStopSyncer(t *testing.T) { desc: "add 2 new ports", namespace: svcNamespace1, name: svcName, - portInfoMap: negtypes.NewPortInfoMap(svcNamespace1, svcName, types.NewSvcPortTupleSet(negtypes.SvcPortTuple{Port: 1000, TargetPort: "80"}, negtypes.SvcPortTuple{Port: 2000, TargetPort: "443"}), namer, false, nil), + portInfoMap: negtypes.NewPortInfoMap(svcNamespace1, svcName, types.NewSvcPortTupleSet(negtypes.SvcPortTuple{Port: 1000, TargetPort: "80"}, negtypes.SvcPortTuple{Port: 2000, TargetPort: "443"}), namer, false, nil, defaultNetwork), stop: false, expectInternals: map[negtypes.NegSyncerKey]bool{ manager.getSyncerKey(svcNamespace1, svcName, negtypes.PortInfoMapKey{ServicePort: 1000}, negtypes.PortInfo{PortTuple: negtypes.SvcPortTuple{Port: 1000, TargetPort: "80"}, NegName: namer.NEG(svcNamespace1, svcName, 1000)}): false, @@ -139,7 +139,7 @@ func TestEnsureAndStopSyncer(t *testing.T) { desc: "modify 1 port to enable readinessGate", namespace: svcNamespace1, name: svcName, - portInfoMap: portInfoUnion(negtypes.NewPortInfoMap(svcNamespace1, svcName, types.NewSvcPortTupleSet(negtypes.SvcPortTuple{Port: 1000, TargetPort: "80"}), namer, false, nil), negtypes.NewPortInfoMap(svcNamespace1, svcName, types.NewSvcPortTupleSet(negtypes.SvcPortTuple{Port: 2000, TargetPort: "443"}), namer, true, nil)), + portInfoMap: portInfoUnion(negtypes.NewPortInfoMap(svcNamespace1, svcName, types.NewSvcPortTupleSet(negtypes.SvcPortTuple{Port: 1000, TargetPort: "80"}), namer, false, nil, defaultNetwork), negtypes.NewPortInfoMap(svcNamespace1, svcName, types.NewSvcPortTupleSet(negtypes.SvcPortTuple{Port: 2000, TargetPort: "443"}), namer, true, nil, defaultNetwork)), stop: false, expectInternals: map[negtypes.NegSyncerKey]bool{ manager.getSyncerKey(svcNamespace1, svcName, negtypes.PortInfoMapKey{ServicePort: 1000}, negtypes.PortInfo{PortTuple: negtypes.SvcPortTuple{Port: 1000, TargetPort: "80"}, NegName: namer.NEG(svcNamespace1, svcName, 1000)}): false, @@ -151,7 +151,7 @@ func TestEnsureAndStopSyncer(t *testing.T) { desc: "add 2 new ports, remove 2 existing ports", namespace: svcNamespace1, name: svcName, - portInfoMap: negtypes.NewPortInfoMap(svcNamespace1, svcName, types.NewSvcPortTupleSet(negtypes.SvcPortTuple{Port: 3000, TargetPort: "80"}, negtypes.SvcPortTuple{Port: 4000, TargetPort: "namedport"}), namer, false, nil), + portInfoMap: negtypes.NewPortInfoMap(svcNamespace1, svcName, types.NewSvcPortTupleSet(negtypes.SvcPortTuple{Port: 3000, TargetPort: "80"}, negtypes.SvcPortTuple{Port: 4000, TargetPort: "namedport"}), namer, false, nil, defaultNetwork), stop: false, expectInternals: map[negtypes.NegSyncerKey]bool{ manager.getSyncerKey(svcNamespace1, svcName, negtypes.PortInfoMapKey{ServicePort: 3000}, negtypes.PortInfo{PortTuple: negtypes.SvcPortTuple{Port: 3000, TargetPort: "80"}, NegName: namer.NEG(svcNamespace1, svcName, 3000)}): false, @@ -162,7 +162,7 @@ func TestEnsureAndStopSyncer(t *testing.T) { desc: "modify 2 existing ports to enable readinessGate", namespace: svcNamespace1, name: svcName, - portInfoMap: negtypes.NewPortInfoMap(svcNamespace1, svcName, types.NewSvcPortTupleSet(negtypes.SvcPortTuple{Port: 3000, TargetPort: "80"}, negtypes.SvcPortTuple{Port: 4000, TargetPort: "namedport"}), namer, true, nil), + portInfoMap: negtypes.NewPortInfoMap(svcNamespace1, svcName, types.NewSvcPortTupleSet(negtypes.SvcPortTuple{Port: 3000, TargetPort: "80"}, negtypes.SvcPortTuple{Port: 4000, TargetPort: "namedport"}), namer, true, nil, defaultNetwork), stop: false, expectInternals: map[negtypes.NegSyncerKey]bool{ manager.getSyncerKey(svcNamespace1, svcName, negtypes.PortInfoMapKey{ServicePort: 3000}, negtypes.PortInfo{PortTuple: negtypes.SvcPortTuple{Port: 3000, TargetPort: "80"}, NegName: namer.NEG(svcNamespace1, svcName, 3000)}): true, @@ -173,7 +173,7 @@ func TestEnsureAndStopSyncer(t *testing.T) { desc: "add 1 new port for a different service", namespace: svcNamespace2, name: svcName, - portInfoMap: negtypes.NewPortInfoMap(svcNamespace2, svcName, types.NewSvcPortTupleSet(negtypes.SvcPortTuple{Port: 3000, TargetPort: "80"}), namer, false, nil), + portInfoMap: negtypes.NewPortInfoMap(svcNamespace2, svcName, types.NewSvcPortTupleSet(negtypes.SvcPortTuple{Port: 3000, TargetPort: "80"}), namer, false, nil, defaultNetwork), stop: false, expectInternals: map[negtypes.NegSyncerKey]bool{ manager.getSyncerKey(svcNamespace1, svcName, negtypes.PortInfoMapKey{ServicePort: 3000}, negtypes.PortInfo{PortTuple: negtypes.SvcPortTuple{Port: 3000, TargetPort: "80"}, NegName: namer.NEG(svcNamespace1, svcName, 3000)}): true, @@ -185,7 +185,7 @@ func TestEnsureAndStopSyncer(t *testing.T) { desc: "change target port of 1 existing port", namespace: svcNamespace1, name: svcName, - portInfoMap: negtypes.NewPortInfoMap(svcNamespace1, svcName, types.NewSvcPortTupleSet(negtypes.SvcPortTuple{Port: 3000, TargetPort: "80"}, negtypes.SvcPortTuple{Port: 4000, TargetPort: "443"}), namer, true, nil), + portInfoMap: negtypes.NewPortInfoMap(svcNamespace1, svcName, types.NewSvcPortTupleSet(negtypes.SvcPortTuple{Port: 3000, TargetPort: "80"}, negtypes.SvcPortTuple{Port: 4000, TargetPort: "443"}), namer, true, nil, defaultNetwork), stop: false, expectInternals: map[negtypes.NegSyncerKey]bool{ manager.getSyncerKey(svcNamespace1, svcName, negtypes.PortInfoMapKey{ServicePort: 3000}, negtypes.PortInfo{PortTuple: negtypes.SvcPortTuple{Port: 3000, TargetPort: "80"}, NegName: namer.NEG(svcNamespace1, svcName, 3000)}): true, @@ -208,7 +208,7 @@ func TestEnsureAndStopSyncer(t *testing.T) { namespace: svcNamespace1, name: svcName, stop: false, - portInfoMap: negtypes.NewPortInfoMap(svcNamespace1, svcName, types.NewSvcPortTupleSet(negtypes.SvcPortTuple{Name: portName1, Port: 3000, TargetPort: "80"}, negtypes.SvcPortTuple{Name: portName2, Port: 4000, TargetPort: "bar"}), namer, true, nil), + portInfoMap: negtypes.NewPortInfoMap(svcNamespace1, svcName, types.NewSvcPortTupleSet(negtypes.SvcPortTuple{Name: portName1, Port: 3000, TargetPort: "80"}, negtypes.SvcPortTuple{Name: portName2, Port: 4000, TargetPort: "bar"}), namer, true, nil, defaultNetwork), expectInternals: map[negtypes.NegSyncerKey]bool{ manager.getSyncerKey(svcNamespace2, svcName, negtypes.PortInfoMapKey{ServicePort: 3000}, negtypes.PortInfo{PortTuple: negtypes.SvcPortTuple{Port: 3000, TargetPort: "80"}, NegName: namer.NEG(svcNamespace2, svcName, 3000)}): false, manager.getSyncerKey(svcNamespace1, svcName, negtypes.PortInfoMapKey{ServicePort: 3000}, negtypes.PortInfo{PortTuple: negtypes.SvcPortTuple{Name: portName1, Port: 3000, TargetPort: "80"}, NegName: namer.NEG(svcNamespace1, svcName, 3000)}): true, @@ -221,7 +221,7 @@ func TestEnsureAndStopSyncer(t *testing.T) { namespace: svcNamespace1, name: svcName, stop: false, - portInfoMap: negtypes.NewPortInfoMap(svcNamespace1, svcName, types.NewSvcPortTupleSet(negtypes.SvcPortTuple{Name: portName2, Port: 3000, TargetPort: "80"}, negtypes.SvcPortTuple{Name: portName0, Port: 4000, TargetPort: "bar"}), namer, true, nil), + portInfoMap: negtypes.NewPortInfoMap(svcNamespace1, svcName, types.NewSvcPortTupleSet(negtypes.SvcPortTuple{Name: portName2, Port: 3000, TargetPort: "80"}, negtypes.SvcPortTuple{Name: portName0, Port: 4000, TargetPort: "bar"}), namer, true, nil, defaultNetwork), expectInternals: map[negtypes.NegSyncerKey]bool{ manager.getSyncerKey(svcNamespace2, svcName, negtypes.PortInfoMapKey{ServicePort: 3000}, negtypes.PortInfo{PortTuple: negtypes.SvcPortTuple{Port: 3000, TargetPort: "80"}, NegName: namer.NEG(svcNamespace2, svcName, 3000)}): false, manager.getSyncerKey(svcNamespace1, svcName, negtypes.PortInfoMapKey{ServicePort: 3000}, negtypes.PortInfo{PortTuple: negtypes.SvcPortTuple{Name: portName2, Port: 3000, TargetPort: "80"}, NegName: namer.NEG(svcNamespace1, svcName, 3000)}): true, @@ -234,7 +234,7 @@ func TestEnsureAndStopSyncer(t *testing.T) { namespace: svcNamespace1, name: svcName, stop: false, - portInfoMap: negtypes.NewPortInfoMap(svcNamespace1, svcName, types.NewSvcPortTupleSet(negtypes.SvcPortTuple{Name: portName2, Port: 3000, TargetPort: "80"}, negtypes.SvcPortTuple{Name: portName0, Port: 4000, TargetPort: "bar"}, negtypes.SvcPortTuple{Name: string(negtypes.VmIpEndpointType), Port: 0}), namer, true, nil), + portInfoMap: negtypes.NewPortInfoMap(svcNamespace1, svcName, types.NewSvcPortTupleSet(negtypes.SvcPortTuple{Name: portName2, Port: 3000, TargetPort: "80"}, negtypes.SvcPortTuple{Name: portName0, Port: 4000, TargetPort: "bar"}, negtypes.SvcPortTuple{Name: string(negtypes.VmIpEndpointType), Port: 0}), namer, true, nil, defaultNetwork), expectInternals: map[negtypes.NegSyncerKey]bool{ manager.getSyncerKey(svcNamespace2, svcName, negtypes.PortInfoMapKey{ServicePort: 3000}, negtypes.PortInfo{PortTuple: negtypes.SvcPortTuple{Port: 3000, TargetPort: "80"}, NegName: namer.NEG(svcNamespace2, svcName, 3000)}): false, manager.getSyncerKey(svcNamespace1, svcName, negtypes.PortInfoMapKey{ServicePort: 3000}, negtypes.PortInfo{PortTuple: negtypes.SvcPortTuple{Name: portName2, Port: 3000, TargetPort: "80"}, NegName: namer.NEG(svcNamespace1, svcName, 3000)}): true, @@ -668,38 +668,38 @@ func TestFilterCommonPorts(t *testing.T) { }, { desc: "empty input 2", - p1: negtypes.NewPortInfoMap(namespace1, name1, types.NewSvcPortTupleSet(negtypes.SvcPortTuple{Port: port1, TargetPort: targetPort1}, negtypes.SvcPortTuple{Port: port2, TargetPort: targetPort2}), namer, false, nil), + p1: negtypes.NewPortInfoMap(namespace1, name1, types.NewSvcPortTupleSet(negtypes.SvcPortTuple{Port: port1, TargetPort: targetPort1}, negtypes.SvcPortTuple{Port: port2, TargetPort: targetPort2}), namer, false, nil, defaultNetwork), p2: negtypes.PortInfoMap{}, - expectP1: negtypes.NewPortInfoMap(namespace1, name1, types.NewSvcPortTupleSet(negtypes.SvcPortTuple{Port: port1, TargetPort: targetPort1}, negtypes.SvcPortTuple{Port: port2, TargetPort: targetPort2}), namer, false, nil), + expectP1: negtypes.NewPortInfoMap(namespace1, name1, types.NewSvcPortTupleSet(negtypes.SvcPortTuple{Port: port1, TargetPort: targetPort1}, negtypes.SvcPortTuple{Port: port2, TargetPort: targetPort2}), namer, false, nil, defaultNetwork), expectP2: negtypes.PortInfoMap{}, }, { desc: "empty input 3", p1: negtypes.PortInfoMap{}, - p2: negtypes.NewPortInfoMap(namespace1, name1, types.NewSvcPortTupleSet(negtypes.SvcPortTuple{Port: port1, TargetPort: targetPort1}, negtypes.SvcPortTuple{Port: port2, TargetPort: targetPort2}), namer, true, nil), + p2: negtypes.NewPortInfoMap(namespace1, name1, types.NewSvcPortTupleSet(negtypes.SvcPortTuple{Port: port1, TargetPort: targetPort1}, negtypes.SvcPortTuple{Port: port2, TargetPort: targetPort2}), namer, true, nil, defaultNetwork), expectP1: negtypes.PortInfoMap{}, - expectP2: negtypes.NewPortInfoMap(namespace1, name1, types.NewSvcPortTupleSet(negtypes.SvcPortTuple{Port: port1, TargetPort: targetPort1}, negtypes.SvcPortTuple{Port: port2, TargetPort: targetPort2}), namer, true, nil), + expectP2: negtypes.NewPortInfoMap(namespace1, name1, types.NewSvcPortTupleSet(negtypes.SvcPortTuple{Port: port1, TargetPort: targetPort1}, negtypes.SvcPortTuple{Port: port2, TargetPort: targetPort2}), namer, true, nil, defaultNetwork), }, { desc: "difference in readiness gate", - p1: negtypes.NewPortInfoMap(namespace1, name1, types.NewSvcPortTupleSet(negtypes.SvcPortTuple{Port: port1, TargetPort: targetPort1}, negtypes.SvcPortTuple{Port: port2, TargetPort: targetPort2}), namer, false, nil), - p2: negtypes.NewPortInfoMap(namespace1, name1, types.NewSvcPortTupleSet(negtypes.SvcPortTuple{Port: port1, TargetPort: targetPort1}, negtypes.SvcPortTuple{Port: port2, TargetPort: targetPort2}), namer, true, nil), + p1: negtypes.NewPortInfoMap(namespace1, name1, types.NewSvcPortTupleSet(negtypes.SvcPortTuple{Port: port1, TargetPort: targetPort1}, negtypes.SvcPortTuple{Port: port2, TargetPort: targetPort2}), namer, false, nil, defaultNetwork), + p2: negtypes.NewPortInfoMap(namespace1, name1, types.NewSvcPortTupleSet(negtypes.SvcPortTuple{Port: port1, TargetPort: targetPort1}, negtypes.SvcPortTuple{Port: port2, TargetPort: targetPort2}), namer, true, nil, defaultNetwork), expectP1: negtypes.PortInfoMap{}, expectP2: negtypes.PortInfoMap{}, }, { desc: "difference in port name and readiness gate", - p1: negtypes.NewPortInfoMap(namespace1, name1, types.NewSvcPortTupleSet(negtypes.SvcPortTuple{Name: portName1, Port: port1, TargetPort: targetPort1}, negtypes.SvcPortTuple{Port: port2, TargetPort: targetPort2}), namer, false, nil), - p2: negtypes.NewPortInfoMap(namespace1, name1, types.NewSvcPortTupleSet(negtypes.SvcPortTuple{Port: port1, TargetPort: targetPort1}, negtypes.SvcPortTuple{Port: port2, TargetPort: targetPort2}), namer, true, nil), - expectP1: negtypes.NewPortInfoMap(namespace1, name1, types.NewSvcPortTupleSet(negtypes.SvcPortTuple{Name: portName1, Port: port1, TargetPort: targetPort1}), namer, false, nil), - expectP2: negtypes.NewPortInfoMap(namespace1, name1, types.NewSvcPortTupleSet(negtypes.SvcPortTuple{Port: port1, TargetPort: targetPort1}), namer, true, nil), + p1: negtypes.NewPortInfoMap(namespace1, name1, types.NewSvcPortTupleSet(negtypes.SvcPortTuple{Name: portName1, Port: port1, TargetPort: targetPort1}, negtypes.SvcPortTuple{Port: port2, TargetPort: targetPort2}), namer, false, nil, defaultNetwork), + p2: negtypes.NewPortInfoMap(namespace1, name1, types.NewSvcPortTupleSet(negtypes.SvcPortTuple{Port: port1, TargetPort: targetPort1}, negtypes.SvcPortTuple{Port: port2, TargetPort: targetPort2}), namer, true, nil, defaultNetwork), + expectP1: negtypes.NewPortInfoMap(namespace1, name1, types.NewSvcPortTupleSet(negtypes.SvcPortTuple{Name: portName1, Port: port1, TargetPort: targetPort1}), namer, false, nil, defaultNetwork), + expectP2: negtypes.NewPortInfoMap(namespace1, name1, types.NewSvcPortTupleSet(negtypes.SvcPortTuple{Port: port1, TargetPort: targetPort1}), namer, true, nil, defaultNetwork), }, { desc: "difference in neg name", - p1: negtypes.NewPortInfoMap(namespace1, name1, types.NewSvcPortTupleSet(negtypes.SvcPortTuple{Port: port1, TargetPort: targetPort1}, negtypes.SvcPortTuple{Port: port2, TargetPort: targetPort2}), namer, false, map[negtypes.SvcPortTuple]string{{Port: port1, TargetPort: targetPort1}: negName1}), - p2: negtypes.NewPortInfoMap(namespace1, name1, types.NewSvcPortTupleSet(negtypes.SvcPortTuple{Port: port1, TargetPort: targetPort1}, negtypes.SvcPortTuple{Port: port2, TargetPort: targetPort2}), namer, true, nil), - expectP1: negtypes.NewPortInfoMap(namespace1, name1, types.NewSvcPortTupleSet(negtypes.SvcPortTuple{Port: port1, TargetPort: targetPort1}), namer, false, map[negtypes.SvcPortTuple]string{{Port: port1, TargetPort: targetPort1}: negName1}), - expectP2: negtypes.NewPortInfoMap(namespace1, name1, types.NewSvcPortTupleSet(negtypes.SvcPortTuple{Port: port1, TargetPort: targetPort1}), namer, true, nil), + p1: negtypes.NewPortInfoMap(namespace1, name1, types.NewSvcPortTupleSet(negtypes.SvcPortTuple{Port: port1, TargetPort: targetPort1}, negtypes.SvcPortTuple{Port: port2, TargetPort: targetPort2}), namer, false, map[negtypes.SvcPortTuple]string{{Port: port1, TargetPort: targetPort1}: negName1}, defaultNetwork), + p2: negtypes.NewPortInfoMap(namespace1, name1, types.NewSvcPortTupleSet(negtypes.SvcPortTuple{Port: port1, TargetPort: targetPort1}, negtypes.SvcPortTuple{Port: port2, TargetPort: targetPort2}), namer, true, nil, defaultNetwork), + expectP1: negtypes.NewPortInfoMap(namespace1, name1, types.NewSvcPortTupleSet(negtypes.SvcPortTuple{Port: port1, TargetPort: targetPort1}), namer, false, map[negtypes.SvcPortTuple]string{{Port: port1, TargetPort: targetPort1}: negName1}, defaultNetwork), + expectP2: negtypes.NewPortInfoMap(namespace1, name1, types.NewSvcPortTupleSet(negtypes.SvcPortTuple{Port: port1, TargetPort: targetPort1}), namer, true, nil, defaultNetwork), }, } { t.Run(tc.desc, func(t *testing.T) { @@ -742,14 +742,9 @@ func TestNegCRCreations(t *testing.T) { t.Errorf("failed to add sample service to service store: %s", err) } - expectedPortInfoMap := negtypes.NewPortInfoMap( - svcNamespace, - svcName, - types.NewSvcPortTupleSet( - negtypes.SvcPortTuple{Port: port1, TargetPort: targetPort1}, - negtypes.SvcPortTuple{Port: port2, TargetPort: targetPort2}), - namer, false, - map[negtypes.SvcPortTuple]string{{Port: port1, TargetPort: targetPort1}: customNegName}) + expectedPortInfoMap := negtypes.NewPortInfoMap(svcNamespace, svcName, types.NewSvcPortTupleSet( + negtypes.SvcPortTuple{Port: port1, TargetPort: targetPort1}, + negtypes.SvcPortTuple{Port: port2, TargetPort: targetPort2}), namer, false, map[negtypes.SvcPortTuple]string{{Port: port1, TargetPort: targetPort1}: customNegName}, defaultNetwork) if _, _, err := manager.EnsureSyncers(svcNamespace, svcName, expectedPortInfoMap); err != nil { t.Errorf("failed to ensure syncer %s/%s-%v: %v", svcNamespace, svcName, expectedPortInfoMap, err) @@ -990,13 +985,7 @@ func TestNegCRDuplicateCreations(t *testing.T) { t.Errorf("failed to add sample service to service store: %s", err) } - portInfoMap := negtypes.NewPortInfoMap( - namespace, - svc1.Name, - types.NewSvcPortTupleSet(svcTuple1), - namer, false, - map[negtypes.SvcPortTuple]string{svcTuple1: customNegName}, - ) + portInfoMap := negtypes.NewPortInfoMap(namespace, svc1.Name, types.NewSvcPortTupleSet(svcTuple1), namer, false, map[negtypes.SvcPortTuple]string{svcTuple1: customNegName}, defaultNetwork) rebuildSvcNegCache(t, manager, manager.svcNegClient, namespace) _, _, err := manager.EnsureSyncers(namespace, svc1.Name, portInfoMap) @@ -1086,15 +1075,9 @@ func TestNegCRDeletions(t *testing.T) { // set up manager current state before deleting namer := manager.namer - expectedPortInfoMap := negtypes.NewPortInfoMap( - svcNamespace, - svcName, - types.NewSvcPortTupleSet( - negtypes.SvcPortTuple{Port: port1, TargetPort: targetPort1}, - negtypes.SvcPortTuple{Port: port2, TargetPort: targetPort2}), - namer, false, - map[negtypes.SvcPortTuple]string{{Port: port1, TargetPort: targetPort1}: customNegName}, - ) + expectedPortInfoMap := negtypes.NewPortInfoMap(svcNamespace, svcName, types.NewSvcPortTupleSet( + negtypes.SvcPortTuple{Port: port1, TargetPort: targetPort1}, + negtypes.SvcPortTuple{Port: port2, TargetPort: targetPort2}), namer, false, map[negtypes.SvcPortTuple]string{{Port: port1, TargetPort: targetPort1}: customNegName}, defaultNetwork) svcPortMap := map[serviceKey]negtypes.PortInfoMap{ {namespace: svcNamespace, name: svcName}: expectedPortInfoMap, @@ -1657,35 +1640,35 @@ func populateSyncerManager(manager *syncerManager, kubeClient kubernetes.Interfa { namespace: namespace1, name: name1, - portInfoMap: portInfoUnion(negtypes.NewPortInfoMap(namespace1, name1, types.NewSvcPortTupleSet(negtypes.SvcPortTuple{Port: port1, TargetPort: targetPort1}, negtypes.SvcPortTuple{Port: port2, TargetPort: targetPort2}), namer, false, nil), - negtypes.NewPortInfoMap(namespace1, name1, types.NewSvcPortTupleSet(negtypes.SvcPortTuple{Port: port3, TargetPort: targetPort3}, negtypes.SvcPortTuple{Port: port4, TargetPort: targetPort4}), namer, true, nil)), + portInfoMap: portInfoUnion(negtypes.NewPortInfoMap(namespace1, name1, types.NewSvcPortTupleSet(negtypes.SvcPortTuple{Port: port1, TargetPort: targetPort1}, negtypes.SvcPortTuple{Port: port2, TargetPort: targetPort2}), namer, false, nil, defaultNetwork), + negtypes.NewPortInfoMap(namespace1, name1, types.NewSvcPortTupleSet(negtypes.SvcPortTuple{Port: port3, TargetPort: targetPort3}, negtypes.SvcPortTuple{Port: port4, TargetPort: targetPort4}), namer, true, nil, defaultNetwork)), selector: map[string]string{labelKey1: labelValue1}, }, { // nil selector namespace: namespace1, name: name2, - portInfoMap: portInfoUnion(negtypes.NewPortInfoMap(namespace1, name2, types.NewSvcPortTupleSet(negtypes.SvcPortTuple{Port: port1, TargetPort: targetPort1}, negtypes.SvcPortTuple{Port: port2, TargetPort: targetPort2}), namer, false, nil), - negtypes.NewPortInfoMap(namespace1, name2, types.NewSvcPortTupleSet(negtypes.SvcPortTuple{Port: port3, TargetPort: targetPort3}, negtypes.SvcPortTuple{Port: port4, TargetPort: targetPort4}), namer, true, nil)), + portInfoMap: portInfoUnion(negtypes.NewPortInfoMap(namespace1, name2, types.NewSvcPortTupleSet(negtypes.SvcPortTuple{Port: port1, TargetPort: targetPort1}, negtypes.SvcPortTuple{Port: port2, TargetPort: targetPort2}), namer, false, nil, defaultNetwork), + negtypes.NewPortInfoMap(namespace1, name2, types.NewSvcPortTupleSet(negtypes.SvcPortTuple{Port: port3, TargetPort: targetPort3}, negtypes.SvcPortTuple{Port: port4, TargetPort: targetPort4}), namer, true, nil, defaultNetwork)), selector: nil, }, { namespace: namespace2, name: name1, - portInfoMap: negtypes.NewPortInfoMap(namespace1, name1, types.NewSvcPortTupleSet(negtypes.SvcPortTuple{Port: port1, TargetPort: targetPort1}, negtypes.SvcPortTuple{Port: port2, TargetPort: targetPort2}), namer, false, nil), + portInfoMap: negtypes.NewPortInfoMap(namespace1, name1, types.NewSvcPortTupleSet(negtypes.SvcPortTuple{Port: port1, TargetPort: targetPort1}, negtypes.SvcPortTuple{Port: port2, TargetPort: targetPort2}), namer, false, nil, defaultNetwork), selector: map[string]string{labelKey1: labelValue1}, }, { namespace: namespace2, name: name2, - portInfoMap: negtypes.NewPortInfoMap(namespace2, name2, types.NewSvcPortTupleSet(negtypes.SvcPortTuple{Port: port1, TargetPort: targetPort1}, negtypes.SvcPortTuple{Port: port2, TargetPort: targetPort2}, negtypes.SvcPortTuple{Port: port3, TargetPort: targetPort3}), namer, true, nil), + portInfoMap: negtypes.NewPortInfoMap(namespace2, name2, types.NewSvcPortTupleSet(negtypes.SvcPortTuple{Port: port1, TargetPort: targetPort1}, negtypes.SvcPortTuple{Port: port2, TargetPort: targetPort2}, negtypes.SvcPortTuple{Port: port3, TargetPort: targetPort3}), namer, true, nil, defaultNetwork), selector: map[string]string{labelKey2: labelValue2}, }, { namespace: namespace2, name: name3, - portInfoMap: portInfoUnion(negtypes.NewPortInfoMap(namespace2, name3, types.NewSvcPortTupleSet(negtypes.SvcPortTuple{Port: port1, TargetPort: targetPort1}, negtypes.SvcPortTuple{Port: port2, TargetPort: targetPort2}, negtypes.SvcPortTuple{Port: port3, TargetPort: targetPort3}), namer, false, nil), - negtypes.NewPortInfoMap(namespace2, name3, types.NewSvcPortTupleSet(negtypes.SvcPortTuple{Port: port4, TargetPort: targetPort4}), namer, true, nil)), + portInfoMap: portInfoUnion(negtypes.NewPortInfoMap(namespace2, name3, types.NewSvcPortTupleSet(negtypes.SvcPortTuple{Port: port1, TargetPort: targetPort1}, negtypes.SvcPortTuple{Port: port2, TargetPort: targetPort2}, negtypes.SvcPortTuple{Port: port3, TargetPort: targetPort3}), namer, false, nil, defaultNetwork), + negtypes.NewPortInfoMap(namespace2, name3, types.NewSvcPortTupleSet(negtypes.SvcPortTuple{Port: port4, TargetPort: targetPort4}), namer, true, nil, defaultNetwork)), selector: map[string]string{labelKey1: labelValue2}, }, } diff --git a/pkg/neg/syncers/transaction.go b/pkg/neg/syncers/transaction.go index ad4c792210..3debbf7388 100644 --- a/pkg/neg/syncers/transaction.go +++ b/pkg/neg/syncers/transaction.go @@ -31,6 +31,7 @@ import ( v1 "k8s.io/api/core/v1" discovery "k8s.io/api/discovery/v1" "k8s.io/ingress-gce/pkg/flags" + "k8s.io/ingress-gce/pkg/network" "k8s.io/ingress-gce/pkg/utils/endpointslices" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" @@ -115,6 +116,10 @@ type transactionSyncer struct { podLabelPropagationConfig labels.PodLabelPropagationConfig dsMigrator *dualstack.Migrator + + // networkInfo contains the network information to use in GCP resources (VPC URL, Subnetwork URL). + // and the k8s network name (can be used in endpoints calculation). + networkInfo network.NetworkInfo } func NewTransactionSyncer( @@ -135,7 +140,9 @@ func NewTransactionSyncer( customName bool, log klog.Logger, lpConfig labels.PodLabelPropagationConfig, - enableDualStackNEG bool) negtypes.NegSyncer { + enableDualStackNEG bool, + networkInfo network.NetworkInfo, +) negtypes.NegSyncer { logger := log.WithName("Syncer").WithValues("service", klog.KRef(negSyncerKey.Namespace, negSyncerKey.Name), "negName", negSyncerKey.NegName) @@ -163,6 +170,7 @@ func NewTransactionSyncer( enableDegradedMode: flags.F.EnableDegradedMode, podLabelPropagationConfig: lpConfig, dsMigrator: dualstack.NewMigrator(enableDualStackNEG), + networkInfo: networkInfo, } // Syncer implements life cycle logic syncer := newSyncer(negSyncerKey, serviceLister, recorder, ts, logger) @@ -385,6 +393,7 @@ func (s *transactionSyncer) ensureNetworkEndpointGroups() error { s.recorder, s.NegSyncerKey.GetAPIVersion(), s.customName, + s.networkInfo, ) if err != nil { errList = append(errList, err) diff --git a/pkg/neg/syncers/transaction_test.go b/pkg/neg/syncers/transaction_test.go index 06a501909f..34c44d369d 100644 --- a/pkg/neg/syncers/transaction_test.go +++ b/pkg/neg/syncers/transaction_test.go @@ -50,6 +50,7 @@ import ( "k8s.io/ingress-gce/pkg/neg/readiness" "k8s.io/ingress-gce/pkg/neg/syncers/labels" negtypes "k8s.io/ingress-gce/pkg/neg/types" + "k8s.io/ingress-gce/pkg/network" "k8s.io/ingress-gce/pkg/utils" "k8s.io/ingress-gce/pkg/utils/endpointslices" "k8s.io/klog/v2" @@ -2124,6 +2125,7 @@ func newTestTransactionSyncer(fakeGCE negtypes.NetworkEndpointGroupCloud, negTyp klog.TODO(), labels.PodLabelPropagationConfig{}, testContext.EnableDualStackNEG, + network.NetworkInfo{NetworkURL: fakeGCE.NetworkURL(), SubnetworkURL: fakeGCE.SubnetworkURL()}, ) transactionSyncer := negsyncer.(*syncer).core.(*transactionSyncer) indexers := map[string]cache.IndexFunc{ diff --git a/pkg/neg/syncers/utils.go b/pkg/neg/syncers/utils.go index 69f5565be0..d5985e428a 100644 --- a/pkg/neg/syncers/utils.go +++ b/pkg/neg/syncers/utils.go @@ -35,6 +35,7 @@ import ( "k8s.io/ingress-gce/pkg/flags" "k8s.io/ingress-gce/pkg/neg/syncers/labels" negtypes "k8s.io/ingress-gce/pkg/neg/types" + "k8s.io/ingress-gce/pkg/network" "k8s.io/ingress-gce/pkg/utils" "k8s.io/klog/v2" ) @@ -116,7 +117,7 @@ func getService(serviceLister cache.Indexer, namespace, name string) *apiv1.Serv } // ensureNetworkEndpointGroup ensures corresponding NEG is configured correctly in the specified zone. -func ensureNetworkEndpointGroup(svcNamespace, svcName, negName, zone, negServicePortName, kubeSystemUID, port string, networkEndpointType negtypes.NetworkEndpointType, cloud negtypes.NetworkEndpointGroupCloud, serviceLister cache.Indexer, recorder record.EventRecorder, version meta.Version, customName bool) (negv1beta1.NegObjectReference, error) { +func ensureNetworkEndpointGroup(svcNamespace, svcName, negName, zone, negServicePortName, kubeSystemUID, port string, networkEndpointType negtypes.NetworkEndpointType, cloud negtypes.NetworkEndpointGroupCloud, serviceLister cache.Indexer, recorder record.EventRecorder, version meta.Version, customName bool, networkInfo network.NetworkInfo) (negv1beta1.NegObjectReference, error) { var negRef negv1beta1.NegObjectReference neg, err := cloud.GetNetworkEndpointGroup(negName, zone, version) if err != nil { @@ -149,8 +150,8 @@ func ensureNetworkEndpointGroup(svcNamespace, svcName, negName, zone, negService if networkEndpointType != negtypes.NonGCPPrivateEndpointType && // Only perform the following checks when the NEGs are not Non-GCP NEGs. // Non-GCP NEGs do not have associated network and subnetwork. - (!utils.EqualResourceIDs(neg.Network, cloud.NetworkURL()) || - !utils.EqualResourceIDs(neg.Subnetwork, cloud.SubnetworkURL())) { + (!utils.EqualResourceIDs(neg.Network, networkInfo.NetworkURL) || + !utils.EqualResourceIDs(neg.Subnetwork, networkInfo.SubnetworkURL)) { needToCreate = true klog.V(2).Infof("NEG %q in %q does not match network and subnetwork of the cluster. Deleting NEG.", negName, zone) @@ -173,7 +174,7 @@ func ensureNetworkEndpointGroup(svcNamespace, svcName, negName, zone, negService case negtypes.NonGCPPrivateEndpointType: subnetwork = "" default: - subnetwork = cloud.SubnetworkURL() + subnetwork = networkInfo.SubnetworkURL } desc := "" @@ -189,7 +190,7 @@ func ensureNetworkEndpointGroup(svcNamespace, svcName, negName, zone, negService Version: version, Name: negName, NetworkEndpointType: string(networkEndpointType), - Network: cloud.NetworkURL(), + Network: networkInfo.NetworkURL, Subnetwork: subnetwork, Description: desc, }, zone) diff --git a/pkg/neg/syncers/utils_test.go b/pkg/neg/syncers/utils_test.go index 28765adff4..f15e4df8ea 100644 --- a/pkg/neg/syncers/utils_test.go +++ b/pkg/neg/syncers/utils_test.go @@ -40,6 +40,7 @@ import ( "k8s.io/ingress-gce/pkg/flags" "k8s.io/ingress-gce/pkg/neg/syncers/labels" negtypes "k8s.io/ingress-gce/pkg/neg/types" + "k8s.io/ingress-gce/pkg/network" "k8s.io/ingress-gce/pkg/utils" ) @@ -321,7 +322,9 @@ func TestEnsureNetworkEndpointGroup(t *testing.T) { enableNonGCPMode bool networkEndpointType negtypes.NetworkEndpointType expectedSubnetwork string + expectedNetwork string apiVersion meta.Version + networkInfo network.NetworkInfo }{ { description: "Create NEG of type GCE_VM_IP_PORT", @@ -371,77 +374,107 @@ func TestEnsureNetworkEndpointGroup(t *testing.T) { expectedSubnetwork: testSubnetwork, apiVersion: meta.VersionAlpha, }, + { + description: "Create NEG of type GCE_VM_IP_PORT in alternate network", + negName: "gcp-neg", + enableNonGCPMode: false, + networkEndpointType: negtypes.VmIpPortEndpointType, + expectedNetwork: cloud.ResourcePath("network", &meta.Key{Name: "other-network"}), + expectedSubnetwork: cloud.ResourcePath("subnetwork", &meta.Key{Zone: testZone, Name: "other-subnet"}), + apiVersion: meta.VersionGA, + networkInfo: network.NetworkInfo{ + IsNonDefault: true, + K8sNetwork: "other-network", + NetworkURL: cloud.ResourcePath("network", &meta.Key{Name: "other-network"}), + SubnetworkURL: cloud.ResourcePath("subnetwork", &meta.Key{Zone: testZone, Name: "other-subnet"}), + }, + }, } for _, tc := range testCases { - fakeCloud := negtypes.NewFakeNetworkEndpointGroupCloud(testSubnetwork, testNetwork) - _, err := ensureNetworkEndpointGroup( - testServiceNameSpace, - testServiceName, - tc.negName, - testZone, - testNamedPort, - testKubesystemUID, - testPort, - tc.networkEndpointType, - fakeCloud, - nil, - nil, - tc.apiVersion, - false, - ) - if err != nil { - t.Errorf("unexpected error: %s", err) - } + t.Run(tc.description, func(t *testing.T) { + fakeCloud := negtypes.NewFakeNetworkEndpointGroupCloud(testSubnetwork, testNetwork) + if !tc.networkInfo.IsNonDefault { + tc.networkInfo.NetworkURL = fakeCloud.NetworkURL() + tc.networkInfo.SubnetworkURL = fakeCloud.SubnetworkURL() + } + _, err := ensureNetworkEndpointGroup( + testServiceNameSpace, + testServiceName, + tc.negName, + testZone, + testNamedPort, + testKubesystemUID, + testPort, + tc.networkEndpointType, + fakeCloud, + nil, + nil, + tc.apiVersion, + false, + tc.networkInfo, + ) + if err != nil { + t.Errorf("unexpected error: %s", err) + } - neg, err := fakeCloud.GetNetworkEndpointGroup(tc.negName, testZone, tc.apiVersion) - if err != nil { - t.Errorf("Failed to retrieve NEG %q: %v", tc.negName, err) - } + neg, err := fakeCloud.GetNetworkEndpointGroup(tc.negName, testZone, tc.apiVersion) + if err != nil { + t.Errorf("Failed to retrieve NEG %q: %v", tc.negName, err) + } - if neg.NetworkEndpointType != string(tc.networkEndpointType) { - t.Errorf("Unexpected NetworkEndpointType, expecting %q but got %q", tc.networkEndpointType, neg.NetworkEndpointType) - } + if neg.NetworkEndpointType != string(tc.networkEndpointType) { + t.Errorf("Unexpected NetworkEndpointType, expecting %q but got %q", tc.networkEndpointType, neg.NetworkEndpointType) + } - if neg.Subnetwork != tc.expectedSubnetwork { - t.Errorf("Unexpected Subnetwork, expecting %q but got %q", tc.expectedSubnetwork, neg.Subnetwork) - } + if neg.Subnetwork != tc.expectedSubnetwork { + t.Errorf("Unexpected Subnetwork, expecting %q but got %q", tc.expectedSubnetwork, neg.Subnetwork) + } - expectedNegDesc := utils.NegDescription{ - ClusterUID: testKubesystemUID, - Namespace: testServiceNamespace, - ServiceName: testServiceName, - Port: testPort, - } + if tc.expectedNetwork == "" { + tc.expectedNetwork = testNetwork + } + if neg.Network != tc.expectedNetwork { + t.Errorf("Unexpected Network, expecting %q but got %q", tc.expectedNetwork, neg.Network) + } - actualNegDesc, err := utils.NegDescriptionFromString(neg.Description) - if err != nil { - t.Errorf("Invalid neg description: %s", err) - } + expectedNegDesc := utils.NegDescription{ + ClusterUID: testKubesystemUID, + Namespace: testServiceNamespace, + ServiceName: testServiceName, + Port: testPort, + } - if !reflect.DeepEqual(*actualNegDesc, expectedNegDesc) { - t.Errorf("Unexpected neg description: %s, expected %s", neg.Description, expectedNegDesc.String()) - } + actualNegDesc, err := utils.NegDescriptionFromString(neg.Description) + if err != nil { + t.Errorf("Invalid neg description: %s", err) + } - // Call ensureNetworkEndpointGroup with the same NEG. - _, err = ensureNetworkEndpointGroup( - testServiceNameSpace, - testServiceName, - tc.negName, - testZone, - testNamedPort, - testKubesystemUID, - testPort, - tc.networkEndpointType, - fakeCloud, - nil, - nil, - tc.apiVersion, - false, - ) + if !reflect.DeepEqual(*actualNegDesc, expectedNegDesc) { + t.Errorf("Unexpected neg description: %s, expected %s", neg.Description, expectedNegDesc.String()) + } - if err != nil { - t.Errorf("Unexpected error when called with duplicated NEG: %v", err) - } + // Call ensureNetworkEndpointGroup with the same NEG. + _, err = ensureNetworkEndpointGroup( + testServiceNameSpace, + testServiceName, + tc.negName, + testZone, + testNamedPort, + testKubesystemUID, + testPort, + tc.networkEndpointType, + fakeCloud, + nil, + nil, + tc.apiVersion, + false, + tc.networkInfo, + ) + + if err != nil { + t.Errorf("Unexpected error when called with duplicated NEG: %v", err) + } + }) } } @@ -1171,6 +1204,10 @@ func TestNameUniqueness(t *testing.T) { negName = "test-neg" apiVersion = meta.VersionGA networkEndpointType = negtypes.VmIpPortEndpointType + networkInfo = network.NetworkInfo{ + NetworkURL: testNetwork, + SubnetworkURL: testSubnetwork, + } ) fakeCloud := negtypes.NewFakeNetworkEndpointGroupCloud(testSubnetwork, testNetwork) _, err := ensureNetworkEndpointGroup( @@ -1187,6 +1224,7 @@ func TestNameUniqueness(t *testing.T) { nil, apiVersion, false, + networkInfo, ) if err != nil { t.Errorf("Errored while ensuring network endpoint groups: %s", err) @@ -1216,6 +1254,7 @@ func TestNameUniqueness(t *testing.T) { nil, apiVersion, false, + networkInfo, ) if err == nil { @@ -1236,6 +1275,10 @@ func TestNegObjectCrd(t *testing.T) { testPort = "80" negName = "test-neg" apiVersion = meta.VersionGA + networkInfo = network.NetworkInfo{ + NetworkURL: testNetwork, + SubnetworkURL: testSubnetwork, + } ) for _, networkEndpointType := range []negtypes.NetworkEndpointType{ @@ -1258,6 +1301,7 @@ func TestNegObjectCrd(t *testing.T) { nil, apiVersion, false, + networkInfo, ) if err != nil { t.Errorf("Errored while ensuring network endpoint groups: %s", err) @@ -1298,6 +1342,7 @@ func TestNegObjectCrd(t *testing.T) { nil, apiVersion, false, + networkInfo, ) if err != nil { @@ -1325,6 +1370,10 @@ func TestNEGRecreate(t *testing.T) { testPort = "80" negName = "test-neg" apiVersion = meta.VersionGA + networkInfo = network.NetworkInfo{ + NetworkURL: testNetwork, + SubnetworkURL: testSubnetwork, + } ) matchingNegDesc := utils.NegDescription{ @@ -1463,6 +1512,7 @@ func TestNEGRecreate(t *testing.T) { nil, apiVersion, tc.customName, + networkInfo, ) if !tc.expectError && err != nil { t.Errorf("TestCase: %s, Errored while ensuring network endpoint groups: %s", tc.desc, err) diff --git a/pkg/neg/types/types.go b/pkg/neg/types/types.go index 8b4ee1d152..7684b2528d 100644 --- a/pkg/neg/types/types.go +++ b/pkg/neg/types/types.go @@ -28,6 +28,7 @@ import ( "k8s.io/apimachinery/pkg/types" "k8s.io/apimachinery/pkg/util/sets" "k8s.io/ingress-gce/pkg/annotations" + "k8s.io/ingress-gce/pkg/network" "k8s.io/ingress-gce/pkg/utils" "k8s.io/ingress-gce/pkg/utils/namer" ) @@ -124,6 +125,8 @@ type PortInfo struct { // This is applicable in GCE_VM_IP NEGs where the endpoints are the nodes instead of pods. // L7 NEGs will have either "" or L7Mode. EpCalculatorMode EndpointsCalculatorMode + // NetworkInfo specifies the network (K8s and VPC) and subnetwork the service port belongs to. + NetworkInfo network.NetworkInfo } // PortInfoMapKey is the Key of PortInfoMap @@ -135,7 +138,7 @@ type PortInfoMapKey struct { // PortInfoMap is a map of PortInfoMapKey:PortInfo type PortInfoMap map[PortInfoMapKey]PortInfo -func NewPortInfoMap(namespace, name string, svcPortTupleSet SvcPortTupleSet, namer NetworkEndpointGroupNamer, readinessGate bool, customNegNames map[SvcPortTuple]string) PortInfoMap { +func NewPortInfoMap(namespace, name string, svcPortTupleSet SvcPortTupleSet, namer NetworkEndpointGroupNamer, readinessGate bool, customNegNames map[SvcPortTuple]string, networkInfo *network.NetworkInfo) PortInfoMap { ret := PortInfoMap{} for svcPortTuple := range svcPortTupleSet { negName, ok := customNegNames[svcPortTuple] @@ -146,6 +149,7 @@ func NewPortInfoMap(namespace, name string, svcPortTupleSet SvcPortTupleSet, nam PortTuple: svcPortTuple, NegName: negName, ReadinessGate: readinessGate, + NetworkInfo: *networkInfo, } } return ret @@ -153,7 +157,7 @@ func NewPortInfoMap(namespace, name string, svcPortTupleSet SvcPortTupleSet, nam // NewPortInfoMapForVMIPNEG creates PortInfoMap with empty port tuple. Since VM_IP NEGs target // the node instead of the pod, there is no port info to be stored. -func NewPortInfoMapForVMIPNEG(namespace, name string, namer namer.L4ResourcesNamer, local bool) PortInfoMap { +func NewPortInfoMapForVMIPNEG(namespace, name string, namer namer.L4ResourcesNamer, local bool, networkInfo *network.NetworkInfo) PortInfoMap { ret := PortInfoMap{} svcPortSet := make(SvcPortTupleSet) svcPortSet.Insert( @@ -170,6 +174,7 @@ func NewPortInfoMapForVMIPNEG(namespace, name string, namer namer.L4ResourcesNam PortTuple: svcPortTuple, NegName: negName, EpCalculatorMode: mode, + NetworkInfo: *networkInfo, } } return ret @@ -202,6 +207,7 @@ func (p1 PortInfoMap) Merge(p2 PortInfoMap) error { // Turn on the readiness gate if one of them is on mergedInfo.ReadinessGate = mergedInfo.ReadinessGate || portInfo.ReadinessGate mergedInfo.EpCalculatorMode = portInfo.EpCalculatorMode + mergedInfo.NetworkInfo = portInfo.NetworkInfo p1[mapKey] = mergedInfo } diff --git a/pkg/neg/types/types_test.go b/pkg/neg/types/types_test.go index 82490a191d..171ee016cf 100644 --- a/pkg/neg/types/types_test.go +++ b/pkg/neg/types/types_test.go @@ -26,6 +26,7 @@ import ( metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/apimachinery/pkg/util/sets" "k8s.io/ingress-gce/pkg/annotations" + "k8s.io/ingress-gce/pkg/network" ) type negNamer struct{} @@ -42,6 +43,10 @@ func TestPortInfoMapMerge(t *testing.T) { namer := &negNamer{} namespace := "namespace" name := "name" + defaultNetwork := &network.NetworkInfo{ + NetworkURL: "defaultNetwork", + SubnetworkURL: "defaultSubnetwork", + } testcases := []struct { desc string p1 PortInfoMap @@ -59,42 +64,42 @@ func TestPortInfoMapMerge(t *testing.T) { { "empty map union a non-empty map is the non-empty map", PortInfoMap{}, - NewPortInfoMap(namespace, name, NewSvcPortTupleSet(SvcPortTuple{Port: 80, TargetPort: "namedport"}, SvcPortTuple{Port: 443, TargetPort: "3000"}), namer, false, nil), - NewPortInfoMap(namespace, name, NewSvcPortTupleSet(SvcPortTuple{Port: 80, TargetPort: "namedport"}, SvcPortTuple{Port: 443, TargetPort: "3000"}), namer, false, nil), + NewPortInfoMap(namespace, name, NewSvcPortTupleSet(SvcPortTuple{Port: 80, TargetPort: "namedport"}, SvcPortTuple{Port: 443, TargetPort: "3000"}), namer, false, nil, defaultNetwork), + NewPortInfoMap(namespace, name, NewSvcPortTupleSet(SvcPortTuple{Port: 80, TargetPort: "namedport"}, SvcPortTuple{Port: 443, TargetPort: "3000"}), namer, false, nil, defaultNetwork), false, }, { "empty map union a non-empty map is the non-empty map 2", - NewPortInfoMap(namespace, name, NewSvcPortTupleSet(SvcPortTuple{Port: 80, TargetPort: "namedport"}, SvcPortTuple{Port: 443, TargetPort: "3000"}), namer, true, nil), + NewPortInfoMap(namespace, name, NewSvcPortTupleSet(SvcPortTuple{Port: 80, TargetPort: "namedport"}, SvcPortTuple{Port: 443, TargetPort: "3000"}), namer, true, nil, defaultNetwork), PortInfoMap{}, - NewPortInfoMap(namespace, name, NewSvcPortTupleSet(SvcPortTuple{Port: 80, TargetPort: "namedport"}, SvcPortTuple{Port: 443, TargetPort: "3000"}), namer, true, nil), + NewPortInfoMap(namespace, name, NewSvcPortTupleSet(SvcPortTuple{Port: 80, TargetPort: "namedport"}, SvcPortTuple{Port: 443, TargetPort: "3000"}), namer, true, nil, defaultNetwork), false, }, { "union of two non-empty maps, none has readiness gate enabled", - NewPortInfoMap(namespace, name, NewSvcPortTupleSet(SvcPortTuple{Port: 443, TargetPort: "3000"}, SvcPortTuple{Port: 5000, TargetPort: "6000"}), namer, false, nil), - NewPortInfoMap(namespace, name, NewSvcPortTupleSet(SvcPortTuple{Port: 80, TargetPort: "namedport"}, SvcPortTuple{Port: 8080, TargetPort: "9000"}), namer, false, nil), - NewPortInfoMap(namespace, name, NewSvcPortTupleSet(SvcPortTuple{Port: 443, TargetPort: "3000"}, SvcPortTuple{Port: 5000, TargetPort: "6000"}, SvcPortTuple{Port: 80, TargetPort: "namedport"}, SvcPortTuple{Port: 8080, TargetPort: "9000"}), namer, false, nil), + NewPortInfoMap(namespace, name, NewSvcPortTupleSet(SvcPortTuple{Port: 443, TargetPort: "3000"}, SvcPortTuple{Port: 5000, TargetPort: "6000"}), namer, false, nil, defaultNetwork), + NewPortInfoMap(namespace, name, NewSvcPortTupleSet(SvcPortTuple{Port: 80, TargetPort: "namedport"}, SvcPortTuple{Port: 8080, TargetPort: "9000"}), namer, false, nil, defaultNetwork), + NewPortInfoMap(namespace, name, NewSvcPortTupleSet(SvcPortTuple{Port: 443, TargetPort: "3000"}, SvcPortTuple{Port: 5000, TargetPort: "6000"}, SvcPortTuple{Port: 80, TargetPort: "namedport"}, SvcPortTuple{Port: 8080, TargetPort: "9000"}), namer, false, nil, defaultNetwork), false, }, { "union of two non-empty maps, all have readiness gate enabled ", - NewPortInfoMap(namespace, name, NewSvcPortTupleSet(SvcPortTuple{Port: 443, TargetPort: "3000"}, SvcPortTuple{Port: 5000, TargetPort: "6000"}), namer, true, nil), - NewPortInfoMap(namespace, name, NewSvcPortTupleSet(SvcPortTuple{Port: 80, TargetPort: "namedport"}, SvcPortTuple{Port: 8080, TargetPort: "9000"}), namer, true, nil), - NewPortInfoMap(namespace, name, NewSvcPortTupleSet(SvcPortTuple{Port: 443, TargetPort: "3000"}, SvcPortTuple{Port: 5000, TargetPort: "6000"}, SvcPortTuple{Port: 80, TargetPort: "namedport"}, SvcPortTuple{Port: 8080, TargetPort: "9000"}), namer, true, nil), + NewPortInfoMap(namespace, name, NewSvcPortTupleSet(SvcPortTuple{Port: 443, TargetPort: "3000"}, SvcPortTuple{Port: 5000, TargetPort: "6000"}), namer, true, nil, defaultNetwork), + NewPortInfoMap(namespace, name, NewSvcPortTupleSet(SvcPortTuple{Port: 80, TargetPort: "namedport"}, SvcPortTuple{Port: 8080, TargetPort: "9000"}), namer, true, nil, defaultNetwork), + NewPortInfoMap(namespace, name, NewSvcPortTupleSet(SvcPortTuple{Port: 443, TargetPort: "3000"}, SvcPortTuple{Port: 5000, TargetPort: "6000"}, SvcPortTuple{Port: 80, TargetPort: "namedport"}, SvcPortTuple{Port: 8080, TargetPort: "9000"}), namer, true, nil, defaultNetwork), false, }, { "union of two non-empty maps with one overlapping service port", - NewPortInfoMap(namespace, name, NewSvcPortTupleSet(SvcPortTuple{Port: 80, TargetPort: "3000"}, SvcPortTuple{Port: 5000, TargetPort: "6000"}), namer, false, nil), - NewPortInfoMap(namespace, name, NewSvcPortTupleSet(SvcPortTuple{Port: 80, TargetPort: "3000"}, SvcPortTuple{Port: 8080, TargetPort: "9000"}), namer, false, nil), - NewPortInfoMap(namespace, name, NewSvcPortTupleSet(SvcPortTuple{Port: 80, TargetPort: "3000"}, SvcPortTuple{Port: 5000, TargetPort: "6000"}, SvcPortTuple{Port: 8080, TargetPort: "9000"}), namer, false, nil), + NewPortInfoMap(namespace, name, NewSvcPortTupleSet(SvcPortTuple{Port: 80, TargetPort: "3000"}, SvcPortTuple{Port: 5000, TargetPort: "6000"}), namer, false, nil, defaultNetwork), + NewPortInfoMap(namespace, name, NewSvcPortTupleSet(SvcPortTuple{Port: 80, TargetPort: "3000"}, SvcPortTuple{Port: 8080, TargetPort: "9000"}), namer, false, nil, defaultNetwork), + NewPortInfoMap(namespace, name, NewSvcPortTupleSet(SvcPortTuple{Port: 80, TargetPort: "3000"}, SvcPortTuple{Port: 5000, TargetPort: "6000"}, SvcPortTuple{Port: 8080, TargetPort: "9000"}), namer, false, nil, defaultNetwork), false, }, { "union of two non-empty maps with overlapping service port and difference in readiness gate configurations ", - NewPortInfoMap(namespace, name, NewSvcPortTupleSet(SvcPortTuple{Port: 80, TargetPort: "3000"}, SvcPortTuple{Port: 5000, TargetPort: "6000"}), namer, true, nil), - NewPortInfoMap(namespace, name, NewSvcPortTupleSet(SvcPortTuple{Port: 80, TargetPort: "3000"}, SvcPortTuple{Port: 8080, TargetPort: "9000"}), namer, false, nil), + NewPortInfoMap(namespace, name, NewSvcPortTupleSet(SvcPortTuple{Port: 80, TargetPort: "3000"}, SvcPortTuple{Port: 5000, TargetPort: "6000"}), namer, true, nil, defaultNetwork), + NewPortInfoMap(namespace, name, NewSvcPortTupleSet(SvcPortTuple{Port: 80, TargetPort: "3000"}, SvcPortTuple{Port: 8080, TargetPort: "9000"}), namer, false, nil, defaultNetwork), PortInfoMap{ PortInfoMapKey{80}: PortInfo{ PortTuple: SvcPortTuple{ @@ -103,6 +108,7 @@ func TestPortInfoMapMerge(t *testing.T) { }, NegName: namer.NEG(namespace, name, 80), ReadinessGate: true, + NetworkInfo: *defaultNetwork, }, PortInfoMapKey{5000}: PortInfo{ PortTuple: SvcPortTuple{ @@ -111,6 +117,7 @@ func TestPortInfoMapMerge(t *testing.T) { }, NegName: namer.NEG(namespace, name, 5000), ReadinessGate: true, + NetworkInfo: *defaultNetwork, }, PortInfoMapKey{8080}: PortInfo{ PortTuple: SvcPortTuple{ @@ -119,14 +126,15 @@ func TestPortInfoMapMerge(t *testing.T) { }, NegName: namer.NEG(namespace, name, 8080), ReadinessGate: false, + NetworkInfo: *defaultNetwork, }, }, false, }, { "union of two non-empty maps with overlapping service port and difference in readiness gate configurations with named port", - NewPortInfoMap(namespace, name, NewSvcPortTupleSet(SvcPortTuple{Port: 80, Name: "foo", TargetPort: "3000"}, SvcPortTuple{Port: 5000, Name: "bar", TargetPort: "6000"}), namer, true, nil), - NewPortInfoMap(namespace, name, NewSvcPortTupleSet(SvcPortTuple{Port: 80, Name: "foo", TargetPort: "3000"}, SvcPortTuple{Port: 8080, TargetPort: "9000"}), namer, false, nil), + NewPortInfoMap(namespace, name, NewSvcPortTupleSet(SvcPortTuple{Port: 80, Name: "foo", TargetPort: "3000"}, SvcPortTuple{Port: 5000, Name: "bar", TargetPort: "6000"}), namer, true, nil, defaultNetwork), + NewPortInfoMap(namespace, name, NewSvcPortTupleSet(SvcPortTuple{Port: 80, Name: "foo", TargetPort: "3000"}, SvcPortTuple{Port: 8080, TargetPort: "9000"}), namer, false, nil, defaultNetwork), PortInfoMap{ PortInfoMapKey{80}: PortInfo{ PortTuple: SvcPortTuple{ @@ -136,6 +144,7 @@ func TestPortInfoMapMerge(t *testing.T) { }, NegName: namer.NEG(namespace, name, 80), ReadinessGate: true, + NetworkInfo: *defaultNetwork, }, PortInfoMapKey{5000}: PortInfo{ PortTuple: SvcPortTuple{ @@ -145,6 +154,7 @@ func TestPortInfoMapMerge(t *testing.T) { }, NegName: namer.NEG(namespace, name, 5000), ReadinessGate: true, + NetworkInfo: *defaultNetwork, }, PortInfoMapKey{8080}: PortInfo{ PortTuple: SvcPortTuple{ @@ -153,28 +163,29 @@ func TestPortInfoMapMerge(t *testing.T) { }, NegName: namer.NEG(namespace, name, 8080), ReadinessGate: false, + NetworkInfo: *defaultNetwork, }, }, false, }, { "error on inconsistent value", - NewPortInfoMap(namespace, name, NewSvcPortTupleSet(SvcPortTuple{Port: 80, TargetPort: "3000"}), namer, false, nil), - NewPortInfoMap(namespace, name, NewSvcPortTupleSet(SvcPortTuple{Port: 80, TargetPort: "namedport"}, SvcPortTuple{Port: 8000, TargetPort: "9000"}), namer, false, nil), - NewPortInfoMap(namespace, name, NewSvcPortTupleSet(SvcPortTuple{Port: 80, TargetPort: "namedport"}, SvcPortTuple{Port: 443, TargetPort: "3000"}, SvcPortTuple{Port: 5000, TargetPort: "6000"}, SvcPortTuple{Port: 8080, TargetPort: "9000"}), namer, false, nil), + NewPortInfoMap(namespace, name, NewSvcPortTupleSet(SvcPortTuple{Port: 80, TargetPort: "3000"}), namer, false, nil, defaultNetwork), + NewPortInfoMap(namespace, name, NewSvcPortTupleSet(SvcPortTuple{Port: 80, TargetPort: "namedport"}, SvcPortTuple{Port: 8000, TargetPort: "9000"}), namer, false, nil, defaultNetwork), + NewPortInfoMap(namespace, name, NewSvcPortTupleSet(SvcPortTuple{Port: 80, TargetPort: "namedport"}, SvcPortTuple{Port: 443, TargetPort: "3000"}, SvcPortTuple{Port: 5000, TargetPort: "6000"}, SvcPortTuple{Port: 8080, TargetPort: "9000"}), namer, false, nil, defaultNetwork), true, }, { "error on inconsistent port name", - NewPortInfoMap(namespace, name, NewSvcPortTupleSet(SvcPortTuple{Port: 80, Name: "foo", TargetPort: "3000"}), namer, false, nil), - NewPortInfoMap(namespace, name, NewSvcPortTupleSet(SvcPortTuple{Port: 80, Name: "bar", TargetPort: "3000"}, SvcPortTuple{Port: 8000, TargetPort: "9000"}), namer, false, nil), + NewPortInfoMap(namespace, name, NewSvcPortTupleSet(SvcPortTuple{Port: 80, Name: "foo", TargetPort: "3000"}), namer, false, nil, defaultNetwork), + NewPortInfoMap(namespace, name, NewSvcPortTupleSet(SvcPortTuple{Port: 80, Name: "bar", TargetPort: "3000"}, SvcPortTuple{Port: 8000, TargetPort: "9000"}), namer, false, nil, defaultNetwork), PortInfoMap{}, true, }, { "error on inconsistent neg name", - NewPortInfoMap(namespace, name, NewSvcPortTupleSet(SvcPortTuple{Port: 80, Name: "foo", TargetPort: "3000"}), namer, false, map[SvcPortTuple]string{SvcPortTuple{Port: 80, Name: "foo", TargetPort: "3000"}: "neg-1"}), - NewPortInfoMap(namespace, name, NewSvcPortTupleSet(SvcPortTuple{Port: 80, Name: "bar", TargetPort: "3000"}, SvcPortTuple{Port: 8000, TargetPort: "9000"}), namer, false, nil), + NewPortInfoMap(namespace, name, NewSvcPortTupleSet(SvcPortTuple{Port: 80, Name: "foo", TargetPort: "3000"}), namer, false, map[SvcPortTuple]string{SvcPortTuple{Port: 80, Name: "foo", TargetPort: "3000"}: "neg-1"}, defaultNetwork), + NewPortInfoMap(namespace, name, NewSvcPortTupleSet(SvcPortTuple{Port: 80, Name: "bar", TargetPort: "3000"}, SvcPortTuple{Port: 8000, TargetPort: "9000"}), namer, false, nil, defaultNetwork), PortInfoMap{}, true, }, @@ -204,6 +215,10 @@ func TestPortInfoMapDifference(t *testing.T) { namer := &negNamer{} namespace := "namespace" name := "name" + defaultNetwork := &network.NetworkInfo{ + NetworkURL: "defaultNetwork", + SubnetworkURL: "defaultSubnetwork", + } testcases := []struct { desc string p1 PortInfoMap @@ -219,68 +234,74 @@ func TestPortInfoMapDifference(t *testing.T) { { "empty map difference a non-empty map is empty map", PortInfoMap{}, - NewPortInfoMap(namespace, name, NewSvcPortTupleSet(SvcPortTuple{Port: 80, TargetPort: "namedport"}, SvcPortTuple{Port: 443, TargetPort: "3000"}), namer, false, nil), + NewPortInfoMap(namespace, name, NewSvcPortTupleSet(SvcPortTuple{Port: 80, TargetPort: "namedport"}, SvcPortTuple{Port: 443, TargetPort: "3000"}), namer, false, nil, defaultNetwork), PortInfoMap{}, }, { "non-empty map difference a non-empty map is the non-empty map", - NewPortInfoMap(namespace, name, NewSvcPortTupleSet(SvcPortTuple{Port: 80, TargetPort: "namedport"}, SvcPortTuple{Port: 443, TargetPort: "3000"}), namer, false, nil), + NewPortInfoMap(namespace, name, NewSvcPortTupleSet(SvcPortTuple{Port: 80, TargetPort: "namedport"}, SvcPortTuple{Port: 443, TargetPort: "3000"}), namer, false, nil, defaultNetwork), PortInfoMap{}, - NewPortInfoMap(namespace, name, NewSvcPortTupleSet(SvcPortTuple{Port: 80, TargetPort: "namedport"}, SvcPortTuple{Port: 443, TargetPort: "3000"}), namer, false, nil), + NewPortInfoMap(namespace, name, NewSvcPortTupleSet(SvcPortTuple{Port: 80, TargetPort: "namedport"}, SvcPortTuple{Port: 443, TargetPort: "3000"}), namer, false, nil, defaultNetwork), }, { "non-empty map difference a non-empty map is the non-empty map 2", - NewPortInfoMap(namespace, name, NewSvcPortTupleSet(SvcPortTuple{Port: 80, TargetPort: "namedport"}, SvcPortTuple{Port: 443, TargetPort: "3000"}), namer, true, nil), + NewPortInfoMap(namespace, name, NewSvcPortTupleSet(SvcPortTuple{Port: 80, TargetPort: "namedport"}, SvcPortTuple{Port: 443, TargetPort: "3000"}), namer, true, nil, defaultNetwork), PortInfoMap{}, - NewPortInfoMap(namespace, name, NewSvcPortTupleSet(SvcPortTuple{Port: 80, TargetPort: "namedport"}, SvcPortTuple{Port: 443, TargetPort: "3000"}), namer, true, nil), + NewPortInfoMap(namespace, name, NewSvcPortTupleSet(SvcPortTuple{Port: 80, TargetPort: "namedport"}, SvcPortTuple{Port: 443, TargetPort: "3000"}), namer, true, nil, defaultNetwork), }, { "difference of two non-empty maps with the same elements", - NewPortInfoMap(namespace, name, NewSvcPortTupleSet(SvcPortTuple{Port: 80, TargetPort: "namedport"}, SvcPortTuple{Port: 443, TargetPort: "3000"}), namer, false, nil), - NewPortInfoMap(namespace, name, NewSvcPortTupleSet(SvcPortTuple{Port: 80, TargetPort: "namedport"}, SvcPortTuple{Port: 443, TargetPort: "3000"}), namer, false, nil), + NewPortInfoMap(namespace, name, NewSvcPortTupleSet(SvcPortTuple{Port: 80, TargetPort: "namedport"}, SvcPortTuple{Port: 443, TargetPort: "3000"}), namer, false, nil, defaultNetwork), + NewPortInfoMap(namespace, name, NewSvcPortTupleSet(SvcPortTuple{Port: 80, TargetPort: "namedport"}, SvcPortTuple{Port: 443, TargetPort: "3000"}), namer, false, nil, defaultNetwork), PortInfoMap{}, }, { "difference of two non-empty maps with no elements in common returns p1", - NewPortInfoMap(namespace, name, NewSvcPortTupleSet(SvcPortTuple{Port: 443, TargetPort: "3000"}, SvcPortTuple{Port: 5000, TargetPort: "6000"}), namer, false, nil), - NewPortInfoMap(namespace, name, NewSvcPortTupleSet(SvcPortTuple{Port: 80, TargetPort: "namedport"}, SvcPortTuple{Port: 8080, TargetPort: "9000"}), namer, false, nil), - NewPortInfoMap(namespace, name, NewSvcPortTupleSet(SvcPortTuple{Port: 443, TargetPort: "3000"}, SvcPortTuple{Port: 5000, TargetPort: "6000"}), namer, false, nil), + NewPortInfoMap(namespace, name, NewSvcPortTupleSet(SvcPortTuple{Port: 443, TargetPort: "3000"}, SvcPortTuple{Port: 5000, TargetPort: "6000"}), namer, false, nil, defaultNetwork), + NewPortInfoMap(namespace, name, NewSvcPortTupleSet(SvcPortTuple{Port: 80, TargetPort: "namedport"}, SvcPortTuple{Port: 8080, TargetPort: "9000"}), namer, false, nil, defaultNetwork), + NewPortInfoMap(namespace, name, NewSvcPortTupleSet(SvcPortTuple{Port: 443, TargetPort: "3000"}, SvcPortTuple{Port: 5000, TargetPort: "6000"}), namer, false, nil, defaultNetwork), }, { "difference of two non-empty maps with elements in common", - NewPortInfoMap(namespace, name, NewSvcPortTupleSet(SvcPortTuple{Port: 80, TargetPort: "namedport"}, SvcPortTuple{Port: 443, TargetPort: "3000"}, SvcPortTuple{Port: 5000, TargetPort: "6000"}, SvcPortTuple{Port: 8080, TargetPort: "9000"}), namer, false, nil), - NewPortInfoMap(namespace, name, NewSvcPortTupleSet(SvcPortTuple{Port: 80, TargetPort: "namedport"}, SvcPortTuple{Port: 8080, TargetPort: "9000"}), namer, false, nil), - NewPortInfoMap(namespace, name, NewSvcPortTupleSet(SvcPortTuple{Port: 443, TargetPort: "3000"}, SvcPortTuple{Port: 5000, TargetPort: "6000"}), namer, false, nil), + NewPortInfoMap(namespace, name, NewSvcPortTupleSet(SvcPortTuple{Port: 80, TargetPort: "namedport"}, SvcPortTuple{Port: 443, TargetPort: "3000"}, SvcPortTuple{Port: 5000, TargetPort: "6000"}, SvcPortTuple{Port: 8080, TargetPort: "9000"}), namer, false, nil, defaultNetwork), + NewPortInfoMap(namespace, name, NewSvcPortTupleSet(SvcPortTuple{Port: 80, TargetPort: "namedport"}, SvcPortTuple{Port: 8080, TargetPort: "9000"}), namer, false, nil, defaultNetwork), + NewPortInfoMap(namespace, name, NewSvcPortTupleSet(SvcPortTuple{Port: 443, TargetPort: "3000"}, SvcPortTuple{Port: 5000, TargetPort: "6000"}), namer, false, nil, defaultNetwork), }, { "difference of two non-empty maps with a key in common but different in value", - NewPortInfoMap(namespace, name, NewSvcPortTupleSet(SvcPortTuple{Port: 80, TargetPort: "namedport"}), namer, false, nil), - NewPortInfoMap(namespace, name, NewSvcPortTupleSet(SvcPortTuple{Port: 80, TargetPort: "8080"}, SvcPortTuple{Port: 8080, TargetPort: "9000"}), namer, false, nil), - NewPortInfoMap(namespace, name, NewSvcPortTupleSet(SvcPortTuple{Port: 80, TargetPort: "namedport"}), namer, false, nil), + NewPortInfoMap(namespace, name, NewSvcPortTupleSet(SvcPortTuple{Port: 80, TargetPort: "namedport"}), namer, false, nil, defaultNetwork), + NewPortInfoMap(namespace, name, NewSvcPortTupleSet(SvcPortTuple{Port: 80, TargetPort: "8080"}, SvcPortTuple{Port: 8080, TargetPort: "9000"}), namer, false, nil, defaultNetwork), + NewPortInfoMap(namespace, name, NewSvcPortTupleSet(SvcPortTuple{Port: 80, TargetPort: "namedport"}), namer, false, nil, defaultNetwork), }, { "difference of two non-empty maps with 2 keys in common but different in values", - NewPortInfoMap(namespace, name, NewSvcPortTupleSet(SvcPortTuple{Port: 80, TargetPort: "namedport"}, SvcPortTuple{Port: 443, TargetPort: "8443"}), namer, false, nil), - NewPortInfoMap(namespace, name, NewSvcPortTupleSet(SvcPortTuple{Port: 80, TargetPort: "8080"}, SvcPortTuple{Port: 443, TargetPort: "9443"}), namer, false, nil), - NewPortInfoMap(namespace, name, NewSvcPortTupleSet(SvcPortTuple{Port: 80, TargetPort: "namedport"}, SvcPortTuple{Port: 443, TargetPort: "8443"}), namer, false, nil), + NewPortInfoMap(namespace, name, NewSvcPortTupleSet(SvcPortTuple{Port: 80, TargetPort: "namedport"}, SvcPortTuple{Port: 443, TargetPort: "8443"}), namer, false, nil, defaultNetwork), + NewPortInfoMap(namespace, name, NewSvcPortTupleSet(SvcPortTuple{Port: 80, TargetPort: "8080"}, SvcPortTuple{Port: 443, TargetPort: "9443"}), namer, false, nil, defaultNetwork), + NewPortInfoMap(namespace, name, NewSvcPortTupleSet(SvcPortTuple{Port: 80, TargetPort: "namedport"}, SvcPortTuple{Port: 443, TargetPort: "8443"}), namer, false, nil, defaultNetwork), }, { "difference of two non-empty maps with a key in common but different in readiness gate fields", - NewPortInfoMap(namespace, name, NewSvcPortTupleSet(SvcPortTuple{Port: 80, TargetPort: "8080"}), namer, true, nil), - NewPortInfoMap(namespace, name, NewSvcPortTupleSet(SvcPortTuple{Port: 80, TargetPort: "8080"}, SvcPortTuple{Port: 8080, TargetPort: "9000"}), namer, false, nil), - NewPortInfoMap(namespace, name, NewSvcPortTupleSet(SvcPortTuple{Port: 80, TargetPort: "8080"}), namer, true, nil), + NewPortInfoMap(namespace, name, NewSvcPortTupleSet(SvcPortTuple{Port: 80, TargetPort: "8080"}), namer, true, nil, defaultNetwork), + NewPortInfoMap(namespace, name, NewSvcPortTupleSet(SvcPortTuple{Port: 80, TargetPort: "8080"}, SvcPortTuple{Port: 8080, TargetPort: "9000"}), namer, false, nil, defaultNetwork), + NewPortInfoMap(namespace, name, NewSvcPortTupleSet(SvcPortTuple{Port: 80, TargetPort: "8080"}), namer, true, nil, defaultNetwork), }, { "difference of two non-empty maps with 2 keys in common and 2 more items with different readinessGate", - NewPortInfoMap(namespace, name, NewSvcPortTupleSet(SvcPortTuple{Port: 80, TargetPort: "namedport"}, SvcPortTuple{Port: 443, TargetPort: "3000"}, SvcPortTuple{Port: 5000, TargetPort: "6000"}, SvcPortTuple{Port: 8080, TargetPort: "9000"}), namer, true, nil), - NewPortInfoMap(namespace, name, NewSvcPortTupleSet(SvcPortTuple{Port: 80, TargetPort: "namedport"}, SvcPortTuple{Port: 8080, TargetPort: "9000"}), namer, false, nil), - NewPortInfoMap(namespace, name, NewSvcPortTupleSet(SvcPortTuple{Port: 80, TargetPort: "namedport"}, SvcPortTuple{Port: 443, TargetPort: "3000"}, SvcPortTuple{Port: 5000, TargetPort: "6000"}, SvcPortTuple{Port: 8080, TargetPort: "9000"}), namer, true, nil), + NewPortInfoMap(namespace, name, NewSvcPortTupleSet(SvcPortTuple{Port: 80, TargetPort: "namedport"}, SvcPortTuple{Port: 443, TargetPort: "3000"}, SvcPortTuple{Port: 5000, TargetPort: "6000"}, SvcPortTuple{Port: 8080, TargetPort: "9000"}), namer, true, nil, defaultNetwork), + NewPortInfoMap(namespace, name, NewSvcPortTupleSet(SvcPortTuple{Port: 80, TargetPort: "namedport"}, SvcPortTuple{Port: 8080, TargetPort: "9000"}), namer, false, nil, defaultNetwork), + NewPortInfoMap(namespace, name, NewSvcPortTupleSet(SvcPortTuple{Port: 80, TargetPort: "namedport"}, SvcPortTuple{Port: 443, TargetPort: "3000"}, SvcPortTuple{Port: 5000, TargetPort: "6000"}, SvcPortTuple{Port: 8080, TargetPort: "9000"}), namer, true, nil, defaultNetwork), }, { "difference of two non-empty maps with a key in common but different neg names", - NewPortInfoMap(namespace, name, NewSvcPortTupleSet(SvcPortTuple{Port: 80, TargetPort: "8080"}), namer, true, map[SvcPortTuple]string{SvcPortTuple{Port: 80, TargetPort: "8080"}: "neg-1"}), - NewPortInfoMap(namespace, name, NewSvcPortTupleSet(SvcPortTuple{Port: 80, TargetPort: "8080"}, SvcPortTuple{Port: 8080, TargetPort: "9000"}), namer, false, nil), - NewPortInfoMap(namespace, name, NewSvcPortTupleSet(SvcPortTuple{Port: 80, TargetPort: "8080"}), namer, true, map[SvcPortTuple]string{SvcPortTuple{Port: 80, TargetPort: "8080"}: "neg-1"}), + NewPortInfoMap(namespace, name, NewSvcPortTupleSet(SvcPortTuple{Port: 80, TargetPort: "8080"}), namer, true, map[SvcPortTuple]string{SvcPortTuple{Port: 80, TargetPort: "8080"}: "neg-1"}, defaultNetwork), + NewPortInfoMap(namespace, name, NewSvcPortTupleSet(SvcPortTuple{Port: 80, TargetPort: "8080"}, SvcPortTuple{Port: 8080, TargetPort: "9000"}), namer, false, nil, defaultNetwork), + NewPortInfoMap(namespace, name, NewSvcPortTupleSet(SvcPortTuple{Port: 80, TargetPort: "8080"}), namer, true, map[SvcPortTuple]string{SvcPortTuple{Port: 80, TargetPort: "8080"}: "neg-1"}, defaultNetwork), + }, + { + "difference of two non-empty maps with different network", + NewPortInfoMap(namespace, name, NewSvcPortTupleSet(SvcPortTuple{Port: 80, TargetPort: "namedport"}, SvcPortTuple{Port: 443, TargetPort: "3000"}), namer, false, nil, &network.NetworkInfo{IsNonDefault: true, NetworkURL: "nonDefault", SubnetworkURL: "nonDefault"}), + NewPortInfoMap(namespace, name, NewSvcPortTupleSet(SvcPortTuple{Port: 80, TargetPort: "namedport"}, SvcPortTuple{Port: 443, TargetPort: "3000"}), namer, false, nil, defaultNetwork), + NewPortInfoMap(namespace, name, NewSvcPortTupleSet(SvcPortTuple{Port: 80, TargetPort: "namedport"}, SvcPortTuple{Port: 443, TargetPort: "3000"}), namer, false, nil, &network.NetworkInfo{IsNonDefault: true, NetworkURL: "nonDefault", SubnetworkURL: "nonDefault"}), }, } @@ -336,6 +357,10 @@ func TestNegsWithReadinessGate(t *testing.T) { namer := &negNamer{} namespace := "namespace" name := "name" + defaultNetwork := &network.NetworkInfo{ + NetworkURL: "defaultNetwork", + SubnetworkURL: "defaultSubnetwork", + } for _, tc := range []struct { desc string getPortInfoMap func() PortInfoMap @@ -349,22 +374,22 @@ func TestNegsWithReadinessGate(t *testing.T) { { desc: "PortInfoMap with no readiness gate enabled", getPortInfoMap: func() PortInfoMap { - return NewPortInfoMap(namespace, name, NewSvcPortTupleSet(SvcPortTuple{Port: 80, TargetPort: "namedport"}, SvcPortTuple{Port: 443, TargetPort: "3000"}, SvcPortTuple{Port: 5000, TargetPort: "6000"}, SvcPortTuple{Port: 8080, TargetPort: "9000"}), namer, false, nil) + return NewPortInfoMap(namespace, name, NewSvcPortTupleSet(SvcPortTuple{Port: 80, TargetPort: "namedport"}, SvcPortTuple{Port: 443, TargetPort: "3000"}, SvcPortTuple{Port: 5000, TargetPort: "6000"}, SvcPortTuple{Port: 8080, TargetPort: "9000"}), namer, false, nil, defaultNetwork) }, expectNegs: sets.NewString(), }, { desc: "PortInfoMap with all readiness gates enabled", getPortInfoMap: func() PortInfoMap { - return NewPortInfoMap(namespace, name, NewSvcPortTupleSet(SvcPortTuple{Port: 80, TargetPort: "namedport"}, SvcPortTuple{Port: 443, TargetPort: "3000"}, SvcPortTuple{Port: 5000, TargetPort: "6000"}, SvcPortTuple{Port: 8080, TargetPort: "9000"}), namer, true, nil) + return NewPortInfoMap(namespace, name, NewSvcPortTupleSet(SvcPortTuple{Port: 80, TargetPort: "namedport"}, SvcPortTuple{Port: 443, TargetPort: "3000"}, SvcPortTuple{Port: 5000, TargetPort: "6000"}, SvcPortTuple{Port: 8080, TargetPort: "9000"}), namer, true, nil, defaultNetwork) }, expectNegs: sets.NewString(namer.NEG(namespace, name, 80), namer.NEG(namespace, name, 443), namer.NEG(namespace, name, 5000), namer.NEG(namespace, name, 8080)), }, { desc: "PortInfoMap with part of readiness gates enabled", getPortInfoMap: func() PortInfoMap { - p := NewPortInfoMap(namespace, name, NewSvcPortTupleSet(SvcPortTuple{Port: 5000, TargetPort: "6000"}, SvcPortTuple{Port: 8080, TargetPort: "9000"}), namer, true, nil) - p.Merge(NewPortInfoMap(namespace, name, NewSvcPortTupleSet(SvcPortTuple{Port: 80, TargetPort: "namedport"}, SvcPortTuple{Port: 443, TargetPort: "3000"}), namer, false, nil)) + p := NewPortInfoMap(namespace, name, NewSvcPortTupleSet(SvcPortTuple{Port: 5000, TargetPort: "6000"}, SvcPortTuple{Port: 8080, TargetPort: "9000"}), namer, true, nil, defaultNetwork) + p.Merge(NewPortInfoMap(namespace, name, NewSvcPortTupleSet(SvcPortTuple{Port: 80, TargetPort: "namedport"}, SvcPortTuple{Port: 443, TargetPort: "3000"}), namer, false, nil, defaultNetwork)) return p }, expectNegs: sets.NewString(namer.NEG(namespace, name, 5000), namer.NEG(namespace, name, 8080)), @@ -379,17 +404,21 @@ func TestNegsWithReadinessGate(t *testing.T) { func TestCustomNamedNegs(t *testing.T) { var ( - svcNamespace = "namespace" - svcName = "svc-name" - negName1 = "neg1" - negName2 = "neg2" - port1 = int32(80) - port2 = int32(432) - targetPort1 = "3000" - targetPort2 = "3001" - namer = &negNamer{} - svcPortTuple1 = SvcPortTuple{Port: port1, TargetPort: targetPort1} - svcPortTuple2 = SvcPortTuple{Port: port2, TargetPort: targetPort2} + svcNamespace = "namespace" + svcName = "svc-name" + negName1 = "neg1" + negName2 = "neg2" + port1 = int32(80) + port2 = int32(432) + targetPort1 = "3000" + targetPort2 = "3001" + namer = &negNamer{} + svcPortTuple1 = SvcPortTuple{Port: port1, TargetPort: targetPort1} + svcPortTuple2 = SvcPortTuple{Port: port2, TargetPort: targetPort2} + defaultNetwork = &network.NetworkInfo{ + NetworkURL: "defaultNetwork", + SubnetworkURL: "defaultSubnetwork", + } ) testcases := []struct { desc string @@ -401,8 +430,8 @@ func TestCustomNamedNegs(t *testing.T) { desc: "no custom named negs", svcPortTuples: NewSvcPortTupleSet(svcPortTuple1, svcPortTuple2), expectedPortInfoMap: PortInfoMap{ - PortInfoMapKey{port1}: PortInfo{PortTuple: svcPortTuple1, NegName: namer.NEG(svcNamespace, svcName, port1), ReadinessGate: false}, - PortInfoMapKey{port2}: PortInfo{PortTuple: svcPortTuple2, NegName: namer.NEG(svcNamespace, svcName, port2), ReadinessGate: false}, + PortInfoMapKey{port1}: PortInfo{PortTuple: svcPortTuple1, NegName: namer.NEG(svcNamespace, svcName, port1), ReadinessGate: false, NetworkInfo: *defaultNetwork}, + PortInfoMapKey{port2}: PortInfo{PortTuple: svcPortTuple2, NegName: namer.NEG(svcNamespace, svcName, port2), ReadinessGate: false, NetworkInfo: *defaultNetwork}, }, }, { @@ -410,8 +439,8 @@ func TestCustomNamedNegs(t *testing.T) { svcPortTuples: NewSvcPortTupleSet(svcPortTuple1, svcPortTuple2), customNamedNegs: map[SvcPortTuple]string{svcPortTuple1: negName1, svcPortTuple2: negName2}, expectedPortInfoMap: PortInfoMap{ - PortInfoMapKey{port1}: PortInfo{PortTuple: svcPortTuple1, NegName: negName1, ReadinessGate: false}, - PortInfoMapKey{port2}: PortInfo{PortTuple: svcPortTuple2, NegName: negName2, ReadinessGate: false}, + PortInfoMapKey{port1}: PortInfo{PortTuple: svcPortTuple1, NegName: negName1, ReadinessGate: false, NetworkInfo: *defaultNetwork}, + PortInfoMapKey{port2}: PortInfo{PortTuple: svcPortTuple2, NegName: negName2, ReadinessGate: false, NetworkInfo: *defaultNetwork}, }, }, { @@ -419,15 +448,15 @@ func TestCustomNamedNegs(t *testing.T) { svcPortTuples: NewSvcPortTupleSet(svcPortTuple1, svcPortTuple2), customNamedNegs: map[SvcPortTuple]string{svcPortTuple1: negName1}, expectedPortInfoMap: PortInfoMap{ - PortInfoMapKey{port1}: PortInfo{PortTuple: svcPortTuple1, NegName: negName1, ReadinessGate: false}, - PortInfoMapKey{port2}: PortInfo{PortTuple: svcPortTuple2, NegName: namer.NEG(svcNamespace, svcName, port2), ReadinessGate: false}, + PortInfoMapKey{port1}: PortInfo{PortTuple: svcPortTuple1, NegName: negName1, ReadinessGate: false, NetworkInfo: *defaultNetwork}, + PortInfoMapKey{port2}: PortInfo{PortTuple: svcPortTuple2, NegName: namer.NEG(svcNamespace, svcName, port2), ReadinessGate: false, NetworkInfo: *defaultNetwork}, }, }, } for _, tc := range testcases { t.Run(tc.desc, func(t *testing.T) { - result := NewPortInfoMap(svcNamespace, svcName, tc.svcPortTuples, namer, false, tc.customNamedNegs) + result := NewPortInfoMap(svcNamespace, svcName, tc.svcPortTuples, namer, false, tc.customNamedNegs, defaultNetwork) if !reflect.DeepEqual(tc.expectedPortInfoMap, result) { t.Errorf("Expected portInfoMap to equal: %v; got: %v", tc.expectedPortInfoMap, result) } @@ -677,15 +706,19 @@ func TestEndpointsDataFromEndpointSlicesNodeNameFromTopology(t *testing.T) { func TestEndpointsCalculatorMode(t *testing.T) { testContext := NewTestContext() + defaultNetwork := &network.NetworkInfo{ + NetworkURL: "defaultNetwork", + SubnetworkURL: "defaultSubnetwork", + } for _, tc := range []struct { desc string portInfoMap PortInfoMap expectMode EndpointsCalculatorMode }{ - {"L4 Local Mode", NewPortInfoMapForVMIPNEG("testns", "testsvc", testContext.L4Namer, true), L4LocalMode}, - {"L4 Cluster Mode", NewPortInfoMapForVMIPNEG("testns", "testsvc", testContext.L4Namer, false), L4ClusterMode}, - {"L7 Mode", NewPortInfoMap("testns", "testsvc", NewSvcPortTupleSet(SvcPortTuple{Name: "http", Port: 80, TargetPort: "targetPort"}), testContext.NegNamer, false, nil), L7Mode}, - {"Empty tupleset returns L7 Mode", NewPortInfoMap("testns", "testsvc", nil, testContext.NegNamer, false, nil), L7Mode}, + {"L4 Local Mode", NewPortInfoMapForVMIPNEG("testns", "testsvc", testContext.L4Namer, true, defaultNetwork), L4LocalMode}, + {"L4 Cluster Mode", NewPortInfoMapForVMIPNEG("testns", "testsvc", testContext.L4Namer, false, defaultNetwork), L4ClusterMode}, + {"L7 Mode", NewPortInfoMap("testns", "testsvc", NewSvcPortTupleSet(SvcPortTuple{Name: "http", Port: 80, TargetPort: "targetPort"}), testContext.NegNamer, false, nil, defaultNetwork), L7Mode}, + {"Empty tupleset returns L7 Mode", NewPortInfoMap("testns", "testsvc", nil, testContext.NegNamer, false, nil, defaultNetwork), L7Mode}, } { t.Run(tc.desc, func(t *testing.T) { mode := tc.portInfoMap.EndpointsCalculatorMode() diff --git a/pkg/network/network.go b/pkg/network/network.go new file mode 100644 index 0000000000..e7ecf87699 --- /dev/null +++ b/pkg/network/network.go @@ -0,0 +1,51 @@ +/* +Copyright 2023 The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package network + +import ( + apiv1 "k8s.io/api/core/v1" +) + +// ServiceNetwork determines the network data to be used for the LB resources. +// This function currently returns only the default network but will provide +// secondary networks information for multi-networked services in the future. +func ServiceNetwork(_ *apiv1.Service, cloudProvider cloudNetworkProvider) (*NetworkInfo, error) { + return &NetworkInfo{ + IsNonDefault: false, + K8sNetwork: "default", + NetworkURL: cloudProvider.NetworkURL(), + SubnetworkURL: cloudProvider.SubnetworkURL(), + }, nil +} + +type cloudNetworkProvider interface { + NetworkURL() string + SubnetworkURL() string +} + +// NetworkInfo contains the information about the network the LB resources should be created in. +type NetworkInfo struct { + // IsNonDefault indicates if the network is not the default one. + IsNonDefault bool + // K8sNetwork is the network name of the Network resource in the cluster. + // This name should be used when referring to k8s API network. + K8sNetwork string + // NetworkURL is the GCE VPC URL (to be used in GCE LB resources). + NetworkURL string + // SubnetworkURL is the GCE subnetwork URL (to be used in GCE LB resources). + SubnetworkURL string +}