From be5aeda1b1829d501617698381759d2577aad69d Mon Sep 17 00:00:00 2001 From: tb365 Date: Wed, 7 Jul 2021 18:17:36 +0800 Subject: [PATCH 1/2] azure application lb sync fix --- pkg/multicloud/azure/loadbalancer.go | 85 ++++++++++++++-------- pkg/multicloud/azure/shell/loadbalancer.go | 8 +- 2 files changed, 61 insertions(+), 32 deletions(-) diff --git a/pkg/multicloud/azure/loadbalancer.go b/pkg/multicloud/azure/loadbalancer.go index d699f7420b..82068aa5c5 100644 --- a/pkg/multicloud/azure/loadbalancer.go +++ b/pkg/multicloud/azure/loadbalancer.go @@ -404,14 +404,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 +433,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 +493,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 +504,7 @@ func (self *SLoadbalancer) getAppLBListener(u *URLPathMap) *SLoadBalancerListene ClientIdleTimeout: 0, EnableFloatingIP: false, EnableTcpReset: false, - rules: u.Properties.PathRules, + rules: rules, } } @@ -611,10 +633,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 } } diff --git a/pkg/multicloud/azure/shell/loadbalancer.go b/pkg/multicloud/azure/shell/loadbalancer.go index 6f9d51fa46..876cbc14d2 100644 --- a/pkg/multicloud/azure/shell/loadbalancer.go +++ b/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 } From 5649af21922a539d71f31d5278926823a32d30f4 Mon Sep 17 00:00:00 2001 From: tb365 Date: Wed, 7 Jul 2021 19:19:23 +0800 Subject: [PATCH 2/2] azure elb support sync ip backend --- pkg/cloudprovider/resources.go | 1 + pkg/compute/models/loadbalancerbackends.go | 32 +++++++++++-------- pkg/multicloud/aliyun/loadbalancerbackend.go | 4 +++ .../aliyun/loadbalancerdefaultbackend.go | 4 +++ .../aliyun/loadbalancermasterslavebackend.go | 4 +++ pkg/multicloud/apsara/loadbalancerbackend.go | 4 +++ .../apsara/loadbalancerdefaultbackend.go | 4 +++ .../apsara/loadbalancermasterslavebackend.go | 4 +++ pkg/multicloud/aws/loadbalancerbackend.go | 4 +++ pkg/multicloud/azure/loadbalancer.go | 10 +++++- pkg/multicloud/azure/loadbalancer_props.go | 5 ++- pkg/multicloud/azure/loadbalancerbackend.go | 7 +++- .../azure/loadbalancerbackendgroup.go | 17 ++++++++++ pkg/multicloud/azure/loadbalancerlistener.go | 17 ++++++++-- pkg/multicloud/huawei/loadbalancer_backend.go | 4 +++ .../openstack/loadbalancermember.go | 4 +++ pkg/multicloud/qcloud/loadbalancer_backend.go | 4 +++ 17 files changed, 111 insertions(+), 18 deletions(-) diff --git a/pkg/cloudprovider/resources.go b/pkg/cloudprovider/resources.go index 0584fe0969..df3b77cd1e 100644 --- a/pkg/cloudprovider/resources.go +++ b/pkg/cloudprovider/resources.go @@ -749,6 +749,7 @@ type ICloudLoadbalancerBackend interface { GetBackendType() string GetBackendRole() string GetBackendId() string + GetIpAddress() string // backend type is ip SyncConf(ctx context.Context, port, weight int) error } diff --git a/pkg/compute/models/loadbalancerbackends.go b/pkg/compute/models/loadbalancerbackends.go index 1994f2642f..f493841980 100644 --- a/pkg/compute/models/loadbalancerbackends.go +++ b/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 } diff --git a/pkg/multicloud/aliyun/loadbalancerbackend.go b/pkg/multicloud/aliyun/loadbalancerbackend.go index 1c3c57340c..ebcc40f59c 100644 --- a/pkg/multicloud/aliyun/loadbalancerbackend.go +++ b/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 diff --git a/pkg/multicloud/aliyun/loadbalancerdefaultbackend.go b/pkg/multicloud/aliyun/loadbalancerdefaultbackend.go index de73829ee7..ff62fcfd96 100644 --- a/pkg/multicloud/aliyun/loadbalancerdefaultbackend.go +++ b/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() } diff --git a/pkg/multicloud/aliyun/loadbalancermasterslavebackend.go b/pkg/multicloud/aliyun/loadbalancermasterslavebackend.go index e51b8bdaa7..142ddec9b2 100644 --- a/pkg/multicloud/aliyun/loadbalancermasterslavebackend.go +++ b/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() } diff --git a/pkg/multicloud/apsara/loadbalancerbackend.go b/pkg/multicloud/apsara/loadbalancerbackend.go index 99fcf50d2b..0980c04def 100644 --- a/pkg/multicloud/apsara/loadbalancerbackend.go +++ b/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 diff --git a/pkg/multicloud/apsara/loadbalancerdefaultbackend.go b/pkg/multicloud/apsara/loadbalancerdefaultbackend.go index 48bcc32f58..1c75af6293 100644 --- a/pkg/multicloud/apsara/loadbalancerdefaultbackend.go +++ b/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 "" } diff --git a/pkg/multicloud/apsara/loadbalancermasterslavebackend.go b/pkg/multicloud/apsara/loadbalancermasterslavebackend.go index 6b2d4452f4..45b188b25f 100644 --- a/pkg/multicloud/apsara/loadbalancermasterslavebackend.go +++ b/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 "" } diff --git a/pkg/multicloud/aws/loadbalancerbackend.go b/pkg/multicloud/aws/loadbalancerbackend.go index 0e49391937..583088130b 100644 --- a/pkg/multicloud/aws/loadbalancerbackend.go +++ b/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 { diff --git a/pkg/multicloud/azure/loadbalancer.go b/pkg/multicloud/azure/loadbalancer.go index 82068aa5c5..a26ad20a49 100644 --- a/pkg/multicloud/azure/loadbalancer.go +++ b/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 diff --git a/pkg/multicloud/azure/loadbalancer_props.go b/pkg/multicloud/azure/loadbalancer_props.go index b4a66a567a..b423b1a82e 100644 --- a/pkg/multicloud/azure/loadbalancer_props.go +++ b/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 { diff --git a/pkg/multicloud/azure/loadbalancerbackend.go b/pkg/multicloud/azure/loadbalancerbackend.go index 59143167af..5243c4f2f0 100644 --- a/pkg/multicloud/azure/loadbalancerbackend.go +++ b/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") } diff --git a/pkg/multicloud/azure/loadbalancerbackendgroup.go b/pkg/multicloud/azure/loadbalancerbackendgroup.go index 07fa27048e..e2777a4500 100644 --- a/pkg/multicloud/azure/loadbalancerbackendgroup.go +++ b/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 } diff --git a/pkg/multicloud/azure/loadbalancerlistener.go b/pkg/multicloud/azure/loadbalancerlistener.go index 8b36439843..3a7cfcbd09 100644 --- a/pkg/multicloud/azure/loadbalancerlistener.go +++ b/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 { diff --git a/pkg/multicloud/huawei/loadbalancer_backend.go b/pkg/multicloud/huawei/loadbalancer_backend.go index b638098651..be540cb22e 100644 --- a/pkg/multicloud/huawei/loadbalancer_backend.go +++ b/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") diff --git a/pkg/multicloud/openstack/loadbalancermember.go b/pkg/multicloud/openstack/loadbalancermember.go index d5b59bf58c..0c00927841 100644 --- a/pkg/multicloud/openstack/loadbalancermember.go +++ b/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 } diff --git a/pkg/multicloud/qcloud/loadbalancer_backend.go b/pkg/multicloud/qcloud/loadbalancer_backend.go index 97aec74ee1..71e35b66fd 100644 --- a/pkg/multicloud/qcloud/loadbalancer_backend.go +++ b/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}