kubeovn/kube-ovn | Build 12365336204 | pkg/controller/node.go | Coveralls

34

func (e *ErrChassisNotFound) Error() string {

×

35

        return fmt.Sprintf("chassis %s not found for node %s", e.Chassis, e.Node)

×

36

×

38

func (c *Controller) enqueueAddNode(obj interface{}) {

×

39

        var key string

×

40

        var err error

×

41

        if key, err = cache.MetaNamespaceKeyFunc(obj); err != nil {

×

42

                utilruntime.HandleError(err)

×

43

                return

×

44

×

45

        klog.V(3).Infof("enqueue add node %s", key)

×

46

        c.addNodeQueue.Add(key)

×

49

func nodeReady(node *v1.Node) bool {

×

50

        for _, con := range node.Status.Conditions {

×

51

                if con.Type == v1.NodeReady && con.Status == v1.ConditionTrue {

×

52

                        return true

×

53

×

55

        return false

×

58

func (c *Controller) enqueueUpdateNode(oldObj, newObj interface{}) {

×

59

        oldNode := oldObj.(*v1.Node)

×

60

        newNode := newObj.(*v1.Node)

×

61

×

62

        if nodeReady(oldNode) != nodeReady(newNode) ||

×

63

                !reflect.DeepEqual(oldNode.Annotations, newNode.Annotations) {

×

64

                var key string

×

65

                var err error

×

66

                if key, err = cache.MetaNamespaceKeyFunc(newObj); err != nil {

×

67

                        utilruntime.HandleError(err)

×

68

                        return

×

69

×

70

                if len(newNode.Annotations) == 0 || newNode.Annotations[util.AllocatedAnnotation] != "true" {

×

71

                        klog.V(3).Infof("enqueue add node %s", key)

×

72

                        c.addNodeQueue.Add(key)

×

73

                } else {

×

74

                        klog.V(3).Infof("enqueue update node %s", key)

×

75

                        c.updateNodeQueue.Add(key)

×

76

×

80

func (c *Controller) enqueueDeleteNode(obj interface{}) {

×

81

        var key string

×

82

        var err error

×

83

        if key, err = cache.MetaNamespaceKeyFunc(obj); err != nil {

×

84

                utilruntime.HandleError(err)

×

85

                return

×

86

×

87

        klog.V(3).Infof("enqueue delete node %s", key)

×

88

×

89

        c.deletingNodeObjMap.Store(key, obj.(*v1.Node))

×

90

        c.deleteNodeQueue.Add(key)

×

93

func nodeUnderlayAddressSetName(node string, af int) string {

×

94

        return fmt.Sprintf("node_%s_underlay_v%d", strings.ReplaceAll(node, "-", "_"), af)

×

95

×

97

func (c *Controller) handleAddNode(key string) error {

×

98

        c.nodeKeyMutex.LockKey(key)

×

99

        defer func() { _ = c.nodeKeyMutex.UnlockKey(key) }()

×

101

        cachedNode, err := c.nodesLister.Get(key)

×

102

        if err != nil {

×

103

                if k8serrors.IsNotFound(err) {

×

104

                        return nil

×

105

×

106

                klog.Errorf("failed to get node %s: %v", key, err)

×

107

                return err

×

109

        node := cachedNode.DeepCopy()

×

110

        klog.Infof("handle add node %s", node.Name)

×

111

×

112

        subnets, err := c.subnetsLister.List(labels.Everything())

×

113

        if err != nil {

×

114

                klog.Errorf("failed to list subnets: %v", err)

×

115

                return err

×

116

×

118

        nodeIPv4, nodeIPv6 := util.GetNodeInternalIP(*node)

×

119

        for _, subnet := range subnets {

×

120

                if subnet.Spec.Vpc != c.config.ClusterRouter {

×

121

                        continue

×

124

                v4, v6 := util.SplitStringIP(subnet.Spec.CIDRBlock)

×

125

                if subnet.Spec.Vlan == "" && (util.CIDRContainIP(v4, nodeIPv4) || util.CIDRContainIP(v6, nodeIPv6)) {

×

126

                        msg := fmt.Sprintf("internal IP address of node %s is in CIDR of subnet %s, this may result in network issues", node.Name, subnet.Name)

×

127

                        klog.Warning(msg)

×

128

                        c.recorder.Eventf(&v1.Node{ObjectMeta: metav1.ObjectMeta{Name: node.Name, UID: types.UID(node.Name)}}, v1.EventTypeWarning, "NodeAddressConflictWithSubnet", msg)

×

129

                        break

×

133

        if err = c.handleNodeAnnotationsForProviderNetworks(node); err != nil {

×

134

                klog.Errorf("failed to handle annotations of node %s for provider networks: %v", node.Name, err)

×

135

                return err

×

136

×

138

        subnet, err := c.subnetsLister.Get(c.config.NodeSwitch)

×

139

        if err != nil {

×

140

                klog.Errorf("failed to get node subnet: %v", err)

×

141

                return err

×

142

×

144

        var v4IP, v6IP, mac string

×

145

        portName := util.NodeLspName(key)

×

146

        if node.Annotations[util.AllocatedAnnotation] == "true" && node.Annotations[util.IPAddressAnnotation] != "" && node.Annotations[util.MacAddressAnnotation] != "" {

×

147

                macStr := node.Annotations[util.MacAddressAnnotation]

×

148

                v4IP, v6IP, mac, err = c.ipam.GetStaticAddress(portName, portName, node.Annotations[util.IPAddressAnnotation],

×

149

                        &macStr, node.Annotations[util.LogicalSwitchAnnotation], true)

×

150

                if err != nil {

×

151

                        klog.Errorf("failed to alloc static ip addrs for node %v: %v", node.Name, err)

×

152

                        return err

×

153

×

154

        } else {

×

155

                v4IP, v6IP, mac, err = c.ipam.GetRandomAddress(portName, portName, nil, c.config.NodeSwitch, "", nil, true)

×

156

                if err != nil {

×

157

                        klog.Errorf("failed to alloc random ip addrs for node %v: %v", node.Name, err)

×

158

                        return err

×

159

×

162

        ipStr := util.GetStringIP(v4IP, v6IP)

×

163

        if err := c.OVNNbClient.CreateBareLogicalSwitchPort(c.config.NodeSwitch, portName, ipStr, mac); err != nil {

×

164

                klog.Errorf("failed to create logical switch port %s: %v", portName, err)

×

165

                return err

×

166

×

168

        for _, ip := range strings.Split(ipStr, ",") {

×

169

                if ip == "" {

×

170

                        continue

×

173

                nodeIP, af := nodeIPv4, 4

×

174

                protocol := util.CheckProtocol(ip)

×

175

                if protocol == kubeovnv1.ProtocolIPv6 {

×

176

                        nodeIP, af = nodeIPv6, 6

×

177

×

178

                if nodeIP != "" {

×

179

                        var (

×

180

                                match       = fmt.Sprintf("ip%d.dst == %s", af, nodeIP)

×

181

                                action      = kubeovnv1.PolicyRouteActionReroute

×

182

                                externalIDs = map[string]string{

×

183

                                        "vendor":         util.CniTypeName,

×

184

                                        "node":           node.Name,

×

185

                                        "address-family": strconv.Itoa(af),

×

186

×

187

×

188

                        klog.Infof("add policy route for router: %s, match %s, action %s, nexthop %s, externalID %v", c.config.ClusterRouter, match, action, ip, externalIDs)

×

189

                        if err = c.addPolicyRouteToVpc(

×

190

                                c.config.ClusterRouter,

×

191

                                &kubeovnv1.PolicyRoute{

×

192

                                        Priority:  util.NodeRouterPolicyPriority,

×

193

                                        Match:     match,

×

194

                                        Action:    action,

×

195

                                        NextHopIP: ip,

×

196

},

×

197

                                externalIDs,

×

198

                        ); err != nil {

×

199

                                klog.Errorf("failed to add logical router policy for node %s: %v", node.Name, err)

×

200

                                return err

×

201

×

203

                        dnsIPs := make([]string, 0, len(c.config.NodeLocalDNSIPs))

×

204

                        for _, ip := range c.config.NodeLocalDNSIPs {

×

205

                                if util.CheckProtocol(ip) == protocol {

×

206

                                        dnsIPs = append(dnsIPs, ip)

×

207

×

210

                        if err = c.addPolicyRouteForLocalDNSCacheOnNode(dnsIPs, portName, ip, node.Name, af); err != nil {

×

211

                                klog.Errorf("failed to add policy route for node %s: %v", node.Name, err)

×

212

                                return err

×

213

×

217

        if err := c.addNodeGatewayStaticRoute(); err != nil {

×

218

                klog.Errorf("failed to add static route for node gw: %v", err)

×

219

                return err

×

220

×

222

        annotations := map[string]any{

×

223

                util.IPAddressAnnotation:     ipStr,

×

224

                util.MacAddressAnnotation:    mac,

×

225

                util.CidrAnnotation:          subnet.Spec.CIDRBlock,

×

226

                util.GatewayAnnotation:       subnet.Spec.Gateway,

×

227

                util.LogicalSwitchAnnotation: c.config.NodeSwitch,

×

228

                util.AllocatedAnnotation:     "true",

×

229

                util.PortNameAnnotation:      portName,

×

230

×

NEW

231

        if err = util.PatchAnnotations(c.config.KubeClient.CoreV1().Nodes(), node.Name, annotations); err != nil {

×

232

                klog.Errorf("failed to update annotations of node %s: %v", node.Name, err)

×

233

                return err

×

234

×

236

        if err := c.createOrUpdateIPCR("", "", ipStr, mac, c.config.NodeSwitch, "", node.Name, ""); err != nil {

×

237

                klog.Errorf("failed to create or update IPs %s: %v", portName, err)

×

238

                return err

×

239

×

241

        for _, subnet := range subnets {

×

242

                if (subnet.Spec.Vlan != "" && !subnet.Spec.LogicalGateway) || subnet.Spec.Vpc != c.config.ClusterRouter || subnet.Name == c.config.NodeSwitch || subnet.Spec.GatewayType != kubeovnv1.GWDistributedType {

×

243

                        continue

×

245

                if err = c.createPortGroupForDistributedSubnet(node, subnet); err != nil {

×

246

                        klog.Errorf("failed to create port group for node %s and subnet %s: %v", node.Name, subnet.Name, err)

×

247

                        return err

×

248

×

250

                c.addOrUpdateSubnetQueue.Add(subnet.Name)

×

254

        pgName := strings.ReplaceAll(portName, "-", ".")

×

255

        if err = c.OVNNbClient.CreatePortGroup(pgName, map[string]string{networkPolicyKey: "node" + "/" + key}); err != nil {

×

256

                klog.Errorf("create port group %s for node %s: %v", pgName, key, err)

×

257

                return err

×

258

×

260

        if err := c.addPolicyRouteForCentralizedSubnetOnNode(node.Name, ipStr); err != nil {

×

261

                klog.Errorf("failed to add policy route for node %s, %v", key, err)

×

262

                return err

×

263

×

265

        if err := c.UpdateChassisTag(node); err != nil {

×

266

                klog.Errorf("failed to update chassis tag for node %s: %v", node.Name, err)

×

267

                return err

×

268

×

270

        if err := c.retryDelDupChassis(util.ChassisRetryMaxTimes, util.ChassisControllerRetryInterval, c.cleanDuplicatedChassis, node); err != nil {

×

271

                klog.Errorf("failed to clean duplicated chassis for node %s: %v", node.Name, err)

×

272

                return err

×

273

×

274

        return nil

×

277

func (c *Controller) handleNodeAnnotationsForProviderNetworks(node *v1.Node) error {

×

278

        providerNetworks, err := c.providerNetworksLister.List(labels.Everything())

×

279

        if err != nil && !k8serrors.IsNotFound(err) {

×

280

                klog.Errorf("failed to list provider networks: %v", err)

×

281

                return err

×

282

×

284

        for _, pn := range providerNetworks {

×

285

                excludeAnno := fmt.Sprintf(util.ProviderNetworkExcludeTemplate, pn.Name)

×

286

                interfaceAnno := fmt.Sprintf(util.ProviderNetworkInterfaceTemplate, pn.Name)

×

287

×

288

                var newPn *kubeovnv1.ProviderNetwork

×

289

                excluded := slices.Contains(pn.Spec.ExcludeNodes, node.Name)

×

290

                if !excluded && len(node.Annotations) != 0 && node.Annotations[excludeAnno] == "true" {

×

291

                        newPn = pn.DeepCopy()

×

292

                        newPn.Spec.ExcludeNodes = append(newPn.Spec.ExcludeNodes, node.Name)

×

293

                        excluded = true

×

294

×

296

                var customInterface string

×

297

                for _, v := range pn.Spec.CustomInterfaces {

×

298

                        if slices.Contains(v.Nodes, node.Name) {

×

299

                                customInterface = v.Interface

×

300

                                break

×

303

                if customInterface == "" && len(node.Annotations) != 0 {

×

304

                        if customInterface = node.Annotations[interfaceAnno]; customInterface != "" {

×

305

                                if newPn == nil {

×

306

                                        newPn = pn.DeepCopy()

×

307

×

308

                                var index *int

×

309

                                for i := range newPn.Spec.CustomInterfaces {

×

310

                                        if newPn.Spec.CustomInterfaces[i].Interface == customInterface {

×

311

                                                index = &i

×

312

                                                break

×

315

                                if index != nil {

×

316

                                        newPn.Spec.CustomInterfaces[*index].Nodes = append(newPn.Spec.CustomInterfaces[*index].Nodes, node.Name)

×

317

                                } else {

×

318

                                        ci := kubeovnv1.CustomInterface{Interface: customInterface, Nodes: []string{node.Name}}

×

319

                                        newPn.Spec.CustomInterfaces = append(newPn.Spec.CustomInterfaces, ci)

×

320

×

324

                if newPn != nil {

×

325

                        if newPn, err = c.config.KubeOvnClient.KubeovnV1().ProviderNetworks().Update(context.Background(), newPn, metav1.UpdateOptions{}); err != nil {

×

326

                                klog.Errorf("failed to update provider network %s: %v", pn.Name, err)

×

327

                                return err

×

328

×

331

                if len(node.Annotations) != 0 {

×

332

                        newNode := node.DeepCopy()

×

333

                        delete(newNode.Annotations, excludeAnno)

×

334

                        delete(newNode.Annotations, interfaceAnno)

×

335

                        if len(newNode.Annotations) != len(node.Annotations) {

×

336

                                if _, err = c.config.KubeClient.CoreV1().Nodes().Update(context.Background(), newNode, metav1.UpdateOptions{}); err != nil {

×

337

                                        klog.Errorf("failed to update node %s: %v", node.Name, err)

×

338

                                        return err

×

339

×

343

                if excluded {

×

344

                        if newPn == nil {

×

345

                                newPn = pn.DeepCopy()

×

346

                        } else {

×

347

                                newPn = newPn.DeepCopy()

×

348

×

350

                        if newPn.Status.EnsureNodeStandardConditions(node.Name) {

×

351

                                _, err = c.config.KubeOvnClient.KubeovnV1().ProviderNetworks().UpdateStatus(context.Background(), newPn, metav1.UpdateOptions{})

×

352

                                if err != nil {

×

353

                                        klog.Errorf("failed to update status of provider network %s: %v", pn.Name, err)

×

354

                                        return err

×

355

×

360

        return nil

×

363

func (c *Controller) handleDeleteNode(key string) (err error) {

×

364

        c.nodeKeyMutex.LockKey(key)

×

365

        defer func() {

×

366

                _ = c.nodeKeyMutex.UnlockKey(key)

×

367

                if err == nil {

×

368

                        c.deletingNodeObjMap.Delete(key)

×

369

×

371

        klog.Infof("handle delete node %s", key)

×

372

×

373

        node, ok := c.deletingNodeObjMap.Load(key)

×

374

        if !ok {

×

375

                return nil

×

376

×

377

        n, _ := c.nodesLister.Get(key)

×

378

        if n != nil && n.UID != node.UID {

×

379

                klog.Warningf("Node %s is adding, skip the node delete handler, but it may leave some gc resources behind", key)

×

380

                return nil

×

381

×

382

        return c.deleteNode(key)

×

385

func (c *Controller) deleteNode(key string) error {

×

386

        portName := util.NodeLspName(key)

×

387

        klog.Infof("delete logical switch port %s", portName)

×

388

        if err := c.OVNNbClient.DeleteLogicalSwitchPort(portName); err != nil {

×

389

                klog.Errorf("failed to delete node switch port %s: %v", portName, err)

×

390

                return err

×

391

×

392

        if err := c.OVNSbClient.DeleteChassisByHost(key); err != nil {

×

393

                klog.Errorf("failed to delete chassis for node %s: %v", key, err)

×

394

                return err

×

395

×

397

        for _, af := range [...]int{4, 6} {

×

398

                if err := c.deletePolicyRouteForLocalDNSCacheOnNode(key, af); err != nil {

×

399

                        klog.Error(err)

×

400

                        return err

×

401

×

405

        pgName := strings.ReplaceAll(portName, "-", ".")

×

406

        if err := c.OVNNbClient.DeletePortGroup(pgName); err != nil {

×

407

                klog.Errorf("delete port group %s for node: %v", portName, err)

×

408

                return err

×

409

×

411

        if err := c.deletePolicyRouteForNode(key, portName); err != nil {

×

412

                klog.Errorf("failed to delete policy route for node %s: %v", key, err)

×

413

                return err

×

414

×

416

        if err := c.OVNNbClient.DeleteAddressSet(nodeUnderlayAddressSetName(key, 4)); err != nil {

×

417

                klog.Errorf("failed to delete address set for node %s: %v", key, err)

×

418

                return err

×

419

×

420

        if err := c.OVNNbClient.DeleteAddressSet(nodeUnderlayAddressSetName(key, 6)); err != nil {

×

421

                klog.Errorf("failed to delete address set for node %s: %v", key, err)

×

422

                return err

×

423

×

425

        klog.Infof("release node port %s", portName)

×

426

        c.ipam.ReleaseAddressByPod(portName, c.config.NodeSwitch)

×

427

×

428

        providerNetworks, err := c.providerNetworksLister.List(labels.Everything())

×

429

        if err != nil && !k8serrors.IsNotFound(err) {

×

430

                klog.Errorf("failed to list provider networks: %v", err)

×

431

                return err

×

432

×

434

        for _, pn := range providerNetworks {

×

435

                if err = c.updateProviderNetworkForNodeDeletion(pn, key); err != nil {

×

436

                        klog.Error(err)

×

437

                        return err

×

438

×

440

        klog.Infof("delete node ip %s", portName)

×

441

        if err = c.config.KubeOvnClient.KubeovnV1().IPs().Delete(context.Background(), portName, metav1.DeleteOptions{}); err != nil && !k8serrors.IsNotFound(err) {

×

442

                return err

×

443

×

445

        return nil

×

448

func (c *Controller) updateProviderNetworkForNodeDeletion(pn *kubeovnv1.ProviderNetwork, node string) error {

×

449

        // update provider network status

×

450

        var needUpdate bool

×

451

        newPn := pn.DeepCopy()

×

452

        if slices.Contains(newPn.Status.ReadyNodes, node) {

×

453

                newPn.Status.ReadyNodes = util.RemoveString(newPn.Status.ReadyNodes, node)

×

454

                needUpdate = true

×

455

×

456

        if newPn.Status.RemoveNodeConditions(node) {

×

457

                needUpdate = true

×

458

×

459

        if needUpdate {

×

460

                var err error

×

461

                newPn, err = c.config.KubeOvnClient.KubeovnV1().ProviderNetworks().UpdateStatus(context.Background(), newPn, metav1.UpdateOptions{})

×

462

                if err != nil {

×

463

                        klog.Errorf("failed to update status of provider network %s: %v", pn.Name, err)

×

464

                        return err

×

465

×

469

        pn, newPn = newPn, nil

×

470

        if excludeNodes := util.RemoveString(pn.Spec.ExcludeNodes, node); len(excludeNodes) != len(pn.Spec.ExcludeNodes) {

×

471

                newPn = pn.DeepCopy()

×

472

                newPn.Spec.ExcludeNodes = excludeNodes

×

473

×

475

        var changed bool

×

476

        customInterfaces := make([]kubeovnv1.CustomInterface, 0, len(pn.Spec.CustomInterfaces))

×

477

        for _, ci := range pn.Spec.CustomInterfaces {

×

478

                nodes := util.RemoveString(ci.Nodes, node)

×

479

                if !changed {

×

480

                        changed = len(nodes) == 0 || len(nodes) != len(ci.Nodes)

×

481

×

482

                if len(nodes) != 0 {

×

483

                        customInterfaces = append(customInterfaces, kubeovnv1.CustomInterface{Interface: ci.Interface, Nodes: nodes})

×

484

×

486

        if changed {

×

487

                newPn = pn.DeepCopy()

×

488

                newPn.Spec.CustomInterfaces = customInterfaces

×

489

×

490

        if newPn != nil {

×

491

                if _, err := c.config.KubeOvnClient.KubeovnV1().ProviderNetworks().Update(context.Background(), newPn, metav1.UpdateOptions{}); err != nil {

×

492

                        klog.Errorf("failed to update provider network %s: %v", pn.Name, err)

×

493

                        return err

×

494

×

497

        return nil

×

500

func (c *Controller) handleUpdateNode(key string) error {

×

501

        c.nodeKeyMutex.LockKey(key)

×

502

        defer func() { _ = c.nodeKeyMutex.UnlockKey(key) }()

×

503

        klog.Infof("handle update node %s", key)

×

504

×

505

        node, err := c.nodesLister.Get(key)

×

506

        if err != nil {

×

507

                if k8serrors.IsNotFound(err) {

×

508

                        return nil

×

509

×

510

                klog.Errorf("failed to get node %s: %v", key, err)

×

511

                return err

×

514

        if err = c.handleNodeAnnotationsForProviderNetworks(node); err != nil {

×

515

                klog.Errorf("failed to handle annotations of node %s for provider networks: %v", node.Name, err)

×

516

                return err

×

517

×

519

        subnets, err := c.subnetsLister.List(labels.Everything())

×

520

        if err != nil {

×

521

                klog.Errorf("failed to get subnets %v", err)

×

522

                return err

×

523

×

525

        if err := c.UpdateChassisTag(node); err != nil {

×

526

                klog.Errorf("failed to update chassis tag for node %s: %v", node.Name, err)

×

527

                return err

×

528

×

529

        if err := c.retryDelDupChassis(util.ChassisRetryMaxTimes, util.ChassisControllerRetryInterval, c.cleanDuplicatedChassis, node); err != nil {

×

530

                klog.Errorf("failed to clean duplicated chassis for node %s: %v", node.Name, err)

×

531

                return err

×

532

×

534

        for _, cachedSubnet := range subnets {

×

535

                subnet := cachedSubnet.DeepCopy()

×

536

                if util.GatewayContains(subnet.Spec.GatewayNode, node.Name) {

×

537

                        if err := c.reconcileOvnDefaultVpcRoute(subnet); err != nil {

×

538

                                klog.Error(err)

×

539

                                return err

×

540

×

544

        return nil

×

547

func (c *Controller) CheckGatewayReady() {

×

548

        if err := c.checkGatewayReady(); err != nil {

×

549

                klog.Errorf("failed to check gateway ready %v", err)

×

550

×

553

func (c *Controller) checkGatewayReady() error {

×

554

        klog.V(3).Infoln("start to check gateway status")

×

555

        subnetList, err := c.subnetsLister.List(labels.Everything())

×

556

        if err != nil {

×

557

                klog.Errorf("failed to list subnets %v", err)

×

558

                return err

×

559

×

560

        nodes, err := c.nodesLister.List(labels.Everything())

×

561

        if err != nil {

×

562

                klog.Errorf("failed to list nodes, %v", err)

×

563

                return err

×

564

×

566

        for _, subnet := range subnetList {

×

567

                if (subnet.Spec.Vlan != "" && !subnet.Spec.LogicalGateway) ||

×

568

                        subnet.Spec.GatewayNode == "" ||

×

569

                        subnet.Spec.GatewayType != kubeovnv1.GWCentralizedType ||

×

570

                        !subnet.Spec.EnableEcmp {

×

571

                        continue

×

574

                for _, node := range nodes {

×

575

                        ipStr := node.Annotations[util.IPAddressAnnotation]

×

576

                        for _, ip := range strings.Split(ipStr, ",") {

×

577

                                for _, cidrBlock := range strings.Split(subnet.Spec.CIDRBlock, ",") {

×

578

                                        if util.CheckProtocol(cidrBlock) != util.CheckProtocol(ip) {

×

579

                                                continue

×

582

                                        exist, err := c.checkPolicyRouteExistForNode(node.Name, cidrBlock, ip, util.GatewayRouterPolicyPriority)

×

583

                                        if err != nil {

×

584

                                                klog.Errorf("check ecmp policy route exist for subnet %v, error %v", subnet.Name, err)

×

585

                                                break

×

587

                                        nextHops, nameIPMap, err := c.getPolicyRouteParas(cidrBlock, util.GatewayRouterPolicyPriority)

×

588

                                        if err != nil {

×

589

                                                klog.Errorf("get ecmp policy route paras for subnet %v, error %v", subnet.Name, err)

×

590

                                                break

×

593

                                        if util.GatewayContains(subnet.Spec.GatewayNode, node.Name) {

×

594

                                                pinger, err := goping.NewPinger(ip)

×

595

                                                if err != nil {

×

596

                                                        return fmt.Errorf("failed to init pinger, %w", err)

×

597

×

598

                                                pinger.SetPrivileged(true)

×

599

×

600

                                                count := 5

×

601

                                                pinger.Count = count

×

602

                                                pinger.Timeout = time.Duration(count) * time.Second

×

603

                                                pinger.Interval = 1 * time.Second

×

604

×

605

                                                success := false

×

606

×

607

                                                pinger.OnRecv = func(_ *goping.Packet) {

×

608

                                                        success = true

×

609

                                                        pinger.Stop()

×

610

×

611

                                                if err = pinger.Run(); err != nil {

×

612

                                                        klog.Errorf("failed to run pinger for destination %s: %v", ip, err)

×

613

                                                        return err

×

614

×

616

                                                if !nodeReady(node) {

×

617

                                                        success = false

×

618

×

620

                                                if !success {

×

621

                                                        if exist {

×

622

                                                                klog.Warningf("failed to ping ovn0 %s or node %s is not ready, delete ecmp policy route for node", ip, node.Name)

×

623

                                                                nextHops.Remove(ip)

×

624

                                                                delete(nameIPMap, node.Name)

×

625

                                                                klog.Infof("update policy route for centralized subnet %s, nextHops %s", subnet.Name, nextHops)

×

626

                                                                if err = c.updatePolicyRouteForCentralizedSubnet(subnet.Name, cidrBlock, nextHops.List(), nameIPMap); err != nil {

×

627

                                                                        klog.Errorf("failed to delete ecmp policy route for subnet %s on node %s, %v", subnet.Name, node.Name, err)

×

628

                                                                        return err

×

629

×

631

                                                } else {

×

632

                                                        klog.V(3).Infof("succeed to ping gw %s", ip)

×

633

                                                        if !exist {

×

634

                                                                nextHops.Add(ip)

×

635

                                                                if nameIPMap == nil {

×

636

                                                                        nameIPMap = make(map[string]string, 1)

×

637

×

638

                                                                nameIPMap[node.Name] = ip

×

639

                                                                klog.Infof("update policy route for centralized subnet %s, nextHops %s", subnet.Name, nextHops)

×

640

                                                                if err = c.updatePolicyRouteForCentralizedSubnet(subnet.Name, cidrBlock, nextHops.List(), nameIPMap); err != nil {

×

641

                                                                        klog.Errorf("failed to add ecmp policy route for subnet %s on node %s, %v", subnet.Name, node.Name, err)

×

642

                                                                        return err

×

643

×

646

                                        } else if exist {

×

647

                                                klog.Infof("subnet %s gatewayNode does not contains node %v, delete policy route for node ip %s", subnet.Name, node.Name, ip)

×

648

                                                nextHops.Remove(ip)

×

649

                                                delete(nameIPMap, node.Name)

×

650

                                                klog.Infof("update policy route for centralized subnet %s, nextHops %s", subnet.Name, nextHops)

×

651

                                                if err = c.updatePolicyRouteForCentralizedSubnet(subnet.Name, cidrBlock, nextHops.List(), nameIPMap); err != nil {

×

652

                                                        klog.Errorf("failed to delete ecmp policy route for subnet %s on node %s, %v", subnet.Name, node.Name, err)

×

653

                                                        return err

×

654

×

660

        return nil

×

663

func (c *Controller) cleanDuplicatedChassis(node *v1.Node) error {

×

664

        // if multi chassis has the same node name, delete all of them

×

665

        chassises, err := c.OVNSbClient.GetAllChassisByHost(node.Name)

×

666

        if err != nil {

×

667

                klog.Errorf("failed to list chassis %v", err)

×

668

                return err

×

669

×

670

        if len(*chassises) > 1 {

×

671

                klog.Warningf("node %s has multiple chassis", node.Name)

×

672

                if err := c.OVNSbClient.DeleteChassisByHost(node.Name); err != nil {

×

673

                        klog.Errorf("failed to delete chassis for node %s: %v", node.Name, err)

×

674

                        return err

×

675

×

677

        return nil

×

680

func (c *Controller) retryDelDupChassis(attempts, sleep int, f func(node *v1.Node) error, node *v1.Node) (err error) {

×

681

        i := 0

×

682

        for ; ; i++ {

×

683

                err = f(node)

×

684

                if err == nil {

×

685

                        return

×

686

×

687

                klog.Errorf("failed to delete duplicated chassis for node %s: %v", node.Name, err)

×

688

                if i >= (attempts - 1) {

×

689

                        break

×

691

                time.Sleep(time.Duration(sleep) * time.Second)

×

693

        if i >= (attempts - 1) {

×

694

                errMsg := errors.New("exhausting all attempts")

×

695

                klog.Error(errMsg)

×

696

                return errMsg

×

697

×

698

        klog.V(3).Infof("finish check chassis")

×

699

        return nil

×

702

func (c *Controller) fetchPodsOnNode(nodeName string, pods []*v1.Pod) ([]string, error) {

×

703

        ports := make([]string, 0, len(pods))

×

704

        for _, pod := range pods {

×

705

                if !isPodAlive(pod) || pod.Spec.HostNetwork || pod.Spec.NodeName != nodeName || pod.Annotations[util.LogicalRouterAnnotation] != c.config.ClusterRouter {

×

706

                        continue

×

708

                podName := c.getNameByPod(pod)

×

709

×

710

                podNets, err := c.getPodKubeovnNets(pod)

×

711

                if err != nil {

×

712

                        klog.Errorf("failed to get pod nets %v", err)

×

713

                        return nil, err

×

714

×

716

                for _, podNet := range podNets {

×

717

                        if !isOvnSubnet(podNet.Subnet) {

×

718

                                continue

×

721

                        if pod.Annotations != nil && pod.Annotations[fmt.Sprintf(util.AllocatedAnnotationTemplate, podNet.ProviderName)] == "true" {

×

722

                                ports = append(ports, ovs.PodNameToPortName(podName, pod.Namespace, podNet.ProviderName))

×

723

×

726

        return ports, nil

×

729

func (c *Controller) CheckNodePortGroup() {

×

730

        if err := c.checkAndUpdateNodePortGroup(); err != nil {

×

731

                klog.Errorf("check node port group status: %v", err)

×

732

×

735

func (c *Controller) checkAndUpdateNodePortGroup() error {

×

736

        klog.V(3).Infoln("start to check node port-group status")

×

737

        np, _ := c.npsLister.List(labels.Everything())

×

738

        networkPolicyExists := len(np) != 0

×

739

×

740

        nodes, err := c.nodesLister.List(labels.Everything())

×

741

        if err != nil {

×

742

                klog.Errorf("list nodes: %v", err)

×

743

                return err

×

744

×

746

        pods, err := c.podsLister.List(labels.Everything())

×

747

        if err != nil {

×

748

                klog.Errorf("list pods, %v", err)

×

749

                return err

×

750

×

752

        for _, node := range nodes {

×

753

                // The port-group should already created when add node

×

754

                pgName := strings.ReplaceAll(node.Annotations[util.PortNameAnnotation], "-", ".")

×

755

×

756

                // use join IP only when no internal IP exists

×

757

                nodeIPv4, nodeIPv6 := util.GetNodeInternalIP(*node)

×

758

                joinIP := node.Annotations[util.IPAddressAnnotation]

×

759

                joinIPv4, joinIPv6 := util.SplitStringIP(joinIP)

×

760

                if nodeIPv4 == "" {

×

761

                        nodeIPv4 = joinIPv4

×

762

×

763

                if nodeIPv6 == "" {

×

764

                        nodeIPv6 = joinIPv6

×

765

×

766

                nodeIP := strings.Trim(fmt.Sprintf("%s,%s", nodeIPv4, nodeIPv6), ",")

×

767

×

768

                nodePorts, err := c.fetchPodsOnNode(node.Name, pods)

×

769

                if err != nil {

×

770

                        klog.Errorf("fetch pods for node %v: %v", node.Name, err)

×

771

                        return err

×

772

×

774

                if err = c.OVNNbClient.PortGroupSetPorts(pgName, nodePorts); err != nil {

×

775

                        klog.Errorf("add ports to port group %s: %v", pgName, err)

×

776

                        return err

×

777

×

779

                if networkPolicyExists {

×

780

                        if err := c.OVNNbClient.CreateNodeACL(pgName, nodeIP, joinIP); err != nil {

×

781

                                klog.Errorf("create node acl for node pg %s: %v", pgName, err)

×

782

×

783

                } else {

×

784

                        // clear all acl

×

785

                        if err = c.OVNNbClient.DeleteAcls(pgName, portGroupKey, "", nil); err != nil {

×

786

                                klog.Errorf("delete node acl for node pg %s: %v", pgName, err)

×

787

×

791

        return nil

×

794

func (c *Controller) UpdateChassisTag(node *v1.Node) error {

×

795

        annoChassisName := node.Annotations[util.ChassisAnnotation]

×

796

        if annoChassisName == "" {

×

797

                // kube-ovn-cni not ready to set chassis

×

798

                return nil

×

799

×

800

        chassis, err := c.OVNSbClient.GetChassis(annoChassisName, true)

×

801

        if err != nil {

×

802

                klog.Errorf("failed to get chassis %s for node %s: %v", annoChassisName, node.Name, err)

×

803

                return err

×

804

×

805

        if chassis == nil {

×

806

                klog.Infof("chassis %q not registered for node %s, do chassis gc once", annoChassisName, node.Name)

×

807

                // chassis name conflict, do GC

×

808

                if err = c.gcChassis(); err != nil {

×

809

                        klog.Errorf("failed to gc chassis: %v", err)

×

810

                        return err

×

811

×

812

                err = &ErrChassisNotFound{Chassis: annoChassisName, Node: node.Name}

×

813

                klog.Error(err)

×

814

                return err

×

817

        if chassis.ExternalIDs == nil || chassis.ExternalIDs["vendor"] != util.CniTypeName {

×

818

                klog.Infof("init tag %s for node %s chassis %s", util.CniTypeName, node.Name, chassis.Name)

×

819

                if err = c.OVNSbClient.UpdateChassisTag(chassis.Name, node.Name); err != nil {

×

820

                        err := fmt.Errorf("failed to init chassis tag, %w", err)

×

821

                        klog.Error(err)

×

822

                        return err

×

823

×

825

        return nil

×

828

func (c *Controller) addNodeGatewayStaticRoute() error {

×

829

        // If user not manage static route for default vpc, just add route about ovn-default to join

×

830

        if vpc, err := c.vpcsLister.Get(c.config.ClusterRouter); err != nil || vpc.Spec.StaticRoutes != nil {

×

831

                existRoute, err := c.OVNNbClient.ListLogicalRouterStaticRoutes(c.config.ClusterRouter, nil, nil, "", nil)

×

832

                if err != nil {

×

833

                        klog.Errorf("failed to get vpc %s static route list, %v", c.config.ClusterRouter, err)

×

834

×

835

                if len(existRoute) != 0 {

×

836

                        klog.Infof("skip add static route for node gw")

×

837

                        return nil

×

838

×

840

        dstCidr := "0.0.0.0/0,::/0"

×

841

        for _, cidrBlock := range strings.Split(dstCidr, ",") {

×

842

                for _, nextHop := range strings.Split(c.config.NodeSwitchGateway, ",") {

×

843

                        if util.CheckProtocol(cidrBlock) != util.CheckProtocol(nextHop) {

×

844

                                continue

×

847

                        if err := c.addStaticRouteToVpc(

×

848

                                c.config.ClusterRouter,

×

849

                                &kubeovnv1.StaticRoute{

×

850

                                        Policy:     kubeovnv1.PolicyDst,

×

851

                                        CIDR:       cidrBlock,

×

852

                                        NextHopIP:  nextHop,

×

853

                                        RouteTable: util.MainRouteTable,

×

854

},

×

855

                        ); err != nil {

×

856

                                klog.Errorf("failed to add static route for node gw: %v", err)

×

857

                                return err

×

858

×

861

        return nil

×

864

func (c *Controller) getPolicyRouteParas(cidr string, priority int) (*strset.Set, map[string]string, error) {

×

865

        ipSuffix := "ip4"

×

866

        if util.CheckProtocol(cidr) == kubeovnv1.ProtocolIPv6 {

×

867

                ipSuffix = "ip6"

×

868

×

869

        match := fmt.Sprintf("%s.src == %s", ipSuffix, cidr)

×

870

        policyList, err := c.OVNNbClient.GetLogicalRouterPolicy(c.config.ClusterRouter, priority, match, true)

×

871

        if err != nil {

×

872

                klog.Errorf("failed to get logical router policy: %v", err)

×

873

                return nil, nil, err

×

874

×

875

        if len(policyList) == 0 {

×

876

                return strset.New(), map[string]string{}, nil

×

877

×

878

        return strset.New(policyList[0].Nexthops...), policyList[0].ExternalIDs, nil

×

881

func (c *Controller) checkPolicyRouteExistForNode(nodeName, cidr, nexthop string, priority int) (bool, error) {

×

882

        _, nameIPMap, err := c.getPolicyRouteParas(cidr, priority)

×

883

        if err != nil {

×

884

                klog.Errorf("failed to get policy route paras, %v", err)

×

885

                return false, err

×

886

×

887

        if nodeIP, ok := nameIPMap[nodeName]; ok && nodeIP == nexthop {

×

888

                return true, nil

×

889

×

890

        return false, nil

×

893

func (c *Controller) deletePolicyRouteForNode(nodeName, portName string) error {

×

894

        subnets, err := c.subnetsLister.List(labels.Everything())

×

895

        if err != nil {

×

896

                klog.Errorf("get subnets: %v", err)

×

897

                return err

×

898

×

900

        addresses := c.ipam.GetPodAddress(portName)

×

901

        for _, addr := range addresses {

×

902

                if addr.IP == "" {

×

903

                        continue

×

905

                klog.Infof("deleting logical router policy with nexthop %q from %s for node %s", addr.IP, c.config.ClusterRouter, nodeName)

×

906

                if err = c.OVNNbClient.DeleteLogicalRouterPolicyByNexthop(c.config.ClusterRouter, util.NodeRouterPolicyPriority, addr.IP); err != nil {

×

907

                        klog.Errorf("failed to delete logical router policy with nexthop %q from %s for node %s: %v", addr.IP, c.config.ClusterRouter, nodeName, err)

×

908

                        return err

×

909

×

912

        for _, subnet := range subnets {

×

913

                if (subnet.Spec.Vlan != "" && !subnet.Spec.LogicalGateway) || subnet.Spec.Vpc != c.config.ClusterRouter || subnet.Name == c.config.NodeSwitch {

×

914

                        continue

×

917

                if subnet.Spec.GatewayType == kubeovnv1.GWDistributedType {

×

918

                        pgName := getOverlaySubnetsPortGroupName(subnet.Name, nodeName)

×

919

                        if err = c.OVNNbClient.DeletePortGroup(pgName); err != nil {

×

920

                                klog.Errorf("delete port group for subnet %s and node %s: %v", subnet.Name, nodeName, err)

×

921

                                return err

×

922

×

924

                        klog.Infof("delete policy route for distributed subnet %s, node %s", subnet.Name, nodeName)

×

925

                        if err = c.deletePolicyRouteForDistributedSubnet(subnet, nodeName); err != nil {

×

926

                                klog.Errorf("delete policy route for subnet %s and node %s: %v", subnet.Name, nodeName, err)

×

927

                                return err

×

928

×

931

                if subnet.Spec.GatewayType == kubeovnv1.GWCentralizedType {

×

932

                        if subnet.Spec.EnableEcmp {

×

933

                                for _, cidrBlock := range strings.Split(subnet.Spec.CIDRBlock, ",") {

×

934

                                        nextHops, nameIPMap, err := c.getPolicyRouteParas(cidrBlock, util.GatewayRouterPolicyPriority)

×

935

                                        if err != nil {

×

936

                                                klog.Errorf("get ecmp policy route paras for subnet %v, error %v", subnet.Name, err)

×

937

                                                continue

×

940

                                        exist := false

×

941

                                        if _, ok := nameIPMap[nodeName]; ok {

×

942

                                                exist = true

×

943

×

945

                                        if exist {

×

946

                                                nextHops.Remove(nameIPMap[nodeName])

×

947

                                                delete(nameIPMap, nodeName)

×

948

×

949

                                                if nextHops.Size() == 0 {

×

950

                                                        klog.Infof("delete policy route for centralized subnet %s, nextHops %s", subnet.Name, nextHops)

×

951

                                                        if err := c.deletePolicyRouteForCentralizedSubnet(subnet); err != nil {

×

952

                                                                klog.Errorf("failed to delete policy route for centralized subnet %s, %v", subnet.Name, err)

×

953

                                                                return err

×

954

×

955

                                                } else {

×

956

                                                        klog.Infof("update policy route for centralized subnet %s, nextHops %s", subnet.Name, nextHops)

×

957

                                                        if err = c.updatePolicyRouteForCentralizedSubnet(subnet.Name, cidrBlock, nextHops.List(), nameIPMap); err != nil {

×

958

                                                                klog.Errorf("failed to update policy route for subnet %s on node %s, %v", subnet.Name, nodeName, err)

×

959

                                                                return err

×

960

×

964

                        } else {

×

965

                                klog.Infof("reconcile policy route for centralized subnet %s", subnet.Name)

×

966

                                if err := c.reconcileDefaultCentralizedSubnetRouteInDefaultVpc(subnet); err != nil {

×

967

                                        klog.Errorf("failed to delete policy route for centralized subnet %s, %v", subnet.Name, err)

×

968

                                        return err

×

969

×

973

        return nil

×

976

func (c *Controller) addPolicyRouteForCentralizedSubnetOnNode(nodeName, nodeIP string) error {

×

977

        subnets, err := c.subnetsLister.List(labels.Everything())

×

978

        if err != nil {

×

979

                klog.Errorf("failed to get subnets %v", err)

×

980

                return err

×

981

×

983

        for _, subnet := range subnets {

×

984

                if (subnet.Spec.Vlan != "" && !subnet.Spec.LogicalGateway) || subnet.Spec.Vpc != c.config.ClusterRouter || subnet.Name == c.config.NodeSwitch || subnet.Spec.GatewayType != kubeovnv1.GWCentralizedType {

×

985

                        continue

×

988

                if subnet.Spec.EnableEcmp {

×

989

                        if !util.GatewayContains(subnet.Spec.GatewayNode, nodeName) {

×

990

                                continue

×

993

                        for _, nextHop := range strings.Split(nodeIP, ",") {

×

994

                                for _, cidrBlock := range strings.Split(subnet.Spec.CIDRBlock, ",") {

×

995

                                        if util.CheckProtocol(cidrBlock) != util.CheckProtocol(nextHop) {

×

996

                                                continue

×

998

                                        exist, err := c.checkPolicyRouteExistForNode(nodeName, cidrBlock, nextHop, util.GatewayRouterPolicyPriority)

×

999

                                        if err != nil {

×

1000

                                                klog.Errorf("check ecmp policy route exist for subnet %v, error %v", subnet.Name, err)

×

1001

                                                continue

×

1003

                                        if exist {

×

1004

                                                continue

×

1007

                                        nextHops, nameIPMap, err := c.getPolicyRouteParas(cidrBlock, util.GatewayRouterPolicyPriority)

×

1008

                                        if err != nil {

×

1009

                                                klog.Errorf("get ecmp policy route paras for subnet %v, error %v", subnet.Name, err)

×

1010

                                                continue

×

1012

                                        nextHops.Add(nextHop)

×

1013

                                        if nameIPMap == nil {

×

1014

                                                nameIPMap = make(map[string]string, 1)

×

1015

×

1016

                                        nameIPMap[nodeName] = nextHop

×

1017

                                        klog.Infof("update policy route for centralized subnet %s, nextHops %s", subnet.Name, nextHops)

×

1018

                                        if err = c.updatePolicyRouteForCentralizedSubnet(subnet.Name, cidrBlock, nextHops.List(), nameIPMap); err != nil {

×

1019

                                                klog.Errorf("failed to update policy route for subnet %s on node %s, %v", subnet.Name, nodeName, err)

×

1020

                                                return err

×

1021

×

1024

                } else {

×

1025

                        if subnet.Status.ActivateGateway != nodeName {

×

1026

                                continue

×

1028

                        klog.Infof("add policy route for centralized subnet %s, on node %s, ip %s", subnet.Name, nodeName, nodeIP)

×

1029

                        if err = c.addPolicyRouteForCentralizedSubnet(subnet, nodeName, nil, strings.Split(nodeIP, ",")); err != nil {

×

1030

                                klog.Errorf("failed to add active-backup policy route for centralized subnet %s: %v", subnet.Name, err)

×

1031

                                return err

×

1032

×

1035

        return nil

×

1038

func (c *Controller) addPolicyRouteForLocalDNSCacheOnNode(dnsIPs []string, nodePortName, nodeIP, nodeName string, af int) error {

×

1039

        if len(dnsIPs) == 0 {

×

1040

                return c.deletePolicyRouteForLocalDNSCacheOnNode(nodeName, af)

×

1041

×

1043

        var (

×

1044

                externalIDs = map[string]string{

×

1045

                        "vendor":          util.CniTypeName,

×

1046

                        "node":            nodeName,

×

1047

                        "address-family":  strconv.Itoa(af),

×

1048

                        "isLocalDnsCache": "true",

×

1049

×

1050

                pgAs     = strings.ReplaceAll(fmt.Sprintf("%s_ip%d", nodePortName, af), "-", ".")

×

1051

                action   = kubeovnv1.PolicyRouteActionReroute

×

1052

                nextHops = []string{nodeIP}

×

1053

×

1054

        matches := strset.NewWithSize(len(dnsIPs))

×

1055

        for _, ip := range dnsIPs {

×

1056

                matches.Add(fmt.Sprintf("ip%d.src == $%s && ip%d.dst == %s", af, pgAs, af, ip))

×

1057

×

1059

        policies, err := c.OVNNbClient.GetLogicalRouterPoliciesByExtID(c.config.ClusterRouter, "node", nodeName)

×

1060

        if err != nil {

×

1061

                klog.Errorf("failed to list logical router policies with external-ids:node = %q: %v", nodeName, err)

×

1062

                return err

×

1063

×

1065

        for _, policy := range policies {

×

1066

                if len(policy.ExternalIDs) == 0 || policy.ExternalIDs["vendor"] != util.CniTypeName || policy.ExternalIDs["isLocalDnsCache"] != "true" {

×

1067

                        continue

×

1069

                if policy.Priority == util.NodeRouterPolicyPriority && policy.Action == string(action) && slices.Equal(policy.Nexthops, nextHops) && matches.Has(policy.Match) {

×

1070

                        matches.Remove(policy.Match)

×

1071

                        continue

×

1074

                klog.Infof("deleting logical router policy by UUID %s", policy.UUID)

×

1075

                if err = c.OVNNbClient.DeleteLogicalRouterPolicyByUUID(c.config.ClusterRouter, policy.UUID); err != nil {

×

1076

                        klog.Errorf("failed to delete logical router policy by UUID %s: %v", policy.UUID, err)

×

1077

                        return err

×

1078

×

1081

        for _, match := range matches.List() {

×

1082

                klog.Infof("add node local dns cache policy route for router %s: match %q, action %q, nexthop %q, externalID %v", c.config.ClusterRouter, match, action, nodeIP, externalIDs)

×

1083

                if err := c.addPolicyRouteToVpc(

×

1084

                        c.config.ClusterRouter,

×

1085

                        &kubeovnv1.PolicyRoute{

×

1086

                                Priority:  util.NodeRouterPolicyPriority,

×

1087

                                Match:     match,

×

1088

                                Action:    action,

×

1089

                                NextHopIP: nodeIP,

×

1090

},

×

1091

                        externalIDs,

×

1092

                ); err != nil {

×

1093

                        klog.Errorf("failed to add logical router policy for node %s: %v", nodeName, err)

×

1094

                        return err

×

1095

×

1098

        return nil

×

1101

func (c *Controller) deletePolicyRouteForLocalDNSCacheOnNode(nodeName string, af int) error {

×

1102

        policies, err := c.OVNNbClient.ListLogicalRouterPolicies(c.config.ClusterRouter, -1, map[string]string{

×

1103

                "vendor":          util.CniTypeName,

×

1104

                "node":            nodeName,

×

1105

                "address-family":  strconv.Itoa(af),

×

1106

                "isLocalDnsCache": "true",

×

1107

        }, true)

×

1108

        if err != nil {

×

1109

                klog.Errorf("failed to list logical router policies: %v", err)

×

1110

                return err

×

1111

×

1112

        if len(policies) == 0 {

×

1113

                return nil

×

1114

×

1116

        for _, policy := range policies {

×

1117

                klog.Infof("delete node local dns cache policy route for router %s with match %s", c.config.ClusterRouter, policy.Match)

×

1118

×

1119

                if err := c.OVNNbClient.DeleteLogicalRouterPolicyByUUID(c.config.ClusterRouter, policy.UUID); err != nil {

×

1120

                        klog.Errorf("failed to delete policy route for node local dns in router %s with match %s: %v", c.config.ClusterRouter, policy.Match, err)

×

1121

                        return err

×

1122

×

1124

        return nil

×

kubeovn / kube-ovn / 12365336204

Source File
Press 'n' to go to next uncovered line, 'b' for previous

kubeovn / kube-ovn / 12365336204

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous