github/kubernetes
1
0
Fork 0
mirror of https://github.com/k3s-io/kubernetes.git synced 2025-08-17 15:50:10 +00:00
Code Issues Projects Releases Wiki Activity

Merge pull request #58276 from feiskyer/vmss-name

Browse Source 
Automatic merge from submit-queue. If you want to cherry-pick this change to another branch, please follow the instructions <a href="https://github.com/kubernetes/community/blob/master/contributors/devel/cherry-picks.md">here</a>.

Convert ComputerName to lower case

**What this PR does / why we need it**:

When instances count is greater than 10, azure will generate instance hostname with upper cases. But kubelet always converts hostname to lower case.

So azure cloud provider should also covert OsProfile.ComputerName to lower case.

**Which issue(s) this PR fixes** *(optional, in `fixes #<issue number>(, fixes #<issue_number>, ...)` format, will close the issue(s) when PR gets merged)*:
Fixes #58274

**Special notes for your reviewer**:

This PR also adds more unit tests for scale sets.

**Release note**:

```release-note
NONE
```
This commit is contained in:
Kubernetes Submit Queue 2018-01-15 22:27:41 -08:00 committed by GitHub
commit bc361fae40
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
8 changed files with 241 additions and 130 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
pkg/cloudprovider/providers/azure/BUILD
View File

@ -12,6 +12,7 @@ go_library(
"azure.go", "azure.go",
"azure_backoff.go", "azure_backoff.go",
"azure_blobDiskController.go", "azure_blobDiskController.go",
"azure_cache.go",
"azure_client.go", "azure_client.go",
"azure_controllerCommon.go", "azure_controllerCommon.go",
"azure_fakes.go", "azure_fakes.go",
@ -21,12 +22,11 @@ go_library(
"azure_managedDiskController.go", "azure_managedDiskController.go",
"azure_metrics.go", "azure_metrics.go",
"azure_routes.go", "azure_routes.go",
"azure_standard.go",
"azure_storage.go", "azure_storage.go",
"azure_storageaccount.go", "azure_storageaccount.go",
"azure_util.go",
"azure_util_cache.go",
"azure_util_vmss.go",
"azure_vmsets.go", "azure_vmsets.go",
"azure_vmss.go",
"azure_wrap.go", "azure_wrap.go",
"azure_zones.go", "azure_zones.go",
], ],
@ -64,11 +64,11 @@ go_library(
go_test( go_test(
name = "go_default_test", name = "go_default_test",
srcs = [ srcs = [
"azure_cache_test.go",
"azure_loadbalancer_test.go", "azure_loadbalancer_test.go",
"azure_metrics_test.go", "azure_metrics_test.go",
"azure_test.go", "azure_test.go",
"azure_util_cache_test.go", "azure_vmss_test.go",
"azure_util_test.go",
"azure_wrap_test.go", "azure_wrap_test.go",
], ],
embed = [":go_default_library"], embed = [":go_default_library"],

0
pkg/cloudprovider/providers/azure/azure_util_cache.go → pkg/cloudprovider/providers/azure/azure_cache.go
View File

0
pkg/cloudprovider/providers/azure/azure_util_cache_test.go → pkg/cloudprovider/providers/azure/azure_cache_test.go
View File

155
pkg/cloudprovider/providers/azure/azure_fakes.go
View File

@ -37,14 +37,14 @@ type fakeAzureLBClient struct {
FakeStore map[string]map[string]network.LoadBalancer FakeStore map[string]map[string]network.LoadBalancer
} }
func newFakeAzureLBClient() fakeAzureLBClient { func newFakeAzureLBClient() *fakeAzureLBClient {
fLBC := fakeAzureLBClient{} fLBC := &fakeAzureLBClient{}
fLBC.FakeStore = make(map[string]map[string]network.LoadBalancer) fLBC.FakeStore = make(map[string]map[string]network.LoadBalancer)
fLBC.mutex = &sync.Mutex{} fLBC.mutex = &sync.Mutex{}
return fLBC return fLBC
} }
func (fLBC fakeAzureLBClient) CreateOrUpdate(resourceGroupName string, loadBalancerName string, parameters network.LoadBalancer, cancel <-chan struct{}) (<-chan network.LoadBalancer, <-chan error) { func (fLBC *fakeAzureLBClient) CreateOrUpdate(resourceGroupName string, loadBalancerName string, parameters network.LoadBalancer, cancel <-chan struct{}) (<-chan network.LoadBalancer, <-chan error) {
fLBC.mutex.Lock() fLBC.mutex.Lock()
defer fLBC.mutex.Unlock() defer fLBC.mutex.Unlock()
resultChan := make(chan network.LoadBalancer, 1) resultChan := make(chan network.LoadBalancer, 1)
@ -80,7 +80,7 @@ func (fLBC fakeAzureLBClient) CreateOrUpdate(resourceGroupName string, loadBalan
return resultChan, errChan return resultChan, errChan
} }
func (fLBC fakeAzureLBClient) Delete(resourceGroupName string, loadBalancerName string, cancel <-chan struct{}) (<-chan autorest.Response, <-chan error) { func (fLBC *fakeAzureLBClient) Delete(resourceGroupName string, loadBalancerName string, cancel <-chan struct{}) (<-chan autorest.Response, <-chan error) {
fLBC.mutex.Lock() fLBC.mutex.Lock()
defer fLBC.mutex.Unlock() defer fLBC.mutex.Unlock()
respChan := make(chan autorest.Response, 1) respChan := make(chan autorest.Response, 1)
@ -113,7 +113,7 @@ func (fLBC fakeAzureLBClient) Delete(resourceGroupName string, loadBalancerName
return respChan, errChan return respChan, errChan
} }
func (fLBC fakeAzureLBClient) Get(resourceGroupName string, loadBalancerName string, expand string) (result network.LoadBalancer, err error) { func (fLBC *fakeAzureLBClient) Get(resourceGroupName string, loadBalancerName string, expand string) (result network.LoadBalancer, err error) {
fLBC.mutex.Lock() fLBC.mutex.Lock()
defer fLBC.mutex.Unlock() defer fLBC.mutex.Unlock()
if _, ok := fLBC.FakeStore[resourceGroupName]; ok { if _, ok := fLBC.FakeStore[resourceGroupName]; ok {
@ -127,7 +127,7 @@ func (fLBC fakeAzureLBClient) Get(resourceGroupName string, loadBalancerName str
} }
} }
func (fLBC fakeAzureLBClient) List(resourceGroupName string) (result network.LoadBalancerListResult, err error) { func (fLBC *fakeAzureLBClient) List(resourceGroupName string) (result network.LoadBalancerListResult, err error) {
fLBC.mutex.Lock() fLBC.mutex.Lock()
defer fLBC.mutex.Unlock() defer fLBC.mutex.Unlock()
var value []network.LoadBalancer var value []network.LoadBalancer
@ -144,7 +144,7 @@ func (fLBC fakeAzureLBClient) List(resourceGroupName string) (result network.Loa
return result, nil return result, nil
} }
func (fLBC fakeAzureLBClient) ListNextResults(resourceGroupName string, lastResult network.LoadBalancerListResult) (result network.LoadBalancerListResult, err error) { func (fLBC *fakeAzureLBClient) ListNextResults(resourceGroupName string, lastResult network.LoadBalancerListResult) (result network.LoadBalancerListResult, err error) {
fLBC.mutex.Lock() fLBC.mutex.Lock()
defer fLBC.mutex.Unlock() defer fLBC.mutex.Unlock()
result.Response.Response = &http.Response{ result.Response.Response = &http.Response{
@ -172,15 +172,15 @@ func getpublicIPAddressID(subscriptionID string, resourceGroupName, pipName stri
pipName) pipName)
} }
func newFakeAzurePIPClient(subscriptionID string) fakeAzurePIPClient { func newFakeAzurePIPClient(subscriptionID string) *fakeAzurePIPClient {
fAPC := fakeAzurePIPClient{} fAPC := &fakeAzurePIPClient{}
fAPC.FakeStore = make(map[string]map[string]network.PublicIPAddress) fAPC.FakeStore = make(map[string]map[string]network.PublicIPAddress)
fAPC.SubscriptionID = subscriptionID fAPC.SubscriptionID = subscriptionID
fAPC.mutex = &sync.Mutex{} fAPC.mutex = &sync.Mutex{}
return fAPC return fAPC
} }
func (fAPC fakeAzurePIPClient) CreateOrUpdate(resourceGroupName string, publicIPAddressName string, parameters network.PublicIPAddress, cancel <-chan struct{}) (<-chan network.PublicIPAddress, <-chan error) { func (fAPC *fakeAzurePIPClient) CreateOrUpdate(resourceGroupName string, publicIPAddressName string, parameters network.PublicIPAddress, cancel <-chan struct{}) (<-chan network.PublicIPAddress, <-chan error) {
fAPC.mutex.Lock() fAPC.mutex.Lock()
defer fAPC.mutex.Unlock() defer fAPC.mutex.Unlock()
resultChan := make(chan network.PublicIPAddress, 1) resultChan := make(chan network.PublicIPAddress, 1)
@ -217,7 +217,7 @@ func (fAPC fakeAzurePIPClient) CreateOrUpdate(resourceGroupName string, publicIP
return resultChan, errChan return resultChan, errChan
} }
func (fAPC fakeAzurePIPClient) Delete(resourceGroupName string, publicIPAddressName string, cancel <-chan struct{}) (<-chan autorest.Response, <-chan error) { func (fAPC *fakeAzurePIPClient) Delete(resourceGroupName string, publicIPAddressName string, cancel <-chan struct{}) (<-chan autorest.Response, <-chan error) {
fAPC.mutex.Lock() fAPC.mutex.Lock()
defer fAPC.mutex.Unlock() defer fAPC.mutex.Unlock()
respChan := make(chan autorest.Response, 1) respChan := make(chan autorest.Response, 1)
@ -250,7 +250,7 @@ func (fAPC fakeAzurePIPClient) Delete(resourceGroupName string, publicIPAddressN
return respChan, errChan return respChan, errChan
} }
func (fAPC fakeAzurePIPClient) Get(resourceGroupName string, publicIPAddressName string, expand string) (result network.PublicIPAddress, err error) { func (fAPC *fakeAzurePIPClient) Get(resourceGroupName string, publicIPAddressName string, expand string) (result network.PublicIPAddress, err error) {
fAPC.mutex.Lock() fAPC.mutex.Lock()
defer fAPC.mutex.Unlock() defer fAPC.mutex.Unlock()
if _, ok := fAPC.FakeStore[resourceGroupName]; ok { if _, ok := fAPC.FakeStore[resourceGroupName]; ok {
@ -264,13 +264,13 @@ func (fAPC fakeAzurePIPClient) Get(resourceGroupName string, publicIPAddressName
} }
} }
func (fAPC fakeAzurePIPClient) ListNextResults(resourceGroupName string, lastResults network.PublicIPAddressListResult) (result network.PublicIPAddressListResult, err error) { func (fAPC *fakeAzurePIPClient) ListNextResults(resourceGroupName string, lastResults network.PublicIPAddressListResult) (result network.PublicIPAddressListResult, err error) {
fAPC.mutex.Lock() fAPC.mutex.Lock()
defer fAPC.mutex.Unlock() defer fAPC.mutex.Unlock()
return network.PublicIPAddressListResult{}, nil return network.PublicIPAddressListResult{}, nil
} }
func (fAPC fakeAzurePIPClient) List(resourceGroupName string) (result network.PublicIPAddressListResult, err error) { func (fAPC *fakeAzurePIPClient) List(resourceGroupName string) (result network.PublicIPAddressListResult, err error) {
fAPC.mutex.Lock() fAPC.mutex.Lock()
defer fAPC.mutex.Unlock() defer fAPC.mutex.Unlock()
var value []network.PublicIPAddress var value []network.PublicIPAddress
@ -292,15 +292,15 @@ type fakeAzureInterfacesClient struct {
FakeStore map[string]map[string]network.Interface FakeStore map[string]map[string]network.Interface
} }
func newFakeAzureInterfacesClient() fakeAzureInterfacesClient { func newFakeAzureInterfacesClient() *fakeAzureInterfacesClient {
fIC := fakeAzureInterfacesClient{} fIC := &fakeAzureInterfacesClient{}
fIC.FakeStore = make(map[string]map[string]network.Interface) fIC.FakeStore = make(map[string]map[string]network.Interface)
fIC.mutex = &sync.Mutex{} fIC.mutex = &sync.Mutex{}
return fIC return fIC
} }
func (fIC fakeAzureInterfacesClient) CreateOrUpdate(resourceGroupName string, networkInterfaceName string, parameters network.Interface, cancel <-chan struct{}) (<-chan network.Interface, <-chan error) { func (fIC *fakeAzureInterfacesClient) CreateOrUpdate(resourceGroupName string, networkInterfaceName string, parameters network.Interface, cancel <-chan struct{}) (<-chan network.Interface, <-chan error) {
fIC.mutex.Lock() fIC.mutex.Lock()
defer fIC.mutex.Unlock() defer fIC.mutex.Unlock()
resultChan := make(chan network.Interface, 1) resultChan := make(chan network.Interface, 1)
@ -326,7 +326,7 @@ func (fIC fakeAzureInterfacesClient) CreateOrUpdate(resourceGroupName string, ne
return resultChan, errChan return resultChan, errChan
} }
func (fIC fakeAzureInterfacesClient) Get(resourceGroupName string, networkInterfaceName string, expand string) (result network.Interface, err error) { func (fIC *fakeAzureInterfacesClient) Get(resourceGroupName string, networkInterfaceName string, expand string) (result network.Interface, err error) {
fIC.mutex.Lock() fIC.mutex.Lock()
defer fIC.mutex.Unlock() defer fIC.mutex.Unlock()
if _, ok := fIC.FakeStore[resourceGroupName]; ok { if _, ok := fIC.FakeStore[resourceGroupName]; ok {
@ -340,7 +340,7 @@ func (fIC fakeAzureInterfacesClient) Get(resourceGroupName string, networkInterf
} }
} }
func (fIC fakeAzureInterfacesClient) GetVirtualMachineScaleSetNetworkInterface(resourceGroupName string, virtualMachineScaleSetName string, virtualmachineIndex string, networkInterfaceName string, expand string) (result network.Interface, err error) { func (fIC *fakeAzureInterfacesClient) GetVirtualMachineScaleSetNetworkInterface(resourceGroupName string, virtualMachineScaleSetName string, virtualmachineIndex string, networkInterfaceName string, expand string) (result network.Interface, err error) {
return result, nil return result, nil
} }
@ -349,14 +349,14 @@ type fakeAzureVirtualMachinesClient struct {
FakeStore map[string]map[string]compute.VirtualMachine FakeStore map[string]map[string]compute.VirtualMachine
} }
func newFakeAzureVirtualMachinesClient() fakeAzureVirtualMachinesClient { func newFakeAzureVirtualMachinesClient() *fakeAzureVirtualMachinesClient {
fVMC := fakeAzureVirtualMachinesClient{} fVMC := &fakeAzureVirtualMachinesClient{}
fVMC.FakeStore = make(map[string]map[string]compute.VirtualMachine) fVMC.FakeStore = make(map[string]map[string]compute.VirtualMachine)
fVMC.mutex = &sync.Mutex{} fVMC.mutex = &sync.Mutex{}
return fVMC return fVMC
} }
func (fVMC fakeAzureVirtualMachinesClient) CreateOrUpdate(resourceGroupName string, VMName string, parameters compute.VirtualMachine, cancel <-chan struct{}) (<-chan compute.VirtualMachine, <-chan error) { func (fVMC *fakeAzureVirtualMachinesClient) CreateOrUpdate(resourceGroupName string, VMName string, parameters compute.VirtualMachine, cancel <-chan struct{}) (<-chan compute.VirtualMachine, <-chan error) {
fVMC.mutex.Lock() fVMC.mutex.Lock()
defer fVMC.mutex.Unlock() defer fVMC.mutex.Unlock()
resultChan := make(chan compute.VirtualMachine, 1) resultChan := make(chan compute.VirtualMachine, 1)
@ -381,7 +381,7 @@ func (fVMC fakeAzureVirtualMachinesClient) CreateOrUpdate(resourceGroupName stri
return resultChan, errChan return resultChan, errChan
} }
func (fVMC fakeAzureVirtualMachinesClient) Get(resourceGroupName string, VMName string, expand compute.InstanceViewTypes) (result compute.VirtualMachine, err error) { func (fVMC *fakeAzureVirtualMachinesClient) Get(resourceGroupName string, VMName string, expand compute.InstanceViewTypes) (result compute.VirtualMachine, err error) {
fVMC.mutex.Lock() fVMC.mutex.Lock()
defer fVMC.mutex.Unlock() defer fVMC.mutex.Unlock()
if _, ok := fVMC.FakeStore[resourceGroupName]; ok { if _, ok := fVMC.FakeStore[resourceGroupName]; ok {
@ -395,7 +395,7 @@ func (fVMC fakeAzureVirtualMachinesClient) Get(resourceGroupName string, VMName
} }
} }
func (fVMC fakeAzureVirtualMachinesClient) List(resourceGroupName string) (result compute.VirtualMachineListResult, err error) { func (fVMC *fakeAzureVirtualMachinesClient) List(resourceGroupName string) (result compute.VirtualMachineListResult, err error) {
fVMC.mutex.Lock() fVMC.mutex.Lock()
defer fVMC.mutex.Unlock() defer fVMC.mutex.Unlock()
var value []compute.VirtualMachine var value []compute.VirtualMachine
@ -411,7 +411,7 @@ func (fVMC fakeAzureVirtualMachinesClient) List(resourceGroupName string) (resul
result.Value = &value result.Value = &value
return result, nil return result, nil
} }
func (fVMC fakeAzureVirtualMachinesClient) ListNextResults(resourceGroupName string, lastResults compute.VirtualMachineListResult) (result compute.VirtualMachineListResult, err error) { func (fVMC *fakeAzureVirtualMachinesClient) ListNextResults(resourceGroupName string, lastResults compute.VirtualMachineListResult) (result compute.VirtualMachineListResult, err error) {
fVMC.mutex.Lock() fVMC.mutex.Lock()
defer fVMC.mutex.Unlock() defer fVMC.mutex.Unlock()
return compute.VirtualMachineListResult{}, nil return compute.VirtualMachineListResult{}, nil
@ -422,14 +422,14 @@ type fakeAzureSubnetsClient struct {
FakeStore map[string]map[string]network.Subnet FakeStore map[string]map[string]network.Subnet
} }
func newFakeAzureSubnetsClient() fakeAzureSubnetsClient { func newFakeAzureSubnetsClient() *fakeAzureSubnetsClient {
fASC := fakeAzureSubnetsClient{} fASC := &fakeAzureSubnetsClient{}
fASC.FakeStore = make(map[string]map[string]network.Subnet) fASC.FakeStore = make(map[string]map[string]network.Subnet)
fASC.mutex = &sync.Mutex{} fASC.mutex = &sync.Mutex{}
return fASC return fASC
} }
func (fASC fakeAzureSubnetsClient) CreateOrUpdate(resourceGroupName string, virtualNetworkName string, subnetName string, subnetParameters network.Subnet, cancel <-chan struct{}) (<-chan network.Subnet, <-chan error) { func (fASC *fakeAzureSubnetsClient) CreateOrUpdate(resourceGroupName string, virtualNetworkName string, subnetName string, subnetParameters network.Subnet, cancel <-chan struct{}) (<-chan network.Subnet, <-chan error) {
fASC.mutex.Lock() fASC.mutex.Lock()
defer fASC.mutex.Unlock() defer fASC.mutex.Unlock()
resultChan := make(chan network.Subnet, 1) resultChan := make(chan network.Subnet, 1)
@ -455,7 +455,7 @@ func (fASC fakeAzureSubnetsClient) CreateOrUpdate(resourceGroupName string, virt
return resultChan, errChan return resultChan, errChan
} }
func (fASC fakeAzureSubnetsClient) Delete(resourceGroupName string, virtualNetworkName string, subnetName string, cancel <-chan struct{}) (<-chan autorest.Response, <-chan error) { func (fASC *fakeAzureSubnetsClient) Delete(resourceGroupName string, virtualNetworkName string, subnetName string, cancel <-chan struct{}) (<-chan autorest.Response, <-chan error) {
fASC.mutex.Lock() fASC.mutex.Lock()
defer fASC.mutex.Unlock() defer fASC.mutex.Unlock()
respChan := make(chan autorest.Response, 1) respChan := make(chan autorest.Response, 1)
@ -489,7 +489,7 @@ func (fASC fakeAzureSubnetsClient) Delete(resourceGroupName string, virtualNetwo
} }
return respChan, errChan return respChan, errChan
} }
func (fASC fakeAzureSubnetsClient) Get(resourceGroupName string, virtualNetworkName string, subnetName string, expand string) (result network.Subnet, err error) { func (fASC *fakeAzureSubnetsClient) Get(resourceGroupName string, virtualNetworkName string, subnetName string, expand string) (result network.Subnet, err error) {
fASC.mutex.Lock() fASC.mutex.Lock()
defer fASC.mutex.Unlock() defer fASC.mutex.Unlock()
rgVnet := strings.Join([]string{resourceGroupName, virtualNetworkName}, "AND") rgVnet := strings.Join([]string{resourceGroupName, virtualNetworkName}, "AND")
@ -503,7 +503,7 @@ func (fASC fakeAzureSubnetsClient) Get(resourceGroupName string, virtualNetworkN
Message: "Not such Subnet", Message: "Not such Subnet",
} }
} }
func (fASC fakeAzureSubnetsClient) List(resourceGroupName string, virtualNetworkName string) (result network.SubnetListResult, err error) { func (fASC *fakeAzureSubnetsClient) List(resourceGroupName string, virtualNetworkName string) (result network.SubnetListResult, err error) {
fASC.mutex.Lock() fASC.mutex.Lock()
defer fASC.mutex.Unlock() defer fASC.mutex.Unlock()
rgVnet := strings.Join([]string{resourceGroupName, virtualNetworkName}, "AND") rgVnet := strings.Join([]string{resourceGroupName, virtualNetworkName}, "AND")
@ -526,14 +526,14 @@ type fakeAzureNSGClient struct {
FakeStore map[string]map[string]network.SecurityGroup FakeStore map[string]map[string]network.SecurityGroup
} }
func newFakeAzureNSGClient() fakeAzureNSGClient { func newFakeAzureNSGClient() *fakeAzureNSGClient {
fNSG := fakeAzureNSGClient{} fNSG := &fakeAzureNSGClient{}
fNSG.FakeStore = make(map[string]map[string]network.SecurityGroup) fNSG.FakeStore = make(map[string]map[string]network.SecurityGroup)
fNSG.mutex = &sync.Mutex{} fNSG.mutex = &sync.Mutex{}
return fNSG return fNSG
} }
func (fNSG fakeAzureNSGClient) CreateOrUpdate(resourceGroupName string, networkSecurityGroupName string, parameters network.SecurityGroup, cancel <-chan struct{}) (<-chan network.SecurityGroup, <-chan error) { func (fNSG *fakeAzureNSGClient) CreateOrUpdate(resourceGroupName string, networkSecurityGroupName string, parameters network.SecurityGroup, cancel <-chan struct{}) (<-chan network.SecurityGroup, <-chan error) {
fNSG.mutex.Lock() fNSG.mutex.Lock()
defer fNSG.mutex.Unlock() defer fNSG.mutex.Unlock()
resultChan := make(chan network.SecurityGroup, 1) resultChan := make(chan network.SecurityGroup, 1)
@ -558,7 +558,7 @@ func (fNSG fakeAzureNSGClient) CreateOrUpdate(resourceGroupName string, networkS
return resultChan, errChan return resultChan, errChan
} }
func (fNSG fakeAzureNSGClient) Delete(resourceGroupName string, networkSecurityGroupName string, cancel <-chan struct{}) (<-chan autorest.Response, <-chan error) { func (fNSG *fakeAzureNSGClient) Delete(resourceGroupName string, networkSecurityGroupName string, cancel <-chan struct{}) (<-chan autorest.Response, <-chan error) {
fNSG.mutex.Lock() fNSG.mutex.Lock()
defer fNSG.mutex.Unlock() defer fNSG.mutex.Unlock()
respChan := make(chan autorest.Response, 1) respChan := make(chan autorest.Response, 1)
@ -591,7 +591,7 @@ func (fNSG fakeAzureNSGClient) Delete(resourceGroupName string, networkSecurityG
return respChan, errChan return respChan, errChan
} }
func (fNSG fakeAzureNSGClient) Get(resourceGroupName string, networkSecurityGroupName string, expand string) (result network.SecurityGroup, err error) { func (fNSG *fakeAzureNSGClient) Get(resourceGroupName string, networkSecurityGroupName string, expand string) (result network.SecurityGroup, err error) {
fNSG.mutex.Lock() fNSG.mutex.Lock()
defer fNSG.mutex.Unlock() defer fNSG.mutex.Unlock()
if _, ok := fNSG.FakeStore[resourceGroupName]; ok { if _, ok := fNSG.FakeStore[resourceGroupName]; ok {
@ -605,7 +605,7 @@ func (fNSG fakeAzureNSGClient) Get(resourceGroupName string, networkSecurityGrou
} }
} }
func (fNSG fakeAzureNSGClient) List(resourceGroupName string) (result network.SecurityGroupListResult, err error) { func (fNSG *fakeAzureNSGClient) List(resourceGroupName string) (result network.SecurityGroupListResult, err error) {
fNSG.mutex.Lock() fNSG.mutex.Lock()
defer fNSG.mutex.Unlock() defer fNSG.mutex.Unlock()
var value []network.SecurityGroup var value []network.SecurityGroup
@ -632,15 +632,22 @@ type fakeVirtualMachineScaleSetVMsClient struct {
FakeStore map[string]map[string]compute.VirtualMachineScaleSetVM FakeStore map[string]map[string]compute.VirtualMachineScaleSetVM
} }
func newFakeVirtualMachineScaleSetVMsClient() fakeVirtualMachineScaleSetVMsClient { func newFakeVirtualMachineScaleSetVMsClient() *fakeVirtualMachineScaleSetVMsClient {
fVMC := fakeVirtualMachineScaleSetVMsClient{} fVMC := &fakeVirtualMachineScaleSetVMsClient{}
fVMC.FakeStore = make(map[string]map[string]compute.VirtualMachineScaleSetVM) fVMC.FakeStore = make(map[string]map[string]compute.VirtualMachineScaleSetVM)
fVMC.mutex = &sync.Mutex{} fVMC.mutex = &sync.Mutex{}
return fVMC return fVMC
} }
func (fVMC fakeVirtualMachineScaleSetVMsClient) List(resourceGroupName string, virtualMachineScaleSetName string, filter string, selectParameter string, expand string) (result compute.VirtualMachineScaleSetVMListResult, err error) { func (fVMC *fakeVirtualMachineScaleSetVMsClient) setFakeStore(store map[string]map[string]compute.VirtualMachineScaleSetVM) {
fVMC.mutex.Lock()
defer fVMC.mutex.Unlock()
fVMC.FakeStore = store
}
func (fVMC *fakeVirtualMachineScaleSetVMsClient) List(resourceGroupName string, virtualMachineScaleSetName string, filter string, selectParameter string, expand string) (result compute.VirtualMachineScaleSetVMListResult, err error) {
fVMC.mutex.Lock() fVMC.mutex.Lock()
defer fVMC.mutex.Unlock() defer fVMC.mutex.Unlock()
@ -659,11 +666,11 @@ func (fVMC fakeVirtualMachineScaleSetVMsClient) List(resourceGroupName string, v
return result, nil return result, nil
} }
func (fVMC fakeVirtualMachineScaleSetVMsClient) ListNextResults(resourceGroupName string, lastResults compute.VirtualMachineScaleSetVMListResult) (result compute.VirtualMachineScaleSetVMListResult, err error) { func (fVMC *fakeVirtualMachineScaleSetVMsClient) ListNextResults(resourceGroupName string, lastResults compute.VirtualMachineScaleSetVMListResult) (result compute.VirtualMachineScaleSetVMListResult, err error) {
return result, nil return result, nil
} }
func (fVMC fakeVirtualMachineScaleSetVMsClient) Get(resourceGroupName string, VMScaleSetName string, instanceID string) (result compute.VirtualMachineScaleSetVM, err error) { func (fVMC *fakeVirtualMachineScaleSetVMsClient) Get(resourceGroupName string, VMScaleSetName string, instanceID string) (result compute.VirtualMachineScaleSetVM, err error) {
fVMC.mutex.Lock() fVMC.mutex.Lock()
defer fVMC.mutex.Unlock() defer fVMC.mutex.Unlock()
@ -680,7 +687,7 @@ func (fVMC fakeVirtualMachineScaleSetVMsClient) Get(resourceGroupName string, VM
} }
} }
func (fVMC fakeVirtualMachineScaleSetVMsClient) GetInstanceView(resourceGroupName string, VMScaleSetName string, instanceID string) (result compute.VirtualMachineScaleSetVMInstanceView, err error) { func (fVMC *fakeVirtualMachineScaleSetVMsClient) GetInstanceView(resourceGroupName string, VMScaleSetName string, instanceID string) (result compute.VirtualMachineScaleSetVMInstanceView, err error) {
_, err = fVMC.Get(resourceGroupName, VMScaleSetName, instanceID) _, err = fVMC.Get(resourceGroupName, VMScaleSetName, instanceID)
if err != nil { if err != nil {
return result, err return result, err
@ -694,15 +701,22 @@ type fakeVirtualMachineScaleSetsClient struct {
FakeStore map[string]map[string]compute.VirtualMachineScaleSet FakeStore map[string]map[string]compute.VirtualMachineScaleSet
} }
func newFakeVirtualMachineScaleSetsClient() fakeVirtualMachineScaleSetsClient { func newFakeVirtualMachineScaleSetsClient() *fakeVirtualMachineScaleSetsClient {
fVMSSC := fakeVirtualMachineScaleSetsClient{} fVMSSC := &fakeVirtualMachineScaleSetsClient{}
fVMSSC.FakeStore = make(map[string]map[string]compute.VirtualMachineScaleSet) fVMSSC.FakeStore = make(map[string]map[string]compute.VirtualMachineScaleSet)
fVMSSC.mutex = &sync.Mutex{} fVMSSC.mutex = &sync.Mutex{}
return fVMSSC return fVMSSC
} }
func (fVMSSC fakeVirtualMachineScaleSetsClient) CreateOrUpdate(resourceGroupName string, VMScaleSetName string, parameters compute.VirtualMachineScaleSet, cancel <-chan struct{}) (<-chan compute.VirtualMachineScaleSet, <-chan error) { func (fVMSSC *fakeVirtualMachineScaleSetsClient) setFakeStore(store map[string]map[string]compute.VirtualMachineScaleSet) {
fVMSSC.mutex.Lock()
defer fVMSSC.mutex.Unlock()
fVMSSC.FakeStore = store
}
func (fVMSSC *fakeVirtualMachineScaleSetsClient) CreateOrUpdate(resourceGroupName string, VMScaleSetName string, parameters compute.VirtualMachineScaleSet, cancel <-chan struct{}) (<-chan compute.VirtualMachineScaleSet, <-chan error) {
fVMSSC.mutex.Lock() fVMSSC.mutex.Lock()
defer fVMSSC.mutex.Unlock() defer fVMSSC.mutex.Unlock()
@ -729,7 +743,7 @@ func (fVMSSC fakeVirtualMachineScaleSetsClient) CreateOrUpdate(resourceGroupName
return resultChan, errChan return resultChan, errChan
} }
func (fVMSSC fakeVirtualMachineScaleSetsClient) Get(resourceGroupName string, VMScaleSetName string) (result compute.VirtualMachineScaleSet, err error) { func (fVMSSC *fakeVirtualMachineScaleSetsClient) Get(resourceGroupName string, VMScaleSetName string) (result compute.VirtualMachineScaleSet, err error) {
fVMSSC.mutex.Lock() fVMSSC.mutex.Lock()
defer fVMSSC.mutex.Unlock() defer fVMSSC.mutex.Unlock()
@ -745,7 +759,7 @@ func (fVMSSC fakeVirtualMachineScaleSetsClient) Get(resourceGroupName string, VM
} }
} }
func (fVMSSC fakeVirtualMachineScaleSetsClient) List(resourceGroupName string) (result compute.VirtualMachineScaleSetListResult, err error) { func (fVMSSC *fakeVirtualMachineScaleSetsClient) List(resourceGroupName string) (result compute.VirtualMachineScaleSetListResult, err error) {
fVMSSC.mutex.Lock() fVMSSC.mutex.Lock()
defer fVMSSC.mutex.Unlock() defer fVMSSC.mutex.Unlock()
@ -755,7 +769,6 @@ func (fVMSSC fakeVirtualMachineScaleSetsClient) List(resourceGroupName string) (
value = append(value, v) value = append(value, v)
} }
} }
result.Response.Response = &http.Response{ result.Response.Response = &http.Response{
StatusCode: http.StatusOK, StatusCode: http.StatusOK,
} }
@ -764,11 +777,11 @@ func (fVMSSC fakeVirtualMachineScaleSetsClient) List(resourceGroupName string) (
return result, nil return result, nil
} }
func (fVMSSC fakeVirtualMachineScaleSetsClient) ListNextResults(resourceGroupName string, lastResults compute.VirtualMachineScaleSetListResult) (result compute.VirtualMachineScaleSetListResult, err error) { func (fVMSSC *fakeVirtualMachineScaleSetsClient) ListNextResults(resourceGroupName string, lastResults compute.VirtualMachineScaleSetListResult) (result compute.VirtualMachineScaleSetListResult, err error) {
return result, nil return result, nil
} }
func (fVMSSC fakeVirtualMachineScaleSetsClient) UpdateInstances(resourceGroupName string, VMScaleSetName string, VMInstanceIDs compute.VirtualMachineScaleSetVMInstanceRequiredIDs, cancel <-chan struct{}) (<-chan compute.OperationStatusResponse, <-chan error) { func (fVMSSC *fakeVirtualMachineScaleSetsClient) UpdateInstances(resourceGroupName string, VMScaleSetName string, VMInstanceIDs compute.VirtualMachineScaleSetVMInstanceRequiredIDs, cancel <-chan struct{}) (<-chan compute.OperationStatusResponse, <-chan error) {
resultChan := make(chan compute.OperationStatusResponse, 1) resultChan := make(chan compute.OperationStatusResponse, 1)
errChan := make(chan error, 1) errChan := make(chan error, 1)
var result compute.OperationStatusResponse var result compute.OperationStatusResponse
@ -792,14 +805,14 @@ type fakeRoutesClient struct {
FakeStore map[string]map[string]network.Route FakeStore map[string]map[string]network.Route
} }
func newFakeRoutesClient() fakeRoutesClient { func newFakeRoutesClient() *fakeRoutesClient {
fRC := fakeRoutesClient{} fRC := &fakeRoutesClient{}
fRC.FakeStore = make(map[string]map[string]network.Route) fRC.FakeStore = make(map[string]map[string]network.Route)
fRC.mutex = &sync.Mutex{} fRC.mutex = &sync.Mutex{}
return fRC return fRC
} }
func (fRC fakeRoutesClient) CreateOrUpdate(resourceGroupName string, routeTableName string, routeName string, routeParameters network.Route, cancel <-chan struct{}) (<-chan network.Route, <-chan error) { func (fRC *fakeRoutesClient) CreateOrUpdate(resourceGroupName string, routeTableName string, routeName string, routeParameters network.Route, cancel <-chan struct{}) (<-chan network.Route, <-chan error) {
fRC.mutex.Lock() fRC.mutex.Lock()
defer fRC.mutex.Unlock() defer fRC.mutex.Unlock()
@ -826,7 +839,7 @@ func (fRC fakeRoutesClient) CreateOrUpdate(resourceGroupName string, routeTableN
return resultChan, errChan return resultChan, errChan
} }
func (fRC fakeRoutesClient) Delete(resourceGroupName string, routeTableName string, routeName string, cancel <-chan struct{}) (<-chan autorest.Response, <-chan error) { func (fRC *fakeRoutesClient) Delete(resourceGroupName string, routeTableName string, routeName string, cancel <-chan struct{}) (<-chan autorest.Response, <-chan error) {
fRC.mutex.Lock() fRC.mutex.Lock()
defer fRC.mutex.Unlock() defer fRC.mutex.Unlock()
@ -866,14 +879,14 @@ type fakeRouteTablesClient struct {
FakeStore map[string]map[string]network.RouteTable FakeStore map[string]map[string]network.RouteTable
} }
func newFakeRouteTablesClient() fakeRouteTablesClient { func newFakeRouteTablesClient() *fakeRouteTablesClient {
fRTC := fakeRouteTablesClient{} fRTC := &fakeRouteTablesClient{}
fRTC.FakeStore = make(map[string]map[string]network.RouteTable) fRTC.FakeStore = make(map[string]map[string]network.RouteTable)
fRTC.mutex = &sync.Mutex{} fRTC.mutex = &sync.Mutex{}
return fRTC return fRTC
} }
func (fRTC fakeRouteTablesClient) CreateOrUpdate(resourceGroupName string, routeTableName string, parameters network.RouteTable, cancel <-chan struct{}) (<-chan network.RouteTable, <-chan error) { func (fRTC *fakeRouteTablesClient) CreateOrUpdate(resourceGroupName string, routeTableName string, parameters network.RouteTable, cancel <-chan struct{}) (<-chan network.RouteTable, <-chan error) {
fRTC.mutex.Lock() fRTC.mutex.Lock()
defer fRTC.mutex.Unlock() defer fRTC.mutex.Unlock()
@ -900,7 +913,7 @@ func (fRTC fakeRouteTablesClient) CreateOrUpdate(resourceGroupName string, route
return resultChan, errChan return resultChan, errChan
} }
func (fRTC fakeRouteTablesClient) Get(resourceGroupName string, routeTableName string, expand string) (result network.RouteTable, err error) { func (fRTC *fakeRouteTablesClient) Get(resourceGroupName string, routeTableName string, expand string) (result network.RouteTable, err error) {
fRTC.mutex.Lock() fRTC.mutex.Lock()
defer fRTC.mutex.Unlock() defer fRTC.mutex.Unlock()
if _, ok := fRTC.FakeStore[resourceGroupName]; ok { if _, ok := fRTC.FakeStore[resourceGroupName]; ok {
@ -919,14 +932,14 @@ type fakeStorageAccountClient struct {
FakeStore map[string]map[string]storage.Account FakeStore map[string]map[string]storage.Account
} }
func newFakeStorageAccountClient() fakeStorageAccountClient { func newFakeStorageAccountClient() *fakeStorageAccountClient {
fSAC := fakeStorageAccountClient{} fSAC := &fakeStorageAccountClient{}
fSAC.FakeStore = make(map[string]map[string]storage.Account) fSAC.FakeStore = make(map[string]map[string]storage.Account)
fSAC.mutex = &sync.Mutex{} fSAC.mutex = &sync.Mutex{}
return fSAC return fSAC
} }
func (fSAC fakeStorageAccountClient) Create(resourceGroupName string, accountName string, parameters storage.AccountCreateParameters, cancel <-chan struct{}) (<-chan storage.Account, <-chan error) { func (fSAC *fakeStorageAccountClient) Create(resourceGroupName string, accountName string, parameters storage.AccountCreateParameters, cancel <-chan struct{}) (<-chan storage.Account, <-chan error) {
fSAC.mutex.Lock() fSAC.mutex.Lock()
defer fSAC.mutex.Unlock() defer fSAC.mutex.Unlock()
@ -961,7 +974,7 @@ func (fSAC fakeStorageAccountClient) Create(resourceGroupName string, accountNam
return resultChan, errChan return resultChan, errChan
} }
func (fSAC fakeStorageAccountClient) Delete(resourceGroupName string, accountName string) (result autorest.Response, err error) { func (fSAC *fakeStorageAccountClient) Delete(resourceGroupName string, accountName string) (result autorest.Response, err error) {
fSAC.mutex.Lock() fSAC.mutex.Lock()
defer fSAC.mutex.Unlock() defer fSAC.mutex.Unlock()
@ -985,15 +998,15 @@ func (fSAC fakeStorageAccountClient) Delete(resourceGroupName string, accountNam
return result, err return result, err
} }
func (fSAC fakeStorageAccountClient) ListKeys(resourceGroupName string, accountName string) (result storage.AccountListKeysResult, err error) { func (fSAC *fakeStorageAccountClient) ListKeys(resourceGroupName string, accountName string) (result storage.AccountListKeysResult, err error) {
return storage.AccountListKeysResult{}, nil return storage.AccountListKeysResult{}, nil
} }
func (fSAC fakeStorageAccountClient) ListByResourceGroup(resourceGroupName string) (result storage.AccountListResult, err error) { func (fSAC *fakeStorageAccountClient) ListByResourceGroup(resourceGroupName string) (result storage.AccountListResult, err error) {
return storage.AccountListResult{}, nil return storage.AccountListResult{}, nil
} }
func (fSAC fakeStorageAccountClient) GetProperties(resourceGroupName string, accountName string) (result storage.Account, err error) { func (fSAC *fakeStorageAccountClient) GetProperties(resourceGroupName string, accountName string) (result storage.Account, err error) {
fSAC.mutex.Lock() fSAC.mutex.Lock()
defer fSAC.mutex.Unlock() defer fSAC.mutex.Unlock()
@ -1014,14 +1027,14 @@ type fakeDisksClient struct {
FakeStore map[string]map[string]disk.Model FakeStore map[string]map[string]disk.Model
} }
func newFakeDisksClient() fakeDisksClient { func newFakeDisksClient() *fakeDisksClient {
fDC := fakeDisksClient{} fDC := &fakeDisksClient{}
fDC.FakeStore = make(map[string]map[string]disk.Model) fDC.FakeStore = make(map[string]map[string]disk.Model)
fDC.mutex = &sync.Mutex{} fDC.mutex = &sync.Mutex{}
return fDC return fDC
} }
func (fDC fakeDisksClient) CreateOrUpdate(resourceGroupName string, diskName string, diskParameter disk.Model, cancel <-chan struct{}) (<-chan disk.Model, <-chan error) { func (fDC *fakeDisksClient) CreateOrUpdate(resourceGroupName string, diskName string, diskParameter disk.Model, cancel <-chan struct{}) (<-chan disk.Model, <-chan error) {
fDC.mutex.Lock() fDC.mutex.Lock()
defer fDC.mutex.Unlock() defer fDC.mutex.Unlock()
@ -1048,7 +1061,7 @@ func (fDC fakeDisksClient) CreateOrUpdate(resourceGroupName string, diskName str
return resultChan, errChan return resultChan, errChan
} }
func (fDC fakeDisksClient) Delete(resourceGroupName string, diskName string, cancel <-chan struct{}) (<-chan disk.OperationStatusResponse, <-chan error) { func (fDC *fakeDisksClient) Delete(resourceGroupName string, diskName string, cancel <-chan struct{}) (<-chan disk.OperationStatusResponse, <-chan error) {
fDC.mutex.Lock() fDC.mutex.Lock()
defer fDC.mutex.Unlock() defer fDC.mutex.Unlock()
@ -1087,7 +1100,7 @@ func (fDC fakeDisksClient) Delete(resourceGroupName string, diskName string, can
return respChan, errChan return respChan, errChan
} }
func (fDC fakeDisksClient) Get(resourceGroupName string, diskName string) (result disk.Model, err error) { func (fDC *fakeDisksClient) Get(resourceGroupName string, diskName string) (result disk.Model, err error) {
fDC.mutex.Lock() fDC.mutex.Lock()
defer fDC.mutex.Unlock() defer fDC.mutex.Unlock()

0
pkg/cloudprovider/providers/azure/azure_util.go → pkg/cloudprovider/providers/azure/azure_standard.go
View File

53
pkg/cloudprovider/providers/azure/azure_util_test.go
View File

@ -1,53 +0,0 @@
/*
Copyright 2017 The Kubernetes Authors.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package azure
import (
"fmt"
"testing"
"github.com/stretchr/testify/assert"
)
func TestGetScaleSetVMInstanceID(t *testing.T) {
tests := []struct {
msg string
machineName string
expectError bool
expectedInstanceID string
}{{
msg: "invalid vmss instance name",
machineName: "vmvm",
expectError: true,
},
{
msg: "valid vmss instance name",
machineName: "vm00000Z",
expectError: false,
expectedInstanceID: "35",
},
}
for i, test := range tests {
instanceID, err := getScaleSetVMInstanceID(test.machineName)
if test.expectError {
assert.Error(t, err, fmt.Sprintf("TestCase[%d]: %s", i, test.msg))
} else {
assert.Equal(t, test.expectedInstanceID, instanceID, fmt.Sprintf("TestCase[%d]: %s", i, test.msg))
}
}
}

4
pkg/cloudprovider/providers/azure/azure_util_vmss.go → pkg/cloudprovider/providers/azure/azure_vmss.go
View File

@ -121,7 +121,7 @@ func (ss *scaleSet) updateCache() error {
for _, vm := range vms { for _, vm := range vms {
nodeName := "" nodeName := ""
if vm.OsProfile != nil && vm.OsProfile.ComputerName != nil { if vm.OsProfile != nil && vm.OsProfile.ComputerName != nil {
nodeName = *vm.OsProfile.ComputerName nodeName = strings.ToLower(*vm.OsProfile.ComputerName)
} }
vmSize := "" vmSize := ""
@ -190,10 +190,12 @@ func (ss *scaleSet) getCachedVirtualMachine(nodeName string) (scaleSetVMInfo, er
} }
// Update cache and try again. // Update cache and try again.
glog.V(10).Infof("vmss cache before updateCache: %v", ss.cache)
if err := ss.updateCache(); err != nil { if err := ss.updateCache(); err != nil {
glog.Errorf("updateCache failed with error: %v", err) glog.Errorf("updateCache failed with error: %v", err)
return scaleSetVMInfo{}, err return scaleSetVMInfo{}, err
} }
glog.V(10).Infof("vmss cache after updateCache: %v", ss.cache)
vm, found = getVMFromCache(nodeName) vm, found = getVMFromCache(nodeName)
if found { if found {
return vm, nil return vm, nil

149
pkg/cloudprovider/providers/azure/azure_vmss_test.go Normal file
View File

@ -0,0 +1,149 @@
/*
Copyright 2018 The Kubernetes Authors.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package azure
import (
"fmt"
"testing"
"github.com/Azure/azure-sdk-for-go/arm/compute"
"github.com/stretchr/testify/assert"
)
func newTestScaleSet() *scaleSet {
ss := newScaleSet(getTestCloud())
return ss.(*scaleSet)
}
func setTestVirtualMachineScaleSets(ss *scaleSet, scaleSetName string, vmList []string) {
virtualMachineScaleSetsClient := newFakeVirtualMachineScaleSetsClient()
scaleSets := make(map[string]map[string]compute.VirtualMachineScaleSet)
scaleSets["rg"] = map[string]compute.VirtualMachineScaleSet{
scaleSetName: {
Name: &scaleSetName,
},
}
virtualMachineScaleSetsClient.setFakeStore(scaleSets)
virtualMachineScaleSetVMsClient := newFakeVirtualMachineScaleSetVMsClient()
ssVMs := make(map[string]map[string]compute.VirtualMachineScaleSetVM)
ssVMs["rg"] = make(map[string]compute.VirtualMachineScaleSetVM)
for i := range vmList {
ID := fmt.Sprintf("azure:///subscriptions/script/resourceGroups/rg/providers/Microsoft.Compute/virtualMachineScaleSets/%s/virtualMachines/%d", scaleSetName, i)
nodeName := vmList[i]
instanceID := fmt.Sprintf("%d", i)
vmKey := fmt.Sprintf("%s-%s", scaleSetName, nodeName)
networkInterfaces := []compute.NetworkInterfaceReference{
{
ID: &nodeName,
},
}
ssVMs["rg"][vmKey] = compute.VirtualMachineScaleSetVM{
VirtualMachineScaleSetVMProperties: &compute.VirtualMachineScaleSetVMProperties{
OsProfile: &compute.OSProfile{
ComputerName: &nodeName,
},
NetworkProfile: &compute.NetworkProfile{
NetworkInterfaces: &networkInterfaces,
},
},
ID: &ID,
InstanceID: &instanceID,
Location: &ss.Cloud.Location,
}
}
virtualMachineScaleSetVMsClient.setFakeStore(ssVMs)
ss.Cloud.VirtualMachineScaleSetsClient = virtualMachineScaleSetsClient
ss.Cloud.VirtualMachineScaleSetVMsClient = virtualMachineScaleSetVMsClient
}
func TestGetScaleSetVMInstanceID(t *testing.T) {
tests := []struct {
msg string
machineName string
expectError bool
expectedInstanceID string
}{{
msg: "invalid vmss instance name",
machineName: "vmvm",
expectError: true,
},
{
msg: "valid vmss instance name",
machineName: "vm00000Z",
expectError: false,
expectedInstanceID: "35",
},
}
for i, test := range tests {
instanceID, err := getScaleSetVMInstanceID(test.machineName)
if test.expectError {
assert.Error(t, err, fmt.Sprintf("TestCase[%d]: %s", i, test.msg))
} else {
assert.Equal(t, test.expectedInstanceID, instanceID, fmt.Sprintf("TestCase[%d]: %s", i, test.msg))
}
}
}
func TestGetInstanceIDByNodeName(t *testing.T) {
ss := newTestScaleSet()
testCases := []struct {
description string
scaleSet string
vmList []string
nodeName string
expected string
expectError bool
}{
{
description: "scaleSet should get instance by node name",
scaleSet: "ss",
vmList: []string{"vm1", "vm2"},
nodeName: "vm1",
expected: "azure:///subscriptions/script/resourceGroups/rg/providers/Microsoft.Compute/virtualMachineScaleSets/ss/virtualMachines/0",
},
{
description: "scaleSet should get instance by node name with upper cases hostname",
scaleSet: "ss",
vmList: []string{"VM1", "vm2"},
nodeName: "vm1",
expected: "azure:///subscriptions/script/resourceGroups/rg/providers/Microsoft.Compute/virtualMachineScaleSets/ss/virtualMachines/0",
},
{
description: "scaleSet should not get instance for non-exist nodes",
scaleSet: "ss",
vmList: []string{"VM1", "vm2"},
nodeName: "vm3",
expectError: true,
},
}
for _, test := range testCases {
setTestVirtualMachineScaleSets(ss, test.scaleSet, test.vmList)
real, err := ss.GetInstanceIDByNodeName(test.nodeName)
if test.expectError {
assert.Error(t, err, test.description)
continue
}
assert.NoError(t, err, test.description)
assert.Equal(t, test.expected, real, test.description)
}
}