kuma

1
package gateway
2

3
import (
4
	"fmt"
5
	"net"
6

7
	. "github.com/onsi/ginkgo/v2"
8
	. "github.com/onsi/gomega"
9

10
	. "github.com/kumahq/kuma/test/framework"
11
	"github.com/kumahq/kuma/test/framework/client"
12
	"github.com/kumahq/kuma/test/framework/deployments/democlient"
13
	"github.com/kumahq/kuma/test/framework/deployments/testserver"
14
	"github.com/kumahq/kuma/test/framework/envs/kubernetes"
15
)
16

17
func Resources() {
18
	meshName := "gateway-resources"
19
	gatewayName := "resources-edge-gateway"
20
	namespace := "gateway-resources"
21
	waitingClientNamespace := "gateway-resources-client-wait"
22
	curlingClientNamespace := "gateway-resources-client-curl"
23

24
	meshGatewayWithoutLimit := fmt.Sprintf(`
25
apiVersion: kuma.io/v1alpha1
26
kind: MeshGateway
27
metadata:
28
  name: %s
29
mesh: %s
30
spec:
31
  selectors:
32
  - match:
33
      kuma.io/service: %s
34
  conf:
35
    listeners:
36
    - port: 8080
37
      protocol: HTTP
38
`, gatewayName, meshName, gatewayName)
39

40
	meshGatewayWithLimit := fmt.Sprintf(`
41
apiVersion: kuma.io/v1alpha1
42
kind: MeshGateway
43
metadata:
44
  name: %s
45
mesh: %s
46
spec:
47
  selectors:
48
  - match:
49
      kuma.io/service: %s
50
  conf:
51
    listeners:
52
    - port: 8080
53
      protocol: HTTP
54
      resources:
55
        connectionLimit: 1
56
`, gatewayName, meshName, gatewayName)
57

58
	serverSvc := fmt.Sprintf("test-server_%s_svc_80", namespace)
59

60
	httpRoute := fmt.Sprintf(`
61
apiVersion: kuma.io/v1alpha1
62
kind: MeshGatewayRoute
63
metadata:
64
  name: %s
65
mesh: %s
66
spec:
67
  selectors:
68
  - match:
69
      kuma.io/service: %s
70
  conf:
71
    http:
72
      rules:
73
      - matches:
74
          - path:
75
              match: PREFIX
76
              value: /
77
        backends:
78
        - destination:
79
            kuma.io/service: %s
80
`, gatewayName, meshName, gatewayName, serverSvc)
81

82
	BeforeAll(func() {
83
		err := NewClusterSetup().
84
			Install(MTLSMeshKubernetes(meshName)).
85
			Install(NamespaceWithSidecarInjection(namespace)).
86
			Install(Namespace(waitingClientNamespace)).
87
			Install(Namespace(curlingClientNamespace)).
88
			Install(MeshTrafficPermissionAllowAllKubernetes(meshName)).
89
			Install(democlient.Install(democlient.WithNamespace(waitingClientNamespace), democlient.WithMesh(meshName))).
90
			Install(democlient.Install(democlient.WithNamespace(curlingClientNamespace), democlient.WithMesh(meshName))).
91
			Install(YamlK8s(meshGatewayWithoutLimit)).
92
			Install(YamlK8s(MkGatewayInstance(gatewayName, namespace, meshName))).
93
			Install(YamlK8s(httpRoute)).
94
			Install(testserver.Install(
95
				testserver.WithMesh(meshName),
96
				testserver.WithNamespace(namespace),
97
				testserver.WithName("test-server"),
98
				testserver.WithEchoArgs("echo", "--instance", "kubernetes"),
99
			)).
100
			Setup(kubernetes.Cluster)
101
		Expect(err).ToNot(HaveOccurred())
102
	})
103

104
	E2EAfterAll(func() {
105
		Expect(kubernetes.Cluster.TriggerDeleteNamespace(namespace)).To(Succeed())
106
		Expect(kubernetes.Cluster.TriggerDeleteNamespace(waitingClientNamespace)).To(Succeed())
107
		Expect(kubernetes.Cluster.TriggerDeleteNamespace(curlingClientNamespace)).To(Succeed())
108
		Expect(kubernetes.Cluster.DeleteMesh(meshName)).To(Succeed())
109
	})
110

111
	gatewayHost := fmt.Sprintf("%s.%s", gatewayName, namespace)
112
	target := fmt.Sprintf("http://%s", net.JoinHostPort(gatewayHost, "8080"))
113

114
	keepConnectionOpen := func() {
115
		// Open TCP connections to the gateway
116
		defer GinkgoRecover()
117

118
		demoClientPod, err := PodNameOfApp(kubernetes.Cluster, "demo-client", waitingClientNamespace)
119
		Expect(err).ToNot(HaveOccurred())
120

121
		cmd := []string{"telnet", gatewayHost, "8080"}
122
		// We pass in a stdin that blocks so that telnet will keep the
123
		// connection open
124
		_, _, _ = kubernetes.Cluster.ExecWithOptions(ExecOptions{
125
			Command:            cmd,
126
			Namespace:          waitingClientNamespace,
127
			PodName:            demoClientPod,
128
			ContainerName:      "demo-client",
129
			Stdin:              &BlockingReader{},
130
			CaptureStdout:      true,
131
			CaptureStderr:      true,
132
			PreserveWhitespace: false,
133
		})
134
	}
135

136
	Specify("connection limit is respected", func() {
137
		By("allowing connections without a limit")
138

139
		Eventually(func(g Gomega) {
140
			response, err := client.CollectEchoResponse(
141
				kubernetes.Cluster, "demo-client", target,
142
				client.FromKubernetesPod(curlingClientNamespace, "demo-client"),
143
			)
144

145
			g.Expect(err).ToNot(HaveOccurred())
146
			g.Expect(response.Instance).To(Equal("kubernetes"))
147
		}, "20s", "1s").Should(Succeed())
148

149
		By("allowing more than 1 connection without a limit")
150

151
		go keepConnectionOpen()
152

153
		Eventually(func(g Gomega) {
154
			_, err := client.CollectEchoResponse(
155
				kubernetes.Cluster, "demo-client", target,
156
				client.FromKubernetesPod(curlingClientNamespace, "demo-client"),
157
			)
158

159
			g.Expect(err).ToNot(HaveOccurred())
160
		}).Should(Succeed())
161
		Consistently(func(g Gomega) {
162
			response, err := client.CollectEchoResponse(
163
				kubernetes.Cluster, "demo-client", target,
164
				client.FromKubernetesPod(curlingClientNamespace, "demo-client"),
165
			)
166

167
			g.Expect(err).ToNot(HaveOccurred())
168
			g.Expect(response.Instance).To(Equal("kubernetes"))
169
		}, "40s", "1s").Should(Succeed())
170

171
		By("not allowing more than 1 connection with a limit of 1")
172

173
		Expect(kubernetes.Cluster.Install(YamlK8s(meshGatewayWithLimit))).To(Succeed())
174

175
		Expect(kubernetes.Cluster.KillAppPod("demo-client", waitingClientNamespace)).To(Succeed())
176

177
		go keepConnectionOpen()
178

179
		Eventually(func(g Gomega) {
180
			response, err := client.CollectFailure(
181
				kubernetes.Cluster, "demo-client", target,
182
				client.FromKubernetesPod(curlingClientNamespace, "demo-client"),
183
			)
184

185
			g.Expect(err).ToNot(HaveOccurred())
186
			g.Expect(response.Exitcode).To(Or(Equal(52), Equal(56)))
187
		}, "40s", "1s").Should(Succeed())
188
	})
189
}
190