diff --git a/cloud-control-manager/cloud-driver/drivers/azure/connect/Azure_CloudConnection.go b/cloud-control-manager/cloud-driver/drivers/azure/connect/Azure_CloudConnection.go index 691120b46..3d8f88330 100644 --- a/cloud-control-manager/cloud-driver/drivers/azure/connect/Azure_CloudConnection.go +++ b/cloud-control-manager/cloud-driver/drivers/azure/connect/Azure_CloudConnection.go @@ -143,6 +143,7 @@ func (cloudConn *AzureCloudConnection) CreateNLBHandler() (irs.NLBHandler, error NLBBackendAddressPoolsClient: cloudConn.NLBBackendAddressPoolsClient, VNicClient: cloudConn.VNicClient, PublicIPClient: cloudConn.PublicIPClient, + VPCClient: cloudConn.VNetClient, VMClient: cloudConn.VMClient, ScaleSetVMsClient: cloudConn.VirtualMachineScaleSetVMsClient, DiskClient: cloudConn.DiskClient, diff --git a/cloud-control-manager/cloud-driver/drivers/azure/resources/NLBHandler.go b/cloud-control-manager/cloud-driver/drivers/azure/resources/NLBHandler.go index 20a818b65..62d415476 100644 --- a/cloud-control-manager/cloud-driver/drivers/azure/resources/NLBHandler.go +++ b/cloud-control-manager/cloud-driver/drivers/azure/resources/NLBHandler.go @@ -4,6 +4,7 @@ import ( "context" "errors" "fmt" + "regexp" "strconv" "strings" "time" @@ -25,6 +26,7 @@ type AzureNLBHandler struct { NLBBackendAddressPoolsClient *armnetwork.LoadBalancerBackendAddressPoolsClient VNicClient *armnetwork.InterfacesClient PublicIPClient *armnetwork.PublicIPAddressesClient + VPCClient *armnetwork.VirtualNetworksClient VMClient *armcompute.VirtualMachinesClient ScaleSetVMsClient *armcompute.VirtualMachineScaleSetVMsClient DiskClient *armcompute.DisksClient @@ -40,16 +42,14 @@ type NLBType string type NLBScope string const ( - FrontEndIPConfigPrefix = "frontEndIp" - LoadBalancingRulesPrefix = "lbrule" - ProbeNamePrefix = "probe" - BackEndAddressPoolPrefix = "backend" - BackendAddressesIPAddressRef BackendAddressesIPRefType = "IPADDRESS" - BackendAddressesIPConfigurationRef BackendAddressesIPRefType = "IPCONFIGURATION" - NLBPublicType NLBType = "PUBLIC" - NLBInternalType NLBType = "INTERNAL" - NLBGlobalType NLBScope = "GLOBAL" - NLBRegionType NLBScope = "REGION" + FrontEndIPConfigPrefix = "frontEndIp" + LoadBalancingRulesPrefix = "lbrule" + ProbeNamePrefix = "probe" + BackEndAddressPoolPrefix = "backend" + NLBPublicType NLBType = "PUBLIC" + NLBInternalType NLBType = "INTERNAL" + NLBGlobalType NLBScope = "GLOBAL" + NLBRegionType NLBScope = "REGION" ) func convertToLoadBalancerBackendAddressStruct(backEndAddressPoolName string, vpcId string, privateIP string) *armnetwork.LoadBalancerBackendAddress { @@ -64,10 +64,57 @@ func convertToLoadBalancerBackendAddressStruct(backEndAddressPoolName string, vp } } -// ------ NLB Management +func (nlbHandler *AzureNLBHandler) getVMPrivateIP(vpcID string, vmIID irs.IID) (privateIP string, err error) { + vmHandler := AzureVMHandler{ + CredentialInfo: nlbHandler.CredentialInfo, + Region: nlbHandler.Region, + Ctx: nlbHandler.Ctx, + Client: nlbHandler.VMClient, + ScaleSetVMsClient: nlbHandler.ScaleSetVMsClient, + SubnetClient: nlbHandler.SubnetClient, + NicClient: nlbHandler.VNicClient, + PublicIPClient: nlbHandler.PublicIPClient, + DiskClient: nlbHandler.DiskClient, + } + + vm, err := vmHandler.GetVM(vmIID) + if err != nil { + err = errors.New(fmt.Sprintf("Failed to get VM. err = %s", err)) + cblogger.Error(err) + return "", err + } + + var nlbVPC *armnetwork.VirtualNetwork + pager := nlbHandler.VPCClient.NewListPager(nlbHandler.Region.Region, nil) + for pager.More() { + page, err := pager.NextPage(nlbHandler.Ctx) + if err != nil { + return "", errors.New(fmt.Sprintf("Failed to get VPC list. err = %s", err)) + } + + for _, vpc := range page.Value { + if *vpc.ID == vpcID { + nlbVPC = vpc + break + } + } + } + + if nlbVPC == nil { + return "", errors.New("failed to get NLB VPC") + } + + if vm.VpcIID.SystemId != *nlbVPC.ID { + return "", errors.New("VM does not belong to VPC") + } + + return vm.PrivateIP, nil +} + func (nlbHandler *AzureNLBHandler) CreateNLB(nlbReqInfo irs.NLBInfo) (createNLB irs.NLBInfo, createError error) { hiscallInfo := GetCallLogScheme(nlbHandler.Region, "NETWORKLOADBALANCE", nlbReqInfo.IId.NameId, "CreateNLB()") start := call.Start() + err := checkValidationNLB(nlbReqInfo) if err != nil { createError = errors.New(fmt.Sprintf("Failed to Create NLB. err = %s", err.Error())) @@ -75,6 +122,7 @@ func (nlbHandler *AzureNLBHandler) CreateNLB(nlbReqInfo irs.NLBInfo) (createNLB LoggingError(hiscallInfo, createError) return irs.NLBInfo{}, createError } + exist, err := nlbHandler.existNLB(nlbReqInfo.IId) if err != nil { createError = errors.New(fmt.Sprintf("Failed to Create NLB. err = %s", err.Error())) @@ -190,6 +238,33 @@ func (nlbHandler *AzureNLBHandler) CreateNLB(nlbReqInfo irs.NLBInfo) (createNLB return irs.NLBInfo{}, createError } + var nlbVPC *armnetwork.VirtualNetwork + pager := nlbHandler.VPCClient.NewListPager(nlbHandler.Region.Region, nil) + for pager.More() { + page, err := pager.NextPage(nlbHandler.Ctx) + if err != nil { + return irs.NLBInfo{}, errors.New(fmt.Sprintf("Failed to get VPC list. err = %s", err)) + } + + for _, vpc := range page.Value { + if *vpc.Name == nlbReqInfo.VpcIID.NameId || *vpc.ID == nlbReqInfo.VpcIID.SystemId { + nlbVPC = vpc + break + } + } + } + + if nlbVPC == nil { + return irs.NLBInfo{}, errors.New("failed to get NLB VPC") + } + + if nlbReqInfo.VpcIID.NameId != "" && nlbReqInfo.VpcIID.NameId != *nlbVPC.Name { + return irs.NLBInfo{}, errors.New("found NLB VPC NameId is not matched") + } + if nlbReqInfo.VpcIID.SystemId != "" && nlbReqInfo.VpcIID.SystemId != *nlbVPC.ID { + return irs.NLBInfo{}, errors.New("found NLB VPC SystemId is not matched") + } + if len(*nlbReqInfo.VMGroup.VMs) > 0 { // Update BackEndPool var privateIPs []string @@ -201,14 +276,18 @@ func (nlbHandler *AzureNLBHandler) CreateNLB(nlbReqInfo irs.NLBInfo) (createNLB LoggingError(hiscallInfo, getErr) return irs.NLBInfo{}, getErr } - privateIP, err := nlbHandler.getVMPrivateIP(convertedIID) - if err == nil { - privateIPs = append(privateIPs, privateIP) + + privateIP, err := nlbHandler.getVMPrivateIP(*nlbVPC.ID, convertedIID) + if err != nil { + getErr := errors.New(fmt.Sprintf("Failed to Create NLB. err = %s", err)) + cblogger.Error(getErr.Error()) + LoggingError(hiscallInfo, getErr) + return irs.NLBInfo{}, getErr } + privateIPs = append(privateIPs, privateIP) } vpcId := GetNetworksResourceIdByName(nlbHandler.CredentialInfo, nlbHandler.Region, AzureVirtualNetworks, nlbReqInfo.VpcIID.NameId) - // subnetId := fmt.Sprintf("%s/subnets/%s", vpcId, subnetName) resp, err := nlbHandler.NLBBackendAddressPoolsClient.Get(nlbHandler.Ctx, nlbHandler.Region.Region, nlbReqInfo.IId.NameId, backEndAddressPoolName, nil) if err != nil { @@ -254,9 +333,11 @@ func (nlbHandler *AzureNLBHandler) CreateNLB(nlbReqInfo irs.NLBInfo) (createNLB LoggingError(hiscallInfo, createError) return irs.NLBInfo{}, createError } + LoggingInfo(hiscallInfo, start) return *info, nil } + func (nlbHandler *AzureNLBHandler) ListNLB() ([]*irs.NLBInfo, error) { hiscallInfo := GetCallLogScheme(nlbHandler.Region, "NETWORKLOADBALANCE", "NLB", "ListNLB()") start := call.Start() @@ -291,12 +372,15 @@ func (nlbHandler *AzureNLBHandler) ListNLB() ([]*irs.NLBInfo, error) { return nil, getErr } } + LoggingInfo(hiscallInfo, start) return nlbInfoList, nil } + func (nlbHandler *AzureNLBHandler) GetNLB(nlbIID irs.IID) (irs.NLBInfo, error) { hiscallInfo := GetCallLogScheme(nlbHandler.Region, "NETWORKLOADBALANCE", nlbIID.NameId, "GetNLB()") start := call.Start() + rawNLB, err := nlbHandler.getRawNLB(nlbIID) if err != nil { getErr := errors.New(fmt.Sprintf("Failed to Get NLB. err = %s", err.Error())) @@ -312,9 +396,11 @@ func (nlbHandler *AzureNLBHandler) GetNLB(nlbIID irs.IID) (irs.NLBInfo, error) { LoggingError(hiscallInfo, getErr) return irs.NLBInfo{}, getErr } + LoggingInfo(hiscallInfo, start) return *info, nil } + func (nlbHandler *AzureNLBHandler) DeleteNLB(nlbIID irs.IID) (bool, error) { hiscallInfo := GetCallLogScheme(nlbHandler.Region, "NETWORKLOADBALANCE", nlbIID.NameId, "DeleteNLB()") start := call.Start() @@ -341,6 +427,7 @@ func (nlbHandler *AzureNLBHandler) ChangeListener(nlbIID irs.IID, listener irs.L LoggingError(hiscallInfo, changeErr) return irs.ListenerInfo{}, changeErr } + frontendPort, err := strconv.Atoi(listener.Port) if err != nil { changeErr := errors.New(fmt.Sprintf("Failed to ChangeListener NLB. err = %s", err.Error())) @@ -375,6 +462,7 @@ func (nlbHandler *AzureNLBHandler) ChangeListener(nlbIID irs.IID, listener irs.L LoggingError(hiscallInfo, changeErr) return irs.ListenerInfo{}, changeErr } + _, err = poller.PollUntilDone(nlbHandler.Ctx, nil) if err != nil { changeErr := errors.New(fmt.Sprintf("Failed to ChangeListener NLB. err = %s", err.Error())) @@ -382,6 +470,7 @@ func (nlbHandler *AzureNLBHandler) ChangeListener(nlbIID irs.IID, listener irs.L LoggingError(hiscallInfo, changeErr) return irs.ListenerInfo{}, changeErr } + rawNLB, err := nlbHandler.getRawNLB(nlbIID) if err != nil { changeErr := errors.New(fmt.Sprintf("Failed to ChangeListener NLB. err = %s", err.Error())) @@ -389,6 +478,7 @@ func (nlbHandler *AzureNLBHandler) ChangeListener(nlbIID irs.IID, listener irs.L LoggingError(hiscallInfo, changeErr) return irs.ListenerInfo{}, changeErr } + info, err := nlbHandler.setterNLB(rawNLB) if err != nil { changeErr := errors.New(fmt.Sprintf("Failed to ChangeListener NLB. err = %s", err.Error())) @@ -396,9 +486,11 @@ func (nlbHandler *AzureNLBHandler) ChangeListener(nlbIID irs.IID, listener irs.L LoggingError(hiscallInfo, changeErr) return irs.ListenerInfo{}, changeErr } + LoggingInfo(hiscallInfo, start) return info.Listener, nil } + func (nlbHandler *AzureNLBHandler) ChangeVMGroupInfo(nlbIID irs.IID, vmGroup irs.VMGroupInfo) (irs.VMGroupInfo, error) { hiscallInfo := GetCallLogScheme(nlbHandler.Region, "NETWORKLOADBALANCE", nlbIID.NameId, "ChangeVMGroupInfo()") start := call.Start() @@ -409,6 +501,7 @@ func (nlbHandler *AzureNLBHandler) ChangeVMGroupInfo(nlbIID irs.IID, vmGroup irs LoggingError(hiscallInfo, changeErr) return irs.VMGroupInfo{}, changeErr } + // Rule Change backendPort, err := strconv.Atoi(vmGroup.Port) if err != nil { @@ -417,6 +510,7 @@ func (nlbHandler *AzureNLBHandler) ChangeVMGroupInfo(nlbIID irs.IID, vmGroup irs LoggingError(hiscallInfo, changeErr) return irs.VMGroupInfo{}, changeErr } + if len(nlb.Properties.LoadBalancingRules) < 1 { return irs.VMGroupInfo{}, errors.New("not Exist Listener") } @@ -431,6 +525,7 @@ func (nlbHandler *AzureNLBHandler) ChangeVMGroupInfo(nlbIID irs.IID, vmGroup irs LoggingError(hiscallInfo, changeErr) return irs.VMGroupInfo{}, changeErr } + _, err = poller.PollUntilDone(nlbHandler.Ctx, nil) if err != nil { changeErr := errors.New(fmt.Sprintf("Failed to ChangeVMGroupInfo NLB. err = %s", err.Error())) @@ -446,6 +541,7 @@ func (nlbHandler *AzureNLBHandler) ChangeVMGroupInfo(nlbIID irs.IID, vmGroup irs LoggingError(hiscallInfo, changeErr) return irs.VMGroupInfo{}, changeErr } + info, err := nlbHandler.setterNLB(nlb) if err != nil { changeErr := errors.New(fmt.Sprintf("Failed to ChangeVMGroupInfo NLB. err = %s", err.Error())) @@ -453,9 +549,11 @@ func (nlbHandler *AzureNLBHandler) ChangeVMGroupInfo(nlbIID irs.IID, vmGroup irs LoggingError(hiscallInfo, changeErr) return irs.VMGroupInfo{}, changeErr } + LoggingInfo(hiscallInfo, start) return info.VMGroup, nil } + func (nlbHandler *AzureNLBHandler) AddVMs(nlbIID irs.IID, vmIIDs *[]irs.IID) (irs.VMGroupInfo, error) { hiscallInfo := GetCallLogScheme(nlbHandler.Region, "NETWORKLOADBALANCE", nlbIID.NameId, "AddVMs()") start := call.Start() @@ -470,8 +568,9 @@ func (nlbHandler *AzureNLBHandler) AddVMs(nlbIID irs.IID, vmIIDs *[]irs.IID) (ir if len(nlb.Properties.BackendAddressPools) > 0 && len(*vmIIDs) > 0 { backendPools := nlb.Properties.BackendAddressPools cbOnlyOneBackendPool := backendPools[0] + vpcID := *cbOnlyOneBackendPool.Properties.LoadBalancerBackendAddresses[0].Properties.VirtualNetwork.ID - nlbCurrentVMIIds, err := nlbHandler.getVMIIDsByLoadBalancerBackendAddresses(cbOnlyOneBackendPool.Properties.LoadBalancerBackendAddresses) + nlbCurrentVMIIds, err := nlbHandler.getVMIIDsByLoadBalancerBackendAddresses(vpcID, cbOnlyOneBackendPool.Properties.LoadBalancerBackendAddresses) existCheck := false for _, currentVMIId := range nlbCurrentVMIIds { for _, addVmIId := range *vmIIDs { @@ -493,46 +592,16 @@ func (nlbHandler *AzureNLBHandler) AddVMs(nlbIID irs.IID, vmIIDs *[]irs.IID) (ir } backendPoolName := *cbOnlyOneBackendPool.Name - privateIPs := make([]string, len(*vmIIDs)) - for i, vmIID := range *vmIIDs { - ip, err := nlbHandler.getVMPrivateIP(vmIID) - if err != nil { - addErr := errors.New(fmt.Sprintf("Failed to AddVMs NLB. err = %s", err.Error())) - cblogger.Error(addErr.Error()) - LoggingError(hiscallInfo, addErr) - return irs.VMGroupInfo{}, addErr - } - privateIPs[i] = ip - } - // 적어도 하나의 VM 존재시 - vpcId := "" - if cbOnlyOneBackendPool.Properties.LoadBalancerBackendAddresses != nil && len(cbOnlyOneBackendPool.Properties.LoadBalancerBackendAddresses) > 0 { - vpcIId, err := nlbHandler.getVPCIIDByLoadBalancerBackendAddresses(cbOnlyOneBackendPool.Properties.LoadBalancerBackendAddresses) + var privateIPs []string + for _, vmIID := range *vmIIDs { + ip, err := nlbHandler.getVMPrivateIP(vpcID, vmIID) if err != nil { addErr := errors.New(fmt.Sprintf("Failed to AddVMs NLB. err = %s", err.Error())) cblogger.Error(addErr.Error()) LoggingError(hiscallInfo, addErr) return irs.VMGroupInfo{}, addErr } - vpcId = vpcIId.SystemId - } else { - for _, vmIId := range *vmIIDs { - vpcIID, err := nlbHandler.getVPCIIDByVM(vmIId) - if err != nil { - addErr := errors.New(fmt.Sprintf("Failed to AddVMs NLB. err = %s", err.Error())) - cblogger.Error(addErr.Error()) - LoggingError(hiscallInfo, addErr) - return irs.VMGroupInfo{}, addErr - } - if vpcId == "" { - vpcId = vpcIID.SystemId - } else if !strings.EqualFold(vpcId, vpcIID.SystemId) { - addErr := errors.New(fmt.Sprintf("Failed to AddVMs NLB. err = vms in the service group must belong to the same vpc")) - cblogger.Error(addErr.Error()) - LoggingError(hiscallInfo, addErr) - return irs.VMGroupInfo{}, addErr - } - } + privateIPs = append(privateIPs, ip) } resp, err := nlbHandler.NLBBackendAddressPoolsClient.Get(nlbHandler.Ctx, nlbHandler.Region.Region, nlbIID.NameId, backendPoolName, nil) @@ -546,7 +615,7 @@ func (nlbHandler *AzureNLBHandler) AddVMs(nlbIID irs.IID, vmIIDs *[]irs.IID) (ir for _, ip := range privateIPs { resp.BackendAddressPool.Properties.LoadBalancerBackendAddresses = append(resp.BackendAddressPool.Properties.LoadBalancerBackendAddresses, - convertToLoadBalancerBackendAddressStruct(backendPoolName, vpcId, ip)) + convertToLoadBalancerBackendAddressStruct(backendPoolName, vpcID, ip)) } poller, err := nlbHandler.NLBBackendAddressPoolsClient.BeginCreateOrUpdate(nlbHandler.Ctx, nlbHandler.Region.Region, nlbIID.NameId, backendPoolName, resp.BackendAddressPool, nil) @@ -581,8 +650,9 @@ func (nlbHandler *AzureNLBHandler) AddVMs(nlbIID irs.IID, vmIIDs *[]irs.IID) (ir LoggingInfo(hiscallInfo, start) return info.VMGroup, nil } + func (nlbHandler *AzureNLBHandler) RemoveVMs(nlbIID irs.IID, vmIIDs *[]irs.IID) (bool, error) { - hiscallInfo := GetCallLogScheme(nlbHandler.Region, "NETWORKLOADBALANCE", nlbIID.NameId, "AddVMs()") + hiscallInfo := GetCallLogScheme(nlbHandler.Region, "NETWORKLOADBALANCE", nlbIID.NameId, "RemoveVMs()") start := call.Start() nlb, err := nlbHandler.getRawNLB(nlbIID) if err != nil { @@ -595,18 +665,27 @@ func (nlbHandler *AzureNLBHandler) RemoveVMs(nlbIID irs.IID, vmIIDs *[]irs.IID) if len(nlb.Properties.BackendAddressPools) > 0 && len(*vmIIDs) > 0 { backendPools := nlb.Properties.BackendAddressPools cbOnlyOneBackendPool := backendPools[0] + vpcID := *cbOnlyOneBackendPool.Properties.LoadBalancerBackendAddresses[0].Properties.VirtualNetwork.ID - nlbCurrentVMIIds, err := nlbHandler.getVMIIDsByLoadBalancerBackendAddresses(cbOnlyOneBackendPool.Properties.LoadBalancerBackendAddresses) + nlbCurrentVMIIds, err := nlbHandler.getVMIIDsByLoadBalancerBackendAddresses(vpcID, cbOnlyOneBackendPool.Properties.LoadBalancerBackendAddresses) + if err != nil { + removeErr := errors.New(fmt.Sprintf("Failed to RemoveVMs NLB. err = %s", err.Error())) + cblogger.Error(removeErr.Error()) + LoggingError(hiscallInfo, removeErr) + return false, removeErr + } for _, removeVmIId := range *vmIIDs { - existCheck := false + found := false for _, currentVMIId := range nlbCurrentVMIIds { if strings.EqualFold(currentVMIId.NameId, removeVmIId.NameId) { - existCheck = true + found = true + break } } - if !existCheck { - removeErr := errors.New(fmt.Sprintf("Failed to RemoveVMs NLB. err = can't remove not exist vm")) + + if !found { + removeErr := errors.New(fmt.Sprintf("Failed to RemoveVMs NLB. err = can't remove not exist vm (" + removeVmIId.NameId + ")")) cblogger.Error(removeErr.Error()) LoggingError(hiscallInfo, removeErr) return false, removeErr @@ -615,73 +694,53 @@ func (nlbHandler *AzureNLBHandler) RemoveVMs(nlbIID irs.IID, vmIIDs *[]irs.IID) backendPoolName := *cbOnlyOneBackendPool.Name - var removePrivateIPs []string - - for _, vmIId := range *vmIIDs { - privateIP, err := nlbHandler.getVMPrivateIP(vmIId) - if err != nil { - removeErr := errors.New(fmt.Sprintf("Failed to RemoveVMs NLB. err = %s", err.Error())) - cblogger.Error(removeErr.Error()) - LoggingError(hiscallInfo, removeErr) - return false, removeErr + var nlbUpdateVMIIds []irs.IID + for _, currentVMIId := range nlbCurrentVMIIds { + found := false + for _, removeVmIId := range *vmIIDs { + if strings.EqualFold(currentVMIId.NameId, removeVmIId.NameId) { + found = true + break + } } - removePrivateIPs = append(removePrivateIPs, privateIP) - } + if found { + continue + } - resp, err := nlbHandler.NLBBackendAddressPoolsClient.Get(nlbHandler.Ctx, nlbHandler.Region.Region, nlbIID.NameId, backendPoolName, nil) - if err != nil { - removeErr := errors.New(fmt.Sprintf("Failed to RemoveVMs NLB. err = %s", err.Error())) - cblogger.Error(removeErr.Error()) - LoggingError(hiscallInfo, removeErr) - return false, removeErr + nlbUpdateVMIIds = append(nlbUpdateVMIIds, currentVMIId) } - currentVMIIds, err := nlbHandler.getVMIIDsByLoadBalancerBackendAddresses(resp.BackendAddressPool.Properties.LoadBalancerBackendAddresses) - if err != nil { - removeErr := errors.New(fmt.Sprintf("Failed to RemoveVMs NLB. err = %s", err.Error())) - cblogger.Error(removeErr.Error()) - LoggingError(hiscallInfo, removeErr) - return false, removeErr - } - - var currentVMPrivateIPs []string - - for _, vmIId := range currentVMIIds { - privateIP, err := nlbHandler.getVMPrivateIP(vmIId) + var updateVMPrivateIPs []string + for _, vmIId := range nlbUpdateVMIIds { + privateIP, err := nlbHandler.getVMPrivateIP(vpcID, vmIId) if err != nil { removeErr := errors.New(fmt.Sprintf("Failed to RemoveVMs NLB. err = %s", err.Error())) cblogger.Error(removeErr.Error()) LoggingError(hiscallInfo, removeErr) return false, removeErr } - currentVMPrivateIPs = append(currentVMPrivateIPs, privateIP) + + updateVMPrivateIPs = append(updateVMPrivateIPs, privateIP) } - vpcIId, err := nlbHandler.getVPCIIDByLoadBalancerBackendAddresses(cbOnlyOneBackendPool.Properties.LoadBalancerBackendAddresses) + resp, err := nlbHandler.NLBBackendAddressPoolsClient.Get(nlbHandler.Ctx, nlbHandler.Region.Region, nlbIID.NameId, backendPoolName, nil) if err != nil { removeErr := errors.New(fmt.Sprintf("Failed to RemoveVMs NLB. err = %s", err.Error())) cblogger.Error(removeErr.Error()) LoggingError(hiscallInfo, removeErr) return false, removeErr } - for _, currentIP := range currentVMPrivateIPs { - chk := false - addIPSet := "" - for _, removeIP := range removePrivateIPs { - if strings.EqualFold(removeIP, currentIP) { - chk = true - break - } - addIPSet = currentIP - } - if !chk { - resp.BackendAddressPool.Properties.LoadBalancerBackendAddresses = - append(resp.BackendAddressPool.Properties.LoadBalancerBackendAddresses, - convertToLoadBalancerBackendAddressStruct(backendPoolName, vpcIId.SystemId, addIPSet)) - } + + var updateLoadBalancerBackendAddresses []*armnetwork.LoadBalancerBackendAddress + for _, updateIP := range updateVMPrivateIPs { + updateLoadBalancerBackendAddresses = + append(updateLoadBalancerBackendAddresses, + convertToLoadBalancerBackendAddressStruct(backendPoolName, vpcID, updateIP)) } + resp.BackendAddressPool.Properties.LoadBalancerBackendAddresses = updateLoadBalancerBackendAddresses + poller, err := nlbHandler.NLBBackendAddressPoolsClient.BeginCreateOrUpdate(nlbHandler.Ctx, nlbHandler.Region.Region, nlbIID.NameId, backendPoolName, resp.BackendAddressPool, nil) if err != nil { removeErr := errors.New(fmt.Sprintf("Failed to RemoveVMs NLB. err = %s", err.Error())) @@ -699,11 +758,13 @@ func (nlbHandler *AzureNLBHandler) RemoveVMs(nlbIID irs.IID, vmIIDs *[]irs.IID) LoggingInfo(hiscallInfo, start) return true, nil } + removeErr := errors.New(fmt.Sprintf("Failed to RemoveVMs NLB. err = no exist vm to remove")) cblogger.Error(removeErr.Error()) LoggingError(hiscallInfo, removeErr) return false, removeErr } + func (nlbHandler *AzureNLBHandler) GetVMGroupHealthInfo(nlbIID irs.IID) (irs.HealthInfo, error) { hiscallInfo := GetCallLogScheme(nlbHandler.Region, "NETWORKLOADBALANCE", nlbIID.NameId, "GetVMGroupHealthInfo()") start := call.Start() @@ -747,6 +808,7 @@ func (nlbHandler *AzureNLBHandler) GetVMGroupHealthInfo(nlbIID irs.IID) (irs.Hea UnHealthyVMs: &unhealthVMIIds, }, nil } + func (nlbHandler *AzureNLBHandler) ChangeHealthCheckerInfo(nlbIID irs.IID, healthChecker irs.HealthCheckerInfo) (irs.HealthCheckerInfo, error) { hiscallInfo := GetCallLogScheme(nlbHandler.Region, "NETWORKLOADBALANCE", nlbIID.NameId, "ChangeHealthCheckerInfo()") start := call.Start() @@ -897,17 +959,19 @@ type vmIP struct { } func (nlbHandler *AzureNLBHandler) getVMIPs(nlbIId irs.IID) ([]vmIP, error) { - rawnlb, err := nlbHandler.getRawNLB(nlbIId) + rawNLB, err := nlbHandler.getRawNLB(nlbIId) if err != nil { return nil, err } - info, err := nlbHandler.setterNLB(rawnlb) + + info, err := nlbHandler.setterNLB(rawNLB) if err != nil { return nil, err } - vmIPs := make([]vmIP, len(*info.VMGroup.VMs)) - for i, vmiid := range *info.VMGroup.VMs { - resp, err := nlbHandler.VMClient.Get(nlbHandler.Ctx, nlbHandler.Region.Region, vmiid.NameId, nil) + + var vmIPs []vmIP + for _, vmIID := range *info.VMGroup.VMs { + resp, err := nlbHandler.VMClient.Get(nlbHandler.Ctx, nlbHandler.Region.Region, vmIID.NameId, nil) if err != nil { return nil, err } @@ -915,13 +979,16 @@ func (nlbHandler *AzureNLBHandler) getVMIPs(nlbIId irs.IID) ([]vmIP, error) { if err != nil { return nil, err } - vmIPs[i] = vmIP{ + + vmIPs = append(vmIPs, vmIP{ IP: ip, - VMIID: vmiid, - } + VMIID: vmIID, + }) } + return vmIPs, nil } + func (nlbHandler *AzureNLBHandler) getPrivateIPByRawVm(rawVm *armcompute.VirtualMachine) (string, error) { niList := rawVm.Properties.NetworkProfile.NetworkInterfaces var VNicId string @@ -941,6 +1008,7 @@ func (nlbHandler *AzureNLBHandler) getPrivateIPByRawVm(rawVm *armcompute.Virtual } return "", errors.New("not found IP") } + func (nlbHandler *AzureNLBHandler) NLBCleaner(nlbIID irs.IID) (bool, error) { // exist Check exist, err := nlbHandler.existNLB(nlbIID) @@ -1014,8 +1082,8 @@ func (nlbHandler *AzureNLBHandler) NLBCleaner(nlbIID irs.IID) (bool, error) { } return true, nil } + func (nlbHandler *AzureNLBHandler) existNLB(nlbIID irs.IID) (bool, error) { - // exist Check var nlbList []*armnetwork.LoadBalancer pager := nlbHandler.NLBClient.NewListPager(nlbHandler.Region.Region, nil) @@ -1038,6 +1106,7 @@ func (nlbHandler *AzureNLBHandler) existNLB(nlbIID irs.IID) (bool, error) { } return false, nil } + func (nlbHandler *AzureNLBHandler) setterNLB(nlb *armnetwork.LoadBalancer) (*irs.NLBInfo, error) { nlbInfo := irs.NLBInfo{ IId: irs.IID{ @@ -1057,11 +1126,14 @@ func (nlbHandler *AzureNLBHandler) setterNLB(nlb *armnetwork.LoadBalancer) (*irs if len(nlb.Properties.BackendAddressPools) > 0 { // TODO: Deliver multiple backendPools in the future cbOnlyOneBackendPool := nlb.Properties.BackendAddressPools[0] - vpcIId, err := nlbHandler.getVPCIIDByLoadBalancerBackendAddresses(cbOnlyOneBackendPool.Properties.LoadBalancerBackendAddresses) - if err != nil { - return nil, err + if len(cbOnlyOneBackendPool.Properties.LoadBalancerBackendAddresses) < 1 { + return nil, errors.New("failed to get VPC information") + } + vpcID := *cbOnlyOneBackendPool.Properties.LoadBalancerBackendAddresses[0].Properties.VirtualNetwork.ID + nlbInfo.VpcIID = irs.IID{ + NameId: GetResourceNameById(vpcID), + SystemId: vpcID, } - nlbInfo.VpcIID = vpcIId } vmGroup, listenerInfo, healthCheckerInfo, err := nlbHandler.getLoadBalancingRuleInfoByNLB(nlb) @@ -1088,88 +1160,105 @@ func (nlbHandler *AzureNLBHandler) setterNLB(nlb *armnetwork.LoadBalancer) (*irs return &nlbInfo, nil } -func (nlbHandler *AzureNLBHandler) getVPCIIDByLoadBalancerBackendAddresses(address []*armnetwork.LoadBalancerBackendAddress) (irs.IID, error) { - for _, addr := range address { - if addr.Properties.VirtualNetwork != nil { - vpcName := GetResourceNameById(*addr.Properties.VirtualNetwork.ID) - return irs.IID{NameId: vpcName, SystemId: *addr.Properties.VirtualNetwork.ID}, nil - } else { - nicNames, err := getNicNameByLoadBalancerBackendAddresses(address) - if err != nil { - return irs.IID{}, err - } - if len(nicNames) > 0 { - nic, err := nlbHandler.getRawNic(irs.IID{NameId: nicNames[0]}) - if err != nil { - return irs.IID{}, err - } - vpcIId, err := nlbHandler.getVPCIIdByNic(*nic) - if err != nil { - return irs.IID{}, err + +func getVNICNames(nlbVPC *armnetwork.VirtualNetwork) []*string { + var VNICNames []*string + + re := regexp.MustCompile(`networkInterfaces/(.+?)/ipConfigurations`) + + subnets := nlbVPC.Properties.Subnets + for _, subnet := range subnets { + ipConfigs := subnet.Properties.IPConfigurations + for _, ipConfig := range ipConfigs { + if ipConfig.ID != nil { + match := re.FindStringSubmatch(*ipConfig.ID) + if len(match) > 1 { + VNICNames = append(VNICNames, &match[1]) } - return vpcIId, nil } } } - return irs.IID{}, errors.New("not found vpc") + + return VNICNames } -func (nlbHandler *AzureNLBHandler) getVMIIDsByLoadBalancerBackendAddresses(address []*armnetwork.LoadBalancerBackendAddress) ([]irs.IID, error) { + +func (nlbHandler *AzureNLBHandler) getVMIIDsByLoadBalancerBackendAddresses(vpcID string, address []*armnetwork.LoadBalancerBackendAddress) ([]irs.IID, error) { vmIIds := make([]irs.IID, 0) + if len(address) < 1 { return vmIIds, nil } - refType, err := checkLoadBalancerBackendAddressesIPRefType(address) + var nlbVPC *armnetwork.VirtualNetwork + pager := nlbHandler.VPCClient.NewListPager(nlbHandler.Region.Region, nil) + for pager.More() { + page, err := pager.NextPage(nlbHandler.Ctx) + if err != nil { + return nil, errors.New(fmt.Sprintf("failed to list VPC list: %s", err.Error())) + } + + for _, vpc := range page.Value { + if *vpc.ID == vpcID { + nlbVPC = vpc + break + } + } + } + + if nlbVPC == nil { + return nil, errors.New("failed to get NLB VPC") + } + + vmHandler := AzureVMHandler{ + CredentialInfo: nlbHandler.CredentialInfo, + Region: nlbHandler.Region, + Ctx: nlbHandler.Ctx, + Client: nlbHandler.VMClient, + ScaleSetVMsClient: nlbHandler.ScaleSetVMsClient, + SubnetClient: nlbHandler.SubnetClient, + NicClient: nlbHandler.VNicClient, + PublicIPClient: nlbHandler.PublicIPClient, + DiskClient: nlbHandler.DiskClient, + } + + vmList, err := vmHandler.ListVM() if err != nil { + err = errors.New(fmt.Sprintf("Failed to get VMs. err = %s", err)) + cblogger.Error(err) return nil, err } - if refType == BackendAddressesIPAddressRef { - vmHandler := AzureVMHandler{ - CredentialInfo: nlbHandler.CredentialInfo, - Region: nlbHandler.Region, - Ctx: nlbHandler.Ctx, - Client: nlbHandler.VMClient, - ScaleSetVMsClient: nlbHandler.ScaleSetVMsClient, - SubnetClient: nlbHandler.SubnetClient, - NicClient: nlbHandler.VNicClient, - PublicIPClient: nlbHandler.PublicIPClient, - DiskClient: nlbHandler.DiskClient, + var ips []*string + for _, addr := range address { + if addr.Properties.IPAddress != nil { + ips = append(ips, addr.Properties.IPAddress) } + } - vmList, err := vmHandler.ListVM() - if err != nil { - err = errors.New(fmt.Sprintf("Failed to get VMs. err = %s", err)) - cblogger.Error(err) - return nil, err - } + vNICNames := getVNICNames(nlbVPC) + for _, vm := range vmList { + vmFound := false - ips, err := getIpsByLoadBalancerBackendAddresses(address) - if err != nil { - return nil, err - } - for _, vm := range vmList { - for _, ip := range ips { - if vm.PrivateIP == ip { - vmIIds = append(vmIIds, vm.IId) - break + for _, vNICName := range vNICNames { + if strings.ToLower(*vNICName) == strings.ToLower(vm.NetworkInterface) { + for _, ip := range ips { + if vm.PrivateIP == *ip { + vmIIds = append(vmIIds, vm.IId) + vmFound = true + break + } } } - } - return vmIIds, err - } else { - nicNames, err := getNicNameByLoadBalancerBackendAddresses(address) - if err != nil { - return nil, err - } - vmIIds, err := nlbHandler.getVMIIDsByNicNames(nicNames) - if err != nil { - return nil, err + if vmFound { + continue + } } - return vmIIds, nil } + + return vmIIds, err } + func (nlbHandler *AzureNLBHandler) getRawNLB(nlbIId irs.IID) (*armnetwork.LoadBalancer, error) { if nlbIId.NameId == "" { return nil, errors.New("invalid IID") @@ -1182,6 +1271,7 @@ func (nlbHandler *AzureNLBHandler) getRawNLB(nlbIId irs.IID) (*armnetwork.LoadBa return &resp.LoadBalancer, err } + func (nlbHandler *AzureNLBHandler) getRawNic(nicIID irs.IID) (*armnetwork.Interface, error) { if nicIID.NameId == "" { return nil, errors.New("invalid IID") @@ -1194,6 +1284,7 @@ func (nlbHandler *AzureNLBHandler) getRawNic(nicIID irs.IID) (*armnetwork.Interf return &resp.Interface, err } + func (nlbHandler *AzureNLBHandler) getVPCIIdByNic(nic armnetwork.Interface) (irs.IID, error) { vpcName := "" for _, ipConfig := range nic.Properties.IPConfigurations { @@ -1212,61 +1303,18 @@ func (nlbHandler *AzureNLBHandler) getVPCIIdByNic(nic armnetwork.Interface) (irs } return irs.IID{}, errors.New("invalid Nic") } -func (nlbHandler *AzureNLBHandler) getVMIIDsByNicNames(nicNames []string) ([]irs.IID, error) { - ids := make([]irs.IID, len(nicNames)) - for i, name := range nicNames { - nic, err := nlbHandler.getRawNic(irs.IID{NameId: name}) - if err != nil { - return nil, err - } - ids[i] = irs.IID{ - NameId: GetResourceNameById(*nic.Properties.VirtualMachine.ID), - SystemId: *nic.Properties.VirtualMachine.ID, - } - } - return ids, nil -} -func checkLoadBalancerBackendAddressesIPRefType(address []*armnetwork.LoadBalancerBackendAddress) (BackendAddressesIPRefType, error) { - for _, addr := range address { - if addr.Properties.IPAddress != nil { - return BackendAddressesIPAddressRef, nil - } - if addr.Properties.NetworkInterfaceIPConfiguration != nil { - return BackendAddressesIPConfigurationRef, nil - } - } - return "", errors.New("BackendAddressesIPRefType cannot be estimated") -} -func getIpsByLoadBalancerBackendAddresses(address []*armnetwork.LoadBalancerBackendAddress) ([]string, error) { - ips := make([]string, 0, len(address)) - for _, addr := range address { - if addr.Properties.IPAddress != nil { - ips = append(ips, *addr.Properties.IPAddress) - } - } - return ips, nil -} -func getNicNameByLoadBalancerBackendAddresses(address []*armnetwork.LoadBalancerBackendAddress) ([]string, error) { - names := make([]string, len(address)) - for i, addr := range address { - if addr.Properties.NetworkInterfaceIPConfiguration != nil { - names[i] = GetResourceNameById(*addr.Properties.NetworkInterfaceIPConfiguration.ID) - } else { - return nil, errors.New("invalid LoadBalancerBackendAddresses") - } - } - return names, nil -} + func (nlbHandler *AzureNLBHandler) getLoadBalancingRuleInfoByNLB(nlb *armnetwork.LoadBalancer) (*irs.VMGroupInfo, *irs.ListenerInfo, *irs.HealthCheckerInfo, error) { LoadBalancingRules := nlb.Properties.LoadBalancingRules - Probes := nlb.Properties.Probes if len(LoadBalancingRules) <= 0 { return nil, nil, nil, errors.New("invalid LoadBalancer") } + frontendIP, err := nlbHandler.getFrontendIPByNLB(nlb) if err != nil { return nil, nil, nil, errors.New("invalid LoadBalancer") } + cbOnlyOneLoadBalancingRule := LoadBalancingRules[0] VMGroup := &irs.VMGroupInfo{ Protocol: strings.ToUpper(string(*cbOnlyOneLoadBalancingRule.Properties.Protocol)), @@ -1274,6 +1322,7 @@ func (nlbHandler *AzureNLBHandler) getLoadBalancingRuleInfoByNLB(nlb *armnetwork // TODO: ? CspID: "", } + listenerInfo := &irs.ListenerInfo{ Protocol: strings.ToUpper(string(*cbOnlyOneLoadBalancingRule.Properties.Protocol)), Port: strconv.Itoa(int(*cbOnlyOneLoadBalancingRule.Properties.FrontendPort)), @@ -1281,22 +1330,24 @@ func (nlbHandler *AzureNLBHandler) getLoadBalancingRuleInfoByNLB(nlb *armnetwork // TODO: ? CspID: "", } + if len(nlb.Properties.BackendAddressPools) < 1 { return nil, nil, nil, errors.New("invalid LoadBalancer") } - backendPools := nlb.Properties.BackendAddressPools + backendPools := nlb.Properties.BackendAddressPools cbOnlyOneBackendPool := backendPools[0] - - vmIIds, err := nlbHandler.getVMIIDsByLoadBalancerBackendAddresses(cbOnlyOneBackendPool.Properties.LoadBalancerBackendAddresses) + vpcID := *cbOnlyOneBackendPool.Properties.LoadBalancerBackendAddresses[0].Properties.VirtualNetwork.ID + vmIIds, err := nlbHandler.getVMIIDsByLoadBalancerBackendAddresses(vpcID, cbOnlyOneBackendPool.Properties.LoadBalancerBackendAddresses) if err != nil { return nil, nil, nil, err } + VMGroup.VMs = &vmIIds healthCheckerInfo := &irs.HealthCheckerInfo{} probeId := *cbOnlyOneLoadBalancingRule.Properties.Probe.ID - for _, probe := range Probes { + for _, probe := range nlb.Properties.Probes { if *probe.ID == probeId { // Azure not support healthCheckerInfo.Timeout = -1 @@ -1309,6 +1360,7 @@ func (nlbHandler *AzureNLBHandler) getLoadBalancingRuleInfoByNLB(nlb *armnetwork } return VMGroup, listenerInfo, healthCheckerInfo, nil } + func (nlbHandler *AzureNLBHandler) getFrontendIPByNLB(nlb *armnetwork.LoadBalancer) (string, error) { FrontendIPConfigurations := nlb.Properties.FrontendIPConfigurations if len(FrontendIPConfigurations) <= 0 { @@ -1326,6 +1378,7 @@ func (nlbHandler *AzureNLBHandler) getFrontendIPByNLB(nlb *armnetwork.LoadBalanc } return "", errors.New("invalid LoadBalancer") } + func getNLBTypeByNLB(nlb *armnetwork.LoadBalancer) (NLBType, error) { FrontendIPConfigurations := nlb.Properties.FrontendIPConfigurations if len(FrontendIPConfigurations) <= 0 { @@ -1339,6 +1392,7 @@ func getNLBTypeByNLB(nlb *armnetwork.LoadBalancer) (NLBType, error) { } return "", errors.New("invalid LoadBalancer") } + func (nlbHandler *AzureNLBHandler) getRawPublicIP(publicIPIId irs.IID) (*armnetwork.PublicIPAddress, error) { if publicIPIId.NameId == "" { return nil, errors.New("invalid IID") @@ -1350,21 +1404,28 @@ func (nlbHandler *AzureNLBHandler) getRawPublicIP(publicIPIId irs.IID) (*armnetw } return &resp.PublicIPAddress, err } -func getAzureLoadBalancingRuleByCBListenerInfo(listenerInfo irs.ListenerInfo, serviceGroupInfo irs.VMGroupInfo, frontEndIPConfigId string, backEndAddressPoolId string, probeId string) (*armnetwork.LoadBalancingRule, error) { - protocol := armnetwork.TransportProtocolTCP + +func getAzureLoadBalancingRuleByCBListenerInfo(listenerInfo irs.ListenerInfo, vmGroupInfo irs.VMGroupInfo, frontEndIPConfigId string, backEndAddressPoolId string, probeId string) (*armnetwork.LoadBalancingRule, error) { + var protocol armnetwork.TransportProtocol + switch strings.ToUpper(listenerInfo.Protocol) { - case "TCP", "ALL", "UDP": - protocol = armnetwork.TransportProtocol(strings.Title(strings.ToLower(listenerInfo.Protocol))) + case "TCP": + protocol = armnetwork.TransportProtocolTCP + case "UDP": + protocol = armnetwork.TransportProtocolUDP + case "ALL": + protocol = armnetwork.TransportProtocolAll default: - return nil, errors.New("invalid listenerInfo Protocol") + return nil, errors.New("invalid listenerInfo protocol") } - backendPort, err := strconv.Atoi(serviceGroupInfo.Port) + + backendPort, err := strconv.Atoi(vmGroupInfo.Port) if err != nil { - return nil, errors.New("invalid serviceGroupInfo Protocol") + return nil, errors.New("invalid vmGroupInfo port") } frontendPort, err := strconv.Atoi(listenerInfo.Port) if err != nil { - return nil, errors.New("invalid listenerInfo Protocol") + return nil, errors.New("invalid listenerInfo port") } loadBalancingRule := &armnetwork.LoadBalancingRule{ @@ -1387,22 +1448,31 @@ func getAzureLoadBalancingRuleByCBListenerInfo(listenerInfo irs.ListenerInfo, se }, }, } + if backEndAddressPoolId == "" { loadBalancingRule.Properties.BackendAddressPool = nil } + return loadBalancingRule, nil } + func getAzureProbeByCBHealthChecker(healthChecker irs.HealthCheckerInfo) (*armnetwork.Probe, error) { - protocol := armnetwork.ProbeProtocolHTTP + var protocol armnetwork.ProbeProtocol + switch strings.ToUpper(healthChecker.Protocol) { - case "HTTP", "HTTPS", "TCP": - protocol = armnetwork.ProbeProtocol(strings.Title(strings.ToLower(healthChecker.Protocol))) + case "HTTP": + protocol = armnetwork.ProbeProtocolHTTP + case "HTTPS": + protocol = armnetwork.ProbeProtocolHTTPS + case "TCP": + protocol = armnetwork.ProbeProtocolTCP default: - return nil, errors.New("invalid HealthCheckerInfo Protocol") + return nil, errors.New("invalid HealthCheckerInfo protocol") } + port, err := strconv.Atoi(healthChecker.Port) if err != nil { - return nil, errors.New("invalid HealthCheckerInfo Protocol") + return nil, errors.New("invalid HealthCheckerInfo port") } if healthChecker.Interval < 5 { @@ -1424,12 +1494,15 @@ func getAzureProbeByCBHealthChecker(healthChecker irs.HealthCheckerInfo) (*armne NumberOfProbes: toInt32Ptr(healthChecker.Threshold), }, } + if protocol == armnetwork.ProbeProtocolHTTP || protocol == armnetwork.ProbeProtocolHTTPS { path := "/" probe.Properties.RequestPath = &path } + return probe, nil } + func getAzureFrontendIPConfiguration(publicIp *armnetwork.PublicIPAddress) *armnetwork.FrontendIPConfiguration { return &armnetwork.FrontendIPConfiguration{ Name: toStrPtr(generateRandName(FrontEndIPConfigPrefix)), @@ -1439,8 +1512,8 @@ func getAzureFrontendIPConfiguration(publicIp *armnetwork.PublicIPAddress) *armn }, } } + func (nlbHandler *AzureNLBHandler) createPublicIP(nlbName string) (armnetwork.PublicIPAddress, error) { - // PublicIP 이름 생성 publicIPName := nlbName createOpts := armnetwork.PublicIPAddress{ @@ -1470,36 +1543,15 @@ func (nlbHandler *AzureNLBHandler) createPublicIP(nlbName string) (armnetwork.Pu return armnetwork.PublicIPAddress{}, createErr } - // 생성된 PublicIP 정보 리턴 resp, err := nlbHandler.PublicIPClient.Get(nlbHandler.Ctx, nlbHandler.Region.Region, publicIPName, nil) if err != nil { createErr := errors.New(fmt.Sprintf("Failed to create PublicIP, error=%s", err)) return armnetwork.PublicIPAddress{}, createErr } + return resp.PublicIPAddress, nil } -func (nlbHandler *AzureNLBHandler) getVMPrivateIP(vmIID irs.IID) (privateIP string, err error) { - vmHandler := AzureVMHandler{ - CredentialInfo: nlbHandler.CredentialInfo, - Region: nlbHandler.Region, - Ctx: nlbHandler.Ctx, - Client: nlbHandler.VMClient, - ScaleSetVMsClient: nlbHandler.ScaleSetVMsClient, - SubnetClient: nlbHandler.SubnetClient, - NicClient: nlbHandler.VNicClient, - PublicIPClient: nlbHandler.PublicIPClient, - DiskClient: nlbHandler.DiskClient, - } - vm, err := vmHandler.GetVM(vmIID) - if err != nil { - err = errors.New(fmt.Sprintf("Failed to get VM. err = %s", err)) - cblogger.Error(err) - return "", err - } - - return vm.PrivateIP, nil -} func (nlbHandler *AzureNLBHandler) getVPCIIDByVM(vmIID irs.IID) (*irs.IID, error) { vmHandler := AzureVMHandler{ CredentialInfo: nlbHandler.CredentialInfo, @@ -1532,6 +1584,7 @@ func (nlbHandler *AzureNLBHandler) getNLBType(nlb armnetwork.LoadBalancer) (stri return "PUBLIC", nil } } + func (nlbHandler *AzureNLBHandler) getPrivateIPBYNicName(nicName string) (string, error) { resp, err := nlbHandler.VNicClient.Get(nlbHandler.Ctx, nlbHandler.Region.Region, nicName, nil) if err != nil { diff --git a/cloud-control-manager/cloud-driver/drivers/azure/resources/VPCHandler.go b/cloud-control-manager/cloud-driver/drivers/azure/resources/VPCHandler.go index b4e1165f0..3d11aadd2 100644 --- a/cloud-control-manager/cloud-driver/drivers/azure/resources/VPCHandler.go +++ b/cloud-control-manager/cloud-driver/drivers/azure/resources/VPCHandler.go @@ -291,7 +291,8 @@ func (vpcHandler *AzureVPCHandler) getRawVPC(vpcIID irs.IID) (*armnetwork.Virtua return vpc, nil } } - return nil, errors.New("not found SecurityGroup") + + return nil, errors.New("VPC not found") } else { resp, err := vpcHandler.Client.Get(vpcHandler.Ctx, vpcHandler.Region.Region, vpcIID.NameId, nil) if err != nil {