From f987dbae92dcf425b81ae774e04ae85f131a23a0 Mon Sep 17 00:00:00 2001 From: zcq98 Date: Tue, 19 Dec 2023 09:24:51 +0800 Subject: [PATCH] fix: apply changes to the latest version Signed-off-by: zcq98 --- pkg/controller/init.go | 8 ++-- pkg/controller/subnet.go | 70 +++++++++++++++++------------ pkg/controller/vip.go | 10 +++-- pkg/controller/vlan.go | 3 +- pkg/controller/vpc.go | 22 ++++----- test/e2e/ovn-vpc-nat-gw/e2e_test.go | 2 +- 6 files changed, 66 insertions(+), 49 deletions(-) diff --git a/pkg/controller/init.go b/pkg/controller/init.go index 8511773c284..d2c3de85226 100644 --- a/pkg/controller/init.go +++ b/pkg/controller/init.go @@ -101,7 +101,7 @@ func (c *Controller) initDefaultLogicalSwitch() error { if util.CheckProtocol(c.config.DefaultCIDR) == kubeovnv1.ProtocolDual { subnet := subnet.DeepCopy() subnet.Spec.CIDRBlock = c.config.DefaultCIDR - if _, err = formatSubnet(subnet, c); err != nil { + if _, err = c.formatSubnet(subnet); err != nil { klog.Errorf("init format subnet %s failed: %v", c.config.DefaultLogicalSwitch, err) return err } @@ -155,7 +155,7 @@ func (c *Controller) initNodeSwitch() error { // single-stack upgrade to dual-stack subnet := subnet.DeepCopy() subnet.Spec.CIDRBlock = c.config.NodeSwitchCIDR - if _, err = formatSubnet(subnet, c); err != nil { + if _, err = c.formatSubnet(subnet); err != nil { klog.Errorf("init format subnet %s failed: %v", c.config.NodeSwitch, err) return err } @@ -612,9 +612,9 @@ func (c *Controller) initSyncCrdSubnets() error { for _, orisubnet := range subnets { subnet := orisubnet.DeepCopy() if util.CheckProtocol(subnet.Spec.CIDRBlock) == kubeovnv1.ProtocolDual { - err = calcDualSubnetStatusIP(subnet, c) + subnet, err = c.calcDualSubnetStatusIP(subnet) } else { - err = calcSubnetStatusIP(subnet, c) + subnet, err = c.calcSubnetStatusIP(subnet) } if err != nil { klog.Errorf("failed to calculate subnet %s used ip: %v", subnet.Name, err) diff --git a/pkg/controller/subnet.go b/pkg/controller/subnet.go index 47c9d806faa..8f7bd2a9361 100644 --- a/pkg/controller/subnet.go +++ b/pkg/controller/subnet.go @@ -272,7 +272,7 @@ func (c *Controller) processNextDeleteSubnetWorkItem() bool { return true } -func formatSubnet(subnet *kubeovnv1.Subnet, c *Controller) (*kubeovnv1.Subnet, error) { +func (c *Controller) formatSubnet(subnet *kubeovnv1.Subnet) (*kubeovnv1.Subnet, error) { var ( changed bool err error @@ -332,13 +332,14 @@ func formatSubnet(subnet *kubeovnv1.Subnet, c *Controller) (*kubeovnv1.Subnet, e klog.Infof("format subnet %v, changed %v", subnet.Name, changed) if changed { - subnet, err = c.config.KubeOvnClient.KubeovnV1().Subnets().Update(context.Background(), subnet, metav1.UpdateOptions{}) + newSubnet, err := c.config.KubeOvnClient.KubeovnV1().Subnets().Update(context.Background(), subnet, metav1.UpdateOptions{}) if err != nil { klog.Errorf("failed to update subnet %s, %v", subnet.Name, err) return nil, err } + return newSubnet, nil } - return subnet.DeepCopy(), nil + return subnet, nil } func (c *Controller) updateNatOutgoingPolicyRulesStatus(subnet *kubeovnv1.Subnet) error { @@ -708,16 +709,17 @@ func (c *Controller) handleAddOrUpdateSubnet(key string) error { } klog.V(3).Infof("handle add or update subnet %s", cachedSubnet.Name) - subnet, err := formatSubnet(cachedSubnet.DeepCopy(), c) + subnet := cachedSubnet.DeepCopy() + subnet, err = c.formatSubnet(subnet) if err != nil { klog.Error(err) return err } if subnet.Spec.Protocol == kubeovnv1.ProtocolDual { - err = calcDualSubnetStatusIP(subnet, c) + subnet, err = c.calcDualSubnetStatusIP(subnet) } else { - err = calcSubnetStatusIP(subnet, c) + subnet, err = c.calcSubnetStatusIP(subnet) } if err != nil { klog.Errorf("calculate subnet %s used ip failed, %v", subnet.Name, err) @@ -917,9 +919,17 @@ func (c *Controller) handleUpdateSubnetStatus(key string) error { } if util.CheckProtocol(subnet.Spec.CIDRBlock) == kubeovnv1.ProtocolDual { - return calcDualSubnetStatusIP(subnet, c) + if _, err := c.calcDualSubnetStatusIP(subnet); err != nil { + klog.Error(err) + return err + } + return nil } - return calcSubnetStatusIP(subnet, c) + if _, err = c.calcSubnetStatusIP(subnet); err != nil { + klog.Error(err) + return err + } + return nil } func (c *Controller) handleDeleteLogicalSwitch(key string) (err error) { @@ -1992,11 +2002,13 @@ func (c *Controller) reconcileU2OInterconnectionIP(subnet *kubeovnv1.Subnet) err klog.Infof("reconcile underlay subnet %s to overlay interconnection with U2OInterconnection %v U2OInterconnectionIP %s ", subnet.Name, subnet.Spec.U2OInterconnection, subnet.Status.U2OInterconnectionIP) if subnet.Spec.Protocol == kubeovnv1.ProtocolDual { - if err := calcDualSubnetStatusIP(subnet, c); err != nil { + if _, err := c.calcDualSubnetStatusIP(subnet); err != nil { + klog.Error(err) return err } } else { - if err := calcSubnetStatusIP(subnet, c); err != nil { + if _, err := c.calcSubnetStatusIP(subnet); err != nil { + klog.Error(err) return err } } @@ -2004,15 +2016,15 @@ func (c *Controller) reconcileU2OInterconnectionIP(subnet *kubeovnv1.Subnet) err return nil } -func calcDualSubnetStatusIP(subnet *kubeovnv1.Subnet, c *Controller) error { +func (c *Controller) calcDualSubnetStatusIP(subnet *kubeovnv1.Subnet) (*kubeovnv1.Subnet, error) { if err := util.CheckCidrs(subnet.Spec.CIDRBlock); err != nil { - return err + return nil, err } // Get the number of pods, not ips. For one pod with two ip(v4 & v6) in dual-stack, num of Items is 1 podUsedIPs, err := c.ipsLister.List(labels.SelectorFromSet(labels.Set{subnet.Name: ""})) if err != nil { klog.Error(err) - return err + return nil, err } // subnet.Spec.ExcludeIps contains both v4 and v6 addresses @@ -2034,7 +2046,7 @@ func calcDualSubnetStatusIP(subnet *kubeovnv1.Subnet, c *Controller) error { })) if err != nil { klog.Error(err) - return err + return nil, err } usingIPs += float64(len(vips)) @@ -2043,7 +2055,7 @@ func calcDualSubnetStatusIP(subnet *kubeovnv1.Subnet, c *Controller) error { labels.SelectorFromSet(labels.Set{util.SubnetNameLabel: subnet.Name})) if err != nil { klog.Error(err) - return err + return nil, err } usingIPs += float64(len(eips)) } @@ -2066,7 +2078,7 @@ func calcDualSubnetStatusIP(subnet *kubeovnv1.Subnet, c *Controller) error { subnet.Status.V6UsingIPRange == v6UsingIPStr && subnet.Status.V4AvailableIPRange == v4AvailableIPStr && subnet.Status.V6AvailableIPRange == v6AvailableIPStr { - return nil + return subnet, nil } subnet.Status.V4AvailableIPs = v4availableIPs @@ -2081,22 +2093,22 @@ func calcDualSubnetStatusIP(subnet *kubeovnv1.Subnet, c *Controller) error { bytes, err := subnet.Status.Bytes() if err != nil { klog.Error(err) - return err + return nil, err } - _, err = c.config.KubeOvnClient.KubeovnV1().Subnets().Patch(context.Background(), subnet.Name, types.MergePatchType, bytes, metav1.PatchOptions{}, "status") - return err + newSubnet, err := c.config.KubeOvnClient.KubeovnV1().Subnets().Patch(context.Background(), subnet.Name, types.MergePatchType, bytes, metav1.PatchOptions{}, "status") + return newSubnet, err } -func calcSubnetStatusIP(subnet *kubeovnv1.Subnet, c *Controller) error { +func (c *Controller) calcSubnetStatusIP(subnet *kubeovnv1.Subnet) (*kubeovnv1.Subnet, error) { _, cidr, err := net.ParseCIDR(subnet.Spec.CIDRBlock) if err != nil { klog.Error(err) - return err + return nil, err } podUsedIPs, err := c.ipsLister.List(labels.SelectorFromSet(labels.Set{subnet.Name: ""})) if err != nil { klog.Error(err) - return err + return nil, err } // gateway always in excludeIPs toSubIPs := util.ExpandExcludeIPs(subnet.Spec.ExcludeIps, subnet.Spec.CIDRBlock) @@ -2108,7 +2120,7 @@ func calcSubnetStatusIP(subnet *kubeovnv1.Subnet, c *Controller) error { })) if err != nil { klog.Error(err) - return err + return nil, err } usingIPs += float64(len(vips)) ovnEips, err := c.ovnEipsLister.List(labels.SelectorFromSet(labels.Set{ @@ -2116,7 +2128,7 @@ func calcSubnetStatusIP(subnet *kubeovnv1.Subnet, c *Controller) error { })) if err != nil { klog.Error(err) - return err + return nil, err } usingIPs += float64(len(ovnEips)) if !isOvnSubnet(subnet) { @@ -2124,7 +2136,7 @@ func calcSubnetStatusIP(subnet *kubeovnv1.Subnet, c *Controller) error { labels.SelectorFromSet(labels.Set{util.SubnetNameLabel: subnet.Name})) if err != nil { klog.Error(err) - return err + return nil, err } usingIPs += float64(len(eips)) } @@ -2174,16 +2186,16 @@ func calcSubnetStatusIP(subnet *kubeovnv1.Subnet, c *Controller) error { subnet.Status.V6UsingIPRange, subnet.Status.V6AvailableIPRange, } { - return nil + return subnet, nil } bytes, err := subnet.Status.Bytes() if err != nil { klog.Error(err) - return err + return nil, err } - _, err = c.config.KubeOvnClient.KubeovnV1().Subnets().Patch(context.Background(), subnet.Name, types.MergePatchType, bytes, metav1.PatchOptions{}, "status") - return err + newSubnet, err := c.config.KubeOvnClient.KubeovnV1().Subnets().Patch(context.Background(), subnet.Name, types.MergePatchType, bytes, metav1.PatchOptions{}, "status") + return newSubnet, err } func isOvnSubnet(subnet *kubeovnv1.Subnet) bool { diff --git a/pkg/controller/vip.go b/pkg/controller/vip.go index d33768de9f3..b7e098d611d 100644 --- a/pkg/controller/vip.go +++ b/pkg/controller/vip.go @@ -482,11 +482,15 @@ func (c *Controller) handleUpdateVirtualParents(key string) error { func (c *Controller) subnetCountIP(subnet *kubeovnv1.Subnet) error { var err error if util.CheckProtocol(subnet.Spec.CIDRBlock) == kubeovnv1.ProtocolDual { - err = calcDualSubnetStatusIP(subnet, c) + _, err = c.calcDualSubnetStatusIP(subnet) } else { - err = calcSubnetStatusIP(subnet, c) + _, err = c.calcSubnetStatusIP(subnet) } - return err + if err != nil { + klog.Error(err) + return err + } + return nil } func (c *Controller) createOrUpdateCrdVip(key, ns, subnet, v4ip, v6ip, mac, pV4ip, pV6ip, pmac string) error { diff --git a/pkg/controller/vlan.go b/pkg/controller/vlan.go index b9df03f7ae6..1ca43ee7dfa 100644 --- a/pkg/controller/vlan.go +++ b/pkg/controller/vlan.go @@ -182,7 +182,6 @@ func (c *Controller) handleAddVlan(key string) error { klog.Errorf("failed to update vlan %s, %v", vlan.Name, err) return err } - vlan = vlan.DeepCopy() } subnets, err := c.subnetsLister.List(labels.Everything()) @@ -200,7 +199,7 @@ func (c *Controller) handleAddVlan(key string) error { } if needUpdate { - _, err = c.config.KubeOvnClient.KubeovnV1().Vlans().UpdateStatus(context.Background(), vlan, metav1.UpdateOptions{}) + vlan, err = c.config.KubeOvnClient.KubeovnV1().Vlans().UpdateStatus(context.Background(), vlan, metav1.UpdateOptions{}) if err != nil { klog.Errorf("failed to update status of vlan %s: %v", vlan.Name, err) return err diff --git a/pkg/controller/vpc.go b/pkg/controller/vpc.go index 4f18b547211..260b071bc77 100644 --- a/pkg/controller/vpc.go +++ b/pkg/controller/vpc.go @@ -274,7 +274,7 @@ func (c *Controller) handleAddOrUpdateVpc(key string) error { } vpc = cachedVpc.DeepCopy() - if err = formatVpc(vpc, c); err != nil { + if vpc, err = c.formatVpc(vpc); err != nil { klog.Errorf("failed to format vpc %s: %v", key, err) return err } @@ -839,7 +839,7 @@ func getStaticRouteItemKey(item *kubeovnv1.StaticRoute) string { return key } -func formatVpc(vpc *kubeovnv1.Vpc, c *Controller) error { +func (c *Controller) formatVpc(vpc *kubeovnv1.Vpc) (*kubeovnv1.Vpc, error) { var changed bool for _, item := range vpc.Spec.StaticRoutes { // check policy @@ -848,19 +848,19 @@ func formatVpc(vpc *kubeovnv1.Vpc, c *Controller) error { changed = true } if item.Policy != kubeovnv1.PolicyDst && item.Policy != kubeovnv1.PolicySrc { - return fmt.Errorf("unknown policy type: %s", item.Policy) + return nil, fmt.Errorf("unknown policy type: %s", item.Policy) } // check cidr if strings.Contains(item.CIDR, "/") { if _, _, err := net.ParseCIDR(item.CIDR); err != nil { - return fmt.Errorf("invalid cidr %s: %w", item.CIDR, err) + return nil, fmt.Errorf("invalid cidr %s: %w", item.CIDR, err) } } else if ip := net.ParseIP(item.CIDR); ip == nil { - return fmt.Errorf("invalid ip %s", item.CIDR) + return nil, fmt.Errorf("invalid ip %s", item.CIDR) } // check next hop ip if ip := net.ParseIP(item.NextHopIP); ip == nil { - return fmt.Errorf("invalid next hop ip %s", item.NextHopIP) + return nil, fmt.Errorf("invalid next hop ip %s", item.NextHopIP) } } @@ -876,20 +876,22 @@ func formatVpc(vpc *kubeovnv1.Vpc, c *Controller) error { if ip := net.ParseIP(ipStr); ip == nil { err := fmt.Errorf("invalid next hop ips: %s", route.NextHopIP) klog.Error(err) - return err + return nil, err } } } } if changed { - if _, err := c.config.KubeOvnClient.KubeovnV1().Vpcs().Update(context.Background(), vpc, metav1.UpdateOptions{}); err != nil { + newVpc, err := c.config.KubeOvnClient.KubeovnV1().Vpcs().Update(context.Background(), vpc, metav1.UpdateOptions{}) + if err != nil { klog.Errorf("failed to update vpc %s: %v", vpc.Name, err) - return err + return nil, err } + return newVpc, err } - return nil + return vpc, nil } func convertPolicies(list []*kubeovnv1.PolicyRoute) string { diff --git a/test/e2e/ovn-vpc-nat-gw/e2e_test.go b/test/e2e/ovn-vpc-nat-gw/e2e_test.go index 1e7829a8512..8a8b5dd6334 100644 --- a/test/e2e/ovn-vpc-nat-gw/e2e_test.go +++ b/test/e2e/ovn-vpc-nat-gw/e2e_test.go @@ -748,7 +748,7 @@ var _ = framework.Describe("[group:ovn-vpc-nat-gw]", func() { CIDR: noBfdExtraSubnetV4Cidr, NextHopIP: gatewayV4, }) - _ = vpcClient.PatchSync(cachedVpc, noBfdVpc, nil, 180*time.Second) + _, err = vpcClient.Update(context.Background(), noBfdVpc, metav1.UpdateOptions{}) framework.ExpectNoError(err) ginkgo.By("Creating overlay subnet " + noBfdExtraSubnetName)