func()

in pkg/provider/alibaba/alb/listener.go [480:680]
189 lines of code
42 McCabe index (conditional complexity)

func (m *ALBProvider) updateListenerAttribute(ctx context.Context, resLS *albmodel.Listener, sdkLs *albsdk.Listener) error {
	traceID := ctx.Value(util.TraceID)

	var (
		isGzipEnabledNeedUpdate,
		isQuicConfigUpdate,
		isHttp2EnabledNeedUpdate,
		isDefaultActionsNeedUpdate,
		isRequestTimeoutNeedUpdate,
		isXForwardedForConfigNeedUpdate,
		isSecurityPolicyIdNeedUpdate,
		isIdleTimeoutNeedUpdate,
		isListenerDescriptionNeedUpdate,
		isCertificatesNeedUpdate bool
	)

	if resLS.Spec.GzipEnabled != sdkLs.GzipEnabled {
		m.logger.V(util.MgrLogLevel).Info("GzipEnabled update",
			"res", resLS.Spec.GzipEnabled,
			"sdk", sdkLs.GzipEnabled,
			"listenerID", sdkLs.ListenerId,
			"traceID", traceID)
		isGzipEnabledNeedUpdate = true
	}
	quicConfig := transQuicConfigToSDK(resLS.Spec.QuicConfig)
	if quicConfig != sdkLs.QuicConfig {
		m.logger.V(util.MgrLogLevel).Info("QuicConfig update",
			"res", resLS.Spec.QuicConfig,
			"sdk", sdkLs.QuicConfig,
			"listenerID", sdkLs.ListenerId,
			"traceID", traceID)
		isQuicConfigUpdate = true
	}
	if len(resLS.Spec.DefaultActions) == 0 {
		return fmt.Errorf("empty listener default action: %v", resLS.Spec.DefaultActions)
	}
	resAction, err := transModelActionsToSDKLs(resLS.Spec.DefaultActions)
	if err != nil {
		return err
	}
	if len(*resAction) == 0 {
		return fmt.Errorf("empty listener default action: %v", *resAction)
	}
	if !reflect.DeepEqual((*resAction)[0], sdkLs.DefaultActions[0]) {
		m.logger.V(util.MgrLogLevel).Info("DefaultActions update",
			"res", (*resAction)[0],
			"sdk", sdkLs.DefaultActions[0],
			"listenerID", sdkLs.ListenerId,
			"traceID", traceID)
		isDefaultActionsNeedUpdate = true
	}

	if !isListenerRequestTimeoutValid(resLS.Spec.RequestTimeout) {
		return fmt.Errorf("invalid listener RequestTimeout: %d", resLS.Spec.RequestTimeout)
	}
	if resLS.Spec.RequestTimeout != sdkLs.RequestTimeout {
		m.logger.V(util.MgrLogLevel).Info("RequestTimeout update",
			"res", resLS.Spec.RequestTimeout,
			"sdk", sdkLs.RequestTimeout,
			"listenerID", sdkLs.ListenerId,
			"traceID", traceID)
		isRequestTimeoutNeedUpdate = true
	}
	xForwardedForConfig := transXForwardedForConfigToSDK(resLS.Spec.XForwardedForConfig)
	if xForwardedForConfig != sdkLs.XForwardedForConfig {
		m.logger.V(util.MgrLogLevel).Info("XForwardedForConfig update",
			"res", resLS.Spec.XForwardedForConfig,
			"sdk", sdkLs.XForwardedForConfig,
			"listenerID", sdkLs.ListenerId,
			"traceID", traceID)
		isXForwardedForConfigNeedUpdate = true
	}

	if !isListenerIdleTimeoutValid(resLS.Spec.IdleTimeout) {
		return fmt.Errorf("invalid listener IdleTimeout: %d", resLS.Spec.IdleTimeout)
	}
	if resLS.Spec.IdleTimeout != sdkLs.IdleTimeout {
		m.logger.V(util.MgrLogLevel).Info("IdleTimeout update",
			"res", resLS.Spec.IdleTimeout,
			"sdk", sdkLs.IdleTimeout,
			"listenerID", sdkLs.ListenerId,
			"traceID", traceID)
		isIdleTimeoutNeedUpdate = true
	}
	if resLS.Spec.ListenerDescription != sdkLs.ListenerDescription {
		m.logger.V(util.MgrLogLevel).Info("ListenerDescription update",
			"res", resLS.Spec.ListenerDescription,
			"sdk", sdkLs.ListenerDescription,
			"listenerID", sdkLs.ListenerId,
			"traceID", traceID)
		isListenerDescriptionNeedUpdate = true
	}

	if isHTTPSListenerProtocol(sdkLs.ListenerProtocol) {
		if len(resLS.Spec.SecurityPolicyId) == 0 {
			return fmt.Errorf("invalid https listener SecurityPolicyId: %s", resLS.Spec.SecurityPolicyId)
		}
		if resLS.Spec.SecurityPolicyId != sdkLs.SecurityPolicyId {
			m.logger.V(util.MgrLogLevel).Info("SecurityPolicyId update",
				"res", resLS.Spec.SecurityPolicyId,
				"sdk", sdkLs.SecurityPolicyId,
				"listenerID", sdkLs.ListenerId,
				"traceID", traceID)
			isSecurityPolicyIdNeedUpdate = true
		}

		desiredDefaultCerts, _ := buildSDKCertificates(resLS.Spec.Certificates)
		if len(desiredDefaultCerts) != 1 {
			return fmt.Errorf("invalid res https listener default certs len: %d", len(desiredDefaultCerts))
		}
		currentDefaultCerts, _ := buildSDKCertificatesModel(m.sdkCerts)
		if len(currentDefaultCerts) != 1 {
			return fmt.Errorf("invalid sdk https listener default certs len: %d", len(currentDefaultCerts))
		}
		if desiredDefaultCerts[0].CertificateId != currentDefaultCerts[0].CertificateId {
			m.logger.V(util.MgrLogLevel).Info("DefaultCerts update",
				"res", desiredDefaultCerts[0],
				"sdk", currentDefaultCerts[0],
				"listenerID", sdkLs.ListenerId,
				"traceID", traceID)
			isCertificatesNeedUpdate = true
		}

		if resLS.Spec.Http2Enabled != sdkLs.Http2Enabled {
			m.logger.V(util.MgrLogLevel).Info("Http2Enabled update",
				"res", resLS.Spec.Http2Enabled,
				"sdk", sdkLs.Http2Enabled,
				"listenerID", sdkLs.ListenerId,
				"traceID", traceID)
			isHttp2EnabledNeedUpdate = true
		}
	}

	if !isGzipEnabledNeedUpdate && !isQuicConfigUpdate && !isHttp2EnabledNeedUpdate &&
		!isDefaultActionsNeedUpdate && !isRequestTimeoutNeedUpdate && !isXForwardedForConfigNeedUpdate &&
		!isSecurityPolicyIdNeedUpdate && !isIdleTimeoutNeedUpdate && !isListenerDescriptionNeedUpdate &&
		!isCertificatesNeedUpdate {
		return nil
	}

	updateLsReq := albsdk.CreateUpdateListenerAttributeRequest()
	updateLsReq.ListenerId = sdkLs.ListenerId

	if isGzipEnabledNeedUpdate {
		updateLsReq.GzipEnabled = requests.NewBoolean(resLS.Spec.GzipEnabled)
	}
	if isQuicConfigUpdate {
		updateLsReq.QuicConfig = transSDKQuicConfigToUpdateLs(resLS.Spec.QuicConfig)
	}
	if isHttp2EnabledNeedUpdate {
		updateLsReq.Http2Enabled = requests.NewBoolean(resLS.Spec.Http2Enabled)
	}
	if isDefaultActionsNeedUpdate {
		defaultAction, err := transModelActionToSDKUpdateLs(resLS.Spec.DefaultActions)
		if err != nil {
			return err
		}
		updateLsReq.DefaultActions = defaultAction
	}
	if isRequestTimeoutNeedUpdate {
		updateLsReq.RequestTimeout = requests.NewInteger(resLS.Spec.RequestTimeout)
	}
	if isXForwardedForConfigNeedUpdate {
		updateLsReq.XForwardedForConfig = transSDKXForwardedForConfigToUpdateLs(resLS.Spec.XForwardedForConfig)
	}
	if isSecurityPolicyIdNeedUpdate {
		updateLsReq.SecurityPolicyId = resLS.Spec.SecurityPolicyId
	}
	if isIdleTimeoutNeedUpdate {
		updateLsReq.IdleTimeout = requests.NewInteger(resLS.Spec.IdleTimeout)
	}
	if isListenerDescriptionNeedUpdate {
		updateLsReq.ListenerDescription = resLS.Spec.ListenerDescription
	}
	if isCertificatesNeedUpdate {
		updateLsReq.Certificates = transSDKCertificatesToUpdateLs(resLS.Spec.Certificates)
	}

	startTime := time.Now()
	m.logger.V(util.MgrLogLevel).Info("updating listener attribute",
		"stackID", resLS.Stack().StackID(),
		"resourceID", resLS.ID(),
		"traceID", traceID,
		"listenerID", sdkLs.ListenerId,
		"startTime", startTime,
		util.Action, util.UpdateALBListenerAttribute)
	updateLsResp, err := m.auth.ALB.UpdateListenerAttribute(updateLsReq)
	if err != nil {
		return err
	}
	m.logger.V(util.MgrLogLevel).Info("updated listener attribute",
		"stackID", resLS.Stack().StackID(),
		"resourceID", resLS.ID(),
		"traceID", traceID,
		"listenerID", sdkLs.ListenerId,
		"requestID", updateLsResp.RequestId,
		"elapsedTime", time.Since(startTime).Milliseconds(),
		util.Action, util.UpdateALBListenerAttribute)

	return nil
}