func()

in watcher/handlerIngress.go [138:332]
143 lines of code
29 McCabe index (conditional complexity)

func (g *IgHandler) update(obj, newObj interface{}) {
	ingressObj, ok := obj.(*nv1.Ingress)
	if !ok {
		log.Println("In HandlerIngress Update; cannot cast to *nv1.Ingress")
		return
	}

	newIngressObj, ok := newObj.(*nv1.Ingress)
	if !ok {
		log.Println("In HandlerIngress Update; cannot cast to *nv1.Ingress")
		return
	}

	m := make(map[string]string)

	namespace := ingressObj.GetNamespace()
	// v1.18 ingress class name field in ingress object
	//ingressClass, _ := util.ExtractIngressClass(ingressObj.GetAnnotations())
	ingressClass, _ := util.ExtractIngressClassName(obj)
	if g.Ep.NsManager.IncludeNamespace(namespace) && g.Ep.ATSManager.IncludeIngressClass(ingressClass) {
		log.Println("Old Namespace included")

		name := ingressObj.GetName()
		version := ingressObj.GetResourceVersion()
		nameversion := util.ConstructNameVersionString(namespace, name, version)

		_, snippetErr := util.ExtractServerSnippet(ingressObj.GetAnnotations())

		// handle default backend rules
		if ingressObj.Spec.DefaultBackend != nil {
			host := "*"
			scheme := "http"
			path := "/"
			pathType := nv1.PathTypePrefix
			hostPath := util.ConstructHostPathString(scheme, host, path, pathType)

			g.Ep.RedisClient.DBOneSUnionStore("temp_"+hostPath, hostPath)
			m["temp_"+hostPath] = hostPath

			service := ingressObj.Spec.DefaultBackend.Service.Name
			port := strconv.Itoa(int(ingressObj.Spec.DefaultBackend.Service.Port.Number))
			svcport := util.ConstructSvcPortString(namespace, service, port)

			g.Ep.RedisClient.DBOneSRem("temp_"+hostPath, svcport)

			if snippetErr == nil {
				g.Ep.RedisClient.DBOneSRem("temp_"+hostPath, nameversion)
			}

			// handle default backend https rule
			scheme = "https"
			hostPath = util.ConstructHostPathString(scheme, host, path, pathType)

			g.Ep.RedisClient.DBOneSUnionStore("temp_"+hostPath, hostPath)
			m["temp_"+hostPath] = hostPath

			g.Ep.RedisClient.DBOneSRem("temp_"+hostPath, svcport)

			if snippetErr == nil {
				g.Ep.RedisClient.DBOneSRem("temp_"+hostPath, nameversion)
			}
		}

		tlsHosts := make(map[string]string)

		for _, ingressTLS := range ingressObj.Spec.TLS {
			for _, tlsHost := range ingressTLS.Hosts {
				tlsHosts[tlsHost] = "1"
			}
		}

		for _, ingressRule := range ingressObj.Spec.Rules {
			host := ingressRule.Host
			if host == "" {
				host = "*"
			}
			scheme := "http"
			if _, ok := tlsHosts[host]; ok {
				scheme = "https"
			}

			for _, httpPath := range ingressRule.HTTP.Paths {

				path := httpPath.Path
				pathType := *httpPath.PathType
				hostPath := util.ConstructHostPathString(scheme, host, path, pathType)

				g.Ep.RedisClient.DBOneSUnionStore("temp_"+hostPath, hostPath)
				m["temp_"+hostPath] = hostPath

				service := httpPath.Backend.Service.Name
				port := strconv.Itoa(int(httpPath.Backend.Service.Port.Number))
				svcport := util.ConstructSvcPortString(namespace, service, port)

				g.Ep.RedisClient.DBOneSRem("temp_"+hostPath, svcport)

				if snippetErr == nil {
					g.Ep.RedisClient.DBOneSRem("temp_"+hostPath, nameversion)
				}
			}

		}
	}

	newNamespace := newIngressObj.GetNamespace()
	// v1.18 ingress class name field in ingress object
	//newIngressClass, _ := util.ExtractIngressClass(newIngressObj.GetAnnotations())
	newIngressClass, _ := util.ExtractIngressClassName(newObj)
	if g.Ep.NsManager.IncludeNamespace(newNamespace) && g.Ep.ATSManager.IncludeIngressClass(newIngressClass) {
		log.Println("New Namespace included")

		name := newIngressObj.GetName()
		version := newIngressObj.GetResourceVersion()
		nameversion := util.ConstructNameVersionString(newNamespace, name, version)

		newSnippet, newSnippetErr := util.ExtractServerSnippet(newIngressObj.GetAnnotations())
		if newSnippetErr == nil {
			g.Ep.RedisClient.DBOneSAdd(nameversion, newSnippet)
		}

		// handle default backend rule
		if newIngressObj.Spec.DefaultBackend != nil {
			host := "*"
			scheme := "http"
			path := "/"
			pathType := nv1.PathTypePrefix
			hostPath := util.ConstructHostPathString(scheme, host, path, pathType)

			service := newIngressObj.Spec.DefaultBackend.Service.Name
			port := strconv.Itoa(int(newIngressObj.Spec.DefaultBackend.Service.Port.Number))
			svcport := util.ConstructSvcPortString(newNamespace, service, port)

			g.Ep.RedisClient.DBOneSAdd("temp_"+hostPath, svcport)
			m["temp_"+hostPath] = hostPath

			if newSnippetErr == nil {
				g.Ep.RedisClient.DBOneSAdd("temp_"+hostPath, nameversion)
			}

			// handle default backend rule for https as well
			scheme = "https"
			hostPath = util.ConstructHostPathString(scheme, host, path, pathType)

			g.Ep.RedisClient.DBOneSAdd("temp_"+hostPath, svcport)
			m["temp_"+hostPath] = hostPath

			if newSnippetErr == nil {
				g.Ep.RedisClient.DBOneSAdd("temp_"+hostPath, nameversion)
			}
		}

		newTlsHosts := make(map[string]string)

		for _, newIngressTLS := range newIngressObj.Spec.TLS {
			for _, newTlsHost := range newIngressTLS.Hosts {
				newTlsHosts[newTlsHost] = "1"
			}
		}

		for _, ingressRule := range newIngressObj.Spec.Rules {
			host := ingressRule.Host
			if host == "" {
				host = "*"
			}
			scheme := "http"
			if _, ok := newTlsHosts[host]; ok {
				scheme = "https"
			}

			for _, httpPath := range ingressRule.HTTP.Paths {

				path := httpPath.Path
				pathType := *httpPath.PathType
				hostPath := util.ConstructHostPathString(scheme, host, path, pathType)

				service := httpPath.Backend.Service.Name
				port := strconv.Itoa(int(httpPath.Backend.Service.Port.Number))
				svcport := util.ConstructSvcPortString(newNamespace, service, port)

				g.Ep.RedisClient.DBOneSAdd("temp_"+hostPath, svcport)
				m["temp_"+hostPath] = hostPath

				if newSnippetErr == nil {
					g.Ep.RedisClient.DBOneSAdd("temp_"+hostPath, nameversion)
				}
			}

		}
	}

	for key, value := range m {
		g.Ep.RedisClient.DBOneSUnionStore(value, key)
		g.Ep.RedisClient.DBOneDel(key)
	}
}