kubeovn/kube-ovn | Build 15200557698 | pkg/controller/pod.go | Coveralls

46

func NewNamedPort() *NamedPort {

×

47

        return &NamedPort{

×

48

                mutex:        sync.RWMutex{},

×

49

                namedPortMap: map[string]map[string]*util.NamedPortInfo{},

×

50

×

51

×

53

func (n *NamedPort) AddNamedPortByPod(pod *v1.Pod) {

×

54

        n.mutex.Lock()

×

55

        defer n.mutex.Unlock()

×

56

        ns := pod.Namespace

×

57

        podName := pod.Name

×

58

×

59

        restartableInitContainers := make([]v1.Container, 0, len(pod.Spec.InitContainers))

×

60

        for i := range pod.Spec.InitContainers {

×

61

                if pod.Spec.InitContainers[i].RestartPolicy != nil &&

×

62

                        *pod.Spec.InitContainers[i].RestartPolicy == v1.ContainerRestartPolicyAlways {

×

63

                        restartableInitContainers = append(restartableInitContainers, pod.Spec.InitContainers[i])

×

64

×

67

        containers := slices.Concat(restartableInitContainers, pod.Spec.Containers)

×

68

        if len(containers) == 0 {

×

69

                return

×

70

×

72

        for _, container := range containers {

×

73

                if len(container.Ports) == 0 {

×

74

                        continue

×

77

                for _, port := range container.Ports {

×

78

                        if port.Name == "" || port.ContainerPort == 0 {

×

79

                                continue

×

82

                        if _, ok := n.namedPortMap[ns]; ok {

×

83

                                if _, ok := n.namedPortMap[ns][port.Name]; ok {

×

84

                                        if n.namedPortMap[ns][port.Name].PortID == port.ContainerPort {

×

85

                                                n.namedPortMap[ns][port.Name].Pods.Add(podName)

×

86

                                        } else {

×

87

                                                klog.Warningf("named port %s has already be defined with portID %d",

×

88

                                                        port.Name, n.namedPortMap[ns][port.Name].PortID)

×

89

×

90

                                        continue

×

92

                        } else {

×

93

                                n.namedPortMap[ns] = make(map[string]*util.NamedPortInfo)

×

94

×

95

                        n.namedPortMap[ns][port.Name] = &util.NamedPortInfo{

×

96

                                PortID: port.ContainerPort,

×

97

                                Pods:   strset.New(podName),

×

98

×

103

func (n *NamedPort) DeleteNamedPortByPod(pod *v1.Pod) {

×

104

        n.mutex.Lock()

×

105

        defer n.mutex.Unlock()

×

106

×

107

        ns := pod.Namespace

×

108

        podName := pod.Name

×

109

×

110

        if pod.Spec.Containers == nil {

×

111

                return

×

112

×

114

        for _, container := range pod.Spec.Containers {

×

115

                if container.Ports == nil {

×

116

                        continue

×

119

                for _, port := range container.Ports {

×

120

                        if port.Name == "" {

×

121

                                continue

×

124

                        if _, ok := n.namedPortMap[ns]; !ok {

×

125

                                continue

×

128

                        if _, ok := n.namedPortMap[ns][port.Name]; !ok {

×

129

                                continue

×

132

                        if !n.namedPortMap[ns][port.Name].Pods.Has(podName) {

×

133

                                continue

×

136

                        n.namedPortMap[ns][port.Name].Pods.Remove(podName)

×

137

                        if n.namedPortMap[ns][port.Name].Pods.Size() == 0 {

×

138

                                delete(n.namedPortMap[ns], port.Name)

×

139

                                if len(n.namedPortMap[ns]) == 0 {

×

140

                                        delete(n.namedPortMap, ns)

×

141

×

147

func (n *NamedPort) GetNamedPortByNs(namespace string) map[string]*util.NamedPortInfo {

×

148

        n.mutex.RLock()

×

149

        defer n.mutex.RUnlock()

×

150

×

151

        if result, ok := n.namedPortMap[namespace]; ok {

×

152

                for portName, info := range result {

×

153

                        klog.Infof("namespace %s's namedPort portname is %s with info %v", namespace, portName, info)

×

154

×

155

                return result

×

157

        return nil

×

160

func isPodAlive(p *v1.Pod) bool {

×

161

        if !p.DeletionTimestamp.IsZero() && p.DeletionGracePeriodSeconds != nil {

×

162

                now := time.Now()

×

163

                deletionTime := p.DeletionTimestamp.Time

×

164

                gracePeriod := time.Duration(*p.DeletionGracePeriodSeconds) * time.Second

×

165

                if now.After(deletionTime.Add(gracePeriod)) {

×

166

                        return false

×

167

×

169

        return isPodStatusPhaseAlive(p)

×

172

func isPodStatusPhaseAlive(p *v1.Pod) bool {

×

173

        if p.Status.Phase == v1.PodSucceeded && p.Spec.RestartPolicy != v1.RestartPolicyAlways {

×

174

                return false

×

175

×

177

        if p.Status.Phase == v1.PodFailed && p.Spec.RestartPolicy == v1.RestartPolicyNever {

×

178

                return false

×

179

×

181

        if p.Status.Phase == v1.PodFailed && p.Status.Reason == "Evicted" {

×

182

                return false

×

183

×

184

        return true

×

187

func (c *Controller) enqueueAddPod(obj any) {

×

188

        p := obj.(*v1.Pod)

×

189

        if p.Spec.HostNetwork {

×

190

                return

×

191

×

194

        if c.config.EnableNP {

×

195

                c.namedPort.AddNamedPortByPod(p)

×

196

                if p.Status.PodIP != "" {

×

197

                        for _, np := range c.podMatchNetworkPolicies(p) {

×

198

                                klog.V(3).Infof("enqueue update network policy %s", np)

×

199

                                c.updateNpQueue.Add(np)

×

200

×

204

        key := cache.MetaObjectToName(p).String()

×

205

        if !isPodAlive(p) {

×

206

                isStateful, statefulSetName, statefulSetUID := isStatefulSetPod(p)

×

207

                isVMPod, vmName := isVMPod(p)

×

208

                if isStateful || (isVMPod && c.config.EnableKeepVMIP) {

×

209

                        if isStateful && isStatefulSetPodToDel(c.config.KubeClient, p, statefulSetName, statefulSetUID) {

×

210

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

×

211

                                c.deletingPodObjMap.Store(key, p)

×

212

                                c.deletePodQueue.Add(key)

×

213

×

214

                        if isVMPod && c.isVMToDel(p, vmName) {

×

215

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

×

216

                                c.deletingPodObjMap.Store(key, p)

×

217

                                c.deletePodQueue.Add(key)

×

218

×

219

                } else {

×

220

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

×

221

                        c.deletingPodObjMap.Store(key, p)

×

222

                        c.deletePodQueue.Add(key)

×

223

×

224

                return

×

227

        need, err := c.podNeedSync(p)

×

228

        if err != nil {

×

229

                klog.Errorf("invalid pod net: %v", err)

×

230

                return

×

231

×

232

        if need {

×

233

                klog.Infof("enqueue add pod %s", key)

×

234

                c.addOrUpdatePodQueue.Add(key)

×

235

×

NEW

237

        if err = c.handlePodEventForVpcEgressGateway(p); err != nil {

×

NEW

238

                klog.Errorf("failed to handle pod event for vpc egress gateway: %v", err)

×

NEW

239

×

242

func (c *Controller) enqueueDeletePod(obj any) {

×

243

        p := obj.(*v1.Pod)

×

244

        if p.Spec.HostNetwork {

×

245

                return

×

246

×

248

        if c.config.EnableNP {

×

249

                c.namedPort.DeleteNamedPortByPod(p)

×

250

                for _, np := range c.podMatchNetworkPolicies(p) {

×

251

                        c.updateNpQueue.Add(np)

×

252

×

255

        if c.config.EnableANP {

×

256

                podNs, _ := c.namespacesLister.Get(obj.(*v1.Pod).Namespace)

×

257

                c.updateAnpsByLabelsMatch(podNs.Labels, obj.(*v1.Pod).Labels)

×

258

×

260

        key := cache.MetaObjectToName(p).String()

×

261

        klog.Infof("enqueue delete pod %s", key)

×

262

        c.deletingPodObjMap.Store(key, p)

×

263

        c.deletePodQueue.Add(key)

×

266

func (c *Controller) enqueueUpdatePod(oldObj, newObj any) {

×

267

        oldPod := oldObj.(*v1.Pod)

×

268

        newPod := newObj.(*v1.Pod)

×

269

×

270

        if oldPod.Annotations[util.AAPsAnnotation] != "" || newPod.Annotations[util.AAPsAnnotation] != "" {

×

271

                oldAAPs := strings.Split(oldPod.Annotations[util.AAPsAnnotation], ",")

×

272

                newAAPs := strings.Split(newPod.Annotations[util.AAPsAnnotation], ",")

×

273

                var vipNames []string

×

274

                for _, vipName := range oldAAPs {

×

275

                        vipNames = append(vipNames, strings.TrimSpace(vipName))

×

276

×

277

                for _, vipName := range newAAPs {

×

278

                        vipName = strings.TrimSpace(vipName)

×

279

                        if !slices.Contains(vipNames, vipName) {

×

280

                                vipNames = append(vipNames, vipName)

×

281

×

283

                for _, vipName := range vipNames {

×

284

                        if vip, err := c.virtualIpsLister.Get(vipName); err == nil {

×

285

                                if vip.Spec.Namespace != newPod.Namespace {

×

286

                                        continue

×

288

                                klog.Infof("enqueue update virtual parents for %s", vipName)

×

289

                                c.updateVirtualParentsQueue.Add(vipName)

×

294

        if oldPod.ResourceVersion == newPod.ResourceVersion {

×

295

                return

×

296

×

297

        if newPod.Spec.HostNetwork {

×

298

                return

×

299

×

301

        podNets, err := c.getPodKubeovnNets(newPod)

×

302

        if err != nil {

×

303

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

×

304

                return

×

305

×

307

        key := cache.MetaObjectToName(newPod).String()

×

308

        if c.config.EnableNP {

×

309

                c.namedPort.AddNamedPortByPod(newPod)

×

310

                newNp := c.podMatchNetworkPolicies(newPod)

×

311

                if !maps.Equal(oldPod.Labels, newPod.Labels) {

×

312

                        oldNp := c.podMatchNetworkPolicies(oldPod)

×

313

                        for _, np := range util.DiffStringSlice(oldNp, newNp) {

×

314

                                c.updateNpQueue.Add(np)

×

315

×

318

                for _, podNet := range podNets {

×

319

                        oldAllocated := oldPod.Annotations[fmt.Sprintf(util.AllocatedAnnotationTemplate, podNet.ProviderName)]

×

320

                        newAllocated := newPod.Annotations[fmt.Sprintf(util.AllocatedAnnotationTemplate, podNet.ProviderName)]

×

321

                        if oldAllocated != newAllocated {

×

322

                                for _, np := range newNp {

×

323

                                        klog.V(3).Infof("enqueue update network policy %s for pod %s", np, key)

×

324

                                        c.updateNpQueue.Add(np)

×

325

×

326

                                break

×

331

        if c.config.EnableANP {

×

332

                podNs, _ := c.namespacesLister.Get(newPod.Namespace)

×

333

                if !maps.Equal(oldPod.Labels, newPod.Labels) {

×

334

                        c.updateAnpsByLabelsMatch(podNs.Labels, newPod.Labels)

×

335

×

337

                for _, podNet := range podNets {

×

338

                        oldAllocated := oldPod.Annotations[fmt.Sprintf(util.AllocatedAnnotationTemplate, podNet.ProviderName)]

×

339

                        newAllocated := newPod.Annotations[fmt.Sprintf(util.AllocatedAnnotationTemplate, podNet.ProviderName)]

×

340

                        if oldAllocated != newAllocated {

×

341

                                c.updateAnpsByLabelsMatch(podNs.Labels, newPod.Labels)

×

342

                                break

×

347

        isStateful, statefulSetName, statefulSetUID := isStatefulSetPod(newPod)

×

348

        isVMPod, vmName := isVMPod(newPod)

×

349

        if !isPodStatusPhaseAlive(newPod) && !isStateful && !isVMPod {

×

350

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

×

351

                c.deletingPodObjMap.Store(key, newPod)

×

352

                c.deletePodQueue.Add(key)

×

353

                return

×

354

×

357

        var delay time.Duration

×

358

        if newPod.Spec.TerminationGracePeriodSeconds != nil {

×

359

                if !newPod.DeletionTimestamp.IsZero() {

×

360

                        delay = time.Until(newPod.DeletionTimestamp.Add(time.Duration(*newPod.Spec.TerminationGracePeriodSeconds) * time.Second))

×

361

                } else {

×

362

                        delay = time.Duration(*newPod.Spec.TerminationGracePeriodSeconds) * time.Second

×

363

×

366

        if !newPod.DeletionTimestamp.IsZero() && !isStateful && !isVMPod {

×

367

                go func() {

×

368

                        // In case node get lost and pod can not be deleted,

×

369

                        // the ip address will not be recycled

×

370

                        klog.V(3).Infof("enqueue delete pod %s after %v", key, delay)

×

371

                        c.deletingPodObjMap.Store(key, newPod)

×

372

                        c.deletePodQueue.AddAfter(key, delay)

×

373

}()

×

374

                return

×

NEW

377

        if err = c.handlePodEventForVpcEgressGateway(newPod); err != nil {

×

NEW

378

                klog.Errorf("failed to handle pod event for vpc egress gateway: %v", err)

×

NEW

379

×

382

        if isStateful && isStatefulSetPodToDel(c.config.KubeClient, newPod, statefulSetName, statefulSetUID) {

×

383

                go func() {

×

384

                        klog.V(3).Infof("enqueue delete pod %s after %v", key, delay)

×

385

                        c.deletingPodObjMap.Store(key, newPod)

×

386

                        c.deletePodQueue.AddAfter(key, delay)

×

387

}()

×

388

                return

×

390

        if isVMPod && c.isVMToDel(newPod, vmName) {

×

391

                go func() {

×

392

                        klog.V(3).Infof("enqueue delete pod %s after %v", key, delay)

×

393

                        c.deletingPodObjMap.Store(key, newPod)

×

394

                        c.deletePodQueue.AddAfter(key, delay)

×

395

}()

×

396

                return

×

398

        klog.Infof("enqueue update pod %s", key)

×

399

        c.addOrUpdatePodQueue.Add(key)

×

400

×

401

        // security policy changed

×

402

        for _, podNet := range podNets {

×

403

                oldSecurity := oldPod.Annotations[fmt.Sprintf(util.PortSecurityAnnotationTemplate, podNet.ProviderName)]

×

404

                newSecurity := newPod.Annotations[fmt.Sprintf(util.PortSecurityAnnotationTemplate, podNet.ProviderName)]

×

405

                oldSg := oldPod.Annotations[fmt.Sprintf(util.SecurityGroupAnnotationTemplate, podNet.ProviderName)]

×

406

                newSg := newPod.Annotations[fmt.Sprintf(util.SecurityGroupAnnotationTemplate, podNet.ProviderName)]

×

407

                oldVips := oldPod.Annotations[fmt.Sprintf(util.PortVipAnnotationTemplate, podNet.ProviderName)]

×

408

                newVips := newPod.Annotations[fmt.Sprintf(util.PortVipAnnotationTemplate, podNet.ProviderName)]

×

409

                oldAAPs := oldPod.Annotations[util.AAPsAnnotation]

×

410

                newAAPs := newPod.Annotations[util.AAPsAnnotation]

×

411

                if oldSecurity != newSecurity || oldSg != newSg || oldVips != newVips || oldAAPs != newAAPs {

×

412

                        c.updatePodSecurityQueue.Add(key)

×

413

                        break

×

418

func (c *Controller) getPodKubeovnNets(pod *v1.Pod) ([]*kubeovnNet, error) {

×

419

        defaultSubnet, err := c.getPodDefaultSubnet(pod)

×

420

        if err != nil {

×

421

                klog.Error(err)

×

422

                return nil, err

×

423

×

425

        attachmentNets, err := c.getPodAttachmentNet(pod)

×

426

        if err != nil {

×

427

                klog.Error(err)

×

428

                return nil, err

×

429

×

431

        podNets := attachmentNets

×

432

        if _, hasOtherDefaultNet := pod.Annotations[util.DefaultNetworkAnnotation]; !hasOtherDefaultNet {

×

433

                podNets = append(attachmentNets, &kubeovnNet{

×

434

                        Type:         providerTypeOriginal,

×

435

                        ProviderName: util.OvnProvider,

×

436

                        Subnet:       defaultSubnet,

×

437

                        IsDefault:    true,

×

438

})

×

439

×

441

        return podNets, nil

×

444

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

×

445

        now := time.Now()

×

446

        klog.Infof("handle add/update pod %s", key)

×

447

×

448

        namespace, name, err := cache.SplitMetaNamespaceKey(key)

×

449

        if err != nil {

×

450

                utilruntime.HandleError(fmt.Errorf("invalid resource key: %s", key))

×

451

                return nil

×

452

×

454

        c.podKeyMutex.LockKey(key)

×

455

        defer func() {

×

456

                _ = c.podKeyMutex.UnlockKey(key)

×

457

                last := time.Since(now)

×

458

                klog.Infof("take %d ms to handle add or update pod %s", last.Milliseconds(), key)

×

459

}()

×

461

        pod, err := c.podsLister.Pods(namespace).Get(name)

×

462

        if err != nil {

×

463

                if k8serrors.IsNotFound(err) {

×

464

                        return nil

×

465

×

466

                klog.Error(err)

×

467

                return err

×

469

        if err := util.ValidatePodNetwork(pod.Annotations); err != nil {

×

470

                klog.Errorf("validate pod %s/%s failed: %v", namespace, name, err)

×

471

                c.recorder.Eventf(pod, v1.EventTypeWarning, "ValidatePodNetworkFailed", err.Error())

×

472

                return err

×

473

×

475

        podNets, err := c.getPodKubeovnNets(pod)

×

476

        if err != nil {

×

477

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

×

478

                return err

×

479

×

482

        if pod, err = c.syncKubeOvnNet(pod, podNets); err != nil {

×

483

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

×

484

                return err

×

485

×

486

        if pod == nil {

×

487

                // pod has been deleted

×

488

                return nil

×

489

×

490

        needAllocatePodNets := needAllocateSubnets(pod, podNets)

×

491

        if len(needAllocatePodNets) != 0 {

×

492

                if pod, err = c.reconcileAllocateSubnets(pod, needAllocatePodNets); err != nil {

×

493

                        klog.Error(err)

×

494

                        return err

×

495

×

496

                if pod == nil {

×

497

                        // pod has been deleted

×

498

                        return nil

×

499

×

502

        if vpcGwName, isVpcNatGw := pod.Annotations[util.VpcNatGatewayAnnotation]; isVpcNatGw {

×

503

                if needRestartNatGatewayPod(pod) {

×

504

                        c.addOrUpdateVpcNatGatewayQueue.Add(vpcGwName)

×

505

×

509

        return c.reconcileRouteSubnets(pod, needRouteSubnets(pod, podNets))

×

513

func (c *Controller) reconcileAllocateSubnets(pod *v1.Pod, needAllocatePodNets []*kubeovnNet) (*v1.Pod, error) {

×

514

        namespace := pod.Namespace

×

515

        name := pod.Name

×

516

        klog.Infof("sync pod %s/%s allocated", namespace, name)

×

517

×

518

        vipsMap := c.getVirtualIPs(pod, needAllocatePodNets)

×

519

        isVMPod, vmName := isVMPod(pod)

×

520

        podType := getPodType(pod)

×

521

        podName := c.getNameByPod(pod)

×

522

        // todo: isVmPod, getPodType, getNameByPod has duplicated logic

×

523

×

524

        var err error

×

525

        var vmKey string

×

526

        if isVMPod && c.config.EnableKeepVMIP {

×

527

                vmKey = fmt.Sprintf("%s/%s", namespace, vmName)

×

528

×

530

        patch := util.KVPatch{}

×

531

        for _, podNet := range needAllocatePodNets {

×

532

                // the subnet may changed when alloc static ip from the latter subnet after ns supports multi subnets

×

533

                v4IP, v6IP, mac, subnet, err := c.acquireAddress(pod, podNet)

×

534

                if err != nil {

×

535

                        c.recorder.Eventf(pod, v1.EventTypeWarning, "AcquireAddressFailed", err.Error())

×

536

                        klog.Error(err)

×

537

                        return nil, err

×

538

×

539

                ipStr := util.GetStringIP(v4IP, v6IP)

×

540

                patch[fmt.Sprintf(util.IPAddressAnnotationTemplate, podNet.ProviderName)] = ipStr

×

541

                if mac == "" {

×

542

                        patch[fmt.Sprintf(util.MacAddressAnnotationTemplate, podNet.ProviderName)] = nil

×

543

                } else {

×

544

                        patch[fmt.Sprintf(util.MacAddressAnnotationTemplate, podNet.ProviderName)] = mac

×

545

×

546

                patch[fmt.Sprintf(util.CidrAnnotationTemplate, podNet.ProviderName)] = subnet.Spec.CIDRBlock

×

547

                patch[fmt.Sprintf(util.GatewayAnnotationTemplate, podNet.ProviderName)] = subnet.Spec.Gateway

×

548

                if isOvnSubnet(podNet.Subnet) {

×

549

                        patch[fmt.Sprintf(util.LogicalSwitchAnnotationTemplate, podNet.ProviderName)] = subnet.Name

×

550

                        if pod.Annotations[fmt.Sprintf(util.PodNicAnnotationTemplate, podNet.ProviderName)] == "" {

×

551

                                patch[fmt.Sprintf(util.PodNicAnnotationTemplate, podNet.ProviderName)] = c.config.PodNicType

×

552

×

553

                } else {

×

554

                        patch[fmt.Sprintf(util.LogicalSwitchAnnotationTemplate, podNet.ProviderName)] = nil

×

555

                        patch[fmt.Sprintf(util.PodNicAnnotationTemplate, podNet.ProviderName)] = nil

×

556

×

557

                patch[fmt.Sprintf(util.AllocatedAnnotationTemplate, podNet.ProviderName)] = "true"

×

558

                if vmKey != "" {

×

559

                        patch[fmt.Sprintf(util.VMAnnotationTemplate, podNet.ProviderName)] = vmName

×

560

×

561

                if err := util.ValidateNetworkBroadcast(podNet.Subnet.Spec.CIDRBlock, ipStr); err != nil {

×

562

                        klog.Errorf("validate pod %s/%s failed: %v", namespace, name, err)

×

563

                        c.recorder.Eventf(pod, v1.EventTypeWarning, "ValidatePodNetworkFailed", err.Error())

×

564

                        return nil, err

×

565

×

567

                if podNet.Type != providerTypeIPAM {

×

568

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

×

569

                                patch[fmt.Sprintf(util.LogicalRouterAnnotationTemplate, podNet.ProviderName)] = subnet.Spec.Vpc

×

570

×

572

                        if subnet.Spec.Vlan != "" {

×

573

                                vlan, err := c.vlansLister.Get(subnet.Spec.Vlan)

×

574

                                if err != nil {

×

575

                                        klog.Error(err)

×

576

                                        c.recorder.Eventf(pod, v1.EventTypeWarning, "GetVlanInfoFailed", err.Error())

×

577

                                        return nil, err

×

578

×

579

                                patch[fmt.Sprintf(util.VlanIDAnnotationTemplate, podNet.ProviderName)] = strconv.Itoa(vlan.Spec.ID)

×

580

                                patch[fmt.Sprintf(util.ProviderNetworkTemplate, podNet.ProviderName)] = vlan.Spec.Provider

×

583

                        portSecurity := false

×

584

                        if pod.Annotations[fmt.Sprintf(util.PortSecurityAnnotationTemplate, podNet.ProviderName)] == "true" {

×

585

                                portSecurity = true

×

586

×

588

                        vips := vipsMap[fmt.Sprintf("%s.%s", podNet.Subnet.Name, podNet.ProviderName)]

×

589

                        for ip := range strings.SplitSeq(vips, ",") {

×

590

                                if ip != "" && net.ParseIP(ip) == nil {

×

591

                                        klog.Errorf("invalid vip address '%s' for pod %s", ip, name)

×

592

                                        vips = ""

×

593

                                        break

×

597

                        portName := ovs.PodNameToPortName(podName, namespace, podNet.ProviderName)

×

598

                        dhcpOptions := &ovs.DHCPOptionsUUIDs{

×

599

                                DHCPv4OptionsUUID: subnet.Status.DHCPv4OptionsUUID,

×

600

                                DHCPv6OptionsUUID: subnet.Status.DHCPv6OptionsUUID,

×

601

×

602

×

603

                        var oldSgList []string

×

604

                        if vmKey != "" {

×

605

                                existingLsp, err := c.OVNNbClient.GetLogicalSwitchPort(portName, true)

×

606

                                if err != nil {

×

607

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

×

608

                                        return nil, err

×

609

×

610

                                if existingLsp != nil {

×

611

                                        oldSgList, _ = c.getPortSg(existingLsp)

×

612

×

615

                        securityGroupAnnotation := pod.Annotations[fmt.Sprintf(util.SecurityGroupAnnotationTemplate, podNet.ProviderName)]

×

616

                        if err := c.OVNNbClient.CreateLogicalSwitchPort(subnet.Name, portName, ipStr, mac, podName, pod.Namespace,

×

617

                                portSecurity, securityGroupAnnotation, vips, podNet.Subnet.Spec.EnableDHCP, dhcpOptions, subnet.Spec.Vpc); err != nil {

×

618

                                c.recorder.Eventf(pod, v1.EventTypeWarning, "CreateOVNPortFailed", err.Error())

×

619

                                klog.Errorf("%v", err)

×

620

                                return nil, err

×

621

×

623

                        if pod.Annotations[fmt.Sprintf(util.Layer2ForwardAnnotationTemplate, podNet.ProviderName)] == "true" {

×

624

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

×

625

                                        c.recorder.Eventf(pod, v1.EventTypeWarning, "SetOVNPortL2ForwardFailed", err.Error())

×

626

                                        klog.Errorf("%v", err)

×

627

                                        return nil, err

×

628

×

631

                        if securityGroupAnnotation != "" || oldSgList != nil {

×

632

                                securityGroups := strings.ReplaceAll(securityGroupAnnotation, " ", "")

×

633

                                newSgList := strings.Split(securityGroups, ",")

×

634

                                sgNames := util.UnionStringSlice(oldSgList, newSgList)

×

635

                                for _, sgName := range sgNames {

×

636

                                        if sgName != "" {

×

637

                                                c.syncSgPortsQueue.Add(sgName)

×

638

×

642

                        if vips != "" {

×

643

                                c.syncVirtualPortsQueue.Add(podNet.Subnet.Name)

×

644

×

647

                ipCRName := ovs.PodNameToPortName(podName, pod.Namespace, podNet.ProviderName)

×

648

                if err := c.createOrUpdateIPCR(ipCRName, podName, ipStr, mac, subnet.Name, pod.Namespace, pod.Spec.NodeName, podType); err != nil {

×

649

                        err = fmt.Errorf("failed to create ips CR %s.%s: %w", podName, pod.Namespace, err)

×

650

                        klog.Error(err)

×

651

                        return nil, err

×

652

×

654

        if err = util.PatchAnnotations(c.config.KubeClient.CoreV1().Pods(namespace), name, patch); err != nil {

×

655

                if k8serrors.IsNotFound(err) {

×

656

                        // Sometimes pod is deleted between kube-ovn configure ovn-nb and patch pod.

×

657

                        // Then we need to recycle the resource again.

×

658

                        key := strings.Join([]string{namespace, name}, "/")

×

659

                        c.deletingPodObjMap.Store(key, pod)

×

660

                        c.deletePodQueue.AddRateLimited(key)

×

661

                        return nil, nil

×

662

×

663

                klog.Errorf("failed to patch pod %s/%s: %v", namespace, name, err)

×

664

                return nil, err

×

667

        if pod, err = c.config.KubeClient.CoreV1().Pods(namespace).Get(context.TODO(), name, metav1.GetOptions{}); err != nil {

×

668

                if k8serrors.IsNotFound(err) {

×

669

                        key := strings.Join([]string{namespace, name}, "/")

×

670

                        c.deletingPodObjMap.Store(key, pod)

×

671

                        c.deletePodQueue.AddRateLimited(key)

×

672

                        return nil, nil

×

673

×

674

                klog.Errorf("failed to get pod %s/%s: %v", namespace, name, err)

×

675

                return nil, err

×

678

        if vpcGwName, isVpcNatGw := pod.Annotations[util.VpcNatGatewayAnnotation]; isVpcNatGw {

×

679

                c.initVpcNatGatewayQueue.Add(vpcGwName)

×

680

×

681

        return pod, nil

×

685

func (c *Controller) reconcileRouteSubnets(pod *v1.Pod, needRoutePodNets []*kubeovnNet) error {

×

686

        // the lb-svc pod has dependencies on Running state, check it when pod state get updated

×

687

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

×

688

                klog.Errorf("failed to init iptable rules for load-balancer pod %s/%s: %v", pod.Namespace, pod.Name, err)

×

689

×

691

        if len(needRoutePodNets) == 0 {

×

692

                return nil

×

693

×

695

        namespace := pod.Namespace

×

696

        name := pod.Name

×

697

        podName := c.getNameByPod(pod)

×

698

×

699

        klog.Infof("sync pod %s/%s routed", namespace, name)

×

700

×

701

        var podIP string

×

702

        var subnet *kubeovnv1.Subnet

×

703

        patch := util.KVPatch{}

×

704

        for _, podNet := range needRoutePodNets {

×

705

                // in case update handler overlap the annotation when cache is not in sync

×

706

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

×

707

                        return fmt.Errorf("no address has been allocated to %s/%s", namespace, name)

×

708

×

710

                podIP = pod.Annotations[fmt.Sprintf(util.IPAddressAnnotationTemplate, podNet.ProviderName)]

×

711

                subnet = podNet.Subnet

×

712

×

713

                // Check if pod uses nodeSwitch subnet

×

714

                if subnet.Name == c.config.NodeSwitch {

×

715

                        return fmt.Errorf("NodeSwitch subnet %s is unavailable for pod", subnet.Name)

×

716

×

718

                portName := ovs.PodNameToPortName(podName, pod.Namespace, podNet.ProviderName)

×

719

                if (!c.config.EnableLb || (subnet.Spec.EnableLb == nil || !*subnet.Spec.EnableLb)) &&

×

720

                        subnet.Spec.Vpc == c.config.ClusterRouter &&

×

721

                        subnet.Spec.U2OInterconnection &&

×

722

                        subnet.Spec.Vlan != "" &&

×

723

                        !subnet.Spec.LogicalGateway {

×

724

                        pgName := getOverlaySubnetsPortGroupName(subnet.Name, pod.Spec.NodeName)

×

725

                        if err := c.OVNNbClient.PortGroupAddPorts(pgName, portName); err != nil {

×

726

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

×

727

                                return err

×

728

×

731

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

×

732

                        node, err := c.nodesLister.Get(pod.Spec.NodeName)

×

733

                        if err != nil {

×

734

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

×

735

                                return err

×

736

×

738

                        pgName := getOverlaySubnetsPortGroupName(subnet.Name, node.Name)

×

739

                        if c.config.EnableEipSnat && (pod.Annotations[util.EipAnnotation] != "" || pod.Annotations[util.SnatAnnotation] != "") {

×

740

                                cm, err := c.configMapsLister.ConfigMaps(c.config.ExternalGatewayConfigNS).Get(util.ExternalGatewayConfig)

×

741

                                if err != nil {

×

742

                                        klog.Errorf("failed to get ex-gateway config, %v", err)

×

743

                                        return err

×

744

×

745

                                nextHop := cm.Data["external-gw-addr"]

×

746

                                if nextHop == "" {

×

747

                                        externalSubnet, err := c.subnetsLister.Get(c.config.ExternalGatewaySwitch)

×

748

                                        if err != nil {

×

749

                                                klog.Errorf("failed to get subnet %s, %v", c.config.ExternalGatewaySwitch, err)

×

750

                                                return err

×

751

×

752

                                        nextHop = externalSubnet.Spec.Gateway

×

753

                                        if nextHop == "" {

×

754

                                                klog.Errorf("no available gateway address")

×

755

                                                return errors.New("no available gateway address")

×

756

×

758

                                if strings.Contains(nextHop, "/") {

×

759

                                        nextHop = strings.Split(nextHop, "/")[0]

×

760

×

762

                                if err := c.addPolicyRouteToVpc(

×

763

                                        subnet.Spec.Vpc,

×

764

                                        &kubeovnv1.PolicyRoute{

×

765

                                                Priority:  util.NorthGatewayRoutePolicyPriority,

×

766

                                                Match:     "ip4.src == " + podIP,

×

767

                                                Action:    kubeovnv1.PolicyRouteActionReroute,

×

768

                                                NextHopIP: nextHop,

×

769

},

×

770

                                        map[string]string{

×

771

                                                "vendor": util.CniTypeName,

×

772

                                                "subnet": subnet.Name,

×

773

},

×

774

                                ); err != nil {

×

775

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

×

776

                                        return err

×

777

×

780

                                if err = c.OVNNbClient.PortGroupRemovePorts(pgName, portName); err != nil {

×

781

                                        klog.Error(err)

×

782

                                        return err

×

783

×

784

                        } else {

×

785

                                if subnet.Spec.GatewayType == kubeovnv1.GWDistributedType && pod.Annotations[util.NorthGatewayAnnotation] == "" {

×

786

                                        nodeTunlIPAddr, err := getNodeTunlIP(node)

×

787

                                        if err != nil {

×

788

                                                klog.Error(err)

×

789

                                                return err

×

790

×

792

                                        var added bool

×

793

×

794

                                        for _, nodeAddr := range nodeTunlIPAddr {

×

795

                                                for podAddr := range strings.SplitSeq(podIP, ",") {

×

796

                                                        if util.CheckProtocol(nodeAddr.String()) != util.CheckProtocol(podAddr) {

×

797

                                                                continue

×

800

                                                        if err := c.OVNNbClient.PortGroupAddPorts(pgName, portName); err != nil {

×

801

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

×

802

                                                                return err

×

803

×

805

                                                        added = true

×

806

                                                        break

×

808

                                                if added {

×

809

                                                        break

×

814

                                if pod.Annotations[util.NorthGatewayAnnotation] != "" && pod.Annotations[util.IPAddressAnnotation] != "" {

×

815

                                        for podAddr := range strings.SplitSeq(pod.Annotations[util.IPAddressAnnotation], ",") {

×

816

                                                if util.CheckProtocol(podAddr) != util.CheckProtocol(pod.Annotations[util.NorthGatewayAnnotation]) {

×

817

                                                        continue

×

819

                                                ipSuffix := "ip4"

×

820

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

×

821

                                                        ipSuffix = "ip6"

×

822

×

824

                                                if err := c.addPolicyRouteToVpc(

×

825

                                                        subnet.Spec.Vpc,

×

826

                                                        &kubeovnv1.PolicyRoute{

×

827

                                                                Priority:  util.NorthGatewayRoutePolicyPriority,

×

828

                                                                Match:     fmt.Sprintf("%s.src == %s", ipSuffix, podAddr),

×

829

                                                                Action:    kubeovnv1.PolicyRouteActionReroute,

×

830

                                                                NextHopIP: pod.Annotations[util.NorthGatewayAnnotation],

×

831

},

×

832

                                                        map[string]string{

×

833

                                                                "vendor": util.CniTypeName,

×

834

                                                                "subnet": subnet.Name,

×

835

},

×

836

                                                ); err != nil {

×

837

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

×

838

                                                        return err

×

839

×

841

                                } else if c.config.EnableEipSnat {

×

842

                                        if err = c.deleteStaticRouteFromVpc(

×

843

                                                c.config.ClusterRouter,

×

844

                                                subnet.Spec.RouteTable,

×

845

                                                podIP,

×

846

"",

×

847

                                                kubeovnv1.PolicyDst,

×

848

                                        ); err != nil {

×

849

                                                klog.Error(err)

×

850

                                                return err

×

851

×

855

                        if c.config.EnableEipSnat {

×

856

                                for ipStr := range strings.SplitSeq(podIP, ",") {

×

857

                                        if eip := pod.Annotations[util.EipAnnotation]; eip == "" {

×

858

                                                if err = c.OVNNbClient.DeleteNats(c.config.ClusterRouter, ovnnb.NATTypeDNATAndSNAT, ipStr); err != nil {

×

859

                                                        klog.Errorf("failed to delete nat rules: %v", err)

×

860

×

861

                                        } else if util.CheckProtocol(eip) == util.CheckProtocol(ipStr) {

×

862

                                                if err = c.OVNNbClient.UpdateDnatAndSnat(c.config.ClusterRouter, eip, ipStr, fmt.Sprintf("%s.%s", podName, pod.Namespace), pod.Annotations[util.MacAddressAnnotation], c.ExternalGatewayType); err != nil {

×

863

                                                        klog.Errorf("failed to add nat rules, %v", err)

×

864

                                                        return err

×

865

×

867

                                        if eip := pod.Annotations[util.SnatAnnotation]; eip == "" {

×

868

                                                if err = c.OVNNbClient.DeleteNats(c.config.ClusterRouter, ovnnb.NATTypeSNAT, ipStr); err != nil {

×

869

                                                        klog.Errorf("failed to delete nat rules: %v", err)

×

870

×

871

                                        } else if util.CheckProtocol(eip) == util.CheckProtocol(ipStr) {

×

872

                                                if err = c.OVNNbClient.UpdateSnat(c.config.ClusterRouter, eip, ipStr); err != nil {

×

873

                                                        klog.Errorf("failed to add nat rules, %v", err)

×

874

                                                        return err

×

875

×

881

                if pod.Annotations[fmt.Sprintf(util.ActivationStrategyTemplate, podNet.ProviderName)] != "" {

×

882

                        if err := c.OVNNbClient.SetLogicalSwitchPortActivationStrategy(portName, pod.Spec.NodeName); err != nil {

×

883

                                klog.Errorf("failed to set activation strategy for lsp %s: %v", portName, err)

×

884

                                return err

×

885

×

888

                patch[fmt.Sprintf(util.RoutedAnnotationTemplate, podNet.ProviderName)] = "true"

×

890

        if err := util.PatchAnnotations(c.config.KubeClient.CoreV1().Pods(namespace), name, patch); err != nil {

×

891

                if k8serrors.IsNotFound(err) {

×

892

                        // Sometimes pod is deleted between kube-ovn configure ovn-nb and patch pod.

×

893

                        // Then we need to recycle the resource again.

×

894

                        key := strings.Join([]string{namespace, name}, "/")

×

895

                        c.deletingPodObjMap.Store(key, pod)

×

896

                        c.deletePodQueue.AddRateLimited(key)

×

897

                        return nil

×

898

×

899

                klog.Errorf("failed to patch pod %s/%s: %v", namespace, name, err)

×

900

                return err

×

902

        return nil

×

905

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

×

906

        pod, ok := c.deletingPodObjMap.Load(key)

×

907

        if !ok {

×

908

                return nil

×

909

×

910

        now := time.Now()

×

911

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

×

912

        podName := c.getNameByPod(pod)

×

913

        c.podKeyMutex.LockKey(key)

×

914

        defer func() {

×

915

                _ = c.podKeyMutex.UnlockKey(key)

×

916

                if err == nil {

×

917

                        c.deletingPodObjMap.Delete(key)

×

918

×

919

                last := time.Since(now)

×

920

                klog.Infof("take %d ms to handle delete pod %s", last.Milliseconds(), key)

×

923

        p, _ := c.podsLister.Pods(pod.Namespace).Get(pod.Name)

×

924

        if p != nil && p.UID != pod.UID {

×

925

                // Pod with same name exists, just return here

×

926

                return nil

×

927

×

929

        if aaps := pod.Annotations[util.AAPsAnnotation]; aaps != "" {

×

930

                for vipName := range strings.SplitSeq(aaps, ",") {

×

931

                        if vip, err := c.virtualIpsLister.Get(vipName); err == nil {

×

932

                                if vip.Spec.Namespace != pod.Namespace {

×

933

                                        continue

×

935

                                klog.Infof("enqueue update virtual parents for %s", vipName)

×

936

                                c.updateVirtualParentsQueue.Add(vipName)

×

941

        podKey := fmt.Sprintf("%s/%s", pod.Namespace, podName)

×

942

×

943

        var keepIPCR bool

×

944

        if ok, stsName, stsUID := isStatefulSetPod(pod); ok {

×

945

                if !pod.DeletionTimestamp.IsZero() {

×

946

                        klog.Infof("handle deletion of sts pod %s", podKey)

×

947

                        toDel := isStatefulSetPodToDel(c.config.KubeClient, pod, stsName, stsUID)

×

948

                        if !toDel {

×

949

                                klog.Infof("try keep ip for sts pod %s", podKey)

×

950

                                keepIPCR = true

×

951

×

953

                if keepIPCR {

×

954

                        isDelete, err := appendCheckPodToDel(c, pod, stsName, util.StatefulSet)

×

955

                        if err != nil {

×

956

                                klog.Error(err)

×

957

                                return err

×

958

×

959

                        if isDelete {

×

960

                                klog.Infof("not keep ip for sts pod %s", podKey)

×

961

                                keepIPCR = false

×

962

×

965

        isVMPod, vmName := isVMPod(pod)

×

966

        if isVMPod && c.config.EnableKeepVMIP {

×

967

                ports, err := c.OVNNbClient.ListNormalLogicalSwitchPorts(true, map[string]string{"pod": podKey})

×

968

                if err != nil {

×

969

                        klog.Errorf("failed to list lsps of pod %s: %v", podKey, err)

×

970

                        return err

×

971

×

972

                for _, port := range ports {

×

973

                        if err := c.OVNNbClient.CleanLogicalSwitchPortMigrateOptions(port.Name); err != nil {

×

974

                                err = fmt.Errorf("failed to clean migrate options for vm lsp %s, %w", port.Name, err)

×

975

                                klog.Error(err)

×

976

                                return err

×

977

×

979

                if pod.DeletionTimestamp != nil {

×

980

                        klog.Infof("handle deletion of vm pod %s", podKey)

×

981

                        vmToBeDel := c.isVMToDel(pod, vmName)

×

982

                        if !vmToBeDel {

×

983

                                klog.Infof("try keep ip for vm pod %s", podKey)

×

984

                                keepIPCR = true

×

985

×

987

                if keepIPCR {

×

988

                        isDelete, err := appendCheckPodToDel(c, pod, vmName, util.VMInstance)

×

989

                        if err != nil {

×

990

                                klog.Error(err)

×

991

                                return err

×

992

×

993

                        if isDelete {

×

994

                                klog.Infof("not keep ip for vm pod %s", podKey)

×

995

                                keepIPCR = false

×

996

×

1000

        podNets, err := c.getPodKubeovnNets(pod)

×

1001

        if err != nil {

×

1002

                klog.Errorf("failed to get kube-ovn nets of pod %s: %v", podKey, err)

×

1003

×

1004

        if !keepIPCR {

×

1005

                ports, err := c.OVNNbClient.ListNormalLogicalSwitchPorts(true, map[string]string{"pod": podKey})

×

1006

                if err != nil {

×

1007

                        klog.Errorf("failed to list lsps of pod %s: %v", podKey, err)

×

1008

                        return err

×

1009

×

1011

                if len(ports) != 0 {

×

1012

                        addresses := c.ipam.GetPodAddress(podKey)

×

1013

                        for _, address := range addresses {

×

1014

                                if strings.TrimSpace(address.IP) == "" {

×

1015

                                        continue

×

1017

                                subnet, err := c.subnetsLister.Get(address.Subnet.Name)

×

1018

                                if k8serrors.IsNotFound(err) {

×

1019

                                        continue

×

1020

                                } else if err != nil {

×

1021

                                        klog.Error(err)

×

1022

                                        return err

×

1023

×

1024

                                vpc, err := c.vpcsLister.Get(subnet.Spec.Vpc)

×

1025

                                if k8serrors.IsNotFound(err) {

×

1026

                                        continue

×

1027

                                } else if err != nil {

×

1028

                                        klog.Error(err)

×

1029

                                        return err

×

1030

×

1032

                                ipSuffix := "ip4"

×

1033

                                if util.CheckProtocol(address.IP) == kubeovnv1.ProtocolIPv6 {

×

1034

                                        ipSuffix = "ip6"

×

1035

×

1036

                                if err = c.deletePolicyRouteFromVpc(

×

1037

                                        vpc.Name,

×

1038

                                        util.NorthGatewayRoutePolicyPriority,

×

1039

                                        fmt.Sprintf("%s.src == %s", ipSuffix, address.IP),

×

1040

                                ); err != nil {

×

1041

                                        klog.Errorf("failed to delete static route, %v", err)

×

1042

                                        return err

×

1043

×

1045

                                if c.config.EnableEipSnat {

×

1046

                                        if pod.Annotations[util.EipAnnotation] != "" {

×

1047

                                                if err = c.OVNNbClient.DeleteNat(c.config.ClusterRouter, ovnnb.NATTypeDNATAndSNAT, pod.Annotations[util.EipAnnotation], address.IP); err != nil {

×

1048

                                                        klog.Errorf("failed to delete nat rules: %v", err)

×

1049

×

1051

                                        if pod.Annotations[util.SnatAnnotation] != "" {

×

1052

                                                if err = c.OVNNbClient.DeleteNat(c.config.ClusterRouter, ovnnb.NATTypeSNAT, "", address.IP); err != nil {

×

1053

                                                        klog.Errorf("failed to delete nat rules: %v", err)

×

1054

×

1059

                for _, port := range ports {

×

1060

                        // when lsp is deleted, the port of pod is deleted from any port-group automatically.

×

1061

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

×

1062

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

×

1063

                                klog.Errorf("failed to delete lsp %s, %v", port.Name, err)

×

1064

                                return err

×

1065

×

1067

                klog.Infof("try release all ip address for deleting pod %s", podKey)

×

1068

                for _, podNet := range podNets {

×

1069

                        portName := ovs.PodNameToPortName(podName, pod.Namespace, podNet.ProviderName)

×

1070

                        ipCR, err := c.ipsLister.Get(portName)

×

1071

                        if err != nil {

×

1072

                                if k8serrors.IsNotFound(err) {

×

1073

                                        continue

×

1075

                                klog.Errorf("failed to get ip %s, %v", portName, err)

×

1076

                                return err

×

1078

                        if ipCR.Labels[util.IPReservedLabel] != "true" {

×

1079

                                klog.Infof("delete ip CR %s", ipCR.Name)

×

1080

                                if err := c.config.KubeOvnClient.KubeovnV1().IPs().Delete(context.Background(), ipCR.Name, metav1.DeleteOptions{}); err != nil {

×

1081

                                        if !k8serrors.IsNotFound(err) {

×

1082

                                                klog.Errorf("failed to delete ip %s, %v", ipCR.Name, err)

×

1083

                                                return err

×

1084

×

1087

                                c.ipam.ReleaseAddressByPod(podKey, podNet.Subnet.Name)

×

1090

                if pod.Annotations[util.VipAnnotation] != "" {

×

1091

                        if err = c.releaseVip(pod.Annotations[util.VipAnnotation]); err != nil {

×

1092

                                klog.Errorf("failed to clean label from vip %s, %v", pod.Annotations[util.VipAnnotation], err)

×

1093

                                return err

×

1094

×

1097

        for _, podNet := range podNets {

×

1098

                c.syncVirtualPortsQueue.Add(podNet.Subnet.Name)

×

1099

                securityGroupAnnotation := pod.Annotations[fmt.Sprintf(util.SecurityGroupAnnotationTemplate, podNet.ProviderName)]

×

1100

                if securityGroupAnnotation != "" {

×

1101

                        securityGroups := strings.ReplaceAll(securityGroupAnnotation, " ", "")

×

1102

                        for sgName := range strings.SplitSeq(securityGroups, ",") {

×

1103

                                if sgName != "" {

×

1104

                                        c.syncSgPortsQueue.Add(sgName)

×

1105

×

1109

        return nil

×

1112

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

×

1113

        now := time.Now()

×

1114

        klog.Infof("handle add/update pod security group %s", key)

×

1115

×

1116

        namespace, name, err := cache.SplitMetaNamespaceKey(key)

×

1117

        if err != nil {

×

1118

                utilruntime.HandleError(fmt.Errorf("invalid resource key: %s", key))

×

1119

                return nil

×

1120

×

1122

        c.podKeyMutex.LockKey(key)

×

1123

        defer func() {

×

1124

                _ = c.podKeyMutex.UnlockKey(key)

×

1125

                last := time.Since(now)

×

1126

                klog.Infof("take %d ms to handle sg for pod %s", last.Milliseconds(), key)

×

1127

}()

×

1129

        pod, err := c.podsLister.Pods(namespace).Get(name)

×

1130

        if err != nil {

×

1131

                if k8serrors.IsNotFound(err) {

×

1132

                        return nil

×

1133

×

1134

                klog.Error(err)

×

1135

                return err

×

1137

        podName := c.getNameByPod(pod)

×

1138

×

1139

        podNets, err := c.getPodKubeovnNets(pod)

×

1140

        if err != nil {

×

1141

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

×

1142

                return err

×

1143

×

1145

        vipsMap := c.getVirtualIPs(pod, podNets)

×

1146

×

1147

        // associated with security group

×

1148

        for _, podNet := range podNets {

×

1149

                portSecurity := false

×

1150

                if pod.Annotations[fmt.Sprintf(util.PortSecurityAnnotationTemplate, podNet.ProviderName)] == "true" {

×

1151

                        portSecurity = true

×

1152

×

1154

                mac := pod.Annotations[fmt.Sprintf(util.MacAddressAnnotationTemplate, podNet.ProviderName)]

×

1155

                ipStr := pod.Annotations[fmt.Sprintf(util.IPAddressAnnotationTemplate, podNet.ProviderName)]

×

1156

                vips := vipsMap[fmt.Sprintf("%s.%s", podNet.Subnet.Name, podNet.ProviderName)]

×

1157

                portName := ovs.PodNameToPortName(podName, namespace, podNet.ProviderName)

×

1158

                if err = c.OVNNbClient.SetLogicalSwitchPortSecurity(portSecurity, portName, mac, ipStr, vips); err != nil {

×

1159

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

×

1160

                        return err

×

1161

×

1163

                c.syncVirtualPortsQueue.Add(podNet.Subnet.Name)

×

1164

                securityGroupAnnotation := pod.Annotations[fmt.Sprintf(util.SecurityGroupAnnotationTemplate, podNet.ProviderName)]

×

1165

                var securityGroups string

×

1166

                if securityGroupAnnotation != "" {

×

1167

                        securityGroups = strings.ReplaceAll(securityGroupAnnotation, " ", "")

×

1168

                        for sgName := range strings.SplitSeq(securityGroups, ",") {

×

1169

                                if sgName != "" {

×

1170

                                        c.syncSgPortsQueue.Add(sgName)

×

1171

×

1174

                if err = c.reconcilePortSg(portName, securityGroups); err != nil {

×

1175

                        klog.Errorf("reconcilePortSg failed. %v", err)

×

1176

                        return err

×

1177

×

1179

        return nil

×

1182

func (c *Controller) syncKubeOvnNet(pod *v1.Pod, podNets []*kubeovnNet) (*v1.Pod, error) {

×

1183

        podName := c.getNameByPod(pod)

×

1184

        key := fmt.Sprintf("%s/%s", pod.Namespace, podName)

×

1185

        targetPortNameList := strset.NewWithSize(len(podNets))

×

1186

        portsNeedToDel := []string{}

×

1187

        annotationsNeedToDel := []string{}

×

1188

        annotationsNeedToAdd := make(map[string]string)

×

1189

        subnetUsedByPort := make(map[string]string)

×

1190

×

1191

        for _, podNet := range podNets {

×

1192

                portName := ovs.PodNameToPortName(podName, pod.Namespace, podNet.ProviderName)

×

1193

                targetPortNameList.Add(portName)

×

1194

                if podNet.IPRequest != "" {

×

1195

                        klog.Infof("pod %s/%s use custom IP %s for provider %s", pod.Namespace, pod.Name, podNet.IPRequest, podNet.ProviderName)

×

1196

                        annotationsNeedToAdd[fmt.Sprintf(util.IPAddressAnnotationTemplate, podNet.ProviderName)] = podNet.IPRequest

×

1197

×

1199

                if podNet.MacRequest != "" {

×

1200

                        klog.Infof("pod %s/%s use custom MAC %s for provider %s", pod.Namespace, pod.Name, podNet.MacRequest, podNet.ProviderName)

×

1201

                        annotationsNeedToAdd[fmt.Sprintf(util.MacAddressAnnotationTemplate, podNet.ProviderName)] = podNet.MacRequest

×

1202

×

1205

        ports, err := c.OVNNbClient.ListNormalLogicalSwitchPorts(true, map[string]string{"pod": key})

×

1206

        if err != nil {

×

1207

                klog.Errorf("failed to list lsps of pod '%s', %v", pod.Name, err)

×

1208

                return nil, err

×

1209

×

1211

        for _, port := range ports {

×

1212

                if !targetPortNameList.Has(port.Name) {

×

1213

                        portsNeedToDel = append(portsNeedToDel, port.Name)

×

1214

                        subnetUsedByPort[port.Name] = port.ExternalIDs["ls"]

×

1215

                        portNameSlice := strings.Split(port.Name, ".")

×

1216

                        providerName := strings.Join(portNameSlice[2:], ".")

×

1217

                        if providerName == util.OvnProvider {

×

1218

                                continue

×

1220

                        annotationsNeedToDel = append(annotationsNeedToDel, providerName)

×

1224

        if len(portsNeedToDel) == 0 && len(annotationsNeedToAdd) == 0 {

×

1225

                return pod, nil

×

1226

×

1228

        for _, portNeedDel := range portsNeedToDel {

×

1229

                klog.Infof("release port %s for pod %s", portNeedDel, podName)

×

1230

                if subnet, ok := c.ipam.Subnets[subnetUsedByPort[portNeedDel]]; ok {

×

1231

                        subnet.ReleaseAddressWithNicName(podName, portNeedDel)

×

1232

×

1233

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

×

1234

                        klog.Errorf("failed to delete lsp %s, %v", portNeedDel, err)

×

1235

                        return nil, err

×

1236

×

1237

                if err := c.config.KubeOvnClient.KubeovnV1().IPs().Delete(context.Background(), portNeedDel, metav1.DeleteOptions{}); err != nil {

×

1238

                        if !k8serrors.IsNotFound(err) {

×

1239

                                klog.Errorf("failed to delete ip %s, %v", portNeedDel, err)

×

1240

                                return nil, err

×

1241

×

1245

        patch := util.KVPatch{}

×

1246

        for _, providerName := range annotationsNeedToDel {

×

1247

                for key := range pod.Annotations {

×

1248

                        if strings.HasPrefix(key, providerName) {

×

1249

                                patch[key] = nil

×

1250

×

1254

        for key, value := range annotationsNeedToAdd {

×

1255

                patch[key] = value

×

1256

×

1258

        if len(patch) == 0 {

×

1259

                return pod, nil

×

1260

×

1262

        if err = util.PatchAnnotations(c.config.KubeClient.CoreV1().Pods(pod.Namespace), pod.Name, patch); err != nil {

×

1263

                if k8serrors.IsNotFound(err) {

×

1264

                        return nil, nil

×

1265

×

1266

                klog.Errorf("failed to clean annotations for pod %s/%s: %v", pod.Namespace, pod.Name, err)

×

1267

                return nil, err

×

1270

        if pod, err = c.config.KubeClient.CoreV1().Pods(pod.Namespace).Get(context.TODO(), pod.Name, metav1.GetOptions{}); err != nil {

×

1271

                if k8serrors.IsNotFound(err) {

×

1272

                        return nil, nil

×

1273

×

1274

                klog.Errorf("failed to get pod %s/%s: %v", pod.Namespace, pod.Name, err)

×

1275

                return nil, err

×

1278

        return pod, nil

×

1281

func isStatefulSetPod(pod *v1.Pod) (bool, string, types.UID) {

×

1282

        for _, owner := range pod.OwnerReferences {

×

1283

                if owner.Kind == util.StatefulSet && strings.HasPrefix(owner.APIVersion, "apps/") {

×

1284

                        if strings.HasPrefix(pod.Name, owner.Name) {

×

1285

                                return true, owner.Name, owner.UID

×

1286

×

1289

        return false, "", ""

×

1292

func isStatefulSetPodToDel(c kubernetes.Interface, pod *v1.Pod, statefulSetName string, statefulSetUID types.UID) bool {

×

1293

        // only delete statefulset pod lsp when statefulset deleted or down scaled

×

1294

        sts, err := c.AppsV1().StatefulSets(pod.Namespace).Get(context.Background(), statefulSetName, metav1.GetOptions{})

×

1295

        if err != nil {

×

1296

                // statefulset is deleted

×

1297

                if k8serrors.IsNotFound(err) {

×

1298

                        klog.Infof("statefulset %s/%s has been deleted", pod.Namespace, statefulSetName)

×

1299

                        return true

×

1300

×

1301

                klog.Errorf("failed to get statefulset %s/%s: %v", pod.Namespace, statefulSetName, err)

×

1302

                return false

×

1306

        if !sts.DeletionTimestamp.IsZero() {

×

1307

                klog.Infof("statefulset %s/%s is being deleted", pod.Namespace, statefulSetName)

×

1308

                return true

×

1309

×

1310

        if sts.UID != statefulSetUID {

×

1311

                klog.Infof("statefulset %s/%s is a newly created one", pod.Namespace, statefulSetName)

×

1312

                return true

×

1313

×

1316

        tempStrs := strings.Split(pod.Name, "-")

×

1317

        numStr := tempStrs[len(tempStrs)-1]

×

1318

        index, err := strconv.ParseInt(numStr, 10, 0)

×

1319

        if err != nil {

×

1320

                klog.Errorf("failed to parse %s to int", numStr)

×

1321

                return false

×

1322

×

1324

        var startOrdinal int64

×

1325

        if sts.Spec.Ordinals != nil {

×

1326

                startOrdinal = int64(sts.Spec.Ordinals.Start)

×

1327

×

1328

        if index >= startOrdinal+int64(*sts.Spec.Replicas) {

×

1329

                klog.Infof("statefulset %s/%s is down scaled", pod.Namespace, statefulSetName)

×

1330

                return true

×

1331

×

1332

        return false

×

1339

func isStatefulSetPodToGC(c kubernetes.Interface, pod *v1.Pod, statefulSetName string, statefulSetUID types.UID) bool {

×

1340

        sts, err := c.AppsV1().StatefulSets(pod.Namespace).Get(context.Background(), statefulSetName, metav1.GetOptions{})

×

1341

        if err != nil {

×

1342

                // the statefulset has been deleted

×

1343

                if k8serrors.IsNotFound(err) {

×

1344

                        klog.Infof("statefulset %s/%s has been deleted", pod.Namespace, statefulSetName)

×

1345

                        return true

×

1346

×

1347

                klog.Errorf("failed to get statefulset %s/%s: %v", pod.Namespace, statefulSetName, err)

×

1348

                return false

×

1352

        if !sts.DeletionTimestamp.IsZero() {

×

1353

                klog.Infof("statefulset %s/%s is being deleted", pod.Namespace, statefulSetName)

×

1354

                return true

×

1355

×

1357

        if sts.UID != statefulSetUID {

×

1358

                klog.Infof("statefulset %s/%s is a newly created one", pod.Namespace, statefulSetName)

×

1359

                return true

×

1360

×

1364

        tempStrs := strings.Split(pod.Name, "-")

×

1365

        numStr := tempStrs[len(tempStrs)-1]

×

1366

        index, err := strconv.ParseInt(numStr, 10, 0)

×

1367

        if err != nil {

×

1368

                klog.Errorf("failed to parse %s to int", numStr)

×

1369

                return false

×

1370

×

1372

        var startOrdinal int64

×

1373

        if sts.Spec.Ordinals != nil {

×

1374

                startOrdinal = int64(sts.Spec.Ordinals.Start)

×

1375

×

1376

        if index >= startOrdinal+int64(*sts.Spec.Replicas) {

×

1377

                klog.Infof("statefulset %s/%s is down scaled", pod.Namespace, statefulSetName)

×

1378

                if !isPodAlive(pod) {

×

1379

                        // we must check whether the pod is alive because we have to consider the following case:

×

1380

                        // 1. the statefulset is down scaled to zero

×

1381

                        // 2. the lsp gc is triggered

×

1382

                        // 3. gc interval, e.g. 90s, is passed and the second gc is triggered

×

1383

                        // 4. the sts is up scaled to the original replicas

×

1384

                        // 5. the pod is still running and it will not be recreated

×

1385

                        return true

×

1386

×

1389

        return false

×

1392

func getNodeTunlIP(node *v1.Node) ([]net.IP, error) {

×

1393

        var nodeTunlIPAddr []net.IP

×

1394

        nodeTunlIP := node.Annotations[util.IPAddressAnnotation]

×

1395

        if nodeTunlIP == "" {

×

1396

                return nil, errors.New("node has no tunnel ip annotation")

×

1397

×

1399

        for ip := range strings.SplitSeq(nodeTunlIP, ",") {

×

1400

                nodeTunlIPAddr = append(nodeTunlIPAddr, net.ParseIP(ip))

×

1401

×

1402

        return nodeTunlIPAddr, nil

×

1405

func getNextHopByTunnelIP(gw []net.IP) string {

×

1406

        // validation check by caller

×

1407

        nextHop := gw[0].String()

×

1408

        if len(gw) == 2 {

×

1409

                nextHop = gw[0].String() + "," + gw[1].String()

×

1410

×

1411

        return nextHop

×

1414

func needAllocateSubnets(pod *v1.Pod, nets []*kubeovnNet) []*kubeovnNet {

×

1415

        // check if allocate from subnet is need.

×

1416

        // allocate subnet when change subnet to hotplug nic

×

1417

        // allocate subnet when migrate vm

×

1418

        if !isPodAlive(pod) {

×

1419

                return nil

×

1420

×

1422

        if pod.Annotations == nil {

×

1423

                return nets

×

1424

×

1426

        migrate := false

×

1427

        if job, ok := pod.Annotations[util.MigrationJobAnnotation]; ok {

×

1428

                klog.Infof("pod %s/%s is in the migration job %s", pod.Namespace, pod.Name, job)

×

1429

                migrate = true

×

1430

×

1432

        result := make([]*kubeovnNet, 0, len(nets))

×

1433

        for _, n := range nets {

×

1434

                if migrate || pod.Annotations[fmt.Sprintf(util.AllocatedAnnotationTemplate, n.ProviderName)] != "true" {

×

1435

                        result = append(result, n)

×

1436

×

1438

        return result

×

1441

func needRestartNatGatewayPod(pod *v1.Pod) bool {

×

1442

        for _, psc := range pod.Status.ContainerStatuses {

×

1443

                if psc.Name != "vpc-nat-gw" {

×

1444

                        continue

×

1446

                if psc.RestartCount > 0 {

×

1447

                        return true

×

1448

×

1450

        return false

×

1453

func (c *Controller) podNeedSync(pod *v1.Pod) (bool, error) {

×

1454

        // 1. check annotations

×

1455

        if pod.Annotations == nil {

×

1456

                return true, nil

×

1457

×

1459

        if pod.Annotations[util.RoutedAnnotation] != "true" {

×

1460

                return true, nil

×

1461

×

1463

        attachmentNets, err := c.getPodAttachmentNet(pod)

×

1464

        if err != nil {

×

1465

                klog.Error(err)

×

1466

                return false, err

×

1467

×

1468

        for _, n := range attachmentNets {

×

1469

                if pod.Annotations[fmt.Sprintf(util.RoutedAnnotationTemplate, n.ProviderName)] != "true" {

×

1470

                        return true, nil

×

1471

×

1472

                ipName := ovs.PodNameToPortName(pod.Name, pod.Namespace, n.ProviderName)

×

1473

                if _, err = c.ipsLister.Get(ipName); err != nil {

×

1474

                        err = fmt.Errorf("pod has no ip %s: %w", ipName, err)

×

1475

                        // need to sync to create ip

×

1476

                        klog.Error(err)

×

1477

                        return true, nil

×

1478

×

1480

        return false, nil

×

1483

func needRouteSubnets(pod *v1.Pod, nets []*kubeovnNet) []*kubeovnNet {

×

1484

        if !isPodAlive(pod) {

×

1485

                return nil

×

1486

×

1488

        if pod.Annotations == nil {

×

1489

                return nets

×

1490

×

1492

        result := make([]*kubeovnNet, 0, len(nets))

×

1493

        for _, n := range nets {

×

1494

                if !isOvnSubnet(n.Subnet) {

×

1495

                        continue

×

1498

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

×

1499

                        if pod.Annotations[fmt.Sprintf(util.RoutedAnnotationTemplate, n.ProviderName)] != "true" {

×

1500

                                result = append(result, n)

×

1501

×

1504

        return result

×

1507

func (c *Controller) getPodDefaultSubnet(pod *v1.Pod) (*kubeovnv1.Subnet, error) {

×

1508

        // check pod annotations

×

1509

        if lsName := pod.Annotations[util.LogicalSwitchAnnotation]; lsName != "" {

×

1510

                subnet, err := c.subnetsLister.Get(lsName)

×

1511

                if err != nil {

×

1512

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

×

1513

                        return nil, err

×

1514

×

1515

                return subnet, nil

×

1518

        ns, err := c.namespacesLister.Get(pod.Namespace)

×

1519

        if err != nil {

×

1520

                klog.Errorf("failed to get namespace %s: %v", pod.Namespace, err)

×

1521

                return nil, err

×

1522

×

1523

        if len(ns.Annotations) == 0 {

×

1524

                err = fmt.Errorf("namespace %s network annotations is empty", ns.Name)

×

1525

                klog.Error(err)

×

1526

                return nil, err

×

1527

×

1529

        subnetNames := ns.Annotations[util.LogicalSwitchAnnotation]

×

1530

        for subnetName := range strings.SplitSeq(subnetNames, ",") {

×

1531

                if subnetName == "" {

×

1532

                        err = fmt.Errorf("namespace %s default logical switch is not found", ns.Name)

×

1533

                        klog.Error(err)

×

1534

                        return nil, err

×

1535

×

1536

                subnet, err := c.subnetsLister.Get(subnetName)

×

1537

                if err != nil {

×

1538

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

×

1539

                        return nil, err

×

1540

×

1542

                switch subnet.Spec.Protocol {

×

1543

                case kubeovnv1.ProtocolDual:

×

1544

                        if subnet.Status.V6AvailableIPs == 0 {

×

1545

                                klog.Infof("there's no available ipv6 address in subnet %s, try next one", subnet.Name)

×

1546

                                continue

×

1548

                        fallthrough

×

1549

                case kubeovnv1.ProtocolIPv4:

×

1550

                        if subnet.Status.V4AvailableIPs == 0 {

×

1551

                                klog.Infof("there's no available ipv4 address in subnet %s, try next one", subnet.Name)

×

1552

                                continue

×

1554

                case kubeovnv1.ProtocolIPv6:

×

1555

                        if subnet.Status.V6AvailableIPs == 0 {

×

1556

                                klog.Infof("there's no available ipv6 address in subnet %s, try next one", subnet.Name)

×

1557

                                continue

×

1560

                return subnet, nil

×

1562

        return nil, ipam.ErrNoAvailable

×

1565

func loadNetConf(bytes []byte) (*multustypes.DelegateNetConf, error) {

×

1566

        delegateConf := &multustypes.DelegateNetConf{}

×

1567

        if err := json.Unmarshal(bytes, &delegateConf.Conf); err != nil {

×

1568

                return nil, logging.Errorf("LoadDelegateNetConf: error unmarshalling delegate config: %v", err)

×

1569

×

1571

        if delegateConf.Conf.Type == "" {

×

1572

                if err := multustypes.LoadDelegateNetConfList(bytes, delegateConf); err != nil {

×

1573

                        return nil, logging.Errorf("LoadDelegateNetConf: failed with: %v", err)

×

1574

×

1576

        return delegateConf, nil

×

1596

func (c *Controller) getPodAttachmentNet(pod *v1.Pod) ([]*kubeovnNet, error) {

×

1597

        var multusNets []*nadv1.NetworkSelectionElement

×

1598

        defaultAttachNetworks := pod.Annotations[util.DefaultNetworkAnnotation]

×

1599

        if defaultAttachNetworks != "" {

×

1600

                attachments, err := nadutils.ParseNetworkAnnotation(defaultAttachNetworks, pod.Namespace)

×

1601

                if err != nil {

×

1602

                        klog.Errorf("failed to parse default attach net for pod '%s', %v", pod.Name, err)

×

1603

                        return nil, err

×

1604

×

1605

                multusNets = attachments

×

1608

        attachNetworks := pod.Annotations[nadv1.NetworkAttachmentAnnot]

×

1609

        if attachNetworks != "" {

×

1610

                attachments, err := nadutils.ParseNetworkAnnotation(attachNetworks, pod.Namespace)

×

1611

                if err != nil {

×

1612

                        klog.Errorf("failed to parse attach net for pod '%s', %v", pod.Name, err)

×

1613

                        return nil, err

×

1614

×

1615

                multusNets = append(multusNets, attachments...)

×

1617

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

×

1618

        if err != nil {

×

1619

                return nil, err

×

1620

×

1622

        result := make([]*kubeovnNet, 0, len(multusNets))

×

1623

        for _, attach := range multusNets {

×

1624

                networkClient := c.config.AttachNetClient.K8sCniCncfIoV1().NetworkAttachmentDefinitions(attach.Namespace)

×

1625

                network, err := networkClient.Get(context.Background(), attach.Name, metav1.GetOptions{})

×

1626

                if err != nil {

×

1627

                        klog.Errorf("failed to get net-attach-def %s, %v", attach.Name, err)

×

1628

                        return nil, err

×

1629

×

1631

                netCfg, err := loadNetConf([]byte(network.Spec.Config))

×

1632

                if err != nil {

×

1633

                        klog.Errorf("failed to load config of net-attach-def %s, %v", attach.Name, err)

×

1634

                        return nil, err

×

1635

×

1638

                var providerName string

×

1639

                if util.IsOvnNetwork(netCfg) {

×

1640

                        allowLiveMigration := false

×

1641

                        isDefault := util.IsDefaultNet(pod.Annotations[util.DefaultNetworkAnnotation], attach)

×

1642

×

1643

                        providerName = fmt.Sprintf("%s.%s.%s", attach.Name, attach.Namespace, util.OvnProvider)

×

1644

                        if pod.Annotations[util.MigrationJobAnnotation] != "" {

×

1645

                                allowLiveMigration = true

×

1646

×

1648

                        subnetName := pod.Annotations[fmt.Sprintf(util.LogicalSwitchAnnotationTemplate, providerName)]

×

1649

                        if subnetName == "" {

×

1650

                                for _, subnet := range subnets {

×

1651

                                        if subnet.Spec.Provider == providerName {

×

1652

                                                subnetName = subnet.Name

×

1653

                                                break

×

1657

                        var subnet *kubeovnv1.Subnet

×

1658

                        if subnetName == "" {

×

1659

                                subnet, err = c.getPodDefaultSubnet(pod)

×

1660

                                if err != nil {

×

1661

                                        klog.Errorf("failed to pod default subnet, %v", err)

×

1662

                                        return nil, err

×

1663

×

1664

                        } else {

×

1665

                                subnet, err = c.subnetsLister.Get(subnetName)

×

1666

                                if err != nil {

×

1667

                                        klog.Errorf("failed to get subnet %s, %v", subnetName, err)

×

1668

                                        return nil, err

×

1669

×

1672

                        ret := &kubeovnNet{

×

1673

                                Type:               providerTypeOriginal,

×

1674

                                ProviderName:       providerName,

×

1675

                                Subnet:             subnet,

×

1676

                                IsDefault:          isDefault,

×

1677

                                AllowLiveMigration: allowLiveMigration,

×

1678

                                MacRequest:         attach.MacRequest,

×

1679

                                IPRequest:          strings.Join(attach.IPRequest, ","),

×

1680

×

1681

                        result = append(result, ret)

×

1682

                } else {

×

1683

                        providerName = fmt.Sprintf("%s.%s", attach.Name, attach.Namespace)

×

1684

                        for _, subnet := range subnets {

×

1685

                                if subnet.Spec.Provider == providerName {

×

1686

                                        result = append(result, &kubeovnNet{

×

1687

                                                Type:         providerTypeIPAM,

×

1688

                                                ProviderName: providerName,

×

1689

                                                Subnet:       subnet,

×

1690

                                                MacRequest:   attach.MacRequest,

×

1691

                                                IPRequest:    strings.Join(attach.IPRequest, ","),

×

1692

})

×

1693

                                        break

×

1698

        return result, nil

×

1701

func (c *Controller) validatePodIP(podName, subnetName, ipv4, ipv6 string) (bool, bool, error) {

×

1702

        subnet, err := c.subnetsLister.Get(subnetName)

×

1703

        if err != nil {

×

1704

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

×

1705

                return false, false, err

×

1706

×

1708

        if subnet.Spec.Vlan == "" && subnet.Spec.Vpc == c.config.ClusterRouter {

×

1709

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

×

1710

                if err != nil {

×

1711

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

×

1712

                        return false, false, err

×

1713

×

1715

                for _, node := range nodes {

×

1716

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

×

1717

                        if ipv4 != "" && ipv4 == nodeIPv4 {

×

1718

                                klog.Errorf("IP address (%s) assigned to pod %s is the same with internal IP address of node %s, reallocating...", ipv4, podName, node.Name)

×

1719

                                return false, true, nil

×

1720

×

1721

                        if ipv6 != "" && ipv6 == nodeIPv6 {

×

1722

                                klog.Errorf("IP address (%s) assigned to pod %s is the same with internal IP address of node %s, reallocating...", ipv6, podName, node.Name)

×

1723

                                return true, false, nil

×

1724

×

1728

        return true, true, nil

×

1731

func (c *Controller) acquireAddress(pod *v1.Pod, podNet *kubeovnNet) (string, string, string, *kubeovnv1.Subnet, error) {

×

1732

        podName := c.getNameByPod(pod)

×

1733

        key := fmt.Sprintf("%s/%s", pod.Namespace, podName)

×

1734

×

1735

        var checkVMPod bool

×

1736

        isStsPod, _, _ := isStatefulSetPod(pod)

×

1737

        // if pod has static vip

×

1738

        vipName := pod.Annotations[util.VipAnnotation]

×

1739

        if vipName != "" {

×

1740

                vip, err := c.virtualIpsLister.Get(vipName)

×

1741

                if err != nil {

×

1742

                        klog.Errorf("failed to get static vip '%s', %v", vipName, err)

×

1743

                        return "", "", "", podNet.Subnet, err

×

1744

×

1745

                portName := ovs.PodNameToPortName(podName, pod.Namespace, podNet.ProviderName)

×

1746

                if c.config.EnableKeepVMIP {

×

1747

                        checkVMPod, _ = isVMPod(pod)

×

1748

×

1749

                if err = c.podReuseVip(vipName, portName, isStsPod || checkVMPod); err != nil {

×

1750

                        return "", "", "", podNet.Subnet, err

×

1751

×

1752

                return vip.Status.V4ip, vip.Status.V6ip, vip.Status.Mac, podNet.Subnet, nil

×

1755

        var macPointer *string

×

1756

        if isOvnSubnet(podNet.Subnet) {

×

1757

                annoMAC := pod.Annotations[fmt.Sprintf(util.MacAddressAnnotationTemplate, podNet.ProviderName)]

×

1758

                if annoMAC != "" {

×

1759

                        if _, err := net.ParseMAC(annoMAC); err != nil {

×

1760

                                return "", "", "", podNet.Subnet, err

×

1761

×

1762

                        macPointer = &annoMAC

×

1764

        } else {

×

1765

                macPointer = ptr.To("")

×

1766

×

1768

        ippoolStr := pod.Annotations[fmt.Sprintf(util.IPPoolAnnotationTemplate, podNet.ProviderName)]

×

1769

        if ippoolStr == "" {

×

1770

                ns, err := c.namespacesLister.Get(pod.Namespace)

×

1771

                if err != nil {

×

1772

                        klog.Errorf("failed to get namespace %s: %v", pod.Namespace, err)

×

1773

                        return "", "", "", podNet.Subnet, err

×

1774

×

1776

                if len(ns.Annotations) != 0 {

×

1777

                        if ipPoolList, ok := ns.Annotations[util.IPPoolAnnotation]; ok {

×

1778

                                for ipPoolName := range strings.SplitSeq(ipPoolList, ",") {

×

1779

                                        ippool, err := c.ippoolLister.Get(ipPoolName)

×

1780

                                        if err != nil {

×

1781

                                                klog.Errorf("failed to get ippool %s: %v", ipPoolName, err)

×

1782

                                                return "", "", "", podNet.Subnet, err

×

1783

×

1785

                                        switch podNet.Subnet.Spec.Protocol {

×

1786

                                        case kubeovnv1.ProtocolDual:

×

1787

                                                if ippool.Status.V4AvailableIPs.Int64() == 0 || ippool.Status.V6AvailableIPs.Int64() == 0 {

×

1788

                                                        continue

×

1790

                                        case kubeovnv1.ProtocolIPv4:

×

1791

                                                if ippool.Status.V4AvailableIPs.Int64() == 0 {

×

1792

                                                        continue

×

1795

                                        default:

×

1796

                                                if ippool.Status.V6AvailableIPs.Int64() == 0 {

×

1797

                                                        continue

×

1801

                                        if ippool.Spec.Subnet == podNet.Subnet.Name {

×

1802

                                                ippoolStr = ippool.Name

×

1803

                                                break

×

1811

        if pod.Annotations[fmt.Sprintf(util.IPAddressAnnotationTemplate, podNet.ProviderName)] == "" &&

×

1812

                ippoolStr == "" {

×

1813

                var skippedAddrs []string

×

1814

                for {

×

1815

                        portName := ovs.PodNameToPortName(podName, pod.Namespace, podNet.ProviderName)

×

1816

×

1817

                        ipv4, ipv6, mac, err := c.ipam.GetRandomAddress(key, portName, macPointer, podNet.Subnet.Name, "", skippedAddrs, !podNet.AllowLiveMigration)

×

1818

                        if err != nil {

×

1819

                                klog.Error(err)

×

1820

                                return "", "", "", podNet.Subnet, err

×

1821

×

1822

                        ipv4OK, ipv6OK, err := c.validatePodIP(pod.Name, podNet.Subnet.Name, ipv4, ipv6)

×

1823

                        if err != nil {

×

1824

                                klog.Error(err)

×

1825

                                return "", "", "", podNet.Subnet, err

×

1826

×

1827

                        if ipv4OK && ipv6OK {

×

1828

                                return ipv4, ipv6, mac, podNet.Subnet, nil

×

1829

×

1831

                        if !ipv4OK {

×

1832

                                skippedAddrs = append(skippedAddrs, ipv4)

×

1833

×

1834

                        if !ipv6OK {

×

1835

                                skippedAddrs = append(skippedAddrs, ipv6)

×

1836

×

1840

        portName := ovs.PodNameToPortName(podName, pod.Namespace, podNet.ProviderName)

×

1841

×

1842

        // The static ip can be assigned from any subnet after ns supports multi subnets

×

1843

        nsNets, _ := c.getNsAvailableSubnets(pod, podNet)

×

1844

        var v4IP, v6IP, mac string

×

1845

        var err error

×

1846

×

1847

        // Static allocate

×

1848

        if pod.Annotations[fmt.Sprintf(util.IPAddressAnnotationTemplate, podNet.ProviderName)] != "" {

×

1849

                ipStr := pod.Annotations[fmt.Sprintf(util.IPAddressAnnotationTemplate, podNet.ProviderName)]

×

1850

×

1851

                for _, net := range nsNets {

×

1852

                        v4IP, v6IP, mac, err = c.acquireStaticAddress(key, portName, ipStr, macPointer, net.Subnet.Name, net.AllowLiveMigration)

×

1853

                        if err == nil {

×

1854

                                return v4IP, v6IP, mac, net.Subnet, nil

×

1855

×

1857

                return v4IP, v6IP, mac, podNet.Subnet, err

×

1861

        if ippoolStr != "" {

×

1862

                var ipPool []string

×

1863

                if strings.ContainsRune(ippoolStr, ';') {

×

1864

                        ipPool = strings.Split(ippoolStr, ";")

×

1865

                } else {

×

1866

                        ipPool = strings.Split(ippoolStr, ",")

×

1867

                        if len(ipPool) == 2 && util.CheckProtocol(ipPool[0]) != util.CheckProtocol(ipPool[1]) {

×

1868

                                ipPool = []string{ippoolStr}

×

1869

×

1871

                for i, ip := range ipPool {

×

1872

                        ipPool[i] = strings.TrimSpace(ip)

×

1873

×

1875

                if len(ipPool) == 1 && (!strings.ContainsRune(ipPool[0], ',') && net.ParseIP(ipPool[0]) == nil) {

×

1876

                        var skippedAddrs []string

×

1877

                        for {

×

1878

                                portName := ovs.PodNameToPortName(podName, pod.Namespace, podNet.ProviderName)

×

1879

                                ipv4, ipv6, mac, err := c.ipam.GetRandomAddress(key, portName, macPointer, podNet.Subnet.Name, ipPool[0], skippedAddrs, !podNet.AllowLiveMigration)

×

1880

                                if err != nil {

×

1881

                                        klog.Error(err)

×

1882

                                        return "", "", "", podNet.Subnet, err

×

1883

×

1884

                                ipv4OK, ipv6OK, err := c.validatePodIP(pod.Name, podNet.Subnet.Name, ipv4, ipv6)

×

1885

                                if err != nil {

×

1886

                                        klog.Error(err)

×

1887

                                        return "", "", "", podNet.Subnet, err

×

1888

×

1889

                                if ipv4OK && ipv6OK {

×

1890

                                        return ipv4, ipv6, mac, podNet.Subnet, nil

×

1891

×

1893

                                if !ipv4OK {

×

1894

                                        skippedAddrs = append(skippedAddrs, ipv4)

×

1895

×

1896

                                if !ipv6OK {

×

1897

                                        skippedAddrs = append(skippedAddrs, ipv6)

×

1898

×

1902

                if !isStsPod {

×

1903

                        for _, net := range nsNets {

×

1904

                                for _, staticIP := range ipPool {

×

1905

                                        var checkIP string

×

1906

                                        ipProtocol := util.CheckProtocol(staticIP)

×

1907

                                        if ipProtocol == kubeovnv1.ProtocolDual {

×

1908

                                                checkIP = strings.Split(staticIP, ",")[0]

×

1909

                                        } else {

×

1910

                                                checkIP = staticIP

×

1911

×

1913

                                        if assignedPod, ok := c.ipam.IsIPAssignedToOtherPod(checkIP, net.Subnet.Name, key); ok {

×

1914

                                                klog.Errorf("static address %s for %s has been assigned to %s", staticIP, key, assignedPod)

×

1915

                                                continue

×

1918

                                        v4IP, v6IP, mac, err = c.acquireStaticAddress(key, portName, staticIP, macPointer, net.Subnet.Name, net.AllowLiveMigration)

×

1919

                                        if err == nil {

×

1920

                                                return v4IP, v6IP, mac, net.Subnet, nil

×

1921

×

1924

                        klog.Errorf("acquire address from ippool %s for %s failed, %v", ippoolStr, key, err)

×

1925

                } else {

×

1926

                        tempStrs := strings.Split(pod.Name, "-")

×

1927

                        numStr := tempStrs[len(tempStrs)-1]

×

1928

                        index, _ := strconv.Atoi(numStr)

×

1929

×

1930

                        if index < len(ipPool) {

×

1931

                                for _, net := range nsNets {

×

1932

                                        v4IP, v6IP, mac, err = c.acquireStaticAddress(key, portName, ipPool[index], macPointer, net.Subnet.Name, net.AllowLiveMigration)

×

1933

                                        if err == nil {

×

1934

                                                return v4IP, v6IP, mac, net.Subnet, nil

×

1935

×

1937

                                klog.Errorf("acquire address %s for %s failed, %v", ipPool[index], key, err)

×

1941

        klog.Errorf("allocate address for %s failed, return NoAvailableAddress", key)

×

1942

        return "", "", "", podNet.Subnet, ipam.ErrNoAvailable

×

1945

func (c *Controller) acquireStaticAddress(key, nicName, ip string, mac *string, subnet string, liveMigration bool) (string, string, string, error) {

×

1946

        var v4IP, v6IP, macStr string

×

1947

        var err error

×

1948

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

×

1949

                if net.ParseIP(ipStr) == nil {

×

1950

                        return "", "", "", fmt.Errorf("failed to parse IP %s", ipStr)

×

1951

×

1954

        if v4IP, v6IP, macStr, err = c.ipam.GetStaticAddress(key, nicName, ip, mac, subnet, !liveMigration); err != nil {

×

1955

                klog.Errorf("failed to get static ip %v, mac %v, subnet %v, err %v", ip, mac, subnet, err)

×

1956

                return "", "", "", err

×

1957

×

1958

        return v4IP, v6IP, macStr, nil

×

1961

func appendCheckPodToDel(c *Controller, pod *v1.Pod, ownerRefName, ownerRefKind string) (bool, error) {

×

1962

        // subnet for ns has been changed, and statefulset pod's ip is not in the range of subnet's cidr anymore

×

1963

        podNs, err := c.namespacesLister.Get(pod.Namespace)

×

1964

        if err != nil {

×

1965

                klog.Errorf("failed to get namespace %s, %v", pod.Namespace, err)

×

1966

                return false, err

×

1967

×

1970

        var ownerRefSubnetExist bool

×

1971

        var ownerRefSubnet string

×

1972

        switch ownerRefKind {

×

1973

        case util.StatefulSet:

×

1974

                ss, err := c.config.KubeClient.AppsV1().StatefulSets(pod.Namespace).Get(context.Background(), ownerRefName, metav1.GetOptions{})

×

1975

                if err != nil {

×

1976

                        if k8serrors.IsNotFound(err) {

×

1977

                                klog.Infof("Statefulset %s is not found", ownerRefName)

×

1978

                                return true, nil

×

1979

×

1980

                        klog.Errorf("failed to get StatefulSet %s, %v", ownerRefName, err)

×

1982

                if ss.Spec.Template.Annotations[util.LogicalSwitchAnnotation] != "" {

×

1983

                        ownerRefSubnetExist = true

×

1984

                        ownerRefSubnet = ss.Spec.Template.Annotations[util.LogicalSwitchAnnotation]

×

1985

×

1987

        case util.VMInstance:

×

1988

                vm, err := c.config.KubevirtClient.VirtualMachine(pod.Namespace).Get(context.Background(), ownerRefName, metav1.GetOptions{})

×

1989

                if err != nil {

×

1990

                        if k8serrors.IsNotFound(err) {

×

1991

                                klog.Infof("VirtualMachine %s is not found", ownerRefName)

×

1992

                                return true, nil

×

1993

×

1994

                        klog.Errorf("failed to get VirtualMachine %s, %v", ownerRefName, err)

×

1996

                if vm != nil &&

×

1997

                        vm.Spec.Template != nil &&

×

1998

                        vm.Spec.Template.ObjectMeta.Annotations != nil &&

×

1999

                        vm.Spec.Template.ObjectMeta.Annotations[util.LogicalSwitchAnnotation] != "" {

×

2000

                        ownerRefSubnetExist = true

×

2001

                        ownerRefSubnet = vm.Spec.Template.ObjectMeta.Annotations[util.LogicalSwitchAnnotation]

×

2002

×

2004

        podSwitch := strings.TrimSpace(pod.Annotations[util.LogicalSwitchAnnotation])

×

2005

        if !ownerRefSubnetExist {

×

2006

                nsSubnetNames := podNs.Annotations[util.LogicalSwitchAnnotation]

×

2007

                // check if pod use the subnet of its ns

×

2008

                if nsSubnetNames != "" && podSwitch != "" && !slices.Contains(strings.Split(nsSubnetNames, ","), podSwitch) {

×

2009

                        klog.Infof("ns %s annotation subnet is %s, which is inconstant with subnet for pod %s, delete pod", pod.Namespace, nsSubnetNames, pod.Name)

×

2010

                        return true, nil

×

2011

×

2015

        podSubnet, err := c.subnetsLister.Get(podSwitch)

×

2016

        if err != nil {

×

2017

                klog.Errorf("failed to get subnet %s, %v, not auto clean ip", podSwitch, err)

×

2018

                return false, err

×

2019

×

2020

        if podSubnet == nil {

×

2021

                // TODO: remove: CRD get interface will retrun a nil subnet ?

×

2022

                klog.Errorf("pod %s/%s subnet %s is nil, not auto clean ip", pod.Namespace, pod.Name, podSwitch)

×

2023

                return false, nil

×

2024

×

2025

        podIP := pod.Annotations[util.IPAddressAnnotation]

×

2026

        if podIP == "" {

×

2027

                // delete pod just after it created < 1ms

×

2028

                klog.Infof("pod %s/%s annotaions has no ip address, not auto clean ip", pod.Namespace, pod.Name)

×

2029

                return false, nil

×

2030

×

2031

        podSubnetCidr := podSubnet.Spec.CIDRBlock

×

2032

        if podSubnetCidr != "" {

×

2033

                // subnet spec cidr changed by user

×

2034

                klog.Errorf("invalid pod subnet %s empty cidr %s, not auto clean ip", podSwitch, podSubnetCidr)

×

2035

                return false, nil

×

2036

×

2037

        if !util.CIDRContainIP(podSubnetCidr, podIP) {

×

2038

                klog.Infof("pod's ip %s is not in the range of subnet %s, delete pod", pod.Annotations[util.IPAddressAnnotation], podSubnet.Name)

×

2039

                return true, nil

×

2040

×

2042

        if ownerRefSubnet != "" && podSubnet.Name != ownerRefSubnet {

×

2043

                klog.Infof("Subnet of owner %s has been changed from %s to %s, delete pod %s/%s", ownerRefName, podSubnet.Name, ownerRefSubnet, pod.Namespace, pod.Name)

×

2044

                return true, nil

×

2045

×

2047

        return false, nil

×

2050

func isVMPod(pod *v1.Pod) (bool, string) {

×

2051

        for _, owner := range pod.OwnerReferences {

×

2052

                // The name of vmi is consistent with vm's name.

×

2053

                if owner.Kind == util.VMInstance && strings.HasPrefix(owner.APIVersion, "kubevirt.io") {

×

2054

                        return true, owner.Name

×

2055

×

2057

        return false, ""

×

2060

func isOwnsByTheVM(vmi metav1.Object) (bool, string) {

×

2061

        for _, owner := range vmi.GetOwnerReferences() {

×

2062

                if owner.Kind == util.VM && strings.HasPrefix(owner.APIVersion, "kubevirt.io") {

×

2063

                        return true, owner.Name

×

2064

×

2066

        return false, ""

×

2069

func (c *Controller) isVMToDel(pod *v1.Pod, vmiName string) bool {

×

2070

        var (

×

2071

                vmiAlive bool

×

2072

                vmName   string

×

2073

×

2074

        // The vmi is also deleted when pod is deleted, only left vm exists.

×

2075

        vmi, err := c.config.KubevirtClient.VirtualMachineInstance(pod.Namespace).Get(context.Background(), vmiName, metav1.GetOptions{})

×

2076

        if err != nil {

×

2077

                if k8serrors.IsNotFound(err) {

×

2078

                        vmiAlive = false

×

2079

                        // The name of vmi is consistent with vm's name.

×

2080

                        vmName = vmiName

×

2081

                        klog.ErrorS(err, "failed to get vmi, will try to get the vm directly", "name", vmiName)

×

2082

                } else {

×

2083

                        klog.ErrorS(err, "failed to get vmi", "name", vmiName)

×

2084

                        return false

×

2085

×

2086

        } else {

×

2087

                var ownsByVM bool

×

2088

                ownsByVM, vmName = isOwnsByTheVM(vmi)

×

2089

                if !ownsByVM && !vmi.DeletionTimestamp.IsZero() {

×

2090

                        klog.Infof("ephemeral vmi %s is deleting", vmiName)

×

2091

                        return true

×

2092

×

2093

                vmiAlive = vmi.DeletionTimestamp.IsZero()

×

2096

        if vmiAlive {

×

2097

                return false

×

2098

×

2100

        vm, err := c.config.KubevirtClient.VirtualMachine(pod.Namespace).Get(context.Background(), vmName, metav1.GetOptions{})

×

2101

        if err != nil {

×

2102

                // the vm has gone

×

2103

                if k8serrors.IsNotFound(err) {

×

2104

                        klog.ErrorS(err, "failed to get vm", "name", vmName)

×

2105

                        return true

×

2106

×

2107

                klog.ErrorS(err, "failed to get vm", "name", vmName)

×

2108

                return false

×

2111

        if !vm.DeletionTimestamp.IsZero() {

×

2112

                klog.Infof("vm %s is deleting", vmName)

×

2113

                return true

×

2114

×

2115

        return false

×

2118

func (c *Controller) getNameByPod(pod *v1.Pod) string {

×

2119

        if c.config.EnableKeepVMIP {

×

2120

                if isVMPod, vmName := isVMPod(pod); isVMPod {

×

2121

                        return vmName

×

2122

×

2124

        return pod.Name

×

2128

func (c *Controller) getNsAvailableSubnets(pod *v1.Pod, podNet *kubeovnNet) ([]*kubeovnNet, error) {

×

2129

        var result []*kubeovnNet

×

2130

        // keep the annotation subnet of the pod in first position

×

2131

        result = append(result, podNet)

×

2132

×

2133

        ns, err := c.namespacesLister.Get(pod.Namespace)

×

2134

        if err != nil {

×

2135

                klog.Errorf("failed to get namespace %s, %v", pod.Namespace, err)

×

2136

                return nil, err

×

2137

×

2138

        if ns.Annotations == nil {

×

2139

                return nil, nil

×

2140

×

2142

        subnetNames := ns.Annotations[util.LogicalSwitchAnnotation]

×

2143

        for subnetName := range strings.SplitSeq(subnetNames, ",") {

×

2144

                if subnetName == "" || subnetName == podNet.Subnet.Name {

×

2145

                        continue

×

2147

                subnet, err := c.subnetsLister.Get(subnetName)

×

2148

                if err != nil {

×

2149

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

×

2150

                        return nil, err

×

2151

×

2153

                result = append(result, &kubeovnNet{

×

2154

                        Type:         providerTypeOriginal,

×

2155

                        ProviderName: subnet.Spec.Provider,

×

2156

                        Subnet:       subnet,

×

2157

})

×

2160

        return result, nil

×

2163

func getPodType(pod *v1.Pod) string {

×

2164

        if ok, _, _ := isStatefulSetPod(pod); ok {

×

2165

                return util.StatefulSet

×

2166

×

2168

        if isVMPod, _ := isVMPod(pod); isVMPod {

×

2169

                return util.VM

×

2170

×

2171

        return ""

×

2174

func (c *Controller) getVirtualIPs(pod *v1.Pod, podNets []*kubeovnNet) map[string]string {

×

2175

        vipsListMap := make(map[string][]string)

×

2176

        var vipNamesList []string

×

2177

        for vipName := range strings.SplitSeq(strings.TrimSpace(pod.Annotations[util.AAPsAnnotation]), ",") {

×

2178

                if vipName = strings.TrimSpace(vipName); vipName == "" {

×

2179

                        continue

×

2181

                if !slices.Contains(vipNamesList, vipName) {

×

2182

                        vipNamesList = append(vipNamesList, vipName)

×

2183

                } else {

×

2184

                        continue

×

2186

                vip, err := c.virtualIpsLister.Get(vipName)

×

2187

                if err != nil {

×

2188

                        klog.Errorf("failed to get vip %s, %v", vipName, err)

×

2189

                        continue

×

2191

                if vip.Spec.Namespace != pod.Namespace || (vip.Status.V4ip == "" && vip.Status.V6ip == "") {

×

2192

                        continue

×

2194

                for _, podNet := range podNets {

×

2195

                        if podNet.Subnet.Name == vip.Spec.Subnet {

×

2196

                                key := fmt.Sprintf("%s.%s", podNet.Subnet.Name, podNet.ProviderName)

×

2197

                                vipsList := vipsListMap[key]

×

2198

                                if vipsList == nil {

×

2199

                                        vipsList = []string{}

×

2200

×

2202

                                if util.IsValidIP(vip.Status.V4ip) {

×

2203

                                        vipsList = append(vipsList, vip.Status.V4ip)

×

2204

×

2205

                                if util.IsValidIP(vip.Status.V6ip) {

×

2206

                                        vipsList = append(vipsList, vip.Status.V6ip)

×

2207

×

2209

                                vipsListMap[key] = vipsList

×

2214

        for _, podNet := range podNets {

×

2215

                vipStr := pod.Annotations[fmt.Sprintf(util.PortVipAnnotationTemplate, podNet.ProviderName)]

×

2216

                if vipStr == "" {

×

2217

                        continue

×

2219

                key := fmt.Sprintf("%s.%s", podNet.Subnet.Name, podNet.ProviderName)

×

2220

                vipsList := vipsListMap[key]

×

2221

                if vipsList == nil {

×

2222

                        vipsList = []string{}

×

2223

×

2225

                for vip := range strings.SplitSeq(vipStr, ",") {

×

2226

                        if util.IsValidIP(vip) && !slices.Contains(vipsList, vip) {

×

2227

                                vipsList = append(vipsList, vip)

×

2228

×

2231

                vipsListMap[key] = vipsList

×

2234

        vipsMap := make(map[string]string)

×

2235

        for key, vipsList := range vipsListMap {

×

2236

                vipsMap[key] = strings.Join(vipsList, ",")

×

2237

×

2238

        return vipsMap

×

2241

func setPodRoutesAnnotation(annotations map[string]string, provider string, routes []request.Route) error {

×

2242

        key := fmt.Sprintf(util.RoutesAnnotationTemplate, provider)

×

2243

        if len(routes) == 0 {

×

2244

                delete(annotations, key)

×

2245

                return nil

×

2246

×

2248

        buf, err := json.Marshal(routes)

×

2249

        if err != nil {

×

2250

                err = fmt.Errorf("failed to marshal routes %+v: %w", routes, err)

×

2251

                klog.Error(err)

×

2252

                return err

×

2253

×

2254

        annotations[key] = string(buf)

×

2255

×

2256

        return nil

×

kubeovn / kube-ovn / 15200557698

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

kubeovn / kube-ovn / 15200557698

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