kuma

1
package meshtcproute
2

3
import (
4
	"fmt"
5

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

9
	core_mesh "github.com/kumahq/kuma/pkg/core/resources/apis/mesh"
10
	"github.com/kumahq/kuma/pkg/plugins/policies/meshtcproute/api/v1alpha1"
11
	. "github.com/kumahq/kuma/test/framework"
12
	"github.com/kumahq/kuma/test/framework/client"
13
	"github.com/kumahq/kuma/test/framework/deployments/testserver"
14
	"github.com/kumahq/kuma/test/framework/envs/kubernetes"
15
)
16

17
func Test() {
18
	meshName := "meshtcproute"
19
	namespace := "meshtcproute"
20

21
	BeforeAll(func() {
22
		Expect(NewClusterSetup().
23
			Install(MeshKubernetes(meshName)).
24
			Install(NamespaceWithSidecarInjection(namespace)).
25
			Install(testserver.Install(
26
				testserver.WithName("test-client"),
27
				testserver.WithMesh(meshName),
28
				testserver.WithNamespace(namespace),
29
			)).
30
			Install(testserver.Install(
31
				testserver.WithName("test-http-server"),
32
				testserver.WithMesh(meshName),
33
				testserver.WithNamespace(namespace),
34
			)).
35
			Install(testserver.Install(
36
				testserver.WithName("test-http-server-2"),
37
				testserver.WithMesh(meshName),
38
				testserver.WithNamespace(namespace),
39
			)).
40
			Install(testserver.Install(
41
				testserver.WithName("test-tcp-server"),
42
				testserver.WithServicePortAppProtocol("tcp"),
43
				testserver.WithMesh(meshName),
44
				testserver.WithNamespace(namespace),
45
			)).
46
			Install(testserver.Install(
47
				testserver.WithName("external-http-service"),
48
				testserver.WithNamespace(namespace),
49
			)).
50
			Install(testserver.Install(
51
				testserver.WithName("external-tcp-service"),
52
				testserver.WithNamespace(namespace),
53
			)).
54
			Setup(kubernetes.Cluster),
55
		).To(Succeed())
56
	})
57

58
	E2EAfterEach(func() {
59
		Expect(DeleteMeshResources(
60
			kubernetes.Cluster,
61
			meshName,
62
			v1alpha1.MeshTCPRouteResourceTypeDescriptor,
63
		)).To(Succeed())
64
		Expect(DeleteMeshResources(
65
			kubernetes.Cluster,
66
			meshName,
67
			core_mesh.ExternalServiceResourceTypeDescriptor,
68
		)).To(Succeed())
69
	})
70

71
	E2EAfterAll(func() {
72
		Expect(kubernetes.Cluster.TriggerDeleteNamespace(namespace)).To(Succeed())
73
		Expect(kubernetes.Cluster.DeleteMesh(meshName)).To(Succeed())
74
	})
75

76
	It("should use MeshTCPRoute if no TrafficRoutes are present", func() {
77
		Eventually(func(g Gomega) {
78
			response, err := client.CollectEchoResponse(
79
				kubernetes.Cluster,
80
				"test-client",
81
				"test-http-server_meshtcproute_svc_80.mesh",
82
				client.FromKubernetesPod(namespace, "test-client"),
83
			)
84
			g.Expect(err).ToNot(HaveOccurred())
85
			g.Expect(response.Instance).To(HavePrefix("test-http-server"))
86
		}, "30s", "1s").Should(Succeed())
87
	})
88

89
	It("should split traffic between internal and external services "+
90
		"with mixed (tcp and http) protocols", func() {
91
		// given
92
		Expect(kubernetes.Cluster.Install(YamlK8s(fmt.Sprintf(`
93
apiVersion: kuma.io/v1alpha1
94
kind: ExternalService
95
metadata:
96
  name: external-http-service-mtcpr
97
mesh: %s
98
spec:
99
  tags:
100
    kuma.io/service: external-http-service-mtcpr
101
    kuma.io/protocol: http
102
  networking:
103
    # .svc.cluster.local is needed, otherwise Kubernetes will resolve this
104
    # to the real IP
105
    address: external-http-service.%s.svc.cluster.local:80
106
`, meshName, namespace)))).To(Succeed())
107

108
		Expect(kubernetes.Cluster.Install(YamlK8s(fmt.Sprintf(`
109
apiVersion: kuma.io/v1alpha1
110
kind: ExternalService
111
metadata:
112
  name: external-tcp-service-mtcpr
113
mesh: %s
114
spec:
115
  tags:
116
    kuma.io/service: external-tcp-service-mtcpr
117
    kuma.io/protocol: tcp
118
  networking:
119
    # .svc.cluster.local is needed, otherwise Kubernetes will resolve this
120
    # to the real IP
121
    address: external-tcp-service.%s.svc.cluster.local:80
122
`, meshName, namespace)))).To(Succeed())
123

124
		// when
125
		Expect(YamlK8s(fmt.Sprintf(`
126
apiVersion: kuma.io/v1alpha1
127
kind: MeshTCPRoute
128
metadata:
129
  name: route-2
130
  namespace: %s
131
  labels:
132
    kuma.io/mesh: %s
133
spec:
134
  targetRef:
135
    kind: MeshService
136
    name: test-client_%s_svc_80
137
  to:
138
  - targetRef:
139
      kind: MeshService
140
      name: test-http-server_meshtcproute_svc_80
141
    rules: 
142
    - default:
143
        backendRefs:
144
        - kind: MeshService
145
          name: test-http-server_meshtcproute_svc_80
146
          weight: 25
147
        - kind: MeshService
148
          name: test-tcp-server_meshtcproute_svc_80
149
          weight: 25
150
        - kind: MeshService
151
          name: external-http-service-mtcpr
152
          weight: 25
153
        - kind: MeshService
154
          name: external-tcp-service-mtcpr
155
          weight: 25
156
`, Config.KumaNamespace, meshName, meshName))(kubernetes.Cluster)).To(Succeed())
157

158
		// then receive responses from "test-http-server_meshtcproute_svc_80"
159
		Eventually(func(g Gomega) {
160
			response, err := client.CollectEchoResponse(
161
				kubernetes.Cluster,
162
				"test-client",
163
				"test-http-server_meshtcproute_svc_80.mesh",
164
				client.FromKubernetesPod(namespace, "test-client"),
165
			)
166
			g.Expect(err).ToNot(HaveOccurred())
167
			g.Expect(response.Instance).To(HavePrefix("test-http-server"))
168
		}, "30s", "1s").Should(Succeed())
169

170
		// then receive responses from "test-tcp-server_meshtcproute_svc_80"
171
		Eventually(func(g Gomega) {
172
			response, err := client.CollectEchoResponse(
173
				kubernetes.Cluster,
174
				"test-client",
175
				"test-http-server_meshtcproute_svc_80.mesh",
176
				client.FromKubernetesPod(namespace, "test-client"),
177
			)
178
			g.Expect(err).ToNot(HaveOccurred())
179
			g.Expect(response.Instance).To(HavePrefix("test-tcp-server"))
180
		}, "30s", "1s").Should(Succeed())
181

182
		// and then receive responses from "external-http-service"
183
		Eventually(func(g Gomega) {
184
			response, err := client.CollectEchoResponse(
185
				kubernetes.Cluster,
186
				"test-client",
187
				"test-http-server_meshtcproute_svc_80.mesh",
188
				client.FromKubernetesPod(namespace, "test-client"),
189
			)
190
			g.Expect(err).ToNot(HaveOccurred())
191
			g.Expect(response.Instance).To(HavePrefix("external-http-service"))
192
		}, "30s", "1s").Should(Succeed())
193

194
		// and then receive responses from "external-tcp-service"
195
		Eventually(func(g Gomega) {
196
			response, err := client.CollectEchoResponse(
197
				kubernetes.Cluster,
198
				"test-client",
199
				"test-http-server_meshtcproute_svc_80.mesh",
200
				client.FromKubernetesPod(namespace, "test-client"),
201
			)
202
			g.Expect(err).ToNot(HaveOccurred())
203
			g.Expect(response.Instance).To(HavePrefix("external-tcp-service"))
204
		}, "30s", "1s").Should(Succeed())
205
	})
206

207
	It("should use MeshHTTPRoute if both MeshTCPRoute and MeshHTTPRoute "+
208
		"are present and point to the same source and http destination", func() {
209
		// given
210
		Expect(kubernetes.Cluster.Install(YamlK8s(fmt.Sprintf(`
211
apiVersion: kuma.io/v1alpha1
212
kind: ExternalService
213
metadata:
214
  name: external-tcp-service-mtcpr
215
mesh: %s
216
spec:
217
  tags:
218
    kuma.io/service: external-tcp-service
219
    kuma.io/protocol: tcp
220
  networking:
221
    # .svc.cluster.local is needed, otherwise Kubernetes will resolve this
222
    # to the real IP
223
    address: external-tcp-service.%s.svc.cluster.local:80
224
`, meshName, namespace)))).To(Succeed())
225

226
		// when
227
		meshRoutes := func(meshName string, namespace string) string {
228
			meshHTTPRoute := fmt.Sprintf(`
229
apiVersion: kuma.io/v1alpha1
230
kind: MeshHTTPRoute
231
metadata:
232
  name: http-route
233
  namespace: %s
234
  labels:
235
    kuma.io/mesh: %s
236
spec:
237
  targetRef:
238
    kind: MeshService
239
    name: test-client_%s_svc_80
240
  to:
241
  - targetRef:
242
      kind: MeshService
243
      name: test-http-server_meshtcproute_svc_80
244
    rules:
245
    - matches:
246
      - path:
247
          type: PathPrefix
248
          value: "/"
249
      default:
250
        backendRefs:
251
        - kind: MeshService
252
          name: test-http-server-2_meshtcproute_svc_80
253
`, Config.KumaNamespace, meshName, namespace)
254
			meshTCPRoute := fmt.Sprintf(`
255
apiVersion: kuma.io/v1alpha1
256
kind: MeshTCPRoute
257
metadata:
258
  name: tcp-route
259
  namespace: %s
260
  labels:
261
    kuma.io/mesh: %s
262
spec:
263
  targetRef:
264
    kind: MeshService
265
    name: test-client_%s_svc_80
266
  to:
267
  - targetRef:
268
      kind: MeshService
269
      name: test-http-server_meshtcproute_svc_80
270
    rules:
271
    - default:
272
        backendRefs:
273
        - kind: MeshService
274
          name: external-tcp-service
275
`, Config.KumaNamespace, meshName, namespace)
276
			return fmt.Sprintf("%s\n---%s", meshTCPRoute, meshHTTPRoute)
277
		}
278

279
		Expect(YamlK8s(meshRoutes(meshName, namespace))(kubernetes.Cluster)).
280
			To(Succeed())
281

282
		// then
283
		Eventually(func(g Gomega) {
284
			response, err := client.CollectEchoResponse(
285
				kubernetes.Cluster,
286
				"test-client",
287
				"test-http-server_meshtcproute_svc_80.mesh",
288
				client.FromKubernetesPod(namespace, "test-client"),
289
			)
290
			g.Expect(err).ToNot(HaveOccurred())
291
			g.Expect(response.Instance).To(HavePrefix("test-http-server-2"))
292
		}, "30s", "1s").Should(Succeed())
293
	})
294

295
	It("should use MeshTCPRoute if both MeshTCPRoute and MeshHTTPRoute "+
296
		"are present and point to the same source and tcp destination", func() {
297
		// given
298
		Expect(kubernetes.Cluster.Install(YamlK8s(fmt.Sprintf(`
299
apiVersion: kuma.io/v1alpha1
300
kind: ExternalService
301
metadata:
302
  name: external-tcp-service-mtcpr
303
mesh: %s
304
spec:
305
  tags:
306
    kuma.io/service: external-tcp-service
307
    kuma.io/protocol: tcp
308
  networking:
309
    # .svc.cluster.local is needed, otherwise Kubernetes will resolve this
310
    # to the real IP
311
    address: external-tcp-service.%s.svc.cluster.local:80
312
`, meshName, namespace)))).To(Succeed())
313

314
		// when
315
		meshRoutes := func(meshName string, namespace string) string {
316
			meshHTTPRoute := fmt.Sprintf(`
317
apiVersion: kuma.io/v1alpha1
318
kind: MeshHTTPRoute
319
metadata:
320
  name: http-route
321
  namespace: %s
322
  labels:
323
    kuma.io/mesh: %s
324
spec:
325
  targetRef:
326
    kind: MeshService
327
    name: test-client_%s_svc_80
328
  to:
329
  - targetRef:
330
      kind: MeshService
331
      name: test-tcp-server_meshtcproute_svc_80
332
    rules:
333
    - matches:
334
      - path:
335
          type: PathPrefix
336
          value: "/"
337
      default:
338
        backendRefs:
339
        - kind: MeshService
340
          name: test-http-server-2_meshtcproute_svc_80
341
`, Config.KumaNamespace, meshName, namespace)
342
			meshTCPRoute := fmt.Sprintf(`
343
apiVersion: kuma.io/v1alpha1
344
kind: MeshTCPRoute
345
metadata:
346
  name: tcp-route
347
  namespace: %s
348
  labels:
349
    kuma.io/mesh: %s
350
spec:
351
  targetRef:
352
    kind: MeshService
353
    name: test-client_%s_svc_80
354
  to:
355
  - targetRef:
356
      kind: MeshService
357
      name: test-tcp-server_meshtcproute_svc_80
358
    rules:
359
    - default:
360
        backendRefs:
361
        - kind: MeshService
362
          name: external-tcp-service
363
`, Config.KumaNamespace, meshName, namespace)
364
			return fmt.Sprintf("%s\n---%s", meshTCPRoute, meshHTTPRoute)
365
		}
366

367
		Expect(YamlK8s(meshRoutes(meshName, namespace))(kubernetes.Cluster)).
368
			To(Succeed())
369

370
		// then
371
		Eventually(func(g Gomega) {
372
			response, err := client.CollectEchoResponse(
373
				kubernetes.Cluster,
374
				"test-client",
375
				"test-tcp-server_meshtcproute_svc_80.mesh",
376
				client.FromKubernetesPod(namespace, "test-client"),
377
			)
378
			g.Expect(err).ToNot(HaveOccurred())
379
			g.Expect(response.Instance).To(HavePrefix("external-tcp-service"))
380
		}, "30s", "1s").Should(Succeed())
381
	})
382
}
383