Cloudpods/backend/pkg/compute/models/cloudsyncelb.go

// Copyright 2019 Yunion
//
// 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 models

import (
	"context"
	"fmt"

	"yunion.io/x/cloudmux/pkg/cloudprovider"
	"yunion.io/x/log"
	"yunion.io/x/pkg/errors"
	"yunion.io/x/pkg/util/compare"

	"yunion.io/x/onecloud/pkg/cloudcommon/db"
	"yunion.io/x/onecloud/pkg/cloudcommon/db/lockman"
	"yunion.io/x/onecloud/pkg/mcclient"
)

func syncRegionLoadbalancerCertificates(
	ctx context.Context,
	userCred mcclient.TokenCredential,
	syncResults SSyncResultSet,
	provider *SCloudprovider,
	localRegion *SCloudregion,
	remoteRegion cloudprovider.ICloudRegion,
	syncRange *SSyncRange,
) {
	certificates, err := func() ([]cloudprovider.ICloudLoadbalancerCertificate, error) {
		defer syncResults.AddRequestCost(LoadbalancerCertificateManager)()
		return remoteRegion.GetILoadBalancerCertificates()
	}()
	if err != nil {
		msg := fmt.Sprintf("GetILoadBalancerCertificates for region %s provider %s failed %s", remoteRegion.GetName(), provider.Name, err)
		log.Errorln(msg)
		return
	}
	result := func() compare.SyncResult {
		defer syncResults.AddSqlCost(LoadbalancerCertificateManager)()
		return localRegion.SyncLoadbalancerCertificates(ctx, userCred, provider, certificates, syncRange.Xor)
	}()

	syncResults.Add(LoadbalancerCertificateManager, result)

	msg := result.Result()
	log.Infof("SyncLoadbalancerCertificates for region %s provider %s result: %s", localRegion.Name, provider.Name, msg)
	if result.IsError() {
		return
	}
}

func syncRegionLoadbalancerHealthChecks(
	ctx context.Context,
	userCred mcclient.TokenCredential,
	syncResults SSyncResultSet,
	provider *SCloudprovider,
	localRegion *SCloudregion,
	remoteRegion cloudprovider.ICloudRegion,
	syncRange *SSyncRange,
) {
	healthChecks, err := func() ([]cloudprovider.ICloudLoadbalancerHealthCheck, error) {
		defer syncResults.AddRequestCost(LoadbalancerHealthCheckManager)()
		return remoteRegion.GetILoadBalancerHealthChecks()
	}()
	if err != nil {
		msg := fmt.Sprintf("GetILoadBalancerHealthChecks for region %s provider %s failed %s", remoteRegion.GetName(), provider.Name, err)
		log.Errorln(msg)
		return
	}
	result := func() compare.SyncResult {
		defer syncResults.AddSqlCost(LoadbalancerHealthCheckManager)()
		return localRegion.SyncLoadbalancerHealthChecks(ctx, userCred, provider, healthChecks)
	}()

	syncResults.Add(LoadbalancerHealthCheckManager, result)

	msg := result.Result()
	log.Infof("SyncLoadbalancerHealthChecks for region %s provider %s result: %s", localRegion.Name, provider.Name, msg)
	if result.IsError() {
		return
	}
}

func syncRegionLoadbalancerAcls(
	ctx context.Context,
	userCred mcclient.TokenCredential,
	syncResults SSyncResultSet,
	provider *SCloudprovider,
	localRegion *SCloudregion,
	remoteRegion cloudprovider.ICloudRegion,
	syncRange *SSyncRange,
) {
	acls, err := func() ([]cloudprovider.ICloudLoadbalancerAcl, error) {
		defer syncResults.AddRequestCost(LoadbalancerAclManager)()
		return remoteRegion.GetILoadBalancerAcls()
	}()
	if err != nil {
		msg := fmt.Sprintf("GetILoadBalancerAcls for region %s provider %s failed %s", remoteRegion.GetName(), provider.Name, err)
		log.Errorln(msg)
		return
	}
	result := func() compare.SyncResult {
		defer syncResults.AddSqlCost(LoadbalancerAclManager)()
		return localRegion.SyncLoadbalancerAcls(ctx, userCred, provider, acls, syncRange.Xor)
	}()

	syncResults.Add(LoadbalancerAclManager, result)

	msg := result.Result()
	log.Infof("SyncLoadbalancerAcls for region %s provider %s result: %s", localRegion.Name, provider.Name, msg)
	if result.IsError() {
		return
	}
}

func syncRegionLoadbalancers(
	ctx context.Context,
	userCred mcclient.TokenCredential,
	syncResults SSyncResultSet,
	provider *SCloudprovider,
	localRegion *SCloudregion,
	remoteRegion cloudprovider.ICloudRegion,
	syncRange *SSyncRange,
) {
	lbs, err := func() ([]cloudprovider.ICloudLoadbalancer, error) {
		defer syncResults.AddRequestCost(LoadbalancerManager)()
		return remoteRegion.GetILoadBalancers()
	}()
	if err != nil {
		msg := fmt.Sprintf("GetILoadBalancers for region %s provider %s failed %s", remoteRegion.GetName(), provider.Name, err)
		log.Errorln(msg)
		return
	}
	func() {
		defer syncResults.AddSqlCost(LoadbalancerManager)()

		localLbs, remoteLbs, result := LoadbalancerManager.SyncLoadbalancers(ctx, userCred, provider, localRegion, lbs, syncRange.Xor)

		syncResults.Add(LoadbalancerManager, result)

		msg := result.Result()
		log.Infof("SyncLoadbalancers for region %s provider %s result: %s", localRegion.Name, provider.Name, msg)
		if result.IsError() {
			return
		}
		db.OpsLog.LogEvent(provider, db.ACT_SYNC_LB_COMPLETE, msg, userCred)

		for i := 0; i < len(localLbs); i++ {
			func() {
				lockman.LockObject(ctx, &localLbs[i])
				defer lockman.ReleaseObject(ctx, &localLbs[i])

				syncLbPeripherals(ctx, userCred, provider, &localLbs[i], remoteLbs[i])
			}()
		}
	}()
}

func syncLbPeripherals(ctx context.Context, userCred mcclient.TokenCredential, provider *SCloudprovider, local *SLoadbalancer, remote cloudprovider.ICloudLoadbalancer) {
	err := syncLoadbalancerEips(ctx, userCred, provider, local, remote)
	if err != nil {
		log.Errorf("syncLoadbalancerEips for loadbalancer %s provider %s error %s", local.Name, provider.Name, err)
	}
	err = syncLoadbalancerBackendgroups(ctx, userCred, SSyncResultSet{}, provider, local, remote)
	if err != nil {
		log.Errorf("syncLoadbalancerBackendgroups for loadbalancer %s provider %s error: %v", local.Name, provider.Name, err)
	}
	err = syncLoadbalancerListeners(ctx, userCred, SSyncResultSet{}, provider, local, remote)
	if err != nil {
		log.Errorf("syncLoadbalancerListeners for loadbalancer %s provider %s error: %v", local.Name, provider.Name, err)
	}

	err = syncLoadbalancerSecurityGroups(ctx, userCred, local, remote)
	if err != nil {
		log.Errorf("syncLoadbalancerSecurityGroups for loadbalancer %s provider %s error: %v", local.Name, provider.Name, err)
	}
}

func syncLoadbalancerSecurityGroups(ctx context.Context, userCred mcclient.TokenCredential, localLb *SLoadbalancer, remoteLb cloudprovider.ICloudLoadbalancer) error {
	secIds, err := remoteLb.GetSecurityGroupIds()
	if err != nil {
		return errors.Wrapf(err, "GetSecurityGroupIds")
	}
	result := localLb.SyncSecurityGroups(ctx, userCred, secIds)
	msg := result.Result()
	log.Infof("SyncSecurityGroups for Loadbalancer %s result: %s", localLb.Name, msg)
	if result.IsError() {
		return result.AllError()
	}
	return nil
}

func syncLoadbalancerEips(ctx context.Context, userCred mcclient.TokenCredential, provider *SCloudprovider, localLb *SLoadbalancer, remoteLb cloudprovider.ICloudLoadbalancer) error {
	eips, err := remoteLb.GetIEIPs()
	if err != nil {
		return errors.Wrapf(err, "GetIEIPs")
	}
	result := localLb.SyncLoadbalancerEips(ctx, userCred, provider, eips)
	msg := result.Result()
	log.Infof("SyncEips for Loadbalancer %s provider %s result: %s", localLb.Name, provider.Name, msg)
	if result.IsError() {
		return result.AllError()
	}
	return nil
}

func syncLoadbalancerListeners(ctx context.Context, userCred mcclient.TokenCredential, syncResults SSyncResultSet, provider *SCloudprovider, localLoadbalancer *SLoadbalancer, remoteLoadbalancer cloudprovider.ICloudLoadbalancer) error {
	remoteListeners, err := remoteLoadbalancer.GetILoadBalancerListeners()
	if err != nil {
		return errors.Wrapf(err, "GetILoadBalancerListeners")
	}
	localListeners, remoteListeners, result := LoadbalancerListenerManager.SyncLoadbalancerListeners(ctx, userCred, provider, localLoadbalancer, remoteListeners)

	syncResults.Add(LoadbalancerListenerManager, result)

	msg := result.Result()
	log.Infof("SyncLoadbalancerListeners for loadbalancer %s provider %s result: %s", localLoadbalancer.Name, provider.Name, msg)
	if result.IsError() {
		return result.AllError()
	}
	for i := 0; i < len(localListeners); i++ {
		func() {
			lockman.LockObject(ctx, &localListeners[i])
			defer lockman.ReleaseObject(ctx, &localListeners[i])

			syncLoadbalancerListenerRules(ctx, userCred, syncResults, provider, &localListeners[i], remoteListeners[i])
		}()
	}
	return nil
}

func syncLoadbalancerListenerRules(ctx context.Context, userCred mcclient.TokenCredential, syncResults SSyncResultSet, provider *SCloudprovider, localListener *SLoadbalancerListener, remoteListener cloudprovider.ICloudLoadbalancerListener) {
	remoteRules, err := remoteListener.GetILoadbalancerListenerRules()
	if err != nil {
		msg := fmt.Sprintf("GetILoadbalancerListenerRules for listener %s provider %s failed %s", localListener.Name, provider.Name, err)
		log.Errorln(msg)
		return
	}
	result := LoadbalancerListenerRuleManager.SyncLoadbalancerListenerRules(ctx, userCred, provider, localListener, remoteRules)

	syncResults.Add(LoadbalancerListenerRuleManager, result)

	msg := result.Result()
	log.Infof("SyncLoadbalancerListenerRules for listener %s provider %s result: %s", localListener.Name, provider.Name, msg)
	if result.IsError() {
		return
	}
}

func syncLoadbalancerBackendgroups(ctx context.Context, userCred mcclient.TokenCredential, syncResults SSyncResultSet, provider *SCloudprovider, local *SLoadbalancer, remote cloudprovider.ICloudLoadbalancer) error {
	exts, err := remote.GetILoadBalancerBackendGroups()
	if err != nil {
		return errors.Wrapf(err, "GetILoadBalancerBackendGroups")
	}
	localLbbgs, remoteLbbgs, result := local.SyncLoadbalancerBackendgroups(ctx, userCred, provider, exts)
	syncResults.Add(LoadbalancerBackendGroupManager, result)

	msg := result.Result()
	log.Infof("SyncLoadbalancerBackendgroups for loadbalancer %s provider %s result: %s", local.Name, provider.Name, msg)
	if result.IsError() {
		return result.AllError()
	}
	for i := 0; i < len(localLbbgs); i++ {
		func() {
			lockman.LockObject(ctx, &localLbbgs[i])
			defer lockman.ReleaseObject(ctx, &localLbbgs[i])

			syncLoadbalancerBackends(ctx, userCred, syncResults, provider, &localLbbgs[i], remoteLbbgs[i])
		}()
	}
	return nil
}

func syncLoadbalancerBackends(ctx context.Context, userCred mcclient.TokenCredential, syncResults SSyncResultSet, provider *SCloudprovider, local *SLoadbalancerBackendGroup, remote cloudprovider.ICloudLoadbalancerBackendGroup) {
	exts, err := remote.GetILoadbalancerBackends()
	if err != nil {
		msg := fmt.Sprintf("GetILoadbalancerBackends for lbbg %s failed %s", local.Name, err)
		log.Errorln(msg)
		return
	}
	result := local.SyncLoadbalancerBackends(ctx, userCred, provider, exts)
	syncResults.Add(LoadbalancerBackendManager, result)

	msg := result.Result()
	log.Infof("SyncLoadbalancerBackends for LoadbalancerBackendgroup %s result: %s", local.Name, msg)
	if result.IsError() {
		return
	}
}