kuma

1
package gateway
2

3
import (
4
	"fmt"
5
	"net"
6
	"net/url"
7
	"path"
8
	"strconv"
9
	"strings"
10

11
	"github.com/gruntwork-io/terratest/modules/k8s"
12
	. "github.com/onsi/ginkgo/v2"
13
	. "github.com/onsi/gomega"
14
	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
15

16
	. "github.com/kumahq/kuma/test/framework"
17
	"github.com/kumahq/kuma/test/framework/client"
18
	"github.com/kumahq/kuma/test/framework/envs/kubernetes"
19
)
20

21
func SuccessfullyProxyRequestToGateway(cluster Cluster, instance string, gatewayAddr string, namespace string) func(Gomega) {
22
	return func(g Gomega) {
23
		target := fmt.Sprintf("http://%s/%s",
24
			gatewayAddr, path.Join("test", url.PathEscape(GinkgoT().Name())),
25
		)
26

27
		response, err := client.CollectEchoResponse(
28
			cluster, "demo-client", target,
29
			client.FromKubernetesPod(namespace, "demo-client"),
30
		)
31

32
		g.Expect(err).ToNot(HaveOccurred())
33
		g.Expect(response.Instance).To(Equal(instance))
34
	}
35
}
36

37
func FailToProxyRequestToGateway(cluster Cluster, gatewayAddr string, namespace string) func(Gomega) {
38
	return func(g Gomega) {
39
		Logf("expecting failure from %q", gatewayAddr)
40
		target := fmt.Sprintf("http://%s/%s",
41
			gatewayAddr, path.Join("test", url.PathEscape(GinkgoT().Name())),
42
		)
43

44
		response, err := client.CollectFailure(
45
			cluster, "demo-client", target,
46
			client.FromKubernetesPod(namespace, "demo-client"),
47
		)
48

49
		g.Expect(err).ToNot(HaveOccurred())
50
		g.Expect(response.Exitcode).To(Or(Equal(56), Equal(7), Equal(28)))
51
	}
52
}
53

54
func mkGateway(resourceName, serviceName, mesh string, crossMesh bool, hostname, backendService string, port int) string {
55
	meshGateway := fmt.Sprintf(`
56
apiVersion: kuma.io/v1alpha1
57
kind: MeshGateway
58
metadata:
59
  name: %s
60
mesh: %s
61
spec:
62
  selectors:
63
  - match:
64
      kuma.io/service: %s
65
  conf:
66
    listeners:
67
    - port: %d
68
      protocol: HTTP
69
      crossMesh: %t
70
      hostname: %s
71
`, resourceName, mesh, serviceName, port, crossMesh, hostname)
72

73
	route := fmt.Sprintf(`
74
apiVersion: kuma.io/v1alpha1
75
kind: MeshGatewayRoute
76
metadata:
77
  name: %s
78
mesh: %s
79
spec:
80
  selectors:
81
  - match:
82
      kuma.io/service: %s
83
  conf:
84
    http:
85
      rules:
86
      - matches:
87
        - path:
88
            match: PREFIX
89
            value: /
90
        backends:
91
        - destination:
92
            kuma.io/service: %s # Matches the echo-server we deployed.
93
`, resourceName, mesh, serviceName, backendService)
94
	return strings.Join([]string{meshGateway, route}, "\n---\n")
95
}
96

97
func MkGatewayInstance(name, namespace, mesh string) string {
98
	instance := fmt.Sprintf(`
99
apiVersion: kuma.io/v1alpha1
100
kind: MeshGatewayInstance
101
metadata:
102
  name: %s
103
  namespace: %s
104
  labels:
105
    kuma.io/mesh: %s
106
spec:
107
  replicas: 1
108
  serviceType: ClusterIP
109
  tags:
110
    kuma.io/service: %s
111
`, name, namespace, mesh, name)
112

113
	return instance
114
}
115

116
func gatewayAddress(instanceName, instanceNamespace string, port int) string {
117
	services, err := k8s.ListServicesE(kubernetes.Cluster.GetTesting(), kubernetes.Cluster.GetKubectlOptions(instanceNamespace), metav1.ListOptions{})
118
	Expect(err).ToNot(HaveOccurred())
119

120
	var rawIP string
121

122
	// Find the service that is owned by the named GatewayInstance.
123
	for _, svc := range services {
124
		for _, ref := range svc.GetOwnerReferences() {
125
			if ref.Kind == "MeshGatewayInstance" && ref.Name == instanceName {
126
				rawIP = svc.Spec.ClusterIP
127
			}
128
		}
129
	}
130

131
	ip := net.ParseIP(rawIP)
132
	Expect(ip).ToNot(BeNil(), "invalid clusterIP for gateway")
133

134
	return net.JoinHostPort(rawIP, strconv.Itoa(port))
135
}
136