Handle Multiple Projects For MIG Cache

Author: nicknagi

cluster-autoscaler/cloudprovider/gce/gce_manager_test.go

@@ -253,7 +253,7 @@ const listInstanceGroupManagerResponsePartTemplate = `
      }
     }
    ],
-   "instanceGroup": "https://www.googleapis.com/compute/v1/projects/lukaszos-gke-dev2/zones/%v/instanceGroups/%v",
+   "instanceGroup": "https://www.googleapis.com/compute/v1/projects/project1/zones/%v/instanceGroups/%v",
    "baseInstanceName": "%s",
    "fingerprint": "ASJwTpesjDI=",
    "currentActions": {
@@ -271,7 +271,7 @@ const listInstanceGroupManagerResponsePartTemplate = `
     "isStable": true
    },
    "targetSize": %v,
-   "selfLink": "https://www.googleapis.com/compute/v1/projects/lukaszos-gke-dev2/zones/us-west1-b/instanceGroupManagers/gke-blah-default-pool-67b773a0-grp",
+   "selfLink": "https://www.googleapis.com/compute/v1/projects/project1/zones/us-west1-b/instanceGroupManagers/gke-blah-default-pool-67b773a0-grp",
    "updatePolicy": {
     "type": "OPPORTUNISTIC",
     "minimalAction": "REPLACE",

cluster-autoscaler/cloudprovider/gce/mig_info_provider.go

@@ -21,6 +21,7 @@ import (
 	"fmt"
 	"net/url"
 	"path"
+	"regexp"
 	"strings"
 	"sync"
 	"time"
@@ -62,6 +63,11 @@ type timeProvider interface {
 	Now() time.Time
 }
 
+var (
+	// Compile a regular expression to find the text between "projects/" and the next "/".
+	migProjectSelfLinkRe = regexp.MustCompile(`projects/([^/]+)`)
+)
+
 type cachingMigInfoProvider struct {
 	migInfoMutex                      sync.Mutex
 	cache                             *GceCache
@@ -479,8 +485,13 @@ func (c *cachingMigInfoProvider) fillMigInfoCache() error {
 
 	for idx, zone := range zones {
 		for _, zoneMig := range migs[idx] {
+			projectId, err := extractProjectWithRegex(zoneMig.SelfLink)
+			if err != nil {
+				klog.Errorf("Unable to extract projectID from MIG self link: %s, err: %v", zoneMig.SelfLink, err)
+				projectId = c.projectId
+			}
 			zoneMigRef := GceRef{
-				c.projectId,
+				projectId,
 				zone,
 				zoneMig.Name,
 			}
@@ -508,6 +519,19 @@ func (c *cachingMigInfoProvider) fillMigInfoCache() error {
 	return nil
 }
 
+// extractProjectWithRegex uses a regular expression to find and return the project name
+// from the selfLink of a MIG.
+func extractProjectWithRegex(selflink string) (string, error) {
+	// FindStringSubmatch returns an array with the full match and all captured groups.
+	// matches[0] will be the full matched string (e.g., "/projects/some-project").
+	// matches[1] will be the content of the first capturing group (e.g., "some-project").
+	matches := migProjectSelfLinkRe.FindStringSubmatch(selflink)
+	if len(matches) < 2 {
+		return "", fmt.Errorf("could not find project name in self link: %s", selflink)
+	}
+	return matches[1], nil
+}
+
 func (c *cachingMigInfoProvider) getRegisteredMigRefs() map[GceRef]bool {
 	migRefs := make(map[GceRef]bool)
 	for _, mig := range c.migLister.GetMigs() {

cluster-autoscaler/cloudprovider/gce/mig_info_provider_test.go

@@ -787,11 +787,19 @@ func TestGetMigTargetSize(t *testing.T) {
 		Zone:       mig.GceRef().Zone,
 		Name:       mig.GceRef().Name,
 		TargetSize: targetSize,
+		SelfLink:   fmt.Sprintf("projects/%s/zones/%s/instanceGroups/%s", mig.GceRef().Project, mig.GceRef().Zone, mig.GceRef().Name),
+	}
+	instanceGroupManager1 := &gce.InstanceGroupManager{
+		Zone:       mig1.GceRef().Zone,
+		Name:       mig1.GceRef().Name,
+		TargetSize: targetSize,
+		SelfLink:   fmt.Sprintf("projects/%s/zones/%s/instanceGroups/%s", mig1.GceRef().Project, mig1.GceRef().Zone, mig1.GceRef().Name),
 	}
 
 	testCases := []struct {
 		name               string
 		cache              *GceCache
+		migQuery           *gceMig
 		fetchMigs          func(string) ([]*gce.InstanceGroupManager, error)
 		fetchMigTargetSize func(GceRef) (int64, error)
 		expectedTargetSize int64
@@ -804,40 +812,53 @@ func TestGetMigTargetSize(t *testing.T) {
 				migTargetSizeCache: map[GceRef]int64{mig.GceRef(): targetSize},
 			},
 			expectedTargetSize: targetSize,
+			migQuery:           mig,
 		},
 		{
 			name:               "target size from cache fill",
 			cache:              emptyCache(),
 			fetchMigs:          fetchMigsConst([]*gce.InstanceGroupManager{instanceGroupManager}),
 			expectedTargetSize: targetSize,
+			migQuery:           mig,
+		},
+		{
+			name:               "target size from cache fill, multiple MIG projects",
+			cache:              emptyCache(),
+			fetchMigs:          fetchMigsConst([]*gce.InstanceGroupManager{instanceGroupManager, instanceGroupManager1}),
+			expectedTargetSize: targetSize,
+			migQuery:           mig1,
 		},
 		{
 			name:               "cache fill without mig, fallback success",
 			cache:              emptyCache(),
 			fetchMigs:          fetchMigsConst([]*gce.InstanceGroupManager{}),
 			fetchMigTargetSize: fetchMigTargetSizeConst(targetSize),
 			expectedTargetSize: targetSize,
+			migQuery:           mig,
 		},
 		{
 			name:               "cache fill failure, fallback success",
 			cache:              emptyCache(),
 			fetchMigs:          fetchMigsFail,
 			fetchMigTargetSize: fetchMigTargetSizeConst(targetSize),
 			expectedTargetSize: targetSize,
+			migQuery:           mig,
 		},
 		{
 			name:               "cache fill without mig, fallback failure",
 			cache:              emptyCache(),
 			fetchMigs:          fetchMigsConst([]*gce.InstanceGroupManager{}),
 			fetchMigTargetSize: fetchMigTargetSizeFail,
 			expectedErr:        errFetchMigTargetSize,
+			migQuery:           mig,
 		},
 		{
 			name:               "cache fill failure, fallback failure",
 			cache:              emptyCache(),
 			fetchMigs:          fetchMigsFail,
 			fetchMigTargetSize: fetchMigTargetSizeFail,
 			expectedErr:        errFetchMigTargetSize,
+			migQuery:           mig,
 		},
 	}
 
@@ -850,8 +871,8 @@ func TestGetMigTargetSize(t *testing.T) {
 			migLister := NewMigLister(tc.cache)
 			provider := NewCachingMigInfoProvider(tc.cache, migLister, client, mig.GceRef().Project, 1, 0*time.Second, false)
 
-			targetSize, err := provider.GetMigTargetSize(mig.GceRef())
-			cachedTargetSize, found := tc.cache.GetMigTargetSize(mig.GceRef())
+			targetSize, err := provider.GetMigTargetSize(tc.migQuery.GceRef())
+			cachedTargetSize, found := tc.cache.GetMigTargetSize(tc.migQuery.GceRef())
 
 			assert.Equal(t, tc.expectedErr, err)
 			assert.Equal(t, tc.expectedErr == nil, found)
@@ -1916,7 +1937,7 @@ func (f *fakeTime) Now() time.Time {
 
 func emptyCache() *GceCache {
 	return &GceCache{
-		migs:                             map[GceRef]Mig{mig.GceRef(): mig},
+		migs:                             map[GceRef]Mig{mig.GceRef(): mig, mig1.GceRef(): mig1},
 		instances:                        make(map[GceRef][]GceInstance),
 		instancesUpdateTime:              make(map[GceRef]time.Time),
 		migTargetSizeCache:               make(map[GceRef]int64),