func()

in pkg/pool/pool.go [133:232]

• 80 lines of code
• 24 McCabe index (conditional complexity)

func (p *pool) ReSync(upstreamResourceGroupIDs []string) {
	p.lock.Lock()
	defer p.lock.Unlock()

	// This is possible if two Re-Syn were requested at same time
	if !p.reSyncRequired {
		p.log.Info("duplicate re-sync request, will be ignored")
		return
	}
	p.reSyncRequired = false

	// Convert list of upstream resource group ids into a list of Resource
	var upstreamResource []Resource
	for _, resourceGroupID := range upstreamResourceGroupIDs {
		if resourceGroupID == "" {
			continue
		}

		if p.isPDPool {
			resourceIDs, err := utils.DeconstructIPsFromPrefix(resourceGroupID)
			if err != nil {
				p.log.Error(err, "failed to sync upstream resource", "resource group id", resourceGroupID, "err", err)
				continue
			}

			var resources []Resource
			for _, resourceID := range resourceIDs {
				resources = append(resources, Resource{resourceGroupID, resourceID})
			}
			upstreamResource = append(upstreamResource, resources...)
		} else {
			upstreamResource = append(upstreamResource, Resource{resourceGroupID, resourceGroupID})
		}
	}

	// Get the list of local resources
	var localResources []Resource
	for _, coolDownResource := range p.coolDownQueue {
		localResources = append(localResources, coolDownResource.Resource)
	}
	for _, usedResource := range p.usedResources {
		localResources = append(localResources, usedResource)
	}
	for _, warmResources := range p.warmResources {
		localResources = append(localResources, warmResources...)
	}

	// resources that are present upstream but missing in the pool
	newResources := utils.Difference(upstreamResource, localResources)

	// resources that are deleted from upstream but still present in the pool
	deletedResources := utils.Difference(localResources, upstreamResource)

	if len(newResources) == 0 && len(deletedResources) == 0 {
		p.log.Info("local and upstream state is in sync")
		return
	}

	if len(newResources) > 0 {
		p.log.Info("adding new resources to warm pool", "resource", newResources)
		for _, resource := range newResources {
			p.warmResources[resource.GroupID] = append(p.warmResources[resource.GroupID], resource)
		}
	}

	if len(deletedResources) > 0 {
		p.log.Info("attempting to remove deleted resources",
			"deleted resources", deletedResources)

		for _, resource := range deletedResources {
			// remove deleted resource from list of warm resources of the resource group
			for i := len(p.warmResources[resource.GroupID]) - 1; i >= 0; i-- {
				if p.warmResources[resource.GroupID] == nil || len(p.warmResources[resource.GroupID]) == 0 {
					continue
				}
				warmResource := p.warmResources[resource.GroupID][i]
				if warmResource.ResourceID == resource.ResourceID {
					p.log.Info("removing resource from warm pool",
						"group id", resource.GroupID, "resource id", resource.ResourceID)
					p.warmResources[resource.GroupID] = append(p.warmResources[resource.GroupID][:i], p.warmResources[resource.GroupID][i+1:]...)
					// if the removed resource is the only one in the group, then delete the resource group from warm pool
					if len(p.warmResources[resource.GroupID]) == 0 {
						delete(p.warmResources, resource.GroupID)
					}
				}
			}

			// remove deleted resource from cool down queue
			for i := len(p.coolDownQueue) - 1; i >= 0; i-- {
				coolDownResource := p.coolDownQueue[i]
				if coolDownResource.Resource.GroupID == resource.GroupID &&
					coolDownResource.Resource.ResourceID == resource.ResourceID {
					p.log.Info("removing resource from cool down queue",
						"group id", resource.GroupID, "resource id", resource.ResourceID)
					p.coolDownQueue = append(p.coolDownQueue[:i], p.coolDownQueue[i+1:]...)
				}
			}
		}
	}
}