feat: support regex in path

Signed-off-by: lxm <lxm.xupt@gmail.com>

pkg/kube/translation/annotations/cors.go

@@ -19,10 +19,10 @@ import (
 )
 
 const (
-	_enableCors       = "k8s.apisix.apache.org/enable-cors"
-	_corsAllowOrigin  = "k8s.apisix.apache.org/cors-allow-origin"
-	_corsAllowHeaders = "k8s.apisix.apache.org/cors-allow-headers"
-	_corsAllowMethods = "k8s.apisix.apache.org/cors-allow-methods"
+	_enableCors       = AnnotationsPrefix + "enable-cors"
+	_corsAllowOrigin  = AnnotationsPrefix + "cors-allow-origin"
+	_corsAllowHeaders = AnnotationsPrefix + "cors-allow-headers"
+	_corsAllowMethods = AnnotationsPrefix + "cors-allow-methods"
 )
 
 type cors struct{}

pkg/kube/translation/annotations/iprestriction.go

@@ -19,8 +19,8 @@ import (
 )
 
 const (
-	_allowlistSourceRange = "k8s.apisix.apache.org/allowlist-source-range"
-	_blocklistSourceRange = "k8s.apisix.apache.org/blocklist-source-range"
+	_allowlistSourceRange = AnnotationsPrefix + "allowlist-source-range"
+	_blocklistSourceRange = AnnotationsPrefix + "blocklist-source-range"
 )
 
 type ipRestriction struct{}

pkg/kube/translation/annotations/redirect.go

@@ -19,7 +19,7 @@ import (
 )
 
 const (
-	_httpToHttps = "k8s.apisix.apache.org/http-to-https"
+	_httpToHttps = AnnotationsPrefix + "http-to-https"
 )
 
 type redirect struct{}

pkg/kube/translation/annotations/rewrite.go

@@ -21,9 +21,9 @@ import (
 )
 
 const (
-	_rewriteTarget              = "k8s.apisix.apache.org/rewrite-target"
-	_rewriteTargetRegex         = "k8s.apisix.apache.org/rewrite-target-regex"
-	_rewriteTargetRegexTemplate = "k8s.apisix.apache.org/rewrite-target-regex-template"
+	_rewriteTarget              = AnnotationsPrefix + "rewrite-target"
+	_rewriteTargetRegex         = AnnotationsPrefix + "rewrite-target-regex"
+	_rewriteTargetRegexTemplate = AnnotationsPrefix + "rewrite-target-regex-template"
 )
 
 type rewrite struct{}

pkg/kube/translation/annotations/types.go

@@ -18,6 +18,10 @@ import (
 	"strings"
 )
 
+const (
+	AnnotationsPrefix = "k8s.apisix.apache.org/"
+)
+
 // Extractor encapsulates some auxiliary methods to extract annotations.
 type Extractor interface {
 	// GetStringAnnotation returns the string value of the target annotation.

pkg/kube/translation/ingress.go

@@ -29,16 +29,23 @@ import (
 
 	"github.com/apache/apisix-ingress-controller/pkg/id"
 	apisixv12 "github.com/apache/apisix-ingress-controller/pkg/kube/apisix/apis/config/v1"
+	configv2alpha1 "github.com/apache/apisix-ingress-controller/pkg/kube/apisix/apis/config/v2alpha1"
+	"github.com/apache/apisix-ingress-controller/pkg/kube/translation/annotations"
 	"github.com/apache/apisix-ingress-controller/pkg/log"
 	apisixv1 "github.com/apache/apisix-ingress-controller/pkg/types/apisix/v1"
 )
 
+const (
+	_regexPriority = 100
+)
+
 func (t *translator) translateIngressV1(ing *networkingv1.Ingress) (*TranslateContext, error) {
 	ctx := &TranslateContext{
 		upstreamMap: make(map[string]struct{}),
 	}
 	plugins := t.translateAnnotations(ing.Annotations)
-
+	annoExtractor := annotations.NewExtractor(ing.Annotations)
+	useRegex := annoExtractor.GetBoolAnnotation(annotations.AnnotationsPrefix + "use-regex")
 	// add https
 	for _, tls := range ing.Spec.TLS {
 		apisixTls := apisixv12.ApisixTls{
@@ -87,29 +94,52 @@ func (t *translator) translateIngressV1(ing *networkingv1.Ingress) (*TranslateCo
 				ctx.addUpstream(ups)
 			}
 			uris := []string{pathRule.Path}
-			if pathRule.PathType != nil && *pathRule.PathType == networkingv1.PathTypePrefix {
-				// As per the specification of Ingress path matching rule:
-				// if the last element of the path is a substring of the
-				// last element in request path, it is not a match, e.g. /foo/bar
-				// matches /foo/bar/baz, but does not match /foo/barbaz.
-				// While in APISIX, /foo/bar matches both /foo/bar/baz and
-				// /foo/barbaz.
-				// In order to be conformant with Ingress specification, here
-				// we create two paths here, the first is the path itself
-				// (exact match), the other is path + "/*" (prefix match).
-				prefix := pathRule.Path
-				if strings.HasSuffix(prefix, "/") {
-					prefix += "*"
-				} else {
-					prefix += "/*"
+			var nginxVars []configv2alpha1.ApisixRouteHTTPMatchExpr
+			if pathRule.PathType != nil {
+				if *pathRule.PathType == networkingv1.PathTypePrefix {
+					// As per the specification of Ingress path matching rule:
+					// if the last element of the path is a substring of the
+					// last element in request path, it is not a match, e.g. /foo/bar
+					// matches /foo/bar/baz, but does not match /foo/barbaz.
+					// While in APISIX, /foo/bar matches both /foo/bar/baz and
+					// /foo/barbaz.
+					// In order to be conformant with Ingress specification, here
+					// we create two paths here, the first is the path itself
+					// (exact match), the other is path + "/*" (prefix match).
+					prefix := pathRule.Path
+					if strings.HasSuffix(prefix, "/") {
+						prefix += "*"
+					} else {
+						prefix += "/*"
+					}
+					uris = append(uris, prefix, pathRule.Path)
+				} else if *pathRule.PathType == networkingv1.PathTypeExact {
+					uris = append(uris, pathRule.Path)
+				} else if *pathRule.PathType == networkingv1.PathTypeImplementationSpecific && useRegex {
+					nginxVars = append(nginxVars, configv2alpha1.ApisixRouteHTTPMatchExpr{
+						Subject: configv2alpha1.ApisixRouteHTTPMatchExprSubject{
+							Scope: configv2alpha1.ScopePath,
+						},
+						Op:    configv2alpha1.OpRegexMatch,
+						Value: &pathRule.Path,
+					})
 				}
-				uris = append(uris, prefix)
+			} else {
+				uris = append(uris, pathRule.Path)
 			}
 			route := apisixv1.NewDefaultRoute()
 			route.Name = composeIngressRouteName(rule.Host, pathRule.Path)
 			route.ID = id.GenID(route.Name)
 			route.Host = rule.Host
 			route.Uris = uris
+			if len(nginxVars) > 0 {
+				routeVars, err := t.translateRouteMatchExprs(nginxVars)
+				if err != nil {
+					return nil, err
+				}
+				route.Vars = routeVars
+				route.Priority = _regexPriority
+			}
 			if len(plugins) > 0 {
 				route.Plugins = *(plugins.DeepCopy())
 			}
@@ -127,6 +157,8 @@ func (t *translator) translateIngressV1beta1(ing *networkingv1beta1.Ingress) (*T
 		upstreamMap: make(map[string]struct{}),
 	}
 	plugins := t.translateAnnotations(ing.Annotations)
+	annoExtractor := annotations.NewExtractor(ing.Annotations)
+	useRegex := annoExtractor.GetBoolAnnotation(annotations.AnnotationsPrefix + "use-regex")
 	// add https
 	for _, tls := range ing.Spec.TLS {
 		apisixTls := apisixv12.ApisixTls{
@@ -174,30 +206,54 @@ func (t *translator) translateIngressV1beta1(ing *networkingv1beta1.Ingress) (*T
 				}
 				ctx.addUpstream(ups)
 			}
-			uris := []string{pathRule.Path}
-			if pathRule.PathType != nil && *pathRule.PathType == networkingv1beta1.PathTypePrefix {
-				// As per the specification of Ingress path matching rule:
-				// if the last element of the path is a substring of the
-				// last element in request path, it is not a match, e.g. /foo/bar
-				// matches /foo/bar/baz, but does not match /foo/barbaz.
-				// While in APISIX, /foo/bar matches both /foo/bar/baz and
-				// /foo/barbaz.
-				// In order to be conformant with Ingress specification, here
-				// we create two paths here, the first is the path itself
-				// (exact match), the other is path + "/*" (prefix match).
-				prefix := pathRule.Path
-				if strings.HasSuffix(prefix, "/") {
-					prefix += "*"
-				} else {
-					prefix += "/*"
+			uris := []string{}
+			var nginxVars []configv2alpha1.ApisixRouteHTTPMatchExpr
+			if pathRule.PathType != nil {
+				if *pathRule.PathType == networkingv1beta1.PathTypePrefix {
+					// As per the specification of Ingress path matching rule:
+					// if the last element of the path is a substring of the
+					// last element in request path, it is not a match, e.g. /foo/bar
+					// matches /foo/bar/baz, but does not match /foo/barbaz.
+					// While in APISIX, /foo/bar matches both /foo/bar/baz and
+					// /foo/barbaz.
+					// In order to be conformant with Ingress specification, here
+					// we create two paths here, the first is the path itself
+					// (exact match), the other is path + "/*" (prefix match).
+					prefix := pathRule.Path
+					if strings.HasSuffix(prefix, "/") {
+						prefix += "*"
+					} else {
+						prefix += "/*"
+					}
+					uris = append(uris, prefix, pathRule.Path)
+				} else if *pathRule.PathType == networkingv1beta1.PathTypeExact {
+					uris = append(uris, pathRule.Path)
+				} else if *pathRule.PathType == networkingv1beta1.PathTypeImplementationSpecific && useRegex {
+					nginxVars = append(nginxVars, configv2alpha1.ApisixRouteHTTPMatchExpr{
+						Subject: configv2alpha1.ApisixRouteHTTPMatchExprSubject{
+							Scope: configv2alpha1.ScopePath,
+						},
+						Op:    configv2alpha1.OpRegexMatch,
+						Value: &pathRule.Path,
+					})
+					uris = append(uris, "/*")
 				}
-				uris = append(uris, prefix)
+			} else {
+				uris = append(uris, pathRule.Path)
 			}
 			route := apisixv1.NewDefaultRoute()
 			route.Name = composeIngressRouteName(rule.Host, pathRule.Path)
 			route.ID = id.GenID(route.Name)
 			route.Host = rule.Host
 			route.Uris = uris
+			if len(nginxVars) > 0 {
+				routeVars, err := t.translateRouteMatchExprs(nginxVars)
+				if err != nil {
+					return nil, err
+				}
+				route.Vars = routeVars
+				route.Priority = _regexPriority
+			}
 			if len(plugins) > 0 {
 				route.Plugins = *(plugins.DeepCopy())
 			}
@@ -246,6 +302,8 @@ func (t *translator) translateIngressExtensionsV1beta1(ing *extensionsv1beta1.In
 		upstreamMap: make(map[string]struct{}),
 	}
 	plugins := t.translateAnnotations(ing.Annotations)
+	annoExtractor := annotations.NewExtractor(ing.Annotations)
+	useRegex := annoExtractor.GetBoolAnnotation(annotations.AnnotationsPrefix + "use-regex")
 
 	for _, rule := range ing.Spec.Rules {
 		for _, pathRule := range rule.HTTP.Paths {
@@ -266,29 +324,53 @@ func (t *translator) translateIngressExtensionsV1beta1(ing *extensionsv1beta1.In
 				ctx.addUpstream(ups)
 			}
 			uris := []string{pathRule.Path}
-			if pathRule.PathType != nil && *pathRule.PathType == extensionsv1beta1.PathTypePrefix {
-				// As per the specification of Ingress path matching rule:
-				// if the last element of the path is a substring of the
-				// last element in request path, it is not a match, e.g. /foo/bar
-				// matches /foo/bar/baz, but does not match /foo/barbaz.
-				// While in APISIX, /foo/bar matches both /foo/bar/baz and
-				// /foo/barbaz.
-				// In order to be conformant with Ingress specification, here
-				// we create two paths here, the first is the path itself
-				// (exact match), the other is path + "/*" (prefix match).
-				prefix := pathRule.Path
-				if strings.HasSuffix(prefix, "/") {
-					prefix += "*"
-				} else {
-					prefix += "/*"
+			var nginxVars []configv2alpha1.ApisixRouteHTTPMatchExpr
+			if pathRule.PathType != nil {
+				if *pathRule.PathType == extensionsv1beta1.PathTypePrefix {
+					// As per the specification of Ingress path matching rule:
+					// if the last element of the path is a substring of the
+					// last element in request path, it is not a match, e.g. /foo/bar
+					// matches /foo/bar/baz, but does not match /foo/barbaz.
+					// While in APISIX, /foo/bar matches both /foo/bar/baz and
+					// /foo/barbaz.
+					// In order to be conformant with Ingress specification, here
+					// we create two paths here, the first is the path itself
+					// (exact match), the other is path + "/*" (prefix match).
+					prefix := pathRule.Path
+					if strings.HasSuffix(prefix, "/") {
+						prefix += "*"
+					} else {
+						prefix += "/*"
+					}
+					uris = append(uris, prefix, pathRule.Path)
+				} else if *pathRule.PathType == extensionsv1beta1.PathTypeExact {
+					uris = append(uris, pathRule.Path)
+				} else if *pathRule.PathType == extensionsv1beta1.PathTypeImplementationSpecific && useRegex {
+					nginxVars = append(nginxVars, configv2alpha1.ApisixRouteHTTPMatchExpr{
+						Subject: configv2alpha1.ApisixRouteHTTPMatchExprSubject{
+							Scope: configv2alpha1.ScopePath,
+						},
+						Op:    configv2alpha1.OpRegexMatch,
+						Value: &pathRule.Path,
+					})
+					uris = append(uris, "/*")
 				}
-				uris = append(uris, prefix)
+			} else {
+				uris = append(uris, pathRule.Path)
 			}
 			route := apisixv1.NewDefaultRoute()
 			route.Name = composeIngressRouteName(rule.Host, pathRule.Path)
 			route.ID = id.GenID(route.Name)
 			route.Host = rule.Host
 			route.Uris = uris
+			if len(nginxVars) > 0 {
+				routeVars, err := t.translateRouteMatchExprs(nginxVars)
+				if err != nil {
+					return nil, err
+				}
+				route.Vars = routeVars
+				route.Priority = _regexPriority
+			}
 			if len(plugins) > 0 {
 				route.Plugins = *(plugins.DeepCopy())
 			}