func()

in pkg/providers/gateway/translation/gateway_tlsroute.go [35:132]
75 lines of code
13 McCabe index (conditional complexity)

func (t *translator) TranslateGatewayTLSRouteV1Alpha2(tlsRoute *gatewayv1alpha2.TLSRoute) (*translation.TranslateContext, error) {
	ctx := translation.DefaultEmptyTranslateContext()

	// TODO: Handle ParentRefs

	var hosts []string
	for _, hostname := range tlsRoute.Spec.Hostnames {
		// TODO: calculate intersection of listeners
		hosts = append(hosts, string(hostname))
	}

	rules := tlsRoute.Spec.Rules

	for i, rule := range rules {
		backends := rule.BackendRefs
		if len(backends) == 0 {
			continue
		}

		var ruleUpstreams []*apisixv1.Upstream

		for j, backend := range backends {
			//TODO: Support filters
			//filters := backend.Filters
			var kind string
			if backend.Kind == nil {
				kind = "service"
			} else {
				kind = strings.ToLower(string(*backend.Kind))
			}
			if kind != "service" {
				log.Warnw(fmt.Sprintf("ignore non-service kind at Rules[%v].BackendRefs[%v]", i, j),
					zap.String("kind", kind),
				)
				continue
			}

			var ns string
			if backend.Namespace == nil {
				ns = tlsRoute.Namespace
			} else {
				ns = string(*backend.Namespace)
			}
			//if ns != tlsRoute.Namespace {
			// TODO: check gatewayv1alpha2.ReferencePolicy
			//}

			if backend.Port == nil {
				log.Warnw(fmt.Sprintf("ignore nil port at Rules[%v].BackendRefs[%v]", i, j),
					zap.String("kind", kind),
				)
				continue
			}

			ups, err := t.KubeTranslator.TranslateService(ns, string(backend.Name), "", int32(*backend.Port))
			if err != nil {
				return nil, errors.Wrap(err, fmt.Sprintf("failed to translate Rules[%v].BackendRefs[%v]", i, j))
			}
			ups.Name = apisixv1.ComposeUpstreamName(ns, string(backend.Name), "", int32(*backend.Port), types.ResolveGranularity.Endpoint)

			ups.Labels["meta_namespace"] = utils.TruncateString(ns, 64)
			ups.Labels["meta_backend"] = utils.TruncateString(string(backend.Name), 64)
			ups.Labels["meta_port"] = fmt.Sprintf("%v", int32(*backend.Port))

			ups.ID = id.GenID(ups.Name)
			ctx.AddUpstream(ups)
			ruleUpstreams = append(ruleUpstreams, ups)
		}
		if len(ruleUpstreams) == 0 {
			log.Warnw(fmt.Sprintf("ignore all-failed backend refs at Rules[%v]", i),
				zap.Any("BackendRefs", rule.BackendRefs),
			)
			continue
		}

		for _, host := range hosts {
			route := apisixv1.NewDefaultStreamRoute()
			name := apisixv1.ComposeRouteName(tlsRoute.Namespace, tlsRoute.Name, fmt.Sprintf("%d-%s", i, host))
			route.ID = id.GenID(name)

			route.Labels["meta_namespace"] = utils.TruncateString(tlsRoute.Namespace, 64)
			route.Labels["meta_tlsroute"] = utils.TruncateString(tlsRoute.Name, 64)

			route.SNI = host

			route.UpstreamId = ruleUpstreams[0].ID
			if len(ruleUpstreams) > 1 {
				log.Warnw("ignore backends which is not the first one",
					zap.String("namespace", tlsRoute.Namespace),
					zap.String("tlsroute", tlsRoute.Name),
				)
			}
			ctx.AddStreamRoute(route)
		}
	}

	return ctx, nil
}