add: openstack loadbalancer (#7497)

Co-authored-by: lvyangyang <lvyangyang@yunion.cn>
yunionio · Aug 14, 2020 · eb56fcf · eb56fcf
1 parent 7a08a60
commit eb56fcf
Show file tree

Hide file tree

Showing 30 changed files with 6,072 additions and 25 deletions.
diff --git a/pkg/apis/compute/loadbalancer_const.go b/pkg/apis/compute/loadbalancer_const.go
@@ -140,11 +140,12 @@ var LB_NETWORK_TYPES = choices.NewChoices(
 
 // TODO https_direct sni
 const (
-	LB_LISTENER_TYPE_TCP     = "tcp"
-	LB_LISTENER_TYPE_UDP     = "udp"
-	LB_LISTENER_TYPE_TCP_UDP = "tcp_udp"
-	LB_LISTENER_TYPE_HTTP    = "http"
-	LB_LISTENER_TYPE_HTTPS   = "https"
+	LB_LISTENER_TYPE_TCP              = "tcp"
+	LB_LISTENER_TYPE_UDP              = "udp"
+	LB_LISTENER_TYPE_TCP_UDP          = "tcp_udp"
+	LB_LISTENER_TYPE_HTTP             = "http"
+	LB_LISTENER_TYPE_HTTPS            = "https"
+	LB_LISTENER_TYPE_TERMINATED_HTTPS = "terminated_https"
 )
 
 var LB_LISTENER_TYPES = choices.NewChoices(
@@ -234,6 +235,7 @@ var LB_STICKY_SESSION_TYPES = choices.NewChoices(
 
 // TODO maybe https check when field need comes ;)
 const (
+	LB_HEALTH_CHECK_PING  = "ping"
 	LB_HEALTH_CHECK_TCP   = "tcp"
 	LB_HEALTH_CHECK_UDP   = "udp"
 	LB_HEALTH_CHECK_HTTP  = "http"

diff --git a/pkg/cloudprovider/loadbalancerlistener.go b/pkg/cloudprovider/loadbalancerlistener.go
@@ -84,4 +84,11 @@ type SLoadbalancerListenerRule struct {
 	HealthCheckFail int // for qcloud only
 
 	StickySessionCookieTimeout int // for qcloud only
+
+	// openstack redirect
+	Redirect       string `width:"16" nullable:"true" list:"user" create:"optional" update:"user" default:"off"` // 跳转类型
+	RedirectCode   int    `nullable:"true" list:"user" create:"optional" update:"user"`                          // 跳转HTTP code
+	RedirectScheme string `width:"16" nullable:"true" list:"user" create:"optional" update:"user"`               // 跳转uri scheme
+	RedirectHost   string `nullable:"true" list:"user" create:"optional" update:"user"`                          // 跳转时变更Host
+	RedirectPath   string `nullable:"true" list:"user" create:"optional" update:"user"`                          // 跳转时变更Path
 }
diff --git a/pkg/compute/models/cloudsyncelb.go b/pkg/compute/models/cloudsyncelb.go
@@ -339,3 +339,48 @@ func syncQcloudLoadbalancerBackends(ctx context.Context, userCred mcclient.Token
 		return
 	}
 }
+
+// openstack elb sync
+func SyncOpenstackLoadbalancerBackendgroups(ctx context.Context, userCred mcclient.TokenCredential, syncResults SSyncResultSet, provider *SCloudprovider, localLoadbalancer *SLoadbalancer, remoteLoadbalancer cloudprovider.ICloudLoadbalancer, syncRange *SSyncRange) {
+	remoteBackendgroups, err := remoteLoadbalancer.GetILoadBalancerBackendGroups()
+	if err != nil {
+		msg := fmt.Sprintf("GetILoadBalancerBackendGroups for loadbalancer %s failed %s", localLoadbalancer.Name, err)
+		log.Errorln(msg)
+		return
+	}
+	localLbbgs, remoteLbbgs, result := OpenstackCachedLbbgManager.SyncLoadbalancerBackendgroups(ctx, userCred, provider, localLoadbalancer, remoteBackendgroups, syncRange)
+
+	syncResults.Add(HuaweiCachedLbbgManager, result)
+
+	msg := result.Result()
+	log.Infof("SyncLoadbalancerBackendgroups for loadbalancer %s result: %s", localLoadbalancer.Name, msg)
+	if result.IsError() {
+		return
+	}
+	for i := 0; i < len(localLbbgs); i++ {
+		func() {
+			lockman.LockObject(ctx, &localLbbgs[i])
+			defer lockman.ReleaseObject(ctx, &localLbbgs[i])
+
+			syncOpenstackLoadbalancerBackends(ctx, userCred, syncResults, provider, &localLbbgs[i], remoteLbbgs[i], syncRange)
+		}()
+	}
+}
+
+func syncOpenstackLoadbalancerBackends(ctx context.Context, userCred mcclient.TokenCredential, syncResults SSyncResultSet, provider *SCloudprovider, localLbbg *SOpenstackCachedLbbg, remoteLbbg cloudprovider.ICloudLoadbalancerBackendGroup, syncRange *SSyncRange) {
+	remoteLbbs, err := remoteLbbg.GetILoadbalancerBackends()
+	if err != nil {
+		msg := fmt.Sprintf("GetILoadbalancerBackends for lbbg %s failed %s", localLbbg.Name, err)
+		log.Errorln(msg)
+		return
+	}
+	result := OpenstackCachedLbManager.SyncLoadbalancerBackends(ctx, userCred, provider, localLbbg, remoteLbbs, syncRange)
+
+	syncResults.Add(LoadbalancerBackendManager, result)
+
+	msg := result.Result()
+	log.Infof("SyncLoadbalancerBackends for LoadbalancerBackendgroup %s result: %s", localLbbg.Name, msg)
+	if result.IsError() {
+		return
+	}
+}
diff --git a/pkg/compute/models/loadbalancerbackendgroups.go b/pkg/compute/models/loadbalancerbackendgroups.go
@@ -535,6 +535,15 @@ func (lbbg *SLoadbalancerBackendGroup) StartAwsLoadBalancerBackendGroupCreateTas
 	return nil
 }
 
+func (lbbg *SLoadbalancerBackendGroup) StartOpenstackLoadBalancerBackendGroupCreateTask(ctx context.Context, userCred mcclient.TokenCredential, params *jsonutils.JSONDict, parentTaskId string) error {
+	task, err := taskman.TaskManager.NewTask(ctx, "OpenstackLoadbalancerLoadbalancerBackendGroupCreateTask", lbbg, userCred, params, parentTaskId, "", nil)
+	if err != nil {
+		return err
+	}
+	task.ScheduleRun(nil)
+	return nil
+}
+
 func (lbbg *SLoadbalancerBackendGroup) LBPendingDelete(ctx context.Context, userCred mcclient.TokenCredential) {
 	if lb := lbbg.GetLoadbalancer(); lb != nil && lb.BackendGroupId == lbbg.Id {
 		if _, err := db.UpdateWithLock(ctx, lb, func() error {
@@ -760,6 +769,52 @@ func (lbbg *SLoadbalancerBackendGroup) GetQcloudBackendGroupParams(lblis *SLoadb
 	return ret, nil
 }
 
+func (lbbg *SLoadbalancerBackendGroup) GetOpenstackBackendGroupParams(lblis *SLoadbalancerListener, lbr *SLoadbalancerListenerRule) (*cloudprovider.SLoadbalancerBackendGroup, error) {
+	ret, err := lbbg.GetBackendGroupParams()
+	if err != nil {
+		return nil, errors.Wrap(err, "lbbg.GetBackendGroupParams()")
+	}
+
+	var stickySession *cloudprovider.SLoadbalancerStickySession
+	if lblis.StickySession == api.LB_BOOL_ON {
+		stickySession = &cloudprovider.SLoadbalancerStickySession{
+			StickySession:              lblis.StickySession,
+			StickySessionCookie:        lblis.StickySessionCookie,
+			StickySessionType:          lblis.StickySessionType,
+			StickySessionCookieTimeout: lblis.StickySessionCookieTimeout,
+		}
+	}
+
+	var healthCheck *cloudprovider.SLoadbalancerHealthCheck
+	if lblis.HealthCheck == api.LB_BOOL_ON {
+		healthCheck = &cloudprovider.SLoadbalancerHealthCheck{
+			HealthCheckType:     lblis.HealthCheckType,
+			HealthCheckReq:      lblis.HealthCheckReq,
+			HealthCheckExp:      lblis.HealthCheckExp,
+			HealthCheck:         lblis.HealthCheck,
+			HealthCheckTimeout:  lblis.HealthCheckTimeout,
+			HealthCheckDomain:   lblis.HealthCheckDomain,
+			HealthCheckHttpCode: lblis.HealthCheckHttpCode,
+			HealthCheckURI:      lblis.HealthCheckURI,
+			HealthCheckInterval: lblis.HealthCheckInterval,
+			HealthCheckRise:     lblis.HealthCheckRise,
+			HealthCheckFail:     lblis.HealthCheckFall,
+		}
+	}
+
+	if lbr != nil {
+		ret.ListenerID = lbr.GetExternalId()
+	} else {
+		ret.ListenerID = lblis.GetExternalId()
+	}
+	ret.ListenType = lblis.ListenerType
+	ret.Scheduler = lblis.Scheduler
+	ret.StickySession = stickySession
+	ret.HealthCheck = healthCheck
+
+	return ret, nil
+}
+
 func (lbbg *SLoadbalancerBackendGroup) GetBackendsParams() ([]cloudprovider.SLoadbalancerBackend, error) {
 	backends, err := lbbg.GetBackends()
 	if err != nil {

diff --git a/pkg/compute/models/loadbalancercachedacls.go b/pkg/compute/models/loadbalancercachedacls.go
@@ -358,6 +358,9 @@ func (man *SCachedLoadbalancerAclManager) GetOrCreateCachedAcl(ctx context.Conte
 	if lblis.GetProviderName() == api.CLOUD_PROVIDER_HUAWEI {
 		listenerId = lblis.Id
 	}
+	if lblis.GetProviderName() == api.CLOUD_PROVIDER_OPENSTACK {
+		listenerId = lblis.Id
+	}
 
 	region := lblis.GetRegion()
 	if region == nil {

diff --git a/pkg/compute/models/loadbalancerlistenerrules.go b/pkg/compute/models/loadbalancerlistenerrules.go
@@ -499,7 +499,7 @@ func (man *SLoadbalancerListenerRuleManager) ValidateCreateData(ctx context.Cont
 	}
 
 	backendGroupV := validators.NewModelIdOrNameValidator("backend_group", "loadbalancerbackendgroup", ownerId)
-	if region.Provider == api.CLOUD_PROVIDER_ONECLOUD {
+	if region.GetDriver().IsSupportLoadbalancerListenerRuleRedirect() {
 		// backend group can be empty if you support redirect in rule
 		backendGroupV.Optional(true)
 	}
@@ -825,6 +825,28 @@ func (lbr *SLoadbalancerListenerRule) updateCachedLoadbalancerBackendGroupAssoci
 				}
 			}
 		}
+	case api.CLOUD_PROVIDER_OPENSTACK:
+		_group, err := db.FetchByExternalId(OpenstackCachedLbbgManager, exteralLbbgId)
+		if err != nil {
+			if err == sql.ErrNoRows {
+				lbr.BackendGroupId = ""
+			}
+			return fmt.Errorf("Fetch openstack loadbalancer backendgroup by external id %s failed: %s", exteralLbbgId, err)
+		}
+
+		if _group != nil {
+			group := _group.(*SOpenstackCachedLbbg)
+			if group.AssociatedId != lbr.Id {
+				_, err := db.UpdateWithLock(ctx, group, func() error {
+					group.AssociatedId = lbr.Id
+					group.AssociatedType = api.LB_ASSOCIATE_TYPE_RULE
+					return nil
+				})
+				if err != nil {
+					return errors.Wrap(err, "LoadbalancerListener.updateCachedLoadbalancerBackendGroupAssociate.openstack")
+				}
+			}
+		}
 	default:
 		return nil
 	}

diff --git a/pkg/compute/models/loadbalancerlisteners.go b/pkg/compute/models/loadbalancerlisteners.go
@@ -458,7 +458,7 @@ func (lblis *SLoadbalancerListener) ValidateUpdateData(ctx context.Context, user
 func (lblis *SLoadbalancerListener) PostUpdate(ctx context.Context, userCred mcclient.TokenCredential, query jsonutils.JSONObject, data jsonutils.JSONObject) {
 	lblis.SVirtualResourceBase.PostUpdate(ctx, userCred, query, data)
 
-	if account := lblis.GetCloudaccount(); account != nil && account.IsPublicCloud.IsTrue() {
+	if account := lblis.GetCloudaccount(); account != nil && !account.IsOnPremise {
 		lblis.StartLoadBalancerListenerSyncTask(ctx, userCred, data, "")
 	}
 }
@@ -783,6 +783,29 @@ func (lblis *SLoadbalancerListener) GetQcloudLoadbalancerListenerParams() (*clou
 	return listener, nil
 }
 
+func (lblis *SLoadbalancerListener) GetOpenstackLoadbalancerListenerParams() (*cloudprovider.SLoadbalancerListener, error) {
+	listener, err := lblis.GetLoadbalancerListenerParams()
+	if err != nil {
+		return nil, err
+	}
+
+	if backendgroup := lblis.GetLoadbalancerBackendGroup(); backendgroup != nil {
+		cachedLbbg, err := OpenstackCachedLbbgManager.GetCachedBackendGroupByAssociateId(lblis.GetId())
+		if err != nil {
+			if errors.Cause(err) != sql.ErrNoRows {
+				return nil, errors.Wrap(err, "loadbalancerListener.GetCachedBackendGroupByAssociateId")
+			} else {
+				log.Debugf("loadbalancerListener.GetCachedBackendGroupByAssociateId %s not found", lblis.GetId())
+			}
+		} else {
+			listener.BackendGroupID = cachedLbbg.ExternalId
+			listener.BackendGroupType = backendgroup.Type
+		}
+	}
+
+	return listener, nil
+}
+
 func (lblis *SLoadbalancerListener) GetLoadbalancerCertificate() (*SCachedLoadbalancerCertificate, error) {
 	if len(lblis.CachedCertificateId) == 0 {
 		return nil, nil
@@ -1089,6 +1112,20 @@ func (lblis *SLoadbalancerListener) constructFieldsFromCloudListener(userCred mc
 				}
 			}
 		}
+	case api.CLOUD_PROVIDER_OPENSTACK:
+		if len(groupId) > 0 {
+			group, err := db.FetchByExternalIdAndManagerId(OpenstackCachedLbbgManager, groupId, func(q *sqlchemy.SQuery) *sqlchemy.SQuery {
+				return q.Equals("manager_id", lb.ManagerId)
+			})
+			if err != nil {
+				if errors.Cause(err) == sql.ErrNoRows {
+					lblis.BackendGroupId = ""
+				}
+				log.Errorf("Fetch openstack loadbalancer backendgroup by external id %s failed: %s", groupId, err)
+			} else {
+				lblis.BackendGroupId = group.(*SOpenstackCachedLbbg).BackendGroupId
+			}
+		}
 	default:
 		if len(lblis.BackendGroupId) == 0 && len(groupId) == 0 {
 			lblis.BackendGroupId = lb.BackendGroupId
@@ -1161,6 +1198,31 @@ func (lblis *SLoadbalancerListener) updateCachedLoadbalancerBackendGroupAssociat
 				}
 			}
 		}
+	case api.CLOUD_PROVIDER_OPENSTACK:
+		_group, err := db.FetchByExternalIdAndManagerId(OpenstackCachedLbbgManager, exteralLbbgId, func(q *sqlchemy.SQuery) *sqlchemy.SQuery {
+			return q.Equals("manager_id", managerId)
+		})
+		if err != nil {
+			if errors.Cause(err) == sql.ErrNoRows {
+				lblis.BackendGroupId = ""
+			} else {
+				return fmt.Errorf("Fetch openstack loadbalancer backendgroup by external id %s failed: %s", exteralLbbgId, err)
+			}
+		}
+
+		if _group != nil {
+			group := _group.(*SOpenstackCachedLbbg)
+			if group.AssociatedId != lblis.Id {
+				_, err := db.UpdateWithLock(ctx, group, func() error {
+					group.AssociatedId = lblis.Id
+					group.AssociatedType = api.LB_ASSOCIATE_TYPE_LISTENER
+					return nil
+				})
+				if err != nil {
+					return errors.Wrap(err, "LoadbalancerListener.updateCachedLoadbalancerBackendGroupAssociate.openstack")
+				}
+			}
+		}
 	default:
 		return nil
 	}