kuma

universal_controlplane.go
241 строка · 5.7 Кб
Перенос по словам
1
package framework
2

3
import (
4
	"encoding/json"
5
	"fmt"
6
	"net"
7

8
	"github.com/gruntwork-io/terratest/modules/retry"
9
	"github.com/gruntwork-io/terratest/modules/testing"
10
	"github.com/pkg/errors"
11

12
	"github.com/kumahq/kuma/pkg/config/core"
13
	core_model "github.com/kumahq/kuma/pkg/core/resources/model"
14
	"github.com/kumahq/kuma/test/framework/kumactl"
15
	"github.com/kumahq/kuma/test/framework/ssh"
16
)
17

18
var _ ControlPlane = &UniversalControlPlane{}
19

20
type UniversalControlPlane struct {
21
	t            testing.TestingT
22
	mode         core.CpMode
23
	name         string
24
	kumactl      *kumactl.KumactlOptions
25
	verbose      bool
26
	cpNetworking UniversalNetworking
27
	setupKumactl bool
28
}
29

30
func NewUniversalControlPlane(
31
	t testing.TestingT,
32
	mode core.CpMode,
33
	clusterName string,
34
	verbose bool,
35
	networking UniversalNetworking,
36
	apiHeaders []string,
37
	setupKumactl bool,
38
) (*UniversalControlPlane, error) {
39
	name := clusterName + "-" + mode
40
	kumactl := NewKumactlOptionsE2E(t, name, verbose)
41
	ucp := &UniversalControlPlane{
42
		t:            t,
43
		mode:         mode,
44
		name:         name,
45
		kumactl:      kumactl,
46
		verbose:      verbose,
47
		cpNetworking: networking,
48
		setupKumactl: setupKumactl,
49
	}
50
	token, err := ucp.retrieveAdminToken()
51
	if err != nil {
52
		return nil, err
53
	}
54

55
	if err := kumactl.KumactlConfigControlPlanesAdd(clusterName, ucp.GetAPIServerAddress(), token, apiHeaders); err != nil {
56
		return nil, err
57
	}
58
	return ucp, nil
59
}
60

61
func (c *UniversalControlPlane) Networking() UniversalNetworking {
62
	return c.cpNetworking
63
}
64

65
func (c *UniversalControlPlane) GetName() string {
66
	return c.name
67
}
68

69
func (c *UniversalControlPlane) GetKDSInsecureServerAddress() string {
70
	return c.getKDSServerAddress(false)
71
}
72

73
func (c *UniversalControlPlane) GetKDSServerAddress() string {
74
	return c.getKDSServerAddress(true)
75
}
76

77
func (c *UniversalControlPlane) GetXDSServerAddress() string {
78
	return net.JoinHostPort(c.cpNetworking.IP, "5678")
79
}
80

81
func (c *UniversalControlPlane) getKDSServerAddress(secure bool) string {
82
	protocol := "grpcs"
83
	if !secure {
84
		protocol = "grpc"
85
	}
86

87
	return protocol + "://" + net.JoinHostPort(c.cpNetworking.IP, "5685")
88
}
89

90
func (c *UniversalControlPlane) GetGlobalStatusAPI() string {
91
	panic("not implemented")
92
}
93

94
func (c *UniversalControlPlane) GetAPIServerAddress() string {
95
	return "http://localhost:" + c.cpNetworking.ApiServerPort
96
}
97

98
func (c *UniversalControlPlane) GetMetrics() (string, error) {
99
	return retry.DoWithRetryE(c.t, "fetching CP metrics", DefaultRetries, DefaultTimeout, func() (string, error) {
100
		sshApp := ssh.NewApp(c.name, "", c.verbose, c.cpNetworking.SshPort, nil, []string{
101
			"curl",
102
			"--fail", "--show-error",
103
			"http://localhost:5680/metrics",
104
		})
105
		if err := sshApp.Run(); err != nil {
106
			return "", err
107
		}
108
		if sshApp.Err() != "" {
109
			return "", errors.New(sshApp.Err())
110
		}
111
		return sshApp.Out(), nil
112
	})
113
}
114

115
func (c *UniversalControlPlane) GetMonitoringAssignment(clientId string) (string, error) {
116
	panic("not implemented")
117
}
118

119
func (c *UniversalControlPlane) generateToken(
120
	tokenPath string,
121
	data string,
122
) (string, error) {
123
	description := fmt.Sprintf("generating %s token", tokenPath)
124

125
	return retry.DoWithRetryE(
126
		c.t,
127
		description,
128
		DefaultRetries,
129
		DefaultTimeout,
130
		func() (string, error) {
131
			sshApp := ssh.NewApp(
132
				c.name,
133
				"",
134
				c.verbose,
135
				c.cpNetworking.SshPort,
136
				nil,
137
				[]string{
138
					"curl",
139
					"--fail", "--show-error",
140
					"-H", "\"Content-Type: application/json\"",
141
					"--data", data,
142
					"http://localhost:5681/tokens" + tokenPath,
143
				},
144
			)
145

146
			if err := sshApp.Run(); err != nil {
147
				return "", err
148
			}
149

150
			if sshApp.Err() != "" {
151
				return "", errors.New(sshApp.Err())
152
			}
153

154
			return sshApp.Out(), nil
155
		},
156
	)
157
}
158

159
func (c *UniversalControlPlane) retrieveAdminToken() (string, error) {
160
	if !c.setupKumactl {
161
		return "", nil
162
	}
163

164
	return retry.DoWithRetryE(
165
		c.t, "fetching user admin token",
166
		DefaultRetries,
167
		DefaultTimeout,
168
		func() (string, error) {
169
			out, stderr, err := c.Exec("curl", "--fail", "--show-error", "http://localhost:5681/global-secrets/admin-user-token")
170
			if err != nil {
171
				return "", err
172
			}
173
			if stderr != "" {
174
				return "", errors.New(stderr)
175
			}
176
			return ExtractSecretDataFromResponse(out)
177
		},
178
	)
179
}
180

181
func (c *UniversalControlPlane) Exec(cmd ...string) (string, string, error) {
182
	sshApp := ssh.NewApp(
183
		c.name,
184
		"",
185
		c.verbose, c.cpNetworking.SshPort, nil, cmd,
186
	)
187
	if err := sshApp.Run(); err != nil {
188
		return "", sshApp.Err(), err
189
	}
190
	return sshApp.Out(), sshApp.Err(), nil
191
}
192

193
func (c *UniversalControlPlane) GenerateDpToken(mesh, service string) (string, error) {
194
	data := fmt.Sprintf(
195
		`'{"mesh": "%s", "tags": {"kuma.io/service":["%s"]}}'`,
196
		mesh,
197
		service,
198
	)
199

200
	return c.generateToken("/dataplane", data)
201
}
202

203
func (c *UniversalControlPlane) GenerateZoneIngressToken(zone string) (string, error) {
204
	data := fmt.Sprintf(`'{"zone": "%s", "scope": ["ingress"]}'`, zone)
205

206
	return c.generateToken("/zone", data)
207
}
208

209
func (c *UniversalControlPlane) GenerateZoneIngressLegacyToken(zone string) (string, error) {
210
	data := fmt.Sprintf(`'{"zone": "%s"}'`, zone)
211

212
	return c.generateToken("/zone-ingress", data)
213
}
214

215
func (c *UniversalControlPlane) GenerateZoneEgressToken(zone string) (string, error) {
216
	data := fmt.Sprintf(`'{"zone": "%s", "scope": ["egress"]}'`, zone)
217

218
	return c.generateToken("/zone", data)
219
}
220

221
func (c *UniversalControlPlane) GenerateZoneToken(
222
	zone string,
223
	scope []string,
224
) (string, error) {
225
	scopeJson, err := json.Marshal(scope)
226
	if err != nil {
227
		return "", err
228
	}
229

230
	data := fmt.Sprintf(`'{"zone": "%s", "scope": %s}'`, zone, scopeJson)
231

232
	return c.generateToken("/zone", data)
233
}
234

235
func (c *UniversalControlPlane) UpdateObject(
236
	typeName string,
237
	objectName string,
238
	update func(object core_model.Resource) core_model.Resource,
239
) error {
240
	return c.kumactl.KumactlUpdateObject(typeName, objectName, update)
241
}
242
kuma

Использование cookies
