func()

in pkg/pool/pool.go [327:384]

• 49 lines of code
• 14 McCabe index (conditional complexity)

func (p *pool) UpdatePool(job *worker.WarmPoolJob, didSucceed bool, prefixAvailable bool) (shouldReconcile bool) {
	p.lock.Lock()
	defer p.lock.Unlock()

	log := p.log.WithValues("operation", job.Operations)

	if !didSucceed {
		// If the job fails, re-sync the state of the Pool with upstream
		p.reSyncRequired = true
		shouldReconcile = true
		log.Error(fmt.Errorf("warm pool job failed: %v", job), "operation failed")
	}

	if p.isPDPool {
		p.prefixAvailable = prefixAvailable
		if !p.prefixAvailable {
			log.Error(fmt.Errorf("warm pool job failed: %v", job), "prefix is not available in subnet")
		}
	}

	if job.Resources != nil && len(job.Resources) > 0 {
		// Add the resources to the warm pool
		for _, resourceGroup := range job.Resources {
			var resources []Resource
			resourceIDs := []string{resourceGroup}
			if p.isPDPool {
				var err error
				if resourceIDs, err = utils.DeconstructIPsFromPrefix(resourceGroup); err != nil {
					log.Error(err, "failed to deconstruct prefix into valid IPs", "prefix", resourceGroup)
				}
			}
			for _, resourceID := range resourceIDs {
				resources = append(resources, Resource{resourceGroup, resourceID})
			}
			p.warmResources[resourceGroup] = append(p.warmResources[resourceGroup], resources...)
		}
		log.Info("added resource to the warm pool", "resources", job.Resources)
	}

	if job.Operations == worker.OperationCreate {
		if p.isPDPool {
			p.pendingCreate -= job.ResourceCount * NumIPv4AddrPerPrefix
		} else {
			p.pendingCreate -= job.ResourceCount
		}
	} else if job.Operations == worker.OperationDeleted {
		if p.isPDPool {
			p.pendingDelete -= job.ResourceCount * NumIPv4AddrPerPrefix
		} else {
			p.pendingDelete -= job.ResourceCount
		}
	}

	log.V(1).Info("processed job response", "job", job, "pending create",
		p.pendingCreate, "pending delete", p.pendingDelete)

	return shouldReconcile
}