follow latest changes on provider-ext

gardener · Jun 5, 2024 · 731c1a8 · 731c1a8
1 parent 3408695
commit 731c1a8
Show file tree

Hide file tree

Showing 4 changed files with 123 additions and 49 deletions.
diff --git a/pkg/azure/api/providerspec.go b/pkg/azure/api/providerspec.go
@@ -319,6 +319,12 @@ const (
 	AzurePublicCloudName string = "AzurePublic"
 )
 
+// The known prefixes in of region names for the various instances.
+var (
+	AzureGovRegionPrefixes   = []string{"usgov", "usdod", "ussec"}
+	AzureChinaRegionPrefixes = []string{"china"}
+)
+
 // CloudConfiguration contains detailed config for the cloud to connect to. Currently we only support selection of well-
 // known Azure-instances by name, but this could be extended in future to support private clouds.
 type CloudConfiguration struct {

diff --git a/pkg/azure/provider/helpers/driver.go b/pkg/azure/provider/helpers/driver.go
@@ -40,10 +40,12 @@ import (
 // ExtractProviderSpecAndConnectConfig extracts api.AzureProviderSpec from mcc and access.ConnectConfig from secret.
 func ExtractProviderSpecAndConnectConfig(mcc *v1alpha1.MachineClass, secret *corev1.Secret) (api.AzureProviderSpec, access.ConnectConfig, error) {
 	var (
-		err                error
-		providerSpec       api.AzureProviderSpec
-		connectConfig      access.ConnectConfig
-		cloudConfiguration cloud.Configuration
+		err                  error
+		providerSpec         api.AzureProviderSpec
+		connectConfig        access.ConnectConfig
+		cloudConfiguration   *api.CloudConfiguration
+		azCloudConfiguration cloud.Configuration
+		region               *string
 	)
 	// validate provider Spec provider. Exit early if it is not azure.
 	if err = validation.ValidateMachineClassProvider(mcc); err != nil {
@@ -57,12 +59,18 @@ func ExtractProviderSpecAndConnectConfig(mcc *v1alpha1.MachineClass, secret *cor
 	if connectConfig, err = ValidateSecretAndCreateConnectConfig(secret); err != nil {
 		return api.AzureProviderSpec{}, access.ConnectConfig{}, err
 	}
+
 	if providerSpec.CloudConfiguration != nil {
-		if cloudConfiguration, err = ExtractCloudConfiguration(&providerSpec); err != nil {
-			return api.AzureProviderSpec{}, access.ConnectConfig{}, err
-		}
-		connectConfig.ClientOptions.Cloud = cloudConfiguration
+		cloudConfiguration = providerSpec.CloudConfiguration
+	}
+	if mcc != nil && mcc.NodeTemplate != nil {
+		region = &mcc.NodeTemplate.Region
 	}
+	if azCloudConfiguration, err = DetermineCloudConfiguration(cloudConfiguration, region); err != nil {
+		return api.AzureProviderSpec{}, access.ConnectConfig{}, err
+	}
+
+	connectConfig.ClientOptions.Cloud = azCloudConfiguration
 	return providerSpec, connectConfig, nil
 }
 

diff --git a/pkg/azure/provider/helpers/providerspec.go b/pkg/azure/provider/helpers/providerspec.go
@@ -13,23 +13,48 @@ import (
 	"github.com/gardener/machine-controller-manager-provider-azure/pkg/azure/api"
 )
 
-// ExtractCloudConfiguration retrieves the name of the cloud instance to connect to from the AzureProviderSpec
-// and returns the corresponding azure cloud Configuration.
-func ExtractCloudConfiguration(spec *api.AzureProviderSpec) (cloud.Configuration, error) {
-	if spec.CloudConfiguration == nil {
-		return cloud.AzurePublic, nil
+// DetermineCloudConfiguration returns the Azure cloud.Configuration corresponding to the instance given by the provided input. If both cloudConfiguration and
+// region are provided, cloudConfiguration takes precedence.
+func DetermineCloudConfiguration(cloudConfiguration *api.CloudConfiguration, region *string) (cloud.Configuration, error) {
+
+	if cloudConfiguration != nil {
+		cloudConfigurationName := cloudConfiguration.Name
+		switch {
+		case strings.EqualFold(cloudConfigurationName, api.AzurePublicCloudName):
+			return cloud.AzurePublic, nil
+		case strings.EqualFold(cloudConfigurationName, api.AzureGovCloudName):
+			return cloud.AzureGovernment, nil
+		case strings.EqualFold(cloudConfigurationName, api.AzureChinaCloudName):
+			return cloud.AzureChina, nil
+
+		default:
+			return cloud.Configuration{}, fmt.Errorf("unknown cloud configuration name '%s'", cloudConfigurationName)
+		}
+	} else if region != nil {
+		return cloudConfigurationFromRegion(*region), nil
+	} else {
+		return cloud.Configuration{}, fmt.Errorf("either CloudConfiguration or region must be provided to determine the cloud configuration to use")
 	}
+}
 
-	cloudConfigurationName := spec.CloudConfiguration.Name
+// cloudConfigurationFromRegion returns a matching cloudConfiguration corresponding to a well known cloud instance for the given region
+func cloudConfigurationFromRegion(region string) cloud.Configuration {
 	switch {
-	case strings.EqualFold(cloudConfigurationName, api.AzurePublicCloudName):
-		return cloud.AzurePublic, nil
-	case strings.EqualFold(cloudConfigurationName, api.AzureGovCloudName):
-		return cloud.AzureGovernment, nil
-	case strings.EqualFold(cloudConfigurationName, api.AzureChinaCloudName):
-		return cloud.AzureChina, nil
-
+	case hasAnyPrefix(region, api.AzureGovRegionPrefixes...):
+		return cloud.AzureGovernment
+	case hasAnyPrefix(region, api.AzureChinaRegionPrefixes...):
+		return cloud.AzureChina
 	default:
-		return cloud.Configuration{}, fmt.Errorf("unknown cloud configuration name '%s'", cloudConfigurationName)
+		return cloud.AzurePublic
+	}
+}
+
+func hasAnyPrefix(s string, prefixes ...string) bool {
+	lString := strings.ToLower(s)
+	for _, p := range prefixes {
+		if strings.HasPrefix(lString, strings.ToLower(p)) {
+			return true
+		}
 	}
+	return false
 }
diff --git a/pkg/azure/provider/helpers/providerspec_test.go b/pkg/azure/provider/helpers/providerspec_test.go
@@ -10,65 +10,100 @@ import (
 	"github.com/Azure/azure-sdk-for-go/sdk/azcore/cloud"
 	"github.com/gardener/machine-controller-manager-provider-azure/pkg/azure/api"
 	. "github.com/onsi/gomega"
+	"k8s.io/utils/ptr"
 )
 
 func TestNilConfig(t *testing.T) {
 	g := NewWithT(t)
 
-	testSpec := &api.AzureProviderSpec{}
+	var (
+		testConfig *api.CloudConfiguration = nil
+		testRegion                         = ptr.To("Foo")
+	)
 
-	configuration, err := ExtractCloudConfiguration(testSpec)
+	configuration, err := DetermineCloudConfiguration(testConfig, testRegion)
 
 	g.Expect(err).ToNot(HaveOccurred())
 	g.Expect(configuration).To(Equal(cloud.AzurePublic))
 }
 
+func TestNilRegion(t *testing.T) {
+	g := NewWithT(t)
+
+	var (
+		testConfig         = &api.CloudConfiguration{Name: api.AzurePublicCloudName}
+		testRegion *string = nil
+	)
+
+	configuration, err := DetermineCloudConfiguration(testConfig, testRegion)
+
+	g.Expect(err).ToNot(HaveOccurred())
+	g.Expect(configuration).To(Equal(cloud.AzurePublic))
+}
+
+func TestNilConfigAndRegion(t *testing.T) {
+	g := NewWithT(t)
+
+	var (
+		testConfig *api.CloudConfiguration = nil
+		testRegion *string                 = nil
+	)
+
+	_, err := DetermineCloudConfiguration(testConfig, testRegion)
+
+	g.Expect(err).To(HaveOccurred())
+}
+
 func TestInvalidConfigName(t *testing.T) {
 	g := NewWithT(t)
 
-	testSpec := &api.AzureProviderSpec{
-		CloudConfiguration: &api.CloudConfiguration{
-			Name: "Foo",
-		},
-	}
+	var (
+		testConfig         = &api.CloudConfiguration{Name: "Foo"}
+		testRegion *string = nil
+	)
 
-	_, err := ExtractCloudConfiguration(testSpec)
+	_, err := DetermineCloudConfiguration(testConfig, testRegion)
 
 	g.Expect(err).To(HaveOccurred())
 }
 
 func TestPredefinedClouds(t *testing.T) {
 	g := NewWithT(t)
 
-	testPublicConfiguration := &api.CloudConfiguration{
-		Name: api.AzurePublicCloudName,
-	}
-	testGovConfiguration := &api.CloudConfiguration{
-		Name: api.AzureGovCloudName,
-	}
-	testChinaConfigration := &api.CloudConfiguration{
-		Name: api.AzureChinaCloudName,
-	}
-	testSpec := &api.AzureProviderSpec{}
-
-	testSpec.CloudConfiguration = testPublicConfiguration
+	var (
+		testPublicConfiguration         = &api.CloudConfiguration{Name: api.AzurePublicCloudName}
+		testGovConfiguration            = &api.CloudConfiguration{Name: api.AzureGovCloudName}
+		testChinaConfigration           = &api.CloudConfiguration{Name: api.AzureChinaCloudName}
+		testRegion              *string = nil
+	)
 
-	configuration, err := ExtractCloudConfiguration(testSpec)
+	configuration, err := DetermineCloudConfiguration(testPublicConfiguration, testRegion)
 
 	g.Expect(err).ToNot(HaveOccurred())
 	g.Expect(configuration).To(Equal(cloud.AzurePublic))
 
-	testSpec.CloudConfiguration = testGovConfiguration
-
-	configuration, err = ExtractCloudConfiguration(testSpec)
+	configuration, err = DetermineCloudConfiguration(testGovConfiguration, testRegion)
 
 	g.Expect(err).ToNot(HaveOccurred())
 	g.Expect(configuration).To(Equal(cloud.AzureGovernment))
 
-	testSpec.CloudConfiguration = testChinaConfigration
-
-	configuration, err = ExtractCloudConfiguration(testSpec)
+	configuration, err = DetermineCloudConfiguration(testChinaConfigration, testRegion)
 
 	g.Expect(err).ToNot(HaveOccurred())
 	g.Expect(configuration).To(Equal(cloud.AzureChina))
 }
+
+func TestRegionMatching(t *testing.T) {
+	g := NewWithT(t)
+
+	var (
+		testConfig *api.CloudConfiguration = nil
+		testRegion *string                 = ptr.To("ussecFoo")
+	)
+
+	configuration, err := DetermineCloudConfiguration(testConfig, testRegion)
+
+	g.Expect(err).ToNot(HaveOccurred())
+	g.Expect(configuration).To(Equal(cloud.AzureGovernment))
+
+}