func()

in pkg/pool/pool.go [107:163]


func (p *pool) ReSync(upstreamResource []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

	// Get the list of local resources
	var localResources []string
	for _, resource := range p.coolDownQueue {
		localResources = append(localResources, resource.ResourceID)
	}
	_, usedResources := utils.GetKeyValSlice(p.usedResources)
	localResources = append(localResources, usedResources...)
	localResources = append(localResources, p.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)
		p.warmResources = append(p.warmResources, newResources...)
	}

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

		for _, deletedResource := range deletedResources {
			for i := len(p.warmResources) - 1; i >= 0; i-- {
				if p.warmResources[i] == deletedResource {
					p.log.Info("removing resource from warm pool",
						"resource id", deletedResource)
					p.warmResources = append(p.warmResources[:i], p.warmResources[i+1:]...)
				}
			}
			for i := len(p.coolDownQueue) - 1; i >= 0; i-- {
				if p.coolDownQueue[i].ResourceID == deletedResource {
					p.log.Info("removing resource from cool down queue",
						"resource id", deletedResource)
					p.coolDownQueue = append(p.coolDownQueue[:i], p.coolDownQueue[i+1:]...)
				}
			}
		}
	}
}