List and cache InstanceGroupManagers instead of getting them separately to improve node pool reconciliation time (#15086) (#10714)

[upstream:634129d661508334a07a089c653708e76cea0c65]

Signed-off-by: Modular Magician <[email protected]>

Author: modular-magician

google-beta/services/container/resource_container_node_pool.go

@@ -17,6 +17,7 @@
 package container
 
 import (
+	"context"
 	"fmt"
 	"log"
 	"regexp"
@@ -33,6 +34,7 @@ import (
 	"github.com/hashicorp/terraform-provider-google-beta/google-beta/tpgresource"
 	transport_tpg "github.com/hashicorp/terraform-provider-google-beta/google-beta/transport"
 
+	compute "google.golang.org/api/compute/v0.beta"
 	container "google.golang.org/api/container/v1beta1"
 )
 
@@ -60,13 +62,13 @@ func (nodePoolCache *nodePoolCache) get(nodePool string) (*container.NodePool, e
 }
 
 func (nodePoolCache *nodePoolCache) refreshIfNeeded(d *schema.ResourceData, config *transport_tpg.Config, userAgent string, nodePoolInfo *NodePoolInformation, name string) error {
+	nodePoolCache.mutex.Lock()
+	defer nodePoolCache.mutex.Unlock()
+
 	if !nodePoolCache.needsRefresh(nodePoolInfo.fullyQualifiedName(name)) {
 		return nil
 	}
 
-	nodePoolCache.mutex.Lock()
-	defer nodePoolCache.mutex.Unlock()
-
 	parent := fmt.Sprintf("projects/%s/locations/%s/clusters/%s", nodePoolInfo.project, nodePoolInfo.location, nodePoolInfo.cluster)
 	clusterNodePoolsListCall := config.NewContainerClient(userAgent).Projects.Locations.Clusters.NodePools.List(parent)
 	if config.UserProjectOverride {
@@ -88,8 +90,6 @@ func (nodePoolCache *nodePoolCache) refreshIfNeeded(d *schema.ResourceData, conf
 }
 
 func (nodePoolCache *nodePoolCache) needsRefresh(nodePool string) bool {
-	nodePoolCache.mutex.RLock()
-	defer nodePoolCache.mutex.RUnlock()
 	np, ok := nodePoolCache.nodePools[nodePool]
 	if !ok {
 		return true
@@ -103,11 +103,80 @@ func (nodePoolCache *nodePoolCache) remove(nodePool string) {
 	delete(nodePoolCache.nodePools, nodePool)
 }
 
-var npCache = &nodePoolCache{
-	nodePools: make(map[string]*nodePoolWithUpdateTime),
-	ttl:       30 * time.Second,
+type instanceGroupManagerWithUpdateTime struct {
+	instanceGroupManager *compute.InstanceGroupManager
+	updateTime           time.Time
+}
+
+type instanceGroupManagerCache struct {
+	instanceGroupManagers map[string]*instanceGroupManagerWithUpdateTime
+	ttl                   time.Duration
+	mutex                 sync.RWMutex
 }
 
+func (instanceGroupManagerCache *instanceGroupManagerCache) get(fullyQualifiedName string) (*compute.InstanceGroupManager, bool) {
+	instanceGroupManagerCache.mutex.RLock()
+	defer instanceGroupManagerCache.mutex.RUnlock()
+	igm, ok := instanceGroupManagerCache.instanceGroupManagers[fullyQualifiedName]
+	if !ok {
+		return nil, false
+	}
+	return igm.instanceGroupManager, true
+}
+
+func (instanceGroupManagerCache *instanceGroupManagerCache) refreshIfNeeded(d *schema.ResourceData, config *transport_tpg.Config, userAgent string, npName string, igmUrl string) error {
+	instanceGroupManagerCache.mutex.Lock()
+	defer instanceGroupManagerCache.mutex.Unlock()
+
+	matches := instanceGroupManagerURL.FindStringSubmatch(igmUrl)
+	if len(matches) < 4 {
+		return fmt.Errorf("Error reading instance group manager URL %q", igmUrl)
+	}
+
+	if !instanceGroupManagerCache.needsRefresh(matches[0]) {
+		return nil
+	}
+
+	updateTime := time.Now()
+	err := config.NewComputeClient(userAgent).InstanceGroupManagers.List(matches[1], matches[2]).Pages(context.Background(), instanceGroupManagerCache.processList(updateTime))
+	if err != nil {
+		return transport_tpg.HandleNotFoundError(err, d, fmt.Sprintf("InstanceGroupManagers for node pool %q", npName))
+	}
+	return nil
+}
+
+func (instanceGroupManagerCache *instanceGroupManagerCache) processList(updateTime time.Time) func(*compute.InstanceGroupManagerList) error {
+	return func(igmList *compute.InstanceGroupManagerList) error {
+		for _, instanceGroupManager := range igmList.Items {
+			fullyQualifiedName := instanceGroupManagerURL.FindString(instanceGroupManager.SelfLink)
+			instanceGroupManagerCache.instanceGroupManagers[fullyQualifiedName] = &instanceGroupManagerWithUpdateTime{
+				instanceGroupManager: instanceGroupManager,
+				updateTime:           updateTime,
+			}
+		}
+		return nil
+	}
+}
+
+func (instanceGroupManagerCache *instanceGroupManagerCache) needsRefresh(fullyQualifiedName string) bool {
+	igm, ok := instanceGroupManagerCache.instanceGroupManagers[fullyQualifiedName]
+	if !ok {
+		return true
+	}
+	return time.Since(igm.updateTime) > instanceGroupManagerCache.ttl
+}
+
+var (
+	npCache = &nodePoolCache{
+		nodePools: make(map[string]*nodePoolWithUpdateTime),
+		ttl:       30 * time.Second,
+	}
+	igmCache = &instanceGroupManagerCache{
+		instanceGroupManagers: make(map[string]*instanceGroupManagerWithUpdateTime),
+		ttl:                   30 * time.Second,
+	}
+)
+
 func ResourceContainerNodePool() *schema.Resource {
 	return &schema.Resource{
 		Create: resourceContainerNodePoolCreate,
@@ -790,7 +859,9 @@ func resourceContainerNodePoolRead(d *schema.ResourceData, meta interface{}) err
 
 	name := getNodePoolName(d.Id())
 
-	npCache.refreshIfNeeded(d, config, userAgent, nodePoolInfo, name)
+	if err := npCache.refreshIfNeeded(d, config, userAgent, nodePoolInfo, name); err != nil {
+		return err
+	}
 	nodePool, err := npCache.get(nodePoolInfo.fullyQualifiedName(name))
 	if err != nil {
 		log.Printf("[WARN] Removing %s because it's gone", fmt.Sprintf("NodePool %q from cluster %q", name, nodePoolInfo.cluster))
@@ -953,7 +1024,9 @@ func resourceContainerNodePoolExists(d *schema.ResourceData, meta interface{}) (
 	}
 
 	name := getNodePoolName(d.Id())
-	npCache.refreshIfNeeded(d, config, userAgent, nodePoolInfo, name)
+	if err := npCache.refreshIfNeeded(d, config, userAgent, nodePoolInfo, name); err != nil {
+		return false, err
+	}
 	_, err = npCache.get(nodePoolInfo.fullyQualifiedName(name))
 	if err != nil {
 		log.Printf("[WARN] Removing %s because it's gone", fmt.Sprintf("NodePool %q from cluster %q", name, nodePoolInfo.cluster))
@@ -1215,13 +1288,17 @@ func flattenNodePool(d *schema.ResourceData, config *transport_tpg.Config, np *c
 		if len(matches) < 4 {
 			return nil, fmt.Errorf("Error reading instance group manage URL '%q'", url)
 		}
-		igm, err := config.NewComputeClient(userAgent).InstanceGroupManagers.Get(matches[1], matches[2], matches[3]).Do()
-		if transport_tpg.IsGoogleApiErrorWithCode(err, 404) {
-			// The IGM URL in is stale; don't include it
+		if strings.HasPrefix("gk3", matches[3]) {
+			// IGM is autopilot so we know it will not be found, skip it
 			continue
 		}
-		if err != nil {
-			return nil, fmt.Errorf("Error reading instance group manager returned as an instance group URL: %q", err)
+		if err := igmCache.refreshIfNeeded(d, config, userAgent, np.Name, url); err != nil {
+			return nil, err
+		}
+		igm, ok := igmCache.get(matches[0])
+		if !ok {
+			// The IGM URL is stale; don't include it
+			continue
 		}
 		size += int(igm.TargetSize)
 		igmUrls = append(igmUrls, url)