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

Author: martin-guillen

mmv1/third_party/terraform/services/container/resource_container_node_pool.go.tmpl

@@ -1,6 +1,9 @@
 package container
 
 import (
+{{- if ne $.TargetVersionName `ga` }}
+    "context"
+{{- end }}
 	"fmt"
 	"log"
 	"regexp"
@@ -22,6 +25,7 @@ import (
 {{ if eq $.TargetVersionName `ga` }}
 	"google.golang.org/api/container/v1"
 {{- else }}
+	compute "google.golang.org/api/compute/v0.beta"
 	container "google.golang.org/api/container/v1beta1"
 {{- end }}
 )
@@ -51,13 +55,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 {
@@ -79,8 +83,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
@@ -94,10 +96,79 @@ 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,
+	}
+)
 {{- end }}
 
 func ResourceContainerNodePool() *schema.Resource {
@@ -794,7 +865,9 @@ func resourceContainerNodePoolRead(d *schema.ResourceData, meta interface{}) err
 	}
 
 {{- else }}
-	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))
@@ -976,7 +1049,9 @@ func resourceContainerNodePoolExists(d *schema.ResourceData, meta interface{}) (
 		return true, err
 	}
 {{- else }}
-	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))
@@ -1239,6 +1314,7 @@ 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)
 		}
+{{- if eq $.TargetVersionName `ga` }}
 		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
@@ -1247,6 +1323,20 @@ func flattenNodePool(d *schema.ResourceData, config *transport_tpg.Config, np *c
 		if err != nil {
 			return nil, fmt.Errorf("Error reading instance group manager returned as an instance group URL: %q", err)
 		}
+{{- else }}
+        if strings.HasPrefix("gk3", matches[3]) {
+            // IGM is autopilot so we know it will not be found, skip it
+            continue
+        }
+		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
+		}
+{{- end }}
 		size += int(igm.TargetSize)
 		igmUrls = append(igmUrls, url)
 		managedIgmUrls = append(managedIgmUrls, igm.InstanceGroup)