This is an automated email from the ASF dual-hosted git repository.
zhangjintao pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/apisix-ingress-controller.git
The following commit(s) were added to refs/heads/master by this push:
new 37a8e5c8 fix: translate error of old Ingress (#1193)
37a8e5c8 is described below
commit 37a8e5c837cd2a8a459bec054c3ed73bac9b52bb
Author: Xin Rong <[email protected]>
AuthorDate: Fri Jul 29 17:31:43 2022 +0800
fix: translate error of old Ingress (#1193)
---
pkg/ingress/apisix_route.go | 80 +---------------
pkg/ingress/controller.go | 2 +
pkg/ingress/ingress.go | 5 +-
pkg/kube/translation/apisix_route.go | 75 +++++++++++++++
pkg/kube/translation/ingress.go | 159 +++++++++++++++++++++++++++++++
pkg/kube/translation/translator.go | 36 +++++++
test/e2e/suite-chore/consistency.go | 179 +++++++++++++++++++++++++++++++++--
7 files changed, 447 insertions(+), 89 deletions(-)
diff --git a/pkg/ingress/apisix_route.go b/pkg/ingress/apisix_route.go
index 89c8824a..28c51a87 100644
--- a/pkg/ingress/apisix_route.go
+++ b/pkg/ingress/apisix_route.go
@@ -326,7 +326,7 @@ func (c *apisixRouteController) sync(ctx context.Context,
ev *types.Event) error
} else if ev.Type == types.EventAdd {
added = m
} else {
- oldCtx, _ := c.getOldTranslateContext(ctx, obj.OldObject)
+ oldCtx, _ :=
c.controller.translator.TranslateOldRoute(obj.OldObject)
om := &utils.Manifest{
Routes: oldCtx.Routes,
Upstreams: oldCtx.Upstreams,
@@ -675,81 +675,3 @@ func (c *apisixRouteController) handleSvcErr(key string,
errOrigin error) {
)
c.workqueue.AddRateLimited(key)
}
-
-// Building objects from cache
-// For old objects, you cannot use TranslateRoute to build. Because it needs
to parse the latest service, which will cause data inconsistency
-func (c *apisixRouteController) getOldTranslateContext(ctx context.Context,
kar kube.ApisixRoute) (*translation.TranslateContext, error) {
- clusterName := c.controller.cfg.APISIX.DefaultClusterName
- oldCtx := translation.DefaultEmptyTranslateContext()
-
- switch c.controller.cfg.Kubernetes.ApisixRouteVersion {
- case config.ApisixV2beta3:
- ar := kar.V2beta3()
- for _, part := range ar.Spec.Stream {
- name := apisixv1.ComposeStreamRouteName(ar.Namespace,
ar.Name, part.Name)
- sr, err :=
c.controller.apisix.Cluster(clusterName).StreamRoute().Get(ctx, name)
- if err != nil {
- continue
- }
- if sr.UpstreamId != "" {
- ups := apisixv1.NewDefaultUpstream()
- ups.ID = sr.UpstreamId
- oldCtx.AddUpstream(ups)
- }
- oldCtx.AddStreamRoute(sr)
- }
- for _, part := range ar.Spec.HTTP {
- name := apisixv1.ComposeRouteName(ar.Namespace,
ar.Name, part.Name)
- r, err :=
c.controller.apisix.Cluster(clusterName).Route().Get(ctx, name)
- if err != nil {
- continue
- }
- if r.UpstreamId != "" {
- ups := apisixv1.NewDefaultUpstream()
- ups.ID = r.UpstreamId
- oldCtx.AddUpstream(ups)
- }
- if r.PluginConfigId != "" {
- pc := apisixv1.NewDefaultPluginConfig()
- pc.ID = r.PluginConfigId
- oldCtx.AddPluginConfig(pc)
- }
- oldCtx.AddRoute(r)
- }
- case config.ApisixV2:
- ar := kar.V2()
- for _, part := range ar.Spec.Stream {
- name := apisixv1.ComposeStreamRouteName(ar.Namespace,
ar.Name, part.Name)
- sr, err :=
c.controller.apisix.Cluster(clusterName).StreamRoute().Get(ctx, name)
- if err != nil {
- continue
- }
- if sr.UpstreamId != "" {
- ups := apisixv1.NewDefaultUpstream()
- ups.ID = sr.UpstreamId
- oldCtx.AddUpstream(ups)
- }
- oldCtx.AddStreamRoute(sr)
- }
- for _, part := range ar.Spec.HTTP {
- name := apisixv1.ComposeRouteName(ar.Namespace,
ar.Name, part.Name)
- r, err :=
c.controller.apisix.Cluster(clusterName).Route().Get(ctx, name)
- if err != nil {
- continue
- }
- if r.UpstreamId != "" {
- ups := apisixv1.NewDefaultUpstream()
- ups.ID = r.UpstreamId
- oldCtx.AddUpstream(ups)
- }
- if r.PluginConfigId != "" {
- pc := apisixv1.NewDefaultPluginConfig()
- pc.ID = r.PluginConfigId
- oldCtx.AddPluginConfig(pc)
- }
- oldCtx.AddRoute(r)
-
- }
- }
- return oldCtx, nil
-}
diff --git a/pkg/ingress/controller.go b/pkg/ingress/controller.go
index 6e1fc95f..5a1a41d1 100644
--- a/pkg/ingress/controller.go
+++ b/pkg/ingress/controller.go
@@ -234,6 +234,8 @@ func (c *Controller) initWhenStartLeading() {
SecretLister: c.secretLister,
UseEndpointSlices: c.cfg.Kubernetes.WatchEndpointSlices,
APIVersion: c.cfg.Kubernetes.APIVersion,
+ Apisix: c.apisix,
+ ClusterName: c.cfg.APISIX.DefaultClusterName,
})
switch c.cfg.Kubernetes.APIVersion {
diff --git a/pkg/ingress/ingress.go b/pkg/ingress/ingress.go
index 1fbad1f9..aea2b990 100644
--- a/pkg/ingress/ingress.go
+++ b/pkg/ingress/ingress.go
@@ -162,10 +162,7 @@ func (c *ingressController) sync(ctx context.Context, ev
*types.Event) error {
} else if ev.Type == types.EventAdd {
added = m
} else {
- // In the update event, there is no need to verify the upstream
in the old ingress,
- // and the update is based on the latest ingress
- // TODO There may be residual upstream data. When the service
is deleted, it has no impact
- oldCtx, err :=
c.controller.translator.TranslateIngress(ingEv.OldObject, true)
+ oldCtx, err :=
c.controller.translator.TranslateOldIngress(ingEv.OldObject)
if err != nil {
log.Errorw("failed to translate ingress",
zap.String("event", "update"),
diff --git a/pkg/kube/translation/apisix_route.go
b/pkg/kube/translation/apisix_route.go
index e951e469..e2bcf1e7 100644
--- a/pkg/kube/translation/apisix_route.go
+++ b/pkg/kube/translation/apisix_route.go
@@ -15,6 +15,7 @@
package translation
import (
+ "context"
"errors"
"strings"
@@ -892,3 +893,77 @@ func (t *translator) translateStreamRouteNotStrictlyV2(ctx
*TranslateContext, ar
}
return nil
}
+
+func (t *translator) translateOldRouteV2(ar *configv2.ApisixRoute)
(*TranslateContext, error) {
+ oldCtx := DefaultEmptyTranslateContext()
+
+ for _, part := range ar.Spec.Stream {
+ name := apisixv1.ComposeStreamRouteName(ar.Namespace, ar.Name,
part.Name)
+ sr, err :=
t.Apisix.Cluster(t.ClusterName).StreamRoute().Get(context.Background(), name)
+ if err != nil {
+ continue
+ }
+ if sr.UpstreamId != "" {
+ ups := apisixv1.NewDefaultUpstream()
+ ups.ID = sr.UpstreamId
+ oldCtx.AddUpstream(ups)
+ }
+ oldCtx.AddStreamRoute(sr)
+ }
+ for _, part := range ar.Spec.HTTP {
+ name := apisixv1.ComposeRouteName(ar.Namespace, ar.Name,
part.Name)
+ r, err :=
t.Apisix.Cluster(t.ClusterName).Route().Get(context.Background(), name)
+ if err != nil {
+ continue
+ }
+ if r.UpstreamId != "" {
+ ups := apisixv1.NewDefaultUpstream()
+ ups.ID = r.UpstreamId
+ oldCtx.AddUpstream(ups)
+ }
+ if r.PluginConfigId != "" {
+ pc := apisixv1.NewDefaultPluginConfig()
+ pc.ID = r.PluginConfigId
+ oldCtx.AddPluginConfig(pc)
+ }
+ oldCtx.AddRoute(r)
+ }
+ return oldCtx, nil
+}
+
+func (t *translator) translateOldRouteV2beta3(ar *configv2beta3.ApisixRoute)
(*TranslateContext, error) {
+ oldCtx := DefaultEmptyTranslateContext()
+
+ for _, part := range ar.Spec.Stream {
+ name := apisixv1.ComposeStreamRouteName(ar.Namespace, ar.Name,
part.Name)
+ sr, err :=
t.Apisix.Cluster(t.ClusterName).StreamRoute().Get(context.Background(), name)
+ if err != nil {
+ continue
+ }
+ if sr.UpstreamId != "" {
+ ups := apisixv1.NewDefaultUpstream()
+ ups.ID = sr.UpstreamId
+ oldCtx.AddUpstream(ups)
+ }
+ oldCtx.AddStreamRoute(sr)
+ }
+ for _, part := range ar.Spec.HTTP {
+ name := apisixv1.ComposeRouteName(ar.Namespace, ar.Name,
part.Name)
+ r, err :=
t.Apisix.Cluster(t.ClusterName).Route().Get(context.Background(), name)
+ if err != nil {
+ continue
+ }
+ if r.UpstreamId != "" {
+ ups := apisixv1.NewDefaultUpstream()
+ ups.ID = r.UpstreamId
+ oldCtx.AddUpstream(ups)
+ }
+ if r.PluginConfigId != "" {
+ pc := apisixv1.NewDefaultPluginConfig()
+ pc.ID = r.PluginConfigId
+ oldCtx.AddPluginConfig(pc)
+ }
+ oldCtx.AddRoute(r)
+ }
+ return oldCtx, nil
+}
diff --git a/pkg/kube/translation/ingress.go b/pkg/kube/translation/ingress.go
index ad024359..3c360b0b 100644
--- a/pkg/kube/translation/ingress.go
+++ b/pkg/kube/translation/ingress.go
@@ -16,6 +16,7 @@ package translation
import (
"bytes"
+ "context"
"fmt"
"strings"
@@ -27,6 +28,7 @@ import (
"k8s.io/apimachinery/pkg/util/intstr"
"github.com/apache/apisix-ingress-controller/pkg/id"
+ configv2
"github.com/apache/apisix-ingress-controller/pkg/kube/apisix/apis/config/v2"
kubev2
"github.com/apache/apisix-ingress-controller/pkg/kube/apisix/apis/config/v2"
kubev2beta3
"github.com/apache/apisix-ingress-controller/pkg/kube/apisix/apis/config/v2beta3"
apisixconst
"github.com/apache/apisix-ingress-controller/pkg/kube/apisix/const"
@@ -479,6 +481,163 @@ func (t *translator)
translateUpstreamFromIngressV1beta1(namespace string, svcNa
return ups, nil
}
+func (t *translator) translateOldIngressV1(ing *networkingv1.Ingress)
(*TranslateContext, error) {
+ oldCtx := DefaultEmptyTranslateContext()
+
+ for _, tls := range ing.Spec.TLS {
+ apisixTls := configv2.ApisixTls{
+ TypeMeta: metav1.TypeMeta{
+ Kind: "ApisixTls",
+ APIVersion: "apisix.apache.org/v1",
+ },
+ ObjectMeta: metav1.ObjectMeta{
+ Name: fmt.Sprintf("%v-%v", ing.Name,
"tls"),
+ Namespace: ing.Namespace,
+ },
+ Spec: &configv2.ApisixTlsSpec{},
+ }
+ for _, host := range tls.Hosts {
+ apisixTls.Spec.Hosts = append(apisixTls.Spec.Hosts,
configv2.HostType(host))
+ }
+ apisixTls.Spec.Secret = configv2.ApisixSecret{
+ Name: tls.SecretName,
+ Namespace: ing.Namespace,
+ }
+ ssl, err := t.TranslateSSLV2(&apisixTls)
+ if err != nil {
+ log.Debugw("failed to translate ingress tls to apisix
tls",
+ zap.Error(err),
+ zap.Any("ingress", ing),
+ )
+ continue
+ }
+ oldCtx.AddSSL(ssl)
+ }
+ for _, rule := range ing.Spec.Rules {
+ for _, pathRule := range rule.HTTP.Paths {
+ name := composeIngressRouteName(ing.Namespace,
ing.Name, rule.Host, pathRule.Path)
+ r, err :=
t.Apisix.Cluster(t.ClusterName).Route().Get(context.Background(), name)
+ if err != nil {
+ continue
+ }
+ if r.UpstreamId != "" {
+ ups := apisixv1.NewDefaultUpstream()
+ ups.ID = r.UpstreamId
+ oldCtx.AddUpstream(ups)
+ }
+ if r.PluginConfigId != "" {
+ pc := apisixv1.NewDefaultPluginConfig()
+ pc.ID = r.PluginConfigId
+ oldCtx.AddPluginConfig(pc)
+ }
+ oldCtx.AddRoute(r)
+ }
+ }
+ return oldCtx, nil
+}
+
+func (t *translator) translateOldIngressV1beta1(ing
*networkingv1beta1.Ingress) (*TranslateContext, error) {
+ oldCtx := DefaultEmptyTranslateContext()
+
+ for _, tls := range ing.Spec.TLS {
+ apisixTls := configv2.ApisixTls{
+ TypeMeta: metav1.TypeMeta{
+ Kind: "ApisixTls",
+ APIVersion: "apisix.apache.org/v1",
+ },
+ ObjectMeta: metav1.ObjectMeta{
+ Name: fmt.Sprintf("%v-%v", ing.Name,
"tls"),
+ Namespace: ing.Namespace,
+ },
+ Spec: &configv2.ApisixTlsSpec{},
+ }
+ for _, host := range tls.Hosts {
+ apisixTls.Spec.Hosts = append(apisixTls.Spec.Hosts,
configv2.HostType(host))
+ }
+ apisixTls.Spec.Secret = configv2.ApisixSecret{
+ Name: tls.SecretName,
+ Namespace: ing.Namespace,
+ }
+ ssl, err := t.TranslateSSLV2(&apisixTls)
+ if err != nil {
+ continue
+ }
+ oldCtx.AddSSL(ssl)
+ }
+ for _, rule := range ing.Spec.Rules {
+ for _, pathRule := range rule.HTTP.Paths {
+ name := composeIngressRouteName(ing.Namespace,
ing.Name, rule.Host, pathRule.Path)
+ r, err :=
t.Apisix.Cluster(t.ClusterName).Route().Get(context.Background(), name)
+ if err != nil {
+ continue
+ }
+ if r.UpstreamId != "" {
+ ups := apisixv1.NewDefaultUpstream()
+ ups.ID = r.UpstreamId
+ oldCtx.AddUpstream(ups)
+ }
+ if r.PluginConfigId != "" {
+ pc := apisixv1.NewDefaultPluginConfig()
+ pc.ID = r.PluginConfigId
+ oldCtx.AddPluginConfig(pc)
+ }
+ oldCtx.AddRoute(r)
+ }
+ }
+ return oldCtx, nil
+}
+
+func (t *translator) translateOldIngressExtensionsv1beta1(ing
*extensionsv1beta1.Ingress) (*TranslateContext, error) {
+ oldCtx := DefaultEmptyTranslateContext()
+
+ for _, tls := range ing.Spec.TLS {
+ apisixTls := configv2.ApisixTls{
+ TypeMeta: metav1.TypeMeta{
+ Kind: "ApisixTls",
+ APIVersion: "apisix.apache.org/v1",
+ },
+ ObjectMeta: metav1.ObjectMeta{
+ Name: fmt.Sprintf("%v-%v", ing.Name,
"tls"),
+ Namespace: ing.Namespace,
+ },
+ Spec: &configv2.ApisixTlsSpec{},
+ }
+ for _, host := range tls.Hosts {
+ apisixTls.Spec.Hosts = append(apisixTls.Spec.Hosts,
configv2.HostType(host))
+ }
+ apisixTls.Spec.Secret = configv2.ApisixSecret{
+ Name: tls.SecretName,
+ Namespace: ing.Namespace,
+ }
+ ssl, err := t.TranslateSSLV2(&apisixTls)
+ if err != nil {
+ continue
+ }
+ oldCtx.AddSSL(ssl)
+ }
+ for _, rule := range ing.Spec.Rules {
+ for _, pathRule := range rule.HTTP.Paths {
+ name := composeIngressRouteName(ing.Namespace,
ing.Name, rule.Host, pathRule.Path)
+ r, err :=
t.Apisix.Cluster(t.ClusterName).Route().Get(context.Background(), name)
+ if err != nil {
+ continue
+ }
+ if r.UpstreamId != "" {
+ ups := apisixv1.NewDefaultUpstream()
+ ups.ID = r.UpstreamId
+ oldCtx.AddUpstream(ups)
+ }
+ if r.PluginConfigId != "" {
+ pc := apisixv1.NewDefaultPluginConfig()
+ pc.ID = r.PluginConfigId
+ oldCtx.AddPluginConfig(pc)
+ }
+ oldCtx.AddRoute(r)
+ }
+ }
+ return oldCtx, nil
+}
+
// In the past, we used host + path directly to form its route name for
readability,
// but this method can cause problems in some scenarios.
// For example, the generated name is too long.
diff --git a/pkg/kube/translation/translator.go
b/pkg/kube/translation/translator.go
index 8ea1273c..28f0afe8 100644
--- a/pkg/kube/translation/translator.go
+++ b/pkg/kube/translation/translator.go
@@ -22,6 +22,7 @@ import (
k8serrors "k8s.io/apimachinery/pkg/api/errors"
listerscorev1 "k8s.io/client-go/listers/core/v1"
+ "github.com/apache/apisix-ingress-controller/pkg/apisix"
config "github.com/apache/apisix-ingress-controller/pkg/config"
"github.com/apache/apisix-ingress-controller/pkg/kube"
configv2
"github.com/apache/apisix-ingress-controller/pkg/kube/apisix/apis/config/v2"
@@ -69,7 +70,11 @@ type Translator interface {
TranslateUpstream(string, string, string, int32) (*apisixv1.Upstream,
error)
// TranslateIngress composes a couple of APISIX Routes and upstreams
according
// to the given Ingress resource.
+ // For old objects, you cannot use TranslateIngress to build. Because
it needs to parse the latest service, which will cause data inconsistency.
TranslateIngress(kube.Ingress, ...bool) (*TranslateContext, error)
+ // TranslateOldIngress get route objects from cache
+ // Build upstream and plugin_config through route
+ TranslateOldIngress(kube.Ingress) (*TranslateContext, error)
// TranslateRouteV2beta2 translates the configv2beta2.ApisixRoute
object into several Route,
// and Upstream resources.
TranslateRouteV2beta2(*configv2beta2.ApisixRoute) (*TranslateContext,
error)
@@ -88,6 +93,9 @@ type Translator interface {
// TranslateRouteV2NotStrictly translates the configv2.ApisixRoute
object into several Route,
// Upstream and PluginConfig resources not strictly, only used for
delete event.
TranslateRouteV2NotStrictly(*configv2.ApisixRoute) (*TranslateContext,
error)
+ // TranslateOldRoute get route and stream_route objects from cache
+ // Build upstream and plugin_config through route and stream_route
+ TranslateOldRoute(kube.ApisixRoute) (*TranslateContext, error)
// TranslateSSLV2Beta3 translates the configv2beta3.ApisixTls object
into the APISIX SSL resource.
TranslateSSLV2Beta3(*configv2beta3.ApisixTls) (*apisixv1.Ssl, error)
// TranslateSSLV2 translates the configv2.ApisixTls object into the
APISIX SSL resource.
@@ -132,6 +140,8 @@ type TranslatorOptions struct {
SecretLister listerscorev1.SecretLister
UseEndpointSlices bool
APIVersion string
+ Apisix apisix.APISIX
+ ClusterName string
}
type translator struct {
@@ -388,3 +398,29 @@ func (t *translator) TranslateIngress(ing kube.Ingress,
args ...bool) (*Translat
return nil, fmt.Errorf("translator: source group version not
supported: %s", ing.GroupVersion())
}
}
+
+func (t *translator) TranslateOldRoute(ar kube.ApisixRoute)
(*TranslateContext, error) {
+ switch ar.GroupVersion() {
+ case config.ApisixV2:
+ return t.translateOldRouteV2(ar.V2())
+ case config.ApisixV2beta3:
+ return t.translateOldRouteV2beta3(ar.V2beta3())
+ case config.ApisixV2beta2:
+ return DefaultEmptyTranslateContext(), nil
+ default:
+ return nil, fmt.Errorf("translator: source group version not
supported: %s", ar.GroupVersion())
+ }
+}
+
+func (t *translator) TranslateOldIngress(ing kube.Ingress) (*TranslateContext,
error) {
+ switch ing.GroupVersion() {
+ case kube.IngressV1:
+ return t.translateOldIngressV1(ing.V1())
+ case kube.IngressV1beta1:
+ return t.translateOldIngressV1beta1(ing.V1beta1())
+ case kube.IngressExtensionsV1beta1:
+ return
t.translateOldIngressExtensionsv1beta1(ing.ExtensionsV1beta1())
+ default:
+ return nil, fmt.Errorf("translator: source group version not
supported: %s", ing.GroupVersion())
+ }
+}
diff --git a/test/e2e/suite-chore/consistency.go
b/test/e2e/suite-chore/consistency.go
index a6cb3a3e..c3758687 100644
--- a/test/e2e/suite-chore/consistency.go
+++ b/test/e2e/suite-chore/consistency.go
@@ -52,21 +52,77 @@ spec:
selector:
app: httpbin-deployment-e2e-test
ports:
- - name: http
+ - name: %s
port: %d
protocol: TCP
targetPort: %d
type: ClusterIP
+`
+ _ingressV1Config = `
+apiVersion: networking.k8s.io/v1
+kind: Ingress
+metadata:
+ annotations:
+ kubernetes.io/ingress.class: apisix
+ name: ingress-v1
+spec:
+ rules:
+ - host: httpbin.org
+ http:
+ paths:
+ - path: /*
+ pathType: Prefix
+ backend:
+ service:
+ name: %s
+ port:
+ name: %s
+`
+ _ingressV1beta1Config = `
+apiVersion: networking.k8s.io/v1beta1
+kind: Ingress
+metadata:
+ annotations:
+ kubernetes.io/ingress.class: apisix
+ name: ingress-v1beta1
+spec:
+ rules:
+ - host: httpbin.org
+ http:
+ paths:
+ - path: /*
+ pathType: Prefix
+ backend:
+ serviceName: %s
+ servicePort: %d
+`
+ _ingressExtensionsV1beta1Config = `
+apiVersion: extensions/v1beta1
+kind: Ingress
+metadata:
+ annotations:
+ kubernetes.io/ingress.class: apisix
+ name: ingress-extensions-v1beta1
+spec:
+ rules:
+ - host: httpbin.org
+ http:
+ paths:
+ - path: /*
+ pathType: Prefix
+ backend:
+ serviceName: %s
+ servicePort: %d
`
)
-var _ = ginkgo.Describe("suite-chore: Consistency between APISIX and Ingress",
func() {
+var _ = ginkgo.Describe("suite-chore: Consistency between APISIX and the CRDs
resource of the IngressController", func() {
suites := func(s *scaffold.Scaffold) {
ginkgo.It("ApisixRoute and APISIX of route and upstream",
func() {
- httpService := fmt.Sprintf(_httpServiceConfig, 8080,
8080)
+ httpService := fmt.Sprintf(_httpServiceConfig, "port1",
9080, 9080)
assert.Nil(ginkgo.GinkgoT(),
s.CreateResourceFromString(httpService))
- ar := fmt.Sprintf(_routeConfig,
"httpbin-service-e2e-test", 8080)
+ ar := fmt.Sprintf(_routeConfig,
"httpbin-service-e2e-test", 9080)
assert.Nil(ginkgo.GinkgoT(),
s.CreateVersionedApisixResource(ar))
assert.Nil(ginkgo.GinkgoT(),
s.EnsureNumApisixRoutesCreated(1))
@@ -75,11 +131,11 @@ var _ = ginkgo.Describe("suite-chore: Consistency between
APISIX and Ingress", f
upstreams, err := s.ListApisixUpstreams()
assert.Nil(ginkgo.GinkgoT(), err)
assert.Len(ginkgo.GinkgoT(), upstreams, 1)
- assert.Contains(ginkgo.GinkgoT(), upstreams[0].Name,
"httpbin-service-e2e-test_8080")
+ assert.Contains(ginkgo.GinkgoT(), upstreams[0].Name,
"httpbin-service-e2e-test_9080")
// The correct httpbin pod port is 80
s.NewAPISIXClient().GET("/ip").WithHeader("Host",
"httpbin.org").Expect().Status(http.StatusBadGateway)
- httpService = fmt.Sprintf(_httpServiceConfig, 80, 80)
+ httpService = fmt.Sprintf(_httpServiceConfig, "port1",
80, 80)
assert.Nil(ginkgo.GinkgoT(),
s.CreateResourceFromString(httpService))
ar = fmt.Sprintf(_routeConfig,
"httpbin-service-e2e-test", 80)
@@ -106,3 +162,114 @@ var _ = ginkgo.Describe("suite-chore: Consistency between
APISIX and Ingress", f
suites(scaffold.NewDefaultV2Scaffold())
})
})
+
+var _ = ginkgo.Describe("suite-chore: Consistency between APISIX and the
Ingress resource of the IngressController", func() {
+ s := scaffold.NewDefaultScaffold()
+ ginkgo.It("Ingress v1 and APISIX of route and upstream", func() {
+ httpService := fmt.Sprintf(_httpServiceConfig, "port1", 9080,
9080)
+ assert.Nil(ginkgo.GinkgoT(),
s.CreateResourceFromString(httpService))
+
+ ing := fmt.Sprintf(_ingressV1Config,
"httpbin-service-e2e-test", "port1")
+ assert.Nil(ginkgo.GinkgoT(), s.CreateResourceFromString(ing))
+
+ assert.Nil(ginkgo.GinkgoT(), s.EnsureNumApisixRoutesCreated(1))
+ assert.Nil(ginkgo.GinkgoT(),
s.EnsureNumApisixUpstreamsCreated(1))
+
+ upstreams, err := s.ListApisixUpstreams()
+ assert.Nil(ginkgo.GinkgoT(), err)
+ assert.Len(ginkgo.GinkgoT(), upstreams, 1)
+ assert.Contains(ginkgo.GinkgoT(), upstreams[0].Name,
"httpbin-service-e2e-test_9080")
+ // The correct httpbin pod port is 80
+ s.NewAPISIXClient().GET("/ip").WithHeader("Host",
"httpbin.org").Expect().Status(http.StatusBadGateway)
+
+ httpService = fmt.Sprintf(_httpServiceConfig, "port2", 80, 80)
+ assert.Nil(ginkgo.GinkgoT(),
s.CreateResourceFromString(httpService))
+
+ ing = fmt.Sprintf(_ingressV1Config, "httpbin-service-e2e-test",
"port2")
+ assert.Nil(ginkgo.GinkgoT(), s.CreateResourceFromString(ing))
+
+ time.Sleep(6 * time.Second)
+
+ routes, err := s.ListApisixRoutes()
+ assert.Nil(ginkgo.GinkgoT(), err)
+ assert.Len(ginkgo.GinkgoT(), routes, 1)
+ upstreams, err = s.ListApisixUpstreams()
+ assert.Nil(ginkgo.GinkgoT(), err)
+ assert.Len(ginkgo.GinkgoT(), upstreams, 1)
+ assert.Contains(ginkgo.GinkgoT(), upstreams[0].Name,
"httpbin-service-e2e-test_80")
+
+ s.NewAPISIXClient().GET("/ip").WithHeader("Host",
"httpbin.org").Expect().Status(http.StatusOK)
+ })
+
+ ginkgo.It("Ingress V1beta1 and APISIX of route and upstream", func() {
+ httpService := fmt.Sprintf(_httpServiceConfig, "port1", 9080,
9080)
+ assert.Nil(ginkgo.GinkgoT(),
s.CreateResourceFromString(httpService))
+
+ ing := fmt.Sprintf(_ingressV1beta1Config,
"httpbin-service-e2e-test", 9080)
+ assert.Nil(ginkgo.GinkgoT(), s.CreateResourceFromString(ing))
+
+ assert.Nil(ginkgo.GinkgoT(), s.EnsureNumApisixRoutesCreated(1))
+ assert.Nil(ginkgo.GinkgoT(),
s.EnsureNumApisixUpstreamsCreated(1))
+
+ upstreams, err := s.ListApisixUpstreams()
+ assert.Nil(ginkgo.GinkgoT(), err)
+ assert.Len(ginkgo.GinkgoT(), upstreams, 1)
+ assert.Contains(ginkgo.GinkgoT(), upstreams[0].Name,
"httpbin-service-e2e-test_9080")
+ // The correct httpbin pod port is 80
+ s.NewAPISIXClient().GET("/ip").WithHeader("Host",
"httpbin.org").Expect().Status(http.StatusBadGateway)
+
+ httpService = fmt.Sprintf(_httpServiceConfig, "port2", 80, 80)
+ assert.Nil(ginkgo.GinkgoT(),
s.CreateResourceFromString(httpService))
+
+ ing = fmt.Sprintf(_ingressV1beta1Config,
"httpbin-service-e2e-test", 80)
+ assert.Nil(ginkgo.GinkgoT(), s.CreateResourceFromString(ing))
+
+ time.Sleep(6 * time.Second)
+
+ routes, err := s.ListApisixRoutes()
+ assert.Nil(ginkgo.GinkgoT(), err)
+ assert.Len(ginkgo.GinkgoT(), routes, 1)
+ upstreams, err = s.ListApisixUpstreams()
+ assert.Nil(ginkgo.GinkgoT(), err)
+ assert.Len(ginkgo.GinkgoT(), upstreams, 1)
+ assert.Contains(ginkgo.GinkgoT(), upstreams[0].Name,
"httpbin-service-e2e-test_80")
+
+ s.NewAPISIXClient().GET("/ip").WithHeader("Host",
"httpbin.org").Expect().Status(http.StatusOK)
+ })
+
+ ginkgo.It("Ingress extensionsV1beta1 and APISIX of route and upstream",
func() {
+ httpService := fmt.Sprintf(_httpServiceConfig, "port1", 9080,
9080)
+ assert.Nil(ginkgo.GinkgoT(),
s.CreateResourceFromString(httpService))
+
+ ing := fmt.Sprintf(_ingressExtensionsV1beta1Config,
"httpbin-service-e2e-test", 9080)
+ assert.Nil(ginkgo.GinkgoT(), s.CreateResourceFromString(ing))
+
+ assert.Nil(ginkgo.GinkgoT(), s.EnsureNumApisixRoutesCreated(1))
+ assert.Nil(ginkgo.GinkgoT(),
s.EnsureNumApisixUpstreamsCreated(1))
+
+ upstreams, err := s.ListApisixUpstreams()
+ assert.Nil(ginkgo.GinkgoT(), err)
+ assert.Len(ginkgo.GinkgoT(), upstreams, 1)
+ assert.Contains(ginkgo.GinkgoT(), upstreams[0].Name,
"httpbin-service-e2e-test_9080")
+ // The correct httpbin pod port is 80
+ s.NewAPISIXClient().GET("/ip").WithHeader("Host",
"httpbin.org").Expect().Status(http.StatusBadGateway)
+
+ httpService = fmt.Sprintf(_httpServiceConfig, "port2", 80, 80)
+ assert.Nil(ginkgo.GinkgoT(),
s.CreateResourceFromString(httpService))
+
+ ing = fmt.Sprintf(_ingressExtensionsV1beta1Config,
"httpbin-service-e2e-test", 80)
+ assert.Nil(ginkgo.GinkgoT(), s.CreateResourceFromString(ing))
+
+ time.Sleep(6 * time.Second)
+
+ routes, err := s.ListApisixRoutes()
+ assert.Nil(ginkgo.GinkgoT(), err)
+ assert.Len(ginkgo.GinkgoT(), routes, 1)
+ upstreams, err = s.ListApisixUpstreams()
+ assert.Nil(ginkgo.GinkgoT(), err)
+ assert.Len(ginkgo.GinkgoT(), upstreams, 1)
+ assert.Contains(ginkgo.GinkgoT(), upstreams[0].Name,
"httpbin-service-e2e-test_80")
+
+ s.NewAPISIXClient().GET("/ip").WithHeader("Host",
"httpbin.org").Expect().Status(http.StatusOK)
+ })
+})
