Repository: traefik/traefik
File: pkg/provider/kubernetes/gateway/kubernetes.go (Go)

Code before:
	// The spec allows for an empty string in which case we should use the
	// scheme of the request which in this case is the listener scheme.
	var listenerScheme string
	switch listener.Protocol {
	case v1alpha2.HTTPProtocolType:
		listenerScheme = "http"
	case v1alpha2.HTTPSProtocolType:
		listenerScheme = "https"
	default:
		return nil, fmt.Errorf("invalid listener protocol %s", listener.Protocol)
	}

	for i, filter := range filters {
		if filter.Type != v1alpha2.HTTPRouteFilterRequestRedirect {
			// As per the spec:
			// https://gateway-api.sigs.k8s.io/api-types/httproute/#filters-optional
			// In all cases where incompatible or unsupported filters are
			// specified, implementations MUST add a warning condition to
			// status.
			return nil, fmt.Errorf("unsupported filter %s", filter.Type)
		}

		middleware, err := createRedirectSchemeMiddleware(listenerScheme, filter.RequestRedirect)
		if err != nil {
			return nil, err
		}

		middlewareName := provider.Normalize(fmt.Sprintf("%s-%s-%d", prefix, strings.ToLower(string(filter.Type)), i))
		middlewares[middlewareName] = middleware
	}

	return middlewares, nil
}

func createRedirectSchemeMiddleware(scheme string, filter *v1alpha2.HTTPRequestRedirectFilter) (*dynamic.Middleware, error) {
	// Use the HTTPRequestRedirectFilter scheme if defined.
	filterScheme := scheme
	if filter.Scheme != nil {
		filterScheme = *filter.Scheme
	}

	if filterScheme != "http" && filterScheme != "https" {
		return nil, fmt.Errorf("invalid scheme %s", filterScheme)
	}

	statusCode := http.StatusFound
	if filter.StatusCode != nil {
		statusCode = *filter.StatusCode
	}

	if statusCode != http.StatusMovedPermanently && statusCode != http.StatusFound {

Review comment (suggestion):
```suggestion
		var middleware *dynamic.Middleware
		switch filter.Type {
		case v1alpha2.HTTPRouteFilterRequestRedirect:
			var err error
			middleware, err = createRedirectRegexMiddleware(listenerScheme, filter.RequestRedirect)
			if err != nil {
				return nil, fmt.Errorf("creating RedirectRegex middleware: %w", err)
			}
		default:
			// As per the spec:
			// https://gateway-api.sigs.k8s.io/api-types/httproute/#filters-optional
			// In all cases where incompatible or unsupported filters are
			// specified, implementations MUST add a warning condition to
			// status.
			return nil, fmt.Errorf("unsupported filter %s", filter.Type)
		}

```

Code after:

		serviceName := provider.Normalize(makeID(service.Namespace, service.Name) + "-" + portStr)
		services[serviceName] = &svc

		wrrSvc.Weighted.Services = append(wrrSvc.Weighted.Services, dynamic.TCPWRRService{Name: serviceName, Weight: &weight})
	}

	if len(wrrSvc.Weighted.Services) == 0 {
		return nil, nil, errors.New("no service has been created")
	}

	return wrrSvc, services, nil
}

func loadMiddlewares(listener v1alpha2.Listener, prefix string, filters []v1alpha2.HTTPRouteFilter) (map[string]*dynamic.Middleware, error) {
	middlewares := make(map[string]*dynamic.Middleware)

	// The spec allows for an empty string in which case we should use the
	// scheme of the request which in this case is the listener scheme.
	var listenerScheme string
	switch listener.Protocol {
	case v1alpha2.HTTPProtocolType:
		listenerScheme = "http"
	case v1alpha2.HTTPSProtocolType:
		listenerScheme = "https"
	default:
		return nil, fmt.Errorf("invalid listener protocol %s", listener.Protocol)
	}

	for i, filter := range filters {
		var middleware *dynamic.Middleware
		switch filter.Type {
		case v1alpha2.HTTPRouteFilterRequestRedirect:
			var err error
			middleware, err = createRedirectRegexMiddleware(listenerScheme, filter.RequestRedirect)
			if err != nil {
				return nil, fmt.Errorf("creating RedirectRegex middleware: %w", err)
			}
		default:
			// As per the spec:
			// https://gateway-api.sigs.k8s.io/api-types/httproute/#filters-optional
			// In all cases where incompatible or unsupported filters are
			// specified, implementations MUST add a warning condition to
			// status.
			return nil, fmt.Errorf("unsupported filter %s", filter.Type)
		}

		middlewareName := provider.Normalize(fmt.Sprintf("%s-%s-%d", prefix, strings.ToLower(string(filter.Type)), i))
		middlewares[middlewareName] = middleware
	}