Merge pull request #2721 from Jont828/tags-at-scope

Use GetAtScope() to get tags when checking if a resource is managed

Author: k8s-ci-robot

azure/defaults.go

@@ -281,6 +281,16 @@ func AvailabilitySetID(subscriptionID, resourceGroup, availabilitySetName string
 	return fmt.Sprintf("/subscriptions/%s/resourceGroups/%s/providers/Microsoft.Compute/availabilitySets/%s", subscriptionID, resourceGroup, availabilitySetName)
 }
 
+// PrivateDNSZoneID returns the azure resource ID for a given private DNS zone.
+func PrivateDNSZoneID(subscriptionID, resourceGroup, privateDNSZoneName string) string {
+	return fmt.Sprintf("subscriptions/%s/resourceGroups/%s/providers/Microsoft.Network/privateDnsZones/%s", subscriptionID, resourceGroup, privateDNSZoneName)
+}
+
+// VirtualNetworkLinkID returns the azure resource ID for a given virtual network link.
+func VirtualNetworkLinkID(subscriptionID, resourceGroup, privateDNSZoneName, virtualNetworkLinkName string) string {
+	return fmt.Sprintf("subscriptions/%s/resourceGroups/%s/providers/Microsoft.Network/privateDnsZones/%s/virtualNetworkLinks/%s", subscriptionID, resourceGroup, privateDNSZoneName, virtualNetworkLinkName)
+}
+
 // GetBootstrappingVMExtension returns the CAPZ Bootstrapping VM extension.
 // The CAPZ Bootstrapping extension is a simple clone of https://github.com/Azure/custom-script-extension-linux for Linux or
 // https://docs.microsoft.com/en-us/azure/virtual-machines/extensions/custom-script-windows for Windows.

azure/services/async/interfaces.go

@@ -19,6 +19,7 @@ package async
 import (
 	"context"
 
+	"github.com/Azure/azure-sdk-for-go/services/resources/mgmt/2019-10-01/resources"
 	azureautorest "github.com/Azure/go-autorest/autorest/azure"
 	"sigs.k8s.io/cluster-api-provider-azure/azure"
 )
@@ -41,6 +42,11 @@ type Getter interface {
 	Get(ctx context.Context, spec azure.ResourceSpecGetter) (result interface{}, err error)
 }
 
+// TagsGetter is an interface that can get a tags resource.
+type TagsGetter interface {
+	GetAtScope(ctx context.Context, scope string) (result resources.TagsResource, err error)
+}
+
 // Creator is a client that can create or update a resource asynchronously.
 type Creator interface {
 	FutureHandler

azure/services/async/mock_async/async_mock.go

@@ -19,12 +19,12 @@ package privatedns
 import (
 	"context"
 
-	"github.com/Azure/azure-sdk-for-go/services/privatedns/mgmt/2018-09-01/privatedns"
 	"github.com/pkg/errors"
 	infrav1 "sigs.k8s.io/cluster-api-provider-azure/api/v1beta1"
 	"sigs.k8s.io/cluster-api-provider-azure/azure"
 	"sigs.k8s.io/cluster-api-provider-azure/azure/converters"
 	"sigs.k8s.io/cluster-api-provider-azure/azure/services/async"
+	"sigs.k8s.io/cluster-api-provider-azure/azure/services/tags"
 	"sigs.k8s.io/cluster-api-provider-azure/util/reconciler"
 	"sigs.k8s.io/cluster-api-provider-azure/util/tele"
 )
@@ -42,8 +42,7 @@ type Scope interface {
 // Service provides operations on Azure resources.
 type Service struct {
 	Scope              Scope
-	zoneGetter         async.Getter
-	vnetLinkGetter     async.Getter
+	TagsGetter         async.TagsGetter
 	zoneReconciler     async.Reconciler
 	vnetLinkReconciler async.Reconciler
 	recordReconciler   async.Reconciler
@@ -54,10 +53,10 @@ func New(scope Scope) *Service {
 	zoneClient := newPrivateZonesClient(scope)
 	vnetLinkClient := newVirtualNetworkLinksClient(scope)
 	recordSetsClient := newRecordSetsClient(scope)
+	tagsClient := tags.NewClient(scope)
 	return &Service{
 		Scope:              scope,
-		zoneGetter:         zoneClient,
-		vnetLinkGetter:     vnetLinkClient,
+		TagsGetter:         tagsClient,
 		zoneReconciler:     async.New(scope, zoneClient, zoneClient),
 		vnetLinkReconciler: async.New(scope, vnetLinkClient, vnetLinkClient),
 		recordReconciler:   async.New(scope, recordSetsClient, recordSetsClient),
@@ -136,17 +135,18 @@ func (s *Service) Delete(ctx context.Context) error {
 // isVnetLinkManaged returns true if the vnet link has an owned tag with the cluster name as value,
 // meaning that the vnet link lifecycle is managed.
 func (s *Service) isVnetLinkManaged(ctx context.Context, spec azure.ResourceSpecGetter) (bool, error) {
-	result, err := s.vnetLinkGetter.Get(ctx, spec)
+	scope := azure.VirtualNetworkLinkID(s.Scope.SubscriptionID(), spec.ResourceGroupName(), spec.OwnerResourceName(), spec.ResourceName())
+	result, err := s.TagsGetter.GetAtScope(ctx, scope)
 	if err != nil {
 		return false, err
 	}
 
-	link, ok := result.(privatedns.VirtualNetworkLink)
-	if !ok {
-		return false, errors.Errorf("%T is not a privatedns.VirtualNetworkLink", link)
+	tagsMap := make(map[string]*string)
+	if result.Properties != nil && result.Properties.Tags != nil {
+		tagsMap = result.Properties.Tags
 	}
 
-	tags := converters.MapToTags(link.Tags)
+	tags := converters.MapToTags(tagsMap)
 	return tags.HasOwned(s.Scope.ClusterName()), nil
 }
 
@@ -158,15 +158,17 @@ func (s *Service) IsManaged(ctx context.Context) (bool, error) {
 		return false, errors.Errorf("no private dns zone spec available")
 	}
 
-	result, err := s.zoneGetter.Get(ctx, zoneSpec)
+	scope := azure.PrivateDNSZoneID(s.Scope.SubscriptionID(), zoneSpec.ResourceGroupName(), zoneSpec.ResourceName())
+	result, err := s.TagsGetter.GetAtScope(ctx, scope)
 	if err != nil {
 		return false, err
 	}
-	zone, ok := result.(privatedns.PrivateZone)
-	if !ok {
-		return false, errors.Errorf("%T is not a privatedns.PrivateZone", zone)
+
+	tagsMap := make(map[string]*string)
+	if result.Properties != nil && result.Properties.Tags != nil {
+		tagsMap = result.Properties.Tags
 	}
 
-	tags := converters.MapToTags(zone.Tags)
+	tags := converters.MapToTags(tagsMap)
 	return tags.HasOwned(s.Scope.ClusterName()), nil
 }