func()

in pilot/pkg/model/push_context.go [1254:1406]

• 133 lines of code
• 45 McCabe index (conditional complexity)

func (ps *PushContext) updateContext(
	env *Environment,
	oldPushContext *PushContext,
	pushReq *PushRequest) error {
	var servicesChanged, virtualServicesChanged, destinationRulesChanged, gatewayChanged,
		authnChanged, authzChanged, envoyFiltersChanged, sidecarsChanged, telemetryChanged, gatewayAPIChanged,
		wasmPluginsChanged, proxyConfigsChanged, servicenamemappingsChanged bool

	for conf := range pushReq.ConfigsUpdated {
		switch conf.Kind {
		case gvk.ServiceEntry:
			servicesChanged = true
		case gvk.DestinationRule:
			destinationRulesChanged = true
		case gvk.VirtualService:
			virtualServicesChanged = true
		case gvk.Gateway:
			gatewayChanged = true
		case gvk.Sidecar:
			sidecarsChanged = true
		case gvk.WasmPlugin:
			wasmPluginsChanged = true
		case gvk.EnvoyFilter:
			envoyFiltersChanged = true
		case gvk.AuthorizationPolicy:
			authzChanged = true
		case gvk.RequestAuthentication,
			gvk.PeerAuthentication:
			authnChanged = true
		case gvk.HTTPRoute, gvk.TCPRoute, gvk.GatewayClass, gvk.KubernetesGateway, gvk.TLSRoute, gvk.ReferencePolicy:
			gatewayAPIChanged = true
			// VS and GW are derived from gatewayAPI, so if it changed we need to update those as well
			virtualServicesChanged = true
			gatewayChanged = true
		case gvk.Telemetry:
			telemetryChanged = true
		case gvk.ProxyConfig:
			proxyConfigsChanged = true
		case gvk.ServiceNameMapping:
			servicenamemappingsChanged = true
		}
	}

	if servicesChanged {
		// Services have changed. initialize service registry
		if err := ps.initServiceRegistry(env); err != nil {
			return err
		}
	} else {
		// make sure we copy over things that would be generated in initServiceRegistry
		ps.ServiceIndex = oldPushContext.ServiceIndex
		ps.ServiceAccounts = oldPushContext.ServiceAccounts
	}

	if servicesChanged || gatewayAPIChanged {
		// Gateway status depends on services, so recompute if they change as well
		if err := ps.initKubernetesGateways(env); err != nil {
			return err
		}
	}

	if virtualServicesChanged {
		if err := ps.initVirtualServices(env); err != nil {
			return err
		}
	} else {
		ps.virtualServiceIndex = oldPushContext.virtualServiceIndex
	}

	if destinationRulesChanged {
		if err := ps.initDestinationRules(env); err != nil {
			return err
		}
	} else {
		ps.destinationRuleIndex = oldPushContext.destinationRuleIndex
	}

	if authnChanged {
		if err := ps.initAuthnPolicies(env); err != nil {
			return err
		}
	} else {
		ps.AuthnPolicies = oldPushContext.AuthnPolicies
	}

	if authzChanged {
		if err := ps.initAuthorizationPolicies(env); err != nil {
			authzLog.Errorf("failed to initialize authorization policies: %v", err)
			return err
		}
	} else {
		ps.AuthzPolicies = oldPushContext.AuthzPolicies
	}

	if telemetryChanged {
		if err := ps.initTelemetry(env); err != nil {
			return err
		}
	} else {
		ps.Telemetry = oldPushContext.Telemetry
	}

	if proxyConfigsChanged {
		if err := ps.initProxyConfigs(env); err != nil {
			return err
		}
	} else {
		ps.ProxyConfigs = oldPushContext.ProxyConfigs
	}

	if wasmPluginsChanged {
		if err := ps.initWasmPlugins(env); err != nil {
			return err
		}
	} else {
		ps.wasmPluginsByNamespace = oldPushContext.wasmPluginsByNamespace
	}

	if envoyFiltersChanged {
		if err := ps.initEnvoyFilters(env); err != nil {
			return err
		}
	} else {
		ps.envoyFiltersByNamespace = oldPushContext.envoyFiltersByNamespace
	}

	if gatewayChanged {
		if err := ps.initGateways(env); err != nil {
			return err
		}
	} else {
		ps.gatewayIndex = oldPushContext.gatewayIndex
	}

	// Must be initialized in the end
	// Sidecars need to be updated if services, virtual services, destination rules, or the sidecar configs change
	if servicesChanged || virtualServicesChanged || destinationRulesChanged || sidecarsChanged {
		if err := ps.initSidecarScopes(env); err != nil {
			return err
		}
	} else {
		ps.sidecarIndex.sidecarsByNamespace = oldPushContext.sidecarIndex.sidecarsByNamespace
	}
	if servicenamemappingsChanged {
		if err := ps.initServiceNameMappings(env); err != nil {
			return err
		}
	} else {
		ps.serviceNameMappingIndex = oldPushContext.serviceNameMappingIndex
	}

	return nil
}