Merge pull request #11593 from tb365/bugfix/tb-bugfix-0700701

Bugfix/tb bugfix 0700701

pkg/cloudprovider/resources.go

@@ -752,6 +752,7 @@ type ICloudLoadbalancerBackend interface {
 	GetBackendType() string
 	GetBackendRole() string
 	GetBackendId() string
+	GetIpAddress() string // backend type is ip
 	SyncConf(ctx context.Context, port, weight int) error
 }
 

pkg/compute/models/loadbalancerbackends.go

@@ -533,21 +533,27 @@ func (lbb *SLoadbalancerBackend) constructFieldsFromCloudLoadbalancerBackend(ext
 	lbb.BackendType = extLoadbalancerBackend.GetBackendType()
 	lbb.BackendRole = extLoadbalancerBackend.GetBackendRole()
 
-	instance, err := db.FetchByExternalIdAndManagerId(GuestManager, extLoadbalancerBackend.GetBackendId(), func(q *sqlchemy.SQuery) *sqlchemy.SQuery {
-		sq := HostManager.Query().SubQuery()
-		return q.Join(sq, sqlchemy.Equals(sq.Field("id"), q.Field("host_id"))).Filter(sqlchemy.Equals(sq.Field("manager_id"), managerId))
-	})
-	if err != nil {
-		return err
-	}
-	guest := instance.(*SGuest)
+	if lbb.BackendType == api.LB_BACKEND_IP {
+		lbb.Address = extLoadbalancerBackend.GetIpAddress()
+	} else {
+		instance, err := db.FetchByExternalIdAndManagerId(GuestManager, extLoadbalancerBackend.GetBackendId(), func(q *sqlchemy.SQuery) *sqlchemy.SQuery {
+			sq := HostManager.Query().SubQuery()
+			return q.Join(sq, sqlchemy.Equals(sq.Field("id"), q.Field("host_id"))).Filter(sqlchemy.Equals(sq.Field("manager_id"), managerId))
+		})
+		if err != nil {
+			return err
+		}
 
-	lbb.BackendId = guest.Id
-	address, err := LoadbalancerBackendManager.GetGuestAddress(guest)
-	if err != nil {
-		return err
+		guest := instance.(*SGuest)
+
+		lbb.BackendId = guest.Id
+		address, err := LoadbalancerBackendManager.GetGuestAddress(guest)
+		if err != nil {
+			return err
+		}
+		lbb.Address = address
 	}
-	lbb.Address = address
+
 	return nil
 }
 

pkg/multicloud/aliyun/loadbalancerbackend.go

@@ -88,6 +88,10 @@ func (backend *SLoadbalancerBackend) GetBackendId() string {
 	return backend.ServerId
 }
 
+func (backend *SLoadbalancerBackend) GetIpAddress() string {
+	return ""
+}
+
 func (region *SRegion) GetLoadbalancerBackends(backendgroupId string) ([]SLoadbalancerBackend, error) {
 	params := map[string]string{}
 	params["RegionId"] = region.RegionId

pkg/multicloud/aliyun/loadbalancerdefaultbackend.go

@@ -77,6 +77,10 @@ func (backend *SLoadbalancerDefaultBackend) GetBackendId() string {
 	return backend.ServerId
 }
 
+func (backend *SLoadbalancerDefaultBackend) GetIpAddress() string {
+	return ""
+}
+
 func (backend *SLoadbalancerDefaultBackend) GetProjectId() string {
 	return backend.lbbg.GetProjectId()
 }

pkg/multicloud/aliyun/loadbalancermasterslavebackend.go

@@ -79,6 +79,10 @@ func (backend *SLoadbalancerMasterSlaveBackend) GetBackendId() string {
 	return backend.ServerId
 }
 
+func (backend *SLoadbalancerMasterSlaveBackend) GetIpAddress() string {
+	return ""
+}
+
 func (backend *SLoadbalancerMasterSlaveBackend) GetProjectId() string {
 	return backend.lbbg.GetProjectId()
 }

pkg/multicloud/apsara/loadbalancerbackend.go

@@ -88,6 +88,10 @@ func (backend *SLoadbalancerBackend) GetBackendId() string {
 	return backend.ServerId
 }
 
+func (backend *SLoadbalancerBackend) GetIpAddress() string {
+	return ""
+}
+
 func (region *SRegion) GetLoadbalancerBackends(backendgroupId string) ([]SLoadbalancerBackend, error) {
 	params := map[string]string{}
 	params["RegionId"] = region.RegionId

pkg/multicloud/apsara/loadbalancerdefaultbackend.go

@@ -77,6 +77,10 @@ func (backend *SLoadbalancerDefaultBackend) GetBackendId() string {
 	return backend.ServerId
 }
 
+func (backend *SLoadbalancerDefaultBackend) GetIpAddress() string {
+	return ""
+}
+
 func (backend *SLoadbalancerDefaultBackend) GetProjectId() string {
 	return ""
 }

pkg/multicloud/apsara/loadbalancermasterslavebackend.go

@@ -79,6 +79,10 @@ func (backend *SLoadbalancerMasterSlaveBackend) GetBackendId() string {
 	return backend.ServerId
 }
 
+func (backend *SLoadbalancerMasterSlaveBackend) GetIpAddress() string {
+	return ""
+}
+
 func (backend *SLoadbalancerMasterSlaveBackend) GetProjectId() string {
 	return ""
 }

pkg/multicloud/aws/loadbalancerbackend.go

@@ -95,6 +95,10 @@ func (self *SElbBackend) SyncConf(ctx context.Context, port, weight int) error {
 	return self.region.SyncElbBackend(self.GetId(), self.GetBackendId(), self.Target.Port, port)
 }
 
+func (self *SElbBackend) GetIpAddress() string {
+	return ""
+}
+
 func (self *SRegion) SyncElbBackend(backendId, serverId string, oldPort, newPort int) error {
 	err := self.RemoveElbBackend(backendId, serverId, 0, oldPort)
 	if err != nil {

pkg/multicloud/azure/loadbalancer.go

@@ -16,6 +16,7 @@ import (
 
 type SLoadbalancer struct {
 	region    *SRegion
+	eip       cloudprovider.ICloudEIP
 	lbbgs     []cloudprovider.ICloudLoadbalancerBackendGroup
 	listeners []cloudprovider.ICloudLoadbalancerListener
 
@@ -78,6 +79,7 @@ func (self *SLoadbalancer) Refresh() error {
 		return errors.Wrap(err, "jsonutils.Update")
 	}
 
+	self.eip = nil
 	self.lbbgs = nil
 	self.listeners = nil
 	return nil
@@ -271,9 +273,15 @@ func (self *SLoadbalancer) getEipIds() []string {
 }
 
 func (self *SLoadbalancer) GetIEIP() (cloudprovider.ICloudEIP, error) {
+	if self.eip != nil {
+		return self.eip, nil
+	}
+
 	eips := self.getEipIds()
 	if len(eips) > 0 {
-		return self.region.GetIEipById(eips[0])
+		eip, err := self.region.GetIEipById(eips[0])
+		self.eip = eip
+		return eip, err
 	}
 
 	return nil, nil
@@ -404,14 +412,27 @@ func (self *SLoadbalancer) getRequestRoutingRule(id string) *RequestRoutingRule
 	return nil
 }
 
+func (self *SLoadbalancer) getURLPathMap(id string) *URLPathMap {
+	ss := self.Properties.URLPathMaps
+	for i := range ss {
+		if ss[i].ID == id {
+			return &ss[i]
+		}
+	}
+	log.Debugf("getURLPathMap %s not found", id)
+	return nil
+}
+
 /*
 应用型LB： urlPathMaps（defaultBackendAddressPool+defaultBackendHttpSettings+requestRoutingRules+httpListeners）= Onecloud监听器
 */
 func (self *SLoadbalancer) getAppLBListeners() ([]cloudprovider.ICloudLoadbalancerListener, error) {
 	lbls := []cloudprovider.ICloudLoadbalancerListener{}
-	for i := range self.Properties.URLPathMaps {
-		u := self.Properties.URLPathMaps[i]
-		lbl := self.getAppLBListener(&u)
+	for i := range self.Properties.RequestRoutingRules {
+		r := self.Properties.RequestRoutingRules[i]
+		uid := strings.Replace(r.ID, "requestRoutingRules", "urlPathMaps", 1)
+		u := self.getURLPathMap(uid)
+		lbl := self.getAppLBListener(&r, u)
 		if lbl != nil {
 			lbls = append(lbls, lbl)
 		}
@@ -420,45 +441,54 @@ func (self *SLoadbalancer) getAppLBListeners() ([]cloudprovider.ICloudLoadbalanc
 	return lbls, nil
 }
 
-func (self *SLoadbalancer) getAppLBListener(u *URLPathMap) *SLoadBalancerListener {
+func (self *SLoadbalancer) getAppLBListener(r *RequestRoutingRule, u *URLPathMap) *SLoadBalancerListener {
 	var redirect *RedirectConfiguration
 	var listener *HTTPListener
 	var fp *FrontendIPConfiguration
 	var fpp *FrontendPort
-	if len(u.Properties.RequestRoutingRules) == 0 {
-		return nil
-	}
-
-	if u.Properties.DefaultRedirectConfiguration != nil {
-		redirect = self.getRedirectConfiguration(u.Properties.DefaultRedirectConfiguration.ID)
-	}
-
-	// httpListener, urlPathMap
-	rrr := self.getRequestRoutingRule(u.Properties.RequestRoutingRules[0].ID)
 	// frontendPort, frontendIPConfiguration, sslCertificate, requestRoutingRules
-	listener = self.getHttpListener(rrr.Properties.HTTPListener.ID)
+	listener = self.getHttpListener(r.Properties.HTTPListener.ID)
 	// frontendPorts
 	fp = self.getFrontendIPConfiguration(listener.Properties.FrontendIPConfiguration.ID)
 	fpp = self.getFrontendPort(listener.Properties.FrontendPort.ID)
-
 	// 配置有异常？？
 	if fpp == nil || listener == nil {
 		return nil
 	}
 
+	lbbgId := r.Properties.BackendAddressPool.ID
+	lbbgSettingId := r.Properties.BackendHTTPSettings.ID
+	provisioningState := "Succeeded"
+	rules := make([]PathRule, 0)
 	var backendGroup *BackendAddressPool
-	if u.Properties.DefaultBackendAddressPool != nil {
-		backendGroup = self.getBackendAddressPool(u.Properties.DefaultBackendAddressPool.ID)
-	}
-
 	var backendSetting *BackendHTTPSettingsCollection
 	var backendPort int
-	if u.Properties.DefaultBackendHTTPSettings != nil {
-		backendSetting = self.getBackendHTTPSettingsCollection(u.Properties.DefaultBackendHTTPSettings.ID)
+	var healthcheck *Probe
+	if u != nil {
+		provisioningState = u.Properties.ProvisioningState
+		rules = u.Properties.PathRules
+		if u.Properties.DefaultRedirectConfiguration != nil {
+			redirect = self.getRedirectConfiguration(u.Properties.DefaultRedirectConfiguration.ID)
+		}
+
+		if len(lbbgId) == 0 && u.Properties.DefaultBackendAddressPool != nil {
+			lbbgId = u.Properties.DefaultBackendAddressPool.ID
+		}
+
+		if len(lbbgSettingId) == 0 && u.Properties.DefaultBackendHTTPSettings != nil {
+			lbbgSettingId = u.Properties.DefaultBackendHTTPSettings.ID
+		}
+	}
+
+	if len(lbbgId) > 0 {
+		backendGroup = self.getBackendAddressPool(lbbgId)
+	}
+
+	if len(lbbgSettingId) > 0 {
+		backendSetting = self.getBackendHTTPSettingsCollection(lbbgSettingId)
 		backendPort = backendSetting.Properties.Port
 	}
 
-	var healthcheck *Probe
 	if backendSetting != nil && backendSetting.Properties.Probe != nil {
 		healthcheck = self.getProbe(backendSetting.Properties.Probe.ID)
 	}
@@ -471,9 +501,9 @@ func (self *SLoadbalancer) getAppLBListener(u *URLPathMap) *SLoadBalancerListene
 		backendGroup:      backendGroup,
 		redirect:          redirect,
 		healthcheck:       healthcheck,
-		Name:              u.Name,
-		ID:                u.ID,
-		ProvisioningState: u.Properties.ProvisioningState,
+		Name:              r.Name,
+		ID:                r.ID,
+		ProvisioningState: provisioningState,
 		IPVersion:         "",
 		Protocol:          listener.Properties.Protocol,
 		LoadDistribution:  "",
@@ -482,7 +512,7 @@ func (self *SLoadbalancer) getAppLBListener(u *URLPathMap) *SLoadBalancerListene
 		ClientIdleTimeout: 0,
 		EnableFloatingIP:  false,
 		EnableTcpReset:    false,
-		rules:             u.Properties.PathRules,
+		rules:             rules,
 	}
 }
 
@@ -611,10 +641,11 @@ func (self *SLoadbalancer) getNetworkLBListenerById(id string) (cloudprovider.IC
 }
 
 func (self *SLoadbalancer) getAppLBListenerById(id string) (cloudprovider.ICloudLoadbalancerListener, error) {
-	for i := range self.Properties.URLPathMaps {
-		u := self.Properties.URLPathMaps[i]
-		if u.ID == id {
-			return self.getAppLBListener(&u), nil
+	for i := range self.Properties.RequestRoutingRules {
+		r := self.Properties.RequestRoutingRules[i]
+		if r.ID == id {
+			u := self.getURLPathMap(strings.Replace(r.ID, "requestRoutingRules", "urlPathMaps", 1))
+			return self.getAppLBListener(&r, u), nil
 		}
 	}
 

pkg/multicloud/azure/loadbalancer_props.go

@@ -34,7 +34,10 @@ type BackendAddressPoolProperties struct {
 	ProvisioningState       string                   `json:"provisioningState"`
 	LoadBalancingRules      []Subnet                 `json:"loadBalancingRules"`
 	BackendIPConfigurations []BackendIPConfiguration `json:"backendIPConfigurations"`
-	// loadBalancerBackendAddresses
+	BackendAddresses        []BackendAddress         `json:"backendAddresses"`
+	RequestRoutingRules     []BackendIPConfiguration `json:"requestRoutingRules"`
+	URLPathMaps             []BackendIPConfiguration `json:"urlPathMaps"`
+	PathRules               []BackendIPConfiguration `json:"pathRules"`
 }
 
 type BackendIPConfiguration struct {

pkg/multicloud/azure/loadbalancerbackend.go

@@ -21,6 +21,7 @@ type SLoadbalancerBackend struct {
 	ID          string `json:"id"`
 	Type        string `json:"type"`
 	BackendPort int
+	BackendIP   string
 }
 
 func (self *SLoadbalancerBackend) GetId() string {
@@ -64,7 +65,7 @@ func (self *SLoadbalancerBackend) GetPort() int {
 }
 
 func (self *SLoadbalancerBackend) GetBackendType() string {
-	return api.LB_BACKEND_GUEST
+	return self.Type
 }
 
 func (self *SLoadbalancerBackend) GetBackendRole() string {
@@ -75,6 +76,10 @@ func (self *SLoadbalancerBackend) GetBackendId() string {
 	return self.ID
 }
 
+func (self *SLoadbalancerBackend) GetIpAddress() string {
+	return self.BackendIP
+}
+
 func (self *SLoadbalancerBackend) SyncConf(ctx context.Context, port, weight int) error {
 	return errors.Wrap(cloudprovider.ErrNotImplemented, "SyncConf")
 }

pkg/multicloud/azure/loadbalancerbackendgroup.go

@@ -2,6 +2,7 @@ package azure
 
 import (
 	"context"
+	"fmt"
 	"strconv"
 	"strings"
 
@@ -137,6 +138,22 @@ func (self *SLoadbalancerBackendGroup) GetILoadbalancerBackends() ([]cloudprovid
 		ret = append(ret, &bg)
 	}
 
+	ips2 := self.Pool.Properties.BackendAddresses
+	for i := range ips2 {
+		name := fmt.Sprintf("ip-%s", ips2[i].IPAddress)
+		bg := SLoadbalancerBackend{
+			SResourceBase: multicloud.SResourceBase{},
+			lbbg:          self,
+			Name:          name,
+			ID:            fmt.Sprintf("%s-%s", self.GetId(), name),
+			Type:          api.LB_BACKEND_IP,
+			BackendIP:     ips2[i].IPAddress,
+			BackendPort:   self.DefaultPort,
+		}
+
+		ret = append(ret, &bg)
+	}
+
 	self.lbbs = ret
 	return ret, nil
 }

pkg/multicloud/azure/loadbalancerlistener.go

@@ -113,7 +113,7 @@ func (self *SLoadBalancerListener) GetGlobalId() string {
 
 func (self *SLoadBalancerListener) GetStatus() string {
 	switch self.ProvisioningState {
-	case "Succeeded":
+	case "Succeeded", "Updating", "Deleting":
 		return api.LB_STATUS_ENABLED
 	case "Failed":
 		return api.LB_STATUS_DISABLED
@@ -146,7 +146,20 @@ func (self *SLoadBalancerListener) GetSysTags() map[string]string {
 }
 
 func (self *SLoadBalancerListener) GetTags() (map[string]string, error) {
-	return nil, nil
+	if self.fp != nil {
+		if self.fp.Properties.PublicIPAddress != nil && len(self.fp.Properties.PublicIPAddress.ID) > 0 {
+			eip, _ := self.lb.GetIEIP()
+			if eip != nil {
+				return map[string]string{"FrontendIP": eip.GetIpAddr()}, nil
+			}
+		}
+
+		if len(self.fp.Properties.PrivateIPAddress) > 0 {
+			return map[string]string{"FrontendIP": self.fp.Properties.PrivateIPAddress}, nil
+		}
+	}
+
+	return map[string]string{}, nil
 }
 
 func (self *SLoadBalancerListener) SetTags(tags map[string]string, replace bool) error {

pkg/multicloud/azure/shell/loadbalancer.go

@@ -105,7 +105,13 @@ func init() {
 		LISTENID string `help:"ID of loadbalancer listener"`
 	}
 	shellutils.R(&LoadbalancerRuleOptions{}, "lbr-list", "List loadbalancer listener rules", func(cli *azure.SRegion, args *LoadbalancerRuleOptions) error {
-		lb, err := cli.GetILoadBalancerById(strings.Split(args.LISTENID, "/urlPathMaps")[0])
+		lbId := ""
+		if strings.Index(args.LISTENID, "/requestRoutingRules") > 0 {
+			lbId = strings.Split(args.LISTENID, "/requestRoutingRules")[0]
+		} else {
+			return nil
+		}
+		lb, err := cli.GetILoadBalancerById(lbId)
 		if err != nil {
 			return err
 		}

pkg/multicloud/huawei/loadbalancer_backend.go

@@ -121,6 +121,10 @@ func (self *SElbBackend) GetBackendId() string {
 	return ""
 }
 
+func (self *SElbBackend) GetIpAddress() string {
+	return ""
+}
+
 func (self *SElbBackend) SyncConf(ctx context.Context, port, weight int) error {
 	if port > 0 {
 		log.Warningf("Elb backend SyncConf unsupport modify port")

pkg/multicloud/openstack/loadbalancermember.go

@@ -224,6 +224,10 @@ func (member *SLoadbalancerMember) GetBackendId() string {
 	return ""
 }
 
+func (member *SLoadbalancerMember) GetIpAddress() string {
+	return ""
+}
+
 func (member *SLoadbalancerMember) GetProjectId() string {
 	return member.ProjectID
 }

pkg/multicloud/qcloud/loadbalancer_backend.go

@@ -115,6 +115,10 @@ func (self *SLBBackend) GetBackendId() string {
 	return self.InstanceID
 }
 
+func (self *SLBBackend) GetIpAddress() string {
+	return ""
+}
+
 // 传统型： https://cloud.tencent.com/document/product/214/31790
 func (self *SRegion) getClassicBackends(lbId, listenerId string) ([]SLBBackend, error) {
 	params := map[string]string{"LoadBalancerId": lbId}