kubernetes
/
kops
mirror of https://github.com/kubernetes/kops.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

azure: Migrate resources to new SDK version

This commit is contained in:
Ciprian Hacman 2024-01-28 07:12:10 +02:00
parent 4198b19438
commit 1bbd3e446f
2 changed files with 129 additions and 136 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

125
pkg/resources/azure/azure.go
View File

@ -20,10 +20,10 @@ import (
"context" "context"
"fmt" "fmt"
"github.com/Azure/azure-sdk-for-go/services/compute/mgmt/2022-08-01/compute" authz "github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/authorization/armauthorization/v3"
"github.com/Azure/azure-sdk-for-go/services/network/mgmt/2022-05-01/network" compute "github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/compute/armcompute"
authz "github.com/Azure/azure-sdk-for-go/services/preview/authorization/mgmt/2020-04-01-preview/authorization" network "github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/network/armnetwork"
azureresources "github.com/Azure/azure-sdk-for-go/services/resources/mgmt/2021-04-01/resources" azureresources "github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/resources/armresources"
"k8s.io/kops/pkg/resources" "k8s.io/kops/pkg/resources"
"k8s.io/kops/upup/pkg/fi" "k8s.io/kops/upup/pkg/fi"
"k8s.io/kops/upup/pkg/fi/cloudup/azure" "k8s.io/kops/upup/pkg/fi/cloudup/azure"
@ -111,14 +111,13 @@ func (g *resourceGetter) listAll() ([]*resources.Resource, error) {
} }
func (g *resourceGetter) listResourceGroups(ctx context.Context) ([]*resources.Resource, error) { func (g *resourceGetter) listResourceGroups(ctx context.Context) ([]*resources.Resource, error) {
rgs, err := g.cloud.ResourceGroup().List(ctx, "" /* filter */) rgs, err := g.cloud.ResourceGroup().List(ctx)
if err != nil { if err != nil {
return nil, err return nil, err
} }
var rs []*resources.Resource var rs []*resources.Resource
for i := range rgs { for _, rg := range rgs {
rg := &rgs[i]
if !g.isOwnedByCluster(rg.Tags) { if !g.isOwnedByCluster(rg.Tags) {
continue continue
} }
@ -127,7 +126,7 @@ func (g *resourceGetter) listResourceGroups(ctx context.Context) ([]*resources.R
return rs, nil return rs, nil
} }
func (g *resourceGetter) toResourceGroupResource(rg *azureresources.Group) *resources.Resource { func (g *resourceGetter) toResourceGroupResource(rg *azureresources.ResourceGroup) *resources.Resource {
return &resources.Resource{ return &resources.Resource{
Obj: rg, Obj: rg,
Type: typeResourceGroup, Type: typeResourceGroup,
@ -149,8 +148,7 @@ func (g *resourceGetter) listVirtualNetworksAndSubnets(ctx context.Context) ([]*
} }
var rs []*resources.Resource var rs []*resources.Resource
for i := range vnets { for _, vnet := range vnets {
vnet := &vnets[i]
if !g.isOwnedByCluster(vnet.Tags) { if !g.isOwnedByCluster(vnet.Tags) {
continue continue
} }
@ -174,17 +172,18 @@ func (g *resourceGetter) toVirtualNetworkResource(vnet *network.VirtualNetwork)
blocks = append(blocks, toKey(typeResourceGroup, g.resourceGroupName())) blocks = append(blocks, toKey(typeResourceGroup, g.resourceGroupName()))
nsgs := set.New[string]() nsgs := set.New[string]()
if vnet.Subnets != nil { if vnet.Properties != nil && vnet.Properties.Subnets != nil {
for _, sn := range *vnet.Subnets { for _, sn := range vnet.Properties.Subnets {
if sn.NetworkSecurityGroup != nil { if sn.Properties == nil || sn.Properties.NetworkSecurityGroup == nil || sn.Properties.NetworkSecurityGroup.ID == nil {
nsgID, err := azure.ParseNetworkSecurityGroupID(*sn.NetworkSecurityGroup.ID) continue
}
nsgID, err := azure.ParseNetworkSecurityGroupID(*sn.Properties.NetworkSecurityGroup.ID)
if err != nil { if err != nil {
return nil, fmt.Errorf("parsing network security group ID: %s", err) return nil, fmt.Errorf("parsing network security group ID: %s", err)
} }
nsgs.Insert(nsgID.NetworkSecurityGroupName) nsgs.Insert(nsgID.NetworkSecurityGroupName)
} }
} }
}
for nsg := range nsgs { for nsg := range nsgs {
blocks = append(blocks, toKey(typeNetworkSecurityGroup, nsg)) blocks = append(blocks, toKey(typeNetworkSecurityGroup, nsg))
} }
@ -211,8 +210,8 @@ func (g *resourceGetter) listSubnets(ctx context.Context, vnetName string) ([]*r
} }
var rs []*resources.Resource var rs []*resources.Resource
for i := range subnets { for _, sn := range subnets {
rs = append(rs, g.toSubnetResource(&subnets[i], vnetName)) rs = append(rs, g.toSubnetResource(sn, vnetName))
} }
return rs, nil return rs, nil
} }
@ -222,8 +221,8 @@ func (g *resourceGetter) toSubnetResource(subnet *network.Subnet, vnetName strin
blocks = append(blocks, toKey(typeVirtualNetwork, vnetName)) blocks = append(blocks, toKey(typeVirtualNetwork, vnetName))
blocks = append(blocks, toKey(typeResourceGroup, g.resourceGroupName())) blocks = append(blocks, toKey(typeResourceGroup, g.resourceGroupName()))
if subnet.NatGateway != nil { if subnet.Properties != nil && subnet.Properties.NatGateway != nil && subnet.Properties.NatGateway.ID != nil {
blocks = append(blocks, toKey(typeNatGateway, *subnet.NatGateway.ID)) blocks = append(blocks, toKey(typeNatGateway, *subnet.Properties.NatGateway.ID))
} }
return &resources.Resource{ return &resources.Resource{
@ -251,7 +250,7 @@ func (g *resourceGetter) listNetworkSecurityGroups(ctx context.Context) ([]*reso
var rs []*resources.Resource var rs []*resources.Resource
for i := range NetworkSecurityGroups { for i := range NetworkSecurityGroups {
r, err := g.toNetworkSecurityGroupResource(&NetworkSecurityGroups[i]) r, err := g.toNetworkSecurityGroupResource(NetworkSecurityGroups[i])
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -265,10 +264,10 @@ func (g *resourceGetter) toNetworkSecurityGroupResource(NetworkSecurityGroup *ne
blocks = append(blocks, toKey(typeResourceGroup, g.resourceGroupName())) blocks = append(blocks, toKey(typeResourceGroup, g.resourceGroupName()))
asgs := set.New[string]() asgs := set.New[string]()
if NetworkSecurityGroup.SecurityRules != nil { if NetworkSecurityGroup.Properties.SecurityRules != nil {
for _, nsr := range *NetworkSecurityGroup.SecurityRules { for _, nsr := range NetworkSecurityGroup.Properties.SecurityRules {
if nsr.SourceApplicationSecurityGroups != nil { if nsr.Properties.SourceApplicationSecurityGroups != nil {
for _, sasg := range *nsr.SourceApplicationSecurityGroups { for _, sasg := range nsr.Properties.SourceApplicationSecurityGroups {
asgID, err := azure.ParseApplicationSecurityGroupID(*sasg.ID) asgID, err := azure.ParseApplicationSecurityGroupID(*sasg.ID)
if err != nil { if err != nil {
return nil, fmt.Errorf("parsing application security group ID: %w", err) return nil, fmt.Errorf("parsing application security group ID: %w", err)
@ -276,8 +275,8 @@ func (g *resourceGetter) toNetworkSecurityGroupResource(NetworkSecurityGroup *ne
asgs.Insert(asgID.ApplicationSecurityGroupName) asgs.Insert(asgID.ApplicationSecurityGroupName)
} }
} }
if nsr.DestinationApplicationSecurityGroups != nil { if nsr.Properties.DestinationApplicationSecurityGroups != nil {
for _, dasg := range *nsr.DestinationApplicationSecurityGroups { for _, dasg := range nsr.Properties.DestinationApplicationSecurityGroups {
asgID, err := azure.ParseApplicationSecurityGroupID(*dasg.ID) asgID, err := azure.ParseApplicationSecurityGroupID(*dasg.ID)
if err != nil { if err != nil {
return nil, fmt.Errorf("parsing application security group ID: %w", err) return nil, fmt.Errorf("parsing application security group ID: %w", err)
@ -314,8 +313,8 @@ func (g *resourceGetter) listApplicationSecurityGroups(ctx context.Context) ([]*
} }
var rs []*resources.Resource var rs []*resources.Resource
for i := range ApplicationSecurityGroups { for _, asg := range ApplicationSecurityGroups {
rs = append(rs, g.toApplicationSecurityGroupResource(&ApplicationSecurityGroups[i])) rs = append(rs, g.toApplicationSecurityGroupResource(asg))
} }
return rs, nil return rs, nil
} }
@ -346,8 +345,7 @@ func (g *resourceGetter) listRouteTables(ctx context.Context) ([]*resources.Reso
} }
var rs []*resources.Resource var rs []*resources.Resource
for i := range rts { for _, rt := range rts {
rt := &rts[i]
if !g.isOwnedByCluster(rt.Tags) { if !g.isOwnedByCluster(rt.Tags) {
continue continue
} }
@ -380,8 +378,7 @@ func (g *resourceGetter) listVMScaleSetsAndRoleAssignments(ctx context.Context)
var rs []*resources.Resource var rs []*resources.Resource
principalIDs := map[string]*compute.VirtualMachineScaleSet{} principalIDs := map[string]*compute.VirtualMachineScaleSet{}
for i := range vmsses { for _, vmss := range vmsses {
vmss := &vmsses[i]
if !g.isOwnedByCluster(vmss.Tags) { if !g.isOwnedByCluster(vmss.Tags) {
continue continue
} }
@ -409,7 +406,7 @@ func (g *resourceGetter) listVMScaleSetsAndRoleAssignments(ctx context.Context)
return rs, nil return rs, nil
} }
func (g *resourceGetter) toVMScaleSetResource(vmss *compute.VirtualMachineScaleSet, vms []compute.VirtualMachineScaleSetVM) (*resources.Resource, error) { func (g *resourceGetter) toVMScaleSetResource(vmss *compute.VirtualMachineScaleSet, vms []*compute.VirtualMachineScaleSetVM) (*resources.Resource, error) {
// Add resources whose deletion is blocked by this VMSS. // Add resources whose deletion is blocked by this VMSS.
var blocks []string var blocks []string
blocks = append(blocks, toKey(typeResourceGroup, g.resourceGroupName())) blocks = append(blocks, toKey(typeResourceGroup, g.resourceGroupName()))
@ -418,16 +415,16 @@ func (g *resourceGetter) toVMScaleSetResource(vmss *compute.VirtualMachineScaleS
subnets := set.New[string]() subnets := set.New[string]()
asgs := set.New[string]() asgs := set.New[string]()
lbs := set.New[string]() lbs := set.New[string]()
for _, iface := range *vmss.VirtualMachineProfile.NetworkProfile.NetworkInterfaceConfigurations { for _, iface := range vmss.Properties.VirtualMachineProfile.NetworkProfile.NetworkInterfaceConfigurations {
for _, ip := range *iface.IPConfigurations { for _, ip := range iface.Properties.IPConfigurations {
subnetID, err := azure.ParseSubnetID(*ip.Subnet.ID) subnetID, err := azure.ParseSubnetID(*ip.Properties.Subnet.ID)
if err != nil { if err != nil {
return nil, fmt.Errorf("parsing subnet ID: %w", err) return nil, fmt.Errorf("parsing subnet ID: %w", err)
} }
vnets.Insert(subnetID.VirtualNetworkName) vnets.Insert(subnetID.VirtualNetworkName)
subnets.Insert(subnetID.SubnetName) subnets.Insert(subnetID.SubnetName)
if ip.ApplicationSecurityGroups != nil { if ip.Properties.ApplicationSecurityGroups != nil {
for _, asg := range *ip.ApplicationSecurityGroups { for _, asg := range ip.Properties.ApplicationSecurityGroups {
asgID, err := azure.ParseApplicationSecurityGroupID(*asg.ID) asgID, err := azure.ParseApplicationSecurityGroupID(*asg.ID)
if err != nil { if err != nil {
return nil, fmt.Errorf("parsing application security group ID: %w", err) return nil, fmt.Errorf("parsing application security group ID: %w", err)
@ -435,8 +432,8 @@ func (g *resourceGetter) toVMScaleSetResource(vmss *compute.VirtualMachineScaleS
asgs.Insert(asgID.ApplicationSecurityGroupName) asgs.Insert(asgID.ApplicationSecurityGroupName)
} }
} }
if ip.LoadBalancerBackendAddressPools != nil { if ip.Properties.LoadBalancerBackendAddressPools != nil {
for _, lb := range *ip.LoadBalancerBackendAddressPools { for _, lb := range ip.Properties.LoadBalancerBackendAddressPools {
lbID, err := azure.ParseLoadBalancerID(*lb.ID) lbID, err := azure.ParseLoadBalancerID(*lb.ID)
if err != nil { if err != nil {
return nil, fmt.Errorf("parsing load balancer ID: %w", err) return nil, fmt.Errorf("parsing load balancer ID: %w", err)
@ -460,8 +457,8 @@ func (g *resourceGetter) toVMScaleSetResource(vmss *compute.VirtualMachineScaleS
} }
for _, vm := range vms { for _, vm := range vms {
if disks := vm.StorageProfile.DataDisks; disks != nil { if disks := vm.Properties.StorageProfile.DataDisks; disks != nil {
for _, d := range *disks { for _, d := range disks {
blocks = append(blocks, toKey(typeDisk, *d.Name)) blocks = append(blocks, toKey(typeDisk, *d.Name))
} }
} }
@ -488,8 +485,7 @@ func (g *resourceGetter) listDisks(ctx context.Context) ([]*resources.Resource,
} }
var rs []*resources.Resource var rs []*resources.Resource
for i := range disks { for _, disk := range disks {
disk := &disks[i]
if !g.isOwnedByCluster(disk.Tags) { if !g.isOwnedByCluster(disk.Tags) {
continue continue
} }
@ -520,13 +516,12 @@ func (g *resourceGetter) listRoleAssignments(ctx context.Context, principalIDs m
} }
var rs []*resources.Resource var rs []*resources.Resource
for i := range ras { for _, ra := range ras {
// Add a Role Assignment to the slice if its principal ID is that of one of the VM Scale Sets. // Add a Role Assignment to the slice if its principal ID is that of one of the VM Scale Sets.
ra := &ras[i] if ra.Properties == nil || ra.Properties.PrincipalID == nil {
if ra.PrincipalID == nil {
continue continue
} }
vmss, ok := principalIDs[*ra.PrincipalID] vmss, ok := principalIDs[*ra.Properties.PrincipalID]
if !ok { if !ok {
continue continue
} }
@ -554,7 +549,7 @@ func (g *resourceGetter) deleteRoleAssignment(_ fi.Cloud, r *resources.Resource)
if !ok { if !ok {
return fmt.Errorf("expected RoleAssignment, but got %T", r) return fmt.Errorf("expected RoleAssignment, but got %T", r)
} }
return g.cloud.RoleAssignment().Delete(context.TODO(), *ra.Scope, *ra.Name) return g.cloud.RoleAssignment().Delete(context.TODO(), *ra.Properties.Scope, *ra.Name)
} }
func (g *resourceGetter) listLoadBalancers(ctx context.Context) ([]*resources.Resource, error) { func (g *resourceGetter) listLoadBalancers(ctx context.Context) ([]*resources.Resource, error) {
@ -564,8 +559,7 @@ func (g *resourceGetter) listLoadBalancers(ctx context.Context) ([]*resources.Re
} }
var rs []*resources.Resource var rs []*resources.Resource
for i := range loadBalancers { for _, lb := range loadBalancers {
lb := &loadBalancers[i]
if !g.isOwnedByCluster(lb.Tags) { if !g.isOwnedByCluster(lb.Tags) {
continue continue
} }
@ -583,17 +577,18 @@ func (g *resourceGetter) toLoadBalancerResource(loadBalancer *network.LoadBalanc
blocks = append(blocks, toKey(typeResourceGroup, g.resourceGroupName())) blocks = append(blocks, toKey(typeResourceGroup, g.resourceGroupName()))
pips := set.New[string]() pips := set.New[string]()
if loadBalancer.FrontendIPConfigurations != nil { if loadBalancer.Properties != nil {
for _, fip := range *loadBalancer.FrontendIPConfigurations { for _, fip := range loadBalancer.Properties.FrontendIPConfigurations {
if fip.PublicIPAddress != nil { if fip.Properties == nil || fip.Properties.PublicIPAddress == nil {
pipID, err := azure.ParsePublicIPAddressID(*fip.PublicIPAddress.ID) continue
}
pipID, err := azure.ParsePublicIPAddressID(*fip.Properties.PublicIPAddress.ID)
if err != nil { if err != nil {
return nil, fmt.Errorf("parsing public IP address ID: %s", err) return nil, fmt.Errorf("parsing public IP address ID: %s", err)
} }
pips.Insert(pipID.PublicIPAddressName) pips.Insert(pipID.PublicIPAddressName)
} }
} }
}
for pip := range pips { for pip := range pips {
blocks = append(blocks, toKey(typePublicIPAddress, pip)) blocks = append(blocks, toKey(typePublicIPAddress, pip))
} }
@ -619,12 +614,11 @@ func (g *resourceGetter) listPublicIPAddresses(ctx context.Context) ([]*resource
} }
var rs []*resources.Resource var rs []*resources.Resource
for i := range publicIPAddresses { for _, pip := range publicIPAddresses {
p := &publicIPAddresses[i] if !g.isOwnedByCluster(pip.Tags) {
if !g.isOwnedByCluster(p.Tags) {
continue continue
} }
rs = append(rs, g.toPublicIPAddressResource(p)) rs = append(rs, g.toPublicIPAddressResource(pip))
} }
return rs, nil return rs, nil
} }
@ -651,12 +645,11 @@ func (g *resourceGetter) listNatGateways(ctx context.Context) ([]*resources.Reso
} }
var rs []*resources.Resource var rs []*resources.Resource
for i := range natGateways { for _, ngw := range natGateways {
p := &natGateways[i] if !g.isOwnedByCluster(ngw.Tags) {
if !g.isOwnedByCluster(p.Tags) {
continue continue
} }
r, err := g.toNatGatewayResource(p) r, err := g.toNatGatewayResource(ngw)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -670,8 +663,8 @@ func (g *resourceGetter) toNatGatewayResource(natGateway *network.NatGateway) (*
blocks = append(blocks, toKey(typeResourceGroup, g.resourceGroupName())) blocks = append(blocks, toKey(typeResourceGroup, g.resourceGroupName()))
pips := set.New[string]() pips := set.New[string]()
if natGateway.PublicIPAddresses != nil { if natGateway.Properties != nil && natGateway.Properties.PublicIPAddresses != nil {
for _, pip := range *natGateway.PublicIPAddresses { for _, pip := range natGateway.Properties.PublicIPAddresses {
pipID, err := azure.ParsePublicIPAddressID(*pip.ID) pipID, err := azure.ParsePublicIPAddressID(*pip.ID)
if err != nil { if err != nil {
return nil, fmt.Errorf("parsing public IP address ID: %s", err) return nil, fmt.Errorf("parsing public IP address ID: %s", err)

124
pkg/resources/azure/azure_test.go
View File

@ -21,11 +21,11 @@ import (
"reflect" "reflect"
"testing" "testing"
"github.com/Azure/azure-sdk-for-go/services/compute/mgmt/2022-08-01/compute" "github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
"github.com/Azure/azure-sdk-for-go/services/network/mgmt/2022-05-01/network" authz "github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/authorization/armauthorization/v3"
authz "github.com/Azure/azure-sdk-for-go/services/preview/authorization/mgmt/2020-04-01-preview/authorization" compute "github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/compute/armcompute"
azureresources "github.com/Azure/azure-sdk-for-go/services/resources/mgmt/2021-04-01/resources" network "github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/network/armnetwork"
"github.com/Azure/go-autorest/autorest/to" "github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/resources/armresources"
"k8s.io/kops/pkg/resources" "k8s.io/kops/pkg/resources"
"k8s.io/kops/upup/pkg/fi/cloudup/azure" "k8s.io/kops/upup/pkg/fi/cloudup/azure"
"k8s.io/kops/upup/pkg/fi/cloudup/azuretasks" "k8s.io/kops/upup/pkg/fi/cloudup/azuretasks"
@ -47,46 +47,46 @@ func TestListResourcesAzure(t *testing.T) {
lbName = "lb" lbName = "lb"
) )
clusterTags := map[string]*string{ clusterTags := map[string]*string{
azure.TagClusterName: to.StringPtr(clusterName), azure.TagClusterName: to.Ptr(clusterName),
} }
cloud := azuretasks.NewMockAzureCloud("eastus") cloud := azuretasks.NewMockAzureCloud("eastus")
// Set up resources in the mock clients. // Set up resources in the mock clients.
rgs := cloud.ResourceGroupsClient.RGs rgs := cloud.ResourceGroupsClient.RGs
rgs[rgName] = azureresources.Group{ rgs[rgName] = &armresources.ResourceGroup{
Name: to.StringPtr(rgName), Name: to.Ptr(rgName),
Tags: clusterTags, Tags: clusterTags,
} }
rgs[irrelevantName] = azureresources.Group{ rgs[irrelevantName] = &armresources.ResourceGroup{
Name: to.StringPtr(irrelevantName), Name: to.Ptr(irrelevantName),
} }
vnets := cloud.VirtualNetworksClient.VNets vnets := cloud.VirtualNetworksClient.VNets
vnets[vnetName] = network.VirtualNetwork{ vnets[vnetName] = &network.VirtualNetwork{
Name: to.StringPtr(vnetName), Name: to.Ptr(vnetName),
Tags: clusterTags, Tags: clusterTags,
VirtualNetworkPropertiesFormat: &network.VirtualNetworkPropertiesFormat{}, Properties: &network.VirtualNetworkPropertiesFormat{},
} }
vnets[irrelevantName] = network.VirtualNetwork{ vnets[irrelevantName] = &network.VirtualNetwork{
Name: to.StringPtr(irrelevantName), Name: to.Ptr(irrelevantName),
} }
subnets := cloud.SubnetsClient.Subnets subnets := cloud.SubnetsClient.Subnets
subnets[rgName] = network.Subnet{ subnets[rgName] = &network.Subnet{
Name: to.StringPtr(subnetName), Name: to.Ptr(subnetName),
SubnetPropertiesFormat: &network.SubnetPropertiesFormat{}, Properties: &network.SubnetPropertiesFormat{},
} }
vnets[irrelevantName] = network.VirtualNetwork{ vnets[irrelevantName] = &network.VirtualNetwork{
Name: to.StringPtr(irrelevantName), Name: to.Ptr(irrelevantName),
} }
rts := cloud.RouteTablesClient.RTs rts := cloud.RouteTablesClient.RTs
rts[rtName] = network.RouteTable{ rts[rtName] = &network.RouteTable{
Name: to.StringPtr(rtName), Name: to.Ptr(rtName),
Tags: clusterTags, Tags: clusterTags,
} }
rts[irrelevantName] = network.RouteTable{ rts[irrelevantName] = &network.RouteTable{
Name: to.StringPtr(irrelevantName), Name: to.Ptr(irrelevantName),
} }
vmsses := cloud.VMScaleSetsClient.VMSSes vmsses := cloud.VMScaleSetsClient.VMSSes
@ -96,47 +96,47 @@ func TestListResourcesAzure(t *testing.T) {
VirtualNetworkName: vnetName, VirtualNetworkName: vnetName,
SubnetName: subnetName, SubnetName: subnetName,
} }
networkConfig := compute.VirtualMachineScaleSetNetworkConfiguration{ networkConfig := &compute.VirtualMachineScaleSetNetworkConfiguration{
VirtualMachineScaleSetNetworkConfigurationProperties: &compute.VirtualMachineScaleSetNetworkConfigurationProperties{ Properties: &compute.VirtualMachineScaleSetNetworkConfigurationProperties{
IPConfigurations: &[]compute.VirtualMachineScaleSetIPConfiguration{ IPConfigurations: []*compute.VirtualMachineScaleSetIPConfiguration{
{ {
VirtualMachineScaleSetIPConfigurationProperties: &compute.VirtualMachineScaleSetIPConfigurationProperties{ Properties: &compute.VirtualMachineScaleSetIPConfigurationProperties{
Subnet: &compute.APIEntityReference{ Subnet: &compute.APIEntityReference{
ID: to.StringPtr(subnetID.String()), ID: to.Ptr(subnetID.String()),
}, },
}, },
}, },
}, },
}, },
} }
vmsses[vmssName] = compute.VirtualMachineScaleSet{ vmsses[vmssName] = &compute.VirtualMachineScaleSet{
Name: to.StringPtr(vmssName), Name: to.Ptr(vmssName),
Tags: clusterTags, Tags: clusterTags,
VirtualMachineScaleSetProperties: &compute.VirtualMachineScaleSetProperties{ Properties: &compute.VirtualMachineScaleSetProperties{
VirtualMachineProfile: &compute.VirtualMachineScaleSetVMProfile{ VirtualMachineProfile: &compute.VirtualMachineScaleSetVMProfile{
NetworkProfile: &compute.VirtualMachineScaleSetNetworkProfile{ NetworkProfile: &compute.VirtualMachineScaleSetNetworkProfile{
NetworkInterfaceConfigurations: &[]compute.VirtualMachineScaleSetNetworkConfiguration{ NetworkInterfaceConfigurations: []*compute.VirtualMachineScaleSetNetworkConfiguration{
networkConfig, networkConfig,
}, },
}, },
}, },
}, },
Identity: &compute.VirtualMachineScaleSetIdentity{ Identity: &compute.VirtualMachineScaleSetIdentity{
Type: compute.ResourceIdentityTypeSystemAssigned, Type: to.Ptr(compute.ResourceIdentityTypeSystemAssigned),
PrincipalID: to.StringPtr(principalID), PrincipalID: to.Ptr(principalID),
}, },
} }
vmsses[irrelevantName] = compute.VirtualMachineScaleSet{ vmsses[irrelevantName] = &compute.VirtualMachineScaleSet{
Name: to.StringPtr(irrelevantName), Name: to.Ptr(irrelevantName),
} }
vms := cloud.VMScaleSetVMsClient.VMs vms := cloud.VMScaleSetVMsClient.VMs
vms[vmName] = compute.VirtualMachineScaleSetVM{ vms[vmName] = &compute.VirtualMachineScaleSetVM{
VirtualMachineScaleSetVMProperties: &compute.VirtualMachineScaleSetVMProperties{ Properties: &compute.VirtualMachineScaleSetVMProperties{
StorageProfile: &compute.StorageProfile{ StorageProfile: &compute.StorageProfile{
DataDisks: &[]compute.DataDisk{ DataDisks: []*compute.DataDisk{
{ {
Name: to.StringPtr(diskName), Name: to.Ptr(diskName),
}, },
}, },
}, },
@ -144,34 +144,34 @@ func TestListResourcesAzure(t *testing.T) {
} }
disks := cloud.DisksClient.Disks disks := cloud.DisksClient.Disks
disks[diskName] = compute.Disk{ disks[diskName] = &compute.Disk{
Name: to.StringPtr(diskName), Name: to.Ptr(diskName),
Tags: clusterTags, Tags: clusterTags,
} }
disks[irrelevantName] = compute.Disk{ disks[irrelevantName] = &compute.Disk{
Name: to.StringPtr(irrelevantName), Name: to.Ptr(irrelevantName),
} }
ras := cloud.RoleAssignmentsClient.RAs ras := cloud.RoleAssignmentsClient.RAs
ras[raName] = authz.RoleAssignment{ ras[raName] = &authz.RoleAssignment{
Name: to.StringPtr(raName), Name: to.Ptr(raName),
RoleAssignmentPropertiesWithScope: &authz.RoleAssignmentPropertiesWithScope{ Properties: &authz.RoleAssignmentProperties{
Scope: to.StringPtr("scope"), Scope: to.Ptr("scope"),
PrincipalID: to.StringPtr(principalID), PrincipalID: to.Ptr(principalID),
}, },
} }
disks[irrelevantName] = compute.Disk{ disks[irrelevantName] = &compute.Disk{
Name: to.StringPtr(irrelevantName), Name: to.Ptr(irrelevantName),
} }
lbs := cloud.LoadBalancersClient.LBs lbs := cloud.LoadBalancersClient.LBs
lbs[lbName] = network.LoadBalancer{ lbs[lbName] = &network.LoadBalancer{
Name: to.StringPtr(lbName), Name: to.Ptr(lbName),
Tags: clusterTags, Tags: clusterTags,
LoadBalancerPropertiesFormat: &network.LoadBalancerPropertiesFormat{}, Properties: &network.LoadBalancerPropertiesFormat{},
} }
lbs[irrelevantName] = network.LoadBalancer{ lbs[irrelevantName] = &network.LoadBalancer{
Name: to.StringPtr(irrelevantName), Name: to.Ptr(irrelevantName),
} }
// Call listResourcesAzure. // Call listResourcesAzure.
@ -277,26 +277,26 @@ func TestIsOwnedByCluster(t *testing.T) {
}{ }{
{ {
tags: map[string]*string{ tags: map[string]*string{
azure.TagClusterName: to.StringPtr(clusterName), azure.TagClusterName: to.Ptr(clusterName),
}, },
expected: true, expected: true,
}, },
{ {
tags: map[string]*string{ tags: map[string]*string{
azure.TagClusterName: to.StringPtr(clusterName), azure.TagClusterName: to.Ptr(clusterName),
"other-key": to.StringPtr("other-tag"), "other-key": to.Ptr("other-tag"),
}, },
expected: true, expected: true,
}, },
{ {
tags: map[string]*string{ tags: map[string]*string{
"other-key": to.StringPtr("other-tag"), "other-key": to.Ptr("other-tag"),
}, },
expected: false, expected: false,
}, },
{ {
tags: map[string]*string{ tags: map[string]*string{
azure.TagClusterName: to.StringPtr("different-cluster"), azure.TagClusterName: to.Ptr("different-cluster"),
}, },
expected: false, expected: false,
}, },