1 package integration_test
2
3 import (
4 "fmt"
5
6 "github.com/udacity/graphb"
7
8 "edge-infra.dev/pkg/edge/api/graph/mapper"
9 "edge-infra.dev/pkg/edge/api/graph/model"
10 "edge-infra.dev/pkg/edge/api/services"
11 "edge-infra.dev/pkg/edge/api/utils"
12 "edge-infra.dev/pkg/edge/constants"
13 "edge-infra.dev/test/framework/integration"
14 )
15
16 var (
17 clusterNetworkServiceEdgeID = "3396a52c-6a22-4049-9593-5a63b596a200"
18 clusterCreateConfigEdgeID = "5bc12c67-d9b0-4f13-a6d4-4852b0c11291"
19 k8sServiceEdgeID = "3396a52c-6a22-4049-9593-5a63b596a210"
20 dnsNetworkServiceID = "bc51dae7-f4cb-4b20-b2c9-508bf9089b3e"
21 dnsNetworkServiceID2 = "f79165b7-ebb7-426e-a91c-0d3bf2a148b5"
22 podNetworkServiceID = "1c67eeb0-e1c4-4a8a-b9e1-46233ef5ad33"
23 serviceNetworkServiceID = "d79dabaf-afc3-4a44-9031-e06a2512b1de"
24 testFamily = "inet"
25 testIP = "8.8.8.8"
26 testIP2 = "9.9.9.9"
27 testIP3 = "10.10.10.10"
28 testServiceType = "dns"
29 falseValue = false
30 trueValue = true
31 )
32
33 func (s *Suite) TestSiteEU() {
34 integration.SkipIf(s.Framework)
35 clusterEdgeID := clusterCreateConfigEdgeID
36 siteQuery := siteQuery(clusterEdgeID)
37 var getStoresSiteResponse struct{ Site *model.StoreSiteInfo }
38 ResolverClient.MustPost(siteQuery, &getStoresSiteResponse)
39 s.NotNil(getStoresSiteResponse)
40 s.Equal(getStoresSiteResponse.Site.SiteName, "test-store")
41 s.Equal(getStoresSiteResponse.Site.EnterpriseUnitName, "test-enterprise-unit-name")
42 s.Equal(getStoresSiteResponse.Site.Status, services.ActiveStatus)
43 s.Equal(*getStoresSiteResponse.Site.ID, "test_bsl_site_id-3")
44 s.Equal(getStoresSiteResponse.Site.Coordinates.Latitude, services.DefaultLatitude)
45 s.Equal(getStoresSiteResponse.Site.Coordinates.Longitude, services.DefaultLongitude)
46 }
47
48 func (s *Suite) TestSiteWithMismatches() {
49 clusterEdgeID := testClusterEdgeID
50 siteQuery := siteQuery(clusterEdgeID)
51 var getStoresSiteResponse struct{ Site *model.StoreSiteInfo }
52 err := ResolverClient.Post(siteQuery, &getStoresSiteResponse)
53 s.NoError(err)
54 s.NotNil(getStoresSiteResponse)
55 s.Equal(getStoresSiteResponse.Site.SiteName, "test-store")
56 s.Equal(getStoresSiteResponse.Site.EnterpriseUnitName, "test-enterprise-unit-name")
57 s.Equal(getStoresSiteResponse.Site.Status, services.ActiveStatus)
58 s.Equal(*getStoresSiteResponse.Site.ID, "test_bsl_site_id")
59 s.Equal(getStoresSiteResponse.Site.Coordinates.Latitude, services.DefaultLatitude)
60 s.Equal(getStoresSiteResponse.Site.Coordinates.Longitude, services.DefaultLongitude)
61 }
62
63 func (s *Suite) TestSiteORG() {
64 integration.SkipIf(s.Framework)
65 siteQuery := siteQuery(testClusterEdgeID2)
66 var getStoresSiteResponse struct{ Site *model.StoreSiteInfo }
67 ResolverClient.MustPost(siteQuery, &getStoresSiteResponse)
68 s.NotNil(getStoresSiteResponse)
69 s.Equal(getStoresSiteResponse.Site.SiteName, "test-store")
70 s.Equal(getStoresSiteResponse.Site.EnterpriseUnitName, "test-enterprise-unit-name")
71 s.Equal(getStoresSiteResponse.Site.Status, services.ActiveStatus)
72 s.Equal(*getStoresSiteResponse.Site.ID, "test_bsl_site_id-2")
73 s.Equal(getStoresSiteResponse.Site.Coordinates.Latitude, services.DefaultLatitude)
74 s.Equal(getStoresSiteResponse.Site.Coordinates.Longitude, services.DefaultLongitude)
75 }
76
77 func (s *Suite) TestUpdateSite() {
78 integration.SkipIf(s.Framework)
79 updateSiteQuery := updateSiteQuery(testClusterEdgeID2)
80 var updateSiteResponse struct{ UpdateSite *model.StoreSiteInfo }
81 ResolverClient.MustPost(updateSiteQuery, &updateSiteResponse)
82 s.NotNil(updateSiteResponse)
83 s.Equal(updateSiteResponse.UpdateSite.SiteName, "test-store")
84 s.Equal(updateSiteResponse.UpdateSite.EnterpriseUnitName, "test-enterprise-unit-name")
85 s.Equal(updateSiteResponse.UpdateSite.Status, services.ActiveStatus)
86 s.Equal(*updateSiteResponse.UpdateSite.ID, "test-site-id")
87 s.Equal(updateSiteResponse.UpdateSite.Coordinates.Latitude, services.DefaultLatitude)
88 s.Equal(updateSiteResponse.UpdateSite.Coordinates.Longitude, services.DefaultLongitude)
89 }
90
91 func (s *Suite) TestDeleteCluster() {
92 integration.SkipIf(s.Framework)
93 clusterEdgeID := "3d589401-8e64-4845-ad7b-0466e8e65f13"
94 deleteSite := false
95 deleteClusterQuery := deleteClusterQuery(clusterEdgeID, deleteSite)
96 var deleteClusterResponse struct{ DeleteCluster *bool }
97 ResolverClient.MustPost(deleteClusterQuery, &deleteClusterResponse)
98 s.NotNil(deleteClusterQuery)
99 }
100
101 func (s *Suite) TestDeleteClusters1() {
102 type test struct {
103 testName string
104 clusterEdgeIDs []string
105 deleteSite bool
106 }
107 tests := []test{
108 {
109 testName: "DeleteClustersWithoutBslSite",
110 clusterEdgeIDs: []string{"2a589401-8e64-4845-ad7b-0466e8e65f13", "2b589401-8e64-4845-ad7b-0466e8e65f13"},
111 deleteSite: false,
112 },
113 {
114 testName: "DeleteClustersAndBslSite",
115 clusterEdgeIDs: []string{"2c589401-8e64-4845-ad7b-0466e8e65f13", "2d589401-8e64-4845-ad7b-0466e8e65f13"},
116 deleteSite: true,
117 },
118 }
119 for _, tc := range tests {
120 integration.SkipIf(s.Framework)
121 clusterEdgeIDs := tc.clusterEdgeIDs
122 deleteSite := tc.deleteSite
123 deleteClustersQuery := deleteClustersQuery(clusterEdgeIDs, deleteSite)
124 var deleteClustersResponse struct{ DeleteClusters *bool }
125 ResolverClient.MustPost(deleteClustersQuery, &deleteClustersResponse)
126 s.NotNil(deleteClustersQuery)
127 }
128 }
129
130 func (s *Suite) TestGetClusters() {
131 integration.SkipIf(s.Framework)
132 query := clustersQuery(testOrgBannerEdgeID, []string{})
133 var clustersResponse struct{ Clusters []*model.Cluster }
134 ResolverClient.MustPost(query, &clustersResponse)
135 }
136
137 func (s *Suite) TestGetClustersWithLabels() {
138 integration.SkipIf(s.Framework)
139 query := clustersQuery(testOrgBannerEdgeID, []string{"store", "basic-store"})
140 var clustersResponse struct{ Clusters []*model.Cluster }
141 ResolverClient.MustPost(query, &clustersResponse)
142 }
143
144 func (s *Suite) TestUpdateClusterName() {
145 clusterEdgeID := "3d589401-0000-1111-2222-0466e8e65f13"
146 updatedName := "new-name"
147 query := clusterQuery(clusterEdgeID)
148 var clusterResponse struct{ Cluster *model.Cluster }
149 ResolverClient.MustPost(query, &clusterResponse)
150
151 s.NotNil(clusterResponse.Cluster)
152 s.NotEqual(updatedName, clusterResponse.Cluster.Name)
153
154 mutation := updateClusterName(clusterEdgeID, updatedName)
155 var response struct{ UpdateClusterName *model.Cluster }
156 ResolverClient.MustPost(mutation, &response)
157
158 s.NotNil(response.UpdateClusterName)
159 s.Equal(updatedName, response.UpdateClusterName.Name)
160 }
161
162 func (s *Suite) TestUpdateClusteFleetVersion() {
163 integration.SkipIf(s.Framework)
164 clusterEdgeID := "dc8e59c3-6338-4c28-a776-f54e93a19ff4"
165 updatedFleetVersion := "0.16.0"
166 query := clusterQuery(clusterEdgeID)
167 var clusterResponse struct{ Cluster *model.Cluster }
168 ResolverClient.MustPost(query, &clusterResponse)
169
170 s.NotNil(clusterResponse.Cluster)
171 s.NotEqual(updatedFleetVersion, clusterResponse.Cluster.FleetVersion)
172
173 mutation := updateClusterFleetVersion(clusterEdgeID, updatedFleetVersion)
174 var response struct{ UpdateClusterFleetVersion *model.Cluster }
175 ResolverClient.MustPost(mutation, &response)
176
177 s.NotNil(response.UpdateClusterFleetVersion)
178 s.Equal(updatedFleetVersion, response.UpdateClusterFleetVersion.FleetVersion)
179 }
180
181 func (s *Suite) TestStoreStatusActive() {
182 integration.SkipIf(s.Framework)
183 q := storeStatus(testClusterEdgeID)
184 var response struct{ StoreStatus *model.StoreStatusInfo }
185 ResolverClient.MustPost(q, &response)
186 s.NotNil(response.StoreStatus)
187 s.Equal("test_cluster", response.StoreStatus.Name)
188 s.Equal(testOrgBannerEdgeID, response.StoreStatus.BannerEdgeID)
189 s.NotNil(response.StoreStatus.KubeVersion)
190 s.NotNil(response.StoreStatus.Status)
191 s.Equal("v1.23.6", *response.StoreStatus.KubeVersion)
192 s.Equal("Ready", response.StoreStatus.Status.Status)
193 s.Equal("Edge Syncing", response.StoreStatus.Status.Message)
194 s.Equal(1, len(response.StoreStatus.BucketStatus))
195 s.Equal("test-bucket-name", response.StoreStatus.BucketStatus[0].BucketName)
196 s.Equal(true, response.StoreStatus.BucketStatus[0].FluxStatus.Suspended)
197 s.Equal("test-bucket-1", response.StoreStatus.BucketStatus[0].FluxStatus.Name)
198 s.Equal(2, len(response.StoreStatus.KustomizationStatus))
199 s.Contains("test-kustomization-1 test-kustomization-2", response.StoreStatus.KustomizationStatus[0].FluxStatus.Name)
200 s.Contains("test-kustomization-1 test-kustomization-2", response.StoreStatus.KustomizationStatus[1].FluxStatus.Name)
201 }
202
203 func (s *Suite) TestStoreStatusNotActive() {
204 integration.SkipIf(s.Framework)
205 if !integration.IsIntegrationTest() {
206 s.NoError(
207 setUpTestBannerAndClusterStatus("3396a52c-6a22-4049-9593-5a63b596a104", "3396a52c-6a22-4049-9593-5a63b596a202"))
208 }
209 q := storeStatus("3396a52c-6a22-4049-9593-5a63b596a202")
210 var response struct{ StoreStatus *model.StoreStatusInfo }
211 ResolverClient.MustPost(q, &response)
212 s.NotNil(response.StoreStatus)
213 s.Equal("status not found", response.StoreStatus.Status.Message)
214 s.Equal(mapper.Provisioning, response.StoreStatus.Status.Status)
215 }
216
217 func (s *Suite) TestDeleteClusterAndBslSite() {
218 integration.SkipIf(s.Framework)
219 clusterEdgeID := "25980ab2-cb78-46ab-bf8f-9a7b78239b7f"
220 deleteBslSite := true
221 deleteClusterQuery := deleteClusterQuery(clusterEdgeID, deleteBslSite)
222 var deleteClusterResponse struct{ DeleteCluster *bool }
223 ResolverClient.MustPost(deleteClusterQuery, &deleteClusterResponse)
224 s.NotNil(deleteClusterResponse)
225 }
226
227 func (s *Suite) TestGetClusterNetworkService() {
228 clusterEdgeID := clusterNetworkServiceEdgeID
229 getCluster := getClusterNetworkServices(clusterEdgeID)
230
231 var getClusterResponse struct {
232 Cluster *model.Cluster
233 }
234
235 err := ResolverClient.Post(getCluster, &getClusterResponse)
236
237 s.NoError(err)
238 s.NotNil(getClusterResponse)
239
240 var dnsService *model.ClusterNetworkServiceInfo
241 for _, service := range getClusterResponse.Cluster.ClusterNetworkServices {
242 if service.ServiceType == "dns" && service.NetworkServiceID == dnsNetworkServiceID {
243 dnsService = service
244 }
245 }
246
247 searchDNSServers := []string{"8.8.8.8"}
248
249 s.Equal(getClusterResponse.Cluster.ClusterEdgeID, clusterEdgeID)
250 s.Equal(dnsService.ServiceType, "dns")
251 s.Equal(dnsService.Family, testFamily)
252 s.Equal(dnsService.ServiceType, testServiceType)
253 s.Contains(searchDNSServers, dnsService.IP)
254 s.Equal(*dnsService.Priority, 100)
255 }
256
257 func (s *Suite) TestCreateClusterNetworkService() {
258 clusterEdgeID := clusterNetworkServiceEdgeID
259
260 testNewIP := "0.0.0.0"
261 networkServiceCreate := createNetworkServiceInput(testNewIP, testFamily, testServiceType, 100)
262 allNetworkServices := []*model.CreateNetworkServiceInfo{networkServiceCreate}
263 createClusterNetworkServiceQuery := createClusterNetworkServiceQuery(clusterEdgeID, allNetworkServices)
264
265 var createClusterNetworkServiceResponse struct {
266 CreateClusterNetworkServices []*model.ClusterNetworkServiceInfo
267 }
268
269 err := ResolverClient.Post(createClusterNetworkServiceQuery, &createClusterNetworkServiceResponse)
270
271 s.NoError(err)
272 s.NotNil(createClusterNetworkServiceResponse)
273 }
274
275 func (s *Suite) TestCreateClusterNetworkServiceInvalidIP() {
276 clusterEdgeID := clusterNetworkServiceEdgeID
277 testIP := "...."
278 networkServiceCreate := createNetworkServiceInput(testIP, testFamily, testServiceType, 100)
279 allNetworkServices := []*model.CreateNetworkServiceInfo{networkServiceCreate}
280 createClusterNetworkServiceQuery := createClusterNetworkServiceQuery(clusterEdgeID, allNetworkServices)
281
282 var createClusterNetworkServiceResponse struct {
283 CreateClusterNetworkServices []*model.ClusterNetworkServiceInfo
284 }
285
286 err := ResolverClient.Post(createClusterNetworkServiceQuery, &createClusterNetworkServiceResponse)
287
288 s.Error(err)
289 s.NotNil(createClusterNetworkServiceResponse)
290 }
291
292 func (s *Suite) TestCreateClusterNetworkServiceInvalidServiceType() {
293 clusterEdgeID := clusterNetworkServiceEdgeID
294 testServiceType := "domainnameserver"
295 networkServiceCreate := createNetworkServiceInput(testIP, testFamily, testServiceType, 100)
296 allNetworkServices := []*model.CreateNetworkServiceInfo{networkServiceCreate}
297 createClusterNetworkServiceQuery := createClusterNetworkServiceQuery(clusterEdgeID, allNetworkServices)
298
299 var createClusterNetworkServiceResponse struct {
300 CreateClusterNetworkServices []*model.ClusterNetworkServiceInfo
301 }
302
303 err := ResolverClient.Post(createClusterNetworkServiceQuery, &createClusterNetworkServiceResponse)
304
305 s.Error(err)
306 s.NotNil(createClusterNetworkServiceResponse)
307 }
308
309 func (s *Suite) TestCreateClusterNetworkServiceDuplicateIP() {
310 clusterEdgeID := clusterNetworkServiceEdgeID
311
312 networkServiceCreate := createNetworkServiceInput(testIP2, testFamily, testServiceType, 100)
313 allNetworkServices := []*model.CreateNetworkServiceInfo{networkServiceCreate}
314 createClusterNetworkServiceQuery := createClusterNetworkServiceQuery(clusterEdgeID, allNetworkServices)
315
316 var createClusterNetworkServiceResponse struct {
317 CreateClusterNetworkServices []*model.ClusterNetworkServiceInfo
318 }
319
320 err := ResolverClient.Post(createClusterNetworkServiceQuery, &createClusterNetworkServiceResponse)
321
322 s.Error(err)
323 s.NotNil(createClusterNetworkServiceResponse)
324 }
325
326 func (s *Suite) TestUpdateAndDeleteClusterNetworkService() {
327 clusterEdgeID := clusterNetworkServiceEdgeID
328 getCluster := getClusterNetworkServices(clusterEdgeID)
329
330 var getClusterResponse struct {
331 Cluster *model.Cluster
332 }
333
334 err := ResolverClient.Post(getCluster, &getClusterResponse)
335 s.NoError(err)
336
337 networkServiceID := getClusterResponse.Cluster.ClusterNetworkServices[0].NetworkServiceID
338 testNewIP := "216.239.35.4"
339 testNewFamily := testFamily
340 testNewPriority := 99
341 networkServiceUpdate := updateNetworkServiceInput(testNewIP, testNewFamily, networkServiceID, testNewPriority)
342 allNetworkServices := []*model.UpdateNetworkServiceInfo{networkServiceUpdate}
343 updateClusterNetworkServiceQuery := updateClusterNetworkServiceQuery(clusterEdgeID, allNetworkServices)
344
345 var updateClusterNetworkServiceResponse struct {
346 UpdateClusterNetworkServices []*model.ClusterNetworkServiceInfo
347 }
348
349 err = ResolverClient.Post(updateClusterNetworkServiceQuery, &updateClusterNetworkServiceResponse)
350
351 s.NoError(err)
352 s.NotNil(updateClusterNetworkServiceResponse)
353
354 s.Equal(updateClusterNetworkServiceResponse.UpdateClusterNetworkServices[0].NetworkServiceID, networkServiceID)
355 s.Equal(updateClusterNetworkServiceResponse.UpdateClusterNetworkServices[0].Family, testNewFamily)
356 s.Equal(updateClusterNetworkServiceResponse.UpdateClusterNetworkServices[0].IP, testNewIP)
357 s.Equal(*updateClusterNetworkServiceResponse.UpdateClusterNetworkServices[0].Priority, 99)
358
359 deleteClusterNetworkServiceQuery := deleteClusterNetworkServiceQuery(clusterEdgeID, networkServiceID)
360 var deleteClusterNetworkServiceResponse struct{ DeleteClusterNetworkService *bool }
361 err = ResolverClient.Post(deleteClusterNetworkServiceQuery, &deleteClusterNetworkServiceResponse)
362 s.NoError(err)
363 s.NotNil(deleteClusterNetworkServiceResponse)
364 s.True(*deleteClusterNetworkServiceResponse.DeleteClusterNetworkService)
365 }
366
367 func (s *Suite) TestUpdateAndDeleteK8sServiceSubnetWhenClusterActive() {
368 clusterEdgeID := clusterNetworkServiceEdgeID
369 networkServiceID := "f20e75ea-28b9-4f1d-8e79-ad871601261b"
370 cidr := "10.96.0.0/17"
371
372 networkServiceUpdate := updateNetworkServiceInput(cidr, testFamily, networkServiceID, 100)
373 allNetworkServices := []*model.UpdateNetworkServiceInfo{networkServiceUpdate}
374 updateClusterNetworkServiceQuery := updateClusterNetworkServiceQuery(clusterEdgeID, allNetworkServices)
375
376 var updateClusterNetworkServiceResponse struct {
377 UpdateClusterNetworkServices []*model.ClusterNetworkServiceInfo
378 }
379
380 err := ResolverClient.Post(updateClusterNetworkServiceQuery, &updateClusterNetworkServiceResponse)
381 s.ErrorContains(err, "cluster network service service-network-cidr cannot be updated after bootstrapping the first")
382 }
383
384 func (s *Suite) TestUpdateK8sServiceSubnetInvalidRangeLowerBound() {
385 clusterEdgeID := k8sServiceEdgeID
386 networkServiceID := serviceNetworkServiceID
387 cidr := "10.96.0.0/15"
388
389 networkServiceUpdate := updateNetworkServiceInput(cidr, testFamily, networkServiceID, 100)
390 allNetworkServices := []*model.UpdateNetworkServiceInfo{networkServiceUpdate}
391 updateClusterNetworkServiceQuery := updateClusterNetworkServiceQuery(clusterEdgeID, allNetworkServices)
392
393 var updateClusterNetworkServiceResponse struct {
394 UpdateClusterNetworkServices []*model.ClusterNetworkServiceInfo
395 }
396
397 err := ResolverClient.Post(updateClusterNetworkServiceQuery, &updateClusterNetworkServiceResponse)
398 s.ErrorContains(err, "invalid prefix length. Prefix length must be between /16 and /22 for k8s service network")
399 }
400
401 func (s *Suite) TestUpdateK8sServiceSubnetInvalidRangeUpperBound() {
402 clusterEdgeID := k8sServiceEdgeID
403 networkServiceID := serviceNetworkServiceID
404 cidr := "10.96.0.0/23"
405
406 networkServiceUpdate := updateNetworkServiceInput(cidr, testFamily, networkServiceID, 100)
407 allNetworkServices := []*model.UpdateNetworkServiceInfo{networkServiceUpdate}
408 updateClusterNetworkServiceQuery := updateClusterNetworkServiceQuery(clusterEdgeID, allNetworkServices)
409
410 var updateClusterNetworkServiceResponse struct {
411 UpdateClusterNetworkServices []*model.ClusterNetworkServiceInfo
412 }
413
414 err := ResolverClient.Post(updateClusterNetworkServiceQuery, &updateClusterNetworkServiceResponse)
415 s.ErrorContains(err, "invalid prefix length. Prefix length must be between /16 and /22 for k8s service network")
416 }
417
418 func (s *Suite) TestUpdateK8sPodSubnetInvalidRangeLowerBound() {
419 clusterEdgeID := k8sServiceEdgeID
420 networkServiceID := podNetworkServiceID
421 cidr := "100.127.0.0/15"
422
423 networkServiceUpdate := updateNetworkServiceInput(cidr, testFamily, networkServiceID, 100)
424 allNetworkServices := []*model.UpdateNetworkServiceInfo{networkServiceUpdate}
425 updateClusterNetworkServiceQuery := updateClusterNetworkServiceQuery(clusterEdgeID, allNetworkServices)
426
427 var updateClusterNetworkServiceResponse struct {
428 UpdateClusterNetworkServices []*model.ClusterNetworkServiceInfo
429 }
430
431 err := ResolverClient.Post(updateClusterNetworkServiceQuery, &updateClusterNetworkServiceResponse)
432 s.ErrorContains(err, "invalid prefix length. Prefix length must be between /16 and /21 for k8s pod network")
433 }
434
435 func (s *Suite) TestUpdateK8sPodSubnetInvalidRangeUpperBound() {
436 clusterEdgeID := k8sServiceEdgeID
437 networkServiceID := podNetworkServiceID
438 cidr := "100.127.0.0/22"
439
440 networkServiceUpdate := updateNetworkServiceInput(cidr, testFamily, networkServiceID, 100)
441 allNetworkServices := []*model.UpdateNetworkServiceInfo{networkServiceUpdate}
442 updateClusterNetworkServiceQuery := updateClusterNetworkServiceQuery(clusterEdgeID, allNetworkServices)
443
444 var updateClusterNetworkServiceResponse struct {
445 UpdateClusterNetworkServices []*model.ClusterNetworkServiceInfo
446 }
447
448 err := ResolverClient.Post(updateClusterNetworkServiceQuery, &updateClusterNetworkServiceResponse)
449 s.ErrorContains(err, "invalid prefix length. Prefix length must be between /16 and /21 for k8s pod network")
450 }
451
452 func (s *Suite) TestUpdateClusterPodNetworkService() {
453 clusterEdgeID := k8sServiceEdgeID
454 networkServiceID := podNetworkServiceID
455 podCidr := "100.156.0.0/16"
456
457 networkServiceUpdate := updateNetworkServiceInput(podCidr, testFamily, networkServiceID, 100)
458 allNetworkServices := []*model.UpdateNetworkServiceInfo{networkServiceUpdate}
459 updateClusterNetworkServiceQuery := updateClusterNetworkServiceQuery(clusterEdgeID, allNetworkServices)
460
461 var updateClusterNetworkServiceResponse struct {
462 UpdateClusterNetworkServices []*model.ClusterNetworkServiceInfo
463 }
464
465 err = ResolverClient.Post(updateClusterNetworkServiceQuery, &updateClusterNetworkServiceResponse)
466 s.NoError(err)
467 s.NotNil(updateClusterNetworkServiceResponse)
468 }
469
470 func (s *Suite) TestForbiddenNetServiceDeletion() {
471 clusterEdgeID := k8sServiceEdgeID
472 networkServiceID := podNetworkServiceID
473
474 deleteClusterNetworkServiceQuery := deleteClusterNetworkServiceQuery(clusterEdgeID, networkServiceID)
475 var deleteClusterNetworkServiceResponse struct{ DeleteClusterNetworkService *bool }
476
477 err = ResolverClient.Post(deleteClusterNetworkServiceQuery, &deleteClusterNetworkServiceResponse)
478 s.ErrorContains(err, fmt.Sprintf("adhoc deletion of the %s is forbidden", constants.ServiceTypePodNetworkCIDR))
479 }
480
481 func (s *Suite) TestInvalidK8sSubnetOverlap() {
482 clusterEdgeID := k8sServiceEdgeID
483 podNetworkServiceType := constants.ServiceTypePodNetworkCIDR
484 serviceNetworkServiceType := constants.ServiceTypeServiceNetworkCIDR
485 networkServiceID := podNetworkServiceID
486 podCidr := "10.96.0.0/16"
487
488 networkServiceUpdate := updateNetworkServiceInput(podCidr, testFamily, networkServiceID, 100)
489 allNetworkServices := []*model.UpdateNetworkServiceInfo{networkServiceUpdate}
490 updateClusterNetworkServiceQuery := updateClusterNetworkServiceQuery(clusterEdgeID, allNetworkServices)
491
492 var updateClusterNetworkServiceResponse struct {
493 UpdateClusterNetworkServices []*model.ClusterNetworkServiceInfo
494 }
495
496 err = ResolverClient.Post(updateClusterNetworkServiceQuery, &updateClusterNetworkServiceResponse)
497 s.ErrorContains(err, fmt.Sprintf("invalid subnet - %s must not overlap with %s", podNetworkServiceType, serviceNetworkServiceType))
498 }
499
500 func (s *Suite) TestValidIPNotASubnet() {
501 clusterEdgeID := k8sServiceEdgeID
502 serviceType := constants.ServiceTypeServiceNetworkCIDR
503 networkServiceID := serviceNetworkServiceID
504 serviceCidr := "10.96.0.0"
505
506 networkServiceUpdate := updateNetworkServiceInput(serviceCidr, testFamily, networkServiceID, 100)
507 allNetworkServices := []*model.UpdateNetworkServiceInfo{networkServiceUpdate}
508 updateClusterNetworkServiceQuery := updateClusterNetworkServiceQuery(clusterEdgeID, allNetworkServices)
509
510 var updateClusterNetworkServiceResponse struct {
511 UpdateClusterNetworkServices []*model.ClusterNetworkServiceInfo
512 }
513
514 err = ResolverClient.Post(updateClusterNetworkServiceQuery, &updateClusterNetworkServiceResponse)
515 s.ErrorContains(err, fmt.Sprintf("invalid CIDR address %s for %s", serviceCidr, serviceType))
516 }
517
518 func (s *Suite) TestUpdateK8sNetworkServiceInvalid() {
519 clusterEdgeID := k8sServiceEdgeID
520 networkServiceID := "1c67eeb0-e1c4-4a8a-b9e1-46233ef5ad33"
521 serviceType := constants.ServiceTypePodNetworkCIDR
522 cidr := "not-a-cidr-subnet"
523
524 networkServiceUpdate := updateNetworkServiceInput(cidr, testFamily, networkServiceID, 100)
525 allNetworkServices := []*model.UpdateNetworkServiceInfo{networkServiceUpdate}
526 updateClusterNetworkServiceQuery := updateClusterNetworkServiceQuery(clusterEdgeID, allNetworkServices)
527
528 var updateClusterNetworkServiceResponse struct {
529 UpdateClusterNetworkServices []*model.ClusterNetworkServiceInfo
530 }
531
532 err := ResolverClient.Post(updateClusterNetworkServiceQuery, &updateClusterNetworkServiceResponse)
533 s.ErrorContains(err, fmt.Sprintf("invalid CIDR address %s for %s", cidr, serviceType))
534 }
535
536 func (s *Suite) TestUpdateK8sClusterDNSNotPermitted() {
537 clusterEdgeID := k8sServiceEdgeID
538 networkServiceID := "7fa65f85-1856-4c8e-90e5-a68c410a6c0d"
539 serviceType := constants.ServiceTypeClusterDNS
540 cidr := "100.127.0.0/23"
541
542 networkServiceUpdate := updateNetworkServiceInput(cidr, testFamily, networkServiceID, 100)
543 allNetworkServices := []*model.UpdateNetworkServiceInfo{networkServiceUpdate}
544 updateClusterNetworkServiceQuery := updateClusterNetworkServiceQuery(clusterEdgeID, allNetworkServices)
545
546 var updateClusterNetworkServiceResponse struct {
547 UpdateClusterNetworkServices []*model.ClusterNetworkServiceInfo
548 }
549
550 err := ResolverClient.Post(updateClusterNetworkServiceQuery, &updateClusterNetworkServiceResponse)
551 s.ErrorContains(err, fmt.Sprintf("cluster network service %s is not configurable", serviceType))
552 }
553
554 func (s *Suite) TestUpdateClusterNetworkServiceDuplicateIP() {
555 clusterEdgeID := clusterNetworkServiceEdgeID
556 testExistingIP := testIP3
557 networkServiceUpdate := updateNetworkServiceInput(testExistingIP, testFamily, dnsNetworkServiceID2, 100)
558
559 allNetworkServicesUpdate := []*model.UpdateNetworkServiceInfo{networkServiceUpdate}
560 updateClusterNetworkServiceQuery := updateClusterNetworkServiceQuery(clusterEdgeID, allNetworkServicesUpdate)
561
562 var updateClusterNetworkServiceResponse struct {
563 UpdateClusterNetworkServices []*model.ClusterNetworkServiceInfo
564 }
565
566 err = ResolverClient.Post(updateClusterNetworkServiceQuery, &updateClusterNetworkServiceResponse)
567 s.Error(err)
568 s.ErrorContains(err, fmt.Sprintf("IP address %s already exists for %s", testExistingIP, testServiceType))
569 }
570
571 func (s *Suite) TestCreateUpdateDeleteGetClusterConfig() {
572 configClusterEdgeID := "3396a52c-6a22-4049-9593-5a63b596a201"
573
574 var responseCreate struct {
575 CreateClusterConfig model.ClusterConfig
576 }
577
578 createClusterConfig := model.CreateClusterConfig{
579 AcRelay: &trueValue,
580 PxeEnabled: &falseValue,
581 BootstrapAck: &falseValue,
582 VpnEnabled: &trueValue,
583 ThickPos: &trueValue,
584 EgressGatewayEnabled: &trueValue,
585 }
586
587 createClusterConfigMutation := createClusterConfigMutation(configClusterEdgeID, createClusterConfig)
588 err := ResolverClient.Post(createClusterConfigMutation, &responseCreate)
589
590 s.NoError(err)
591 s.NotEmpty(responseCreate.CreateClusterConfig)
592 s.True(responseCreate.CreateClusterConfig.AcRelay)
593 s.False(responseCreate.CreateClusterConfig.PxeEnabled)
594 s.False(responseCreate.CreateClusterConfig.BootstrapAck)
595 s.True(responseCreate.CreateClusterConfig.VpnEnabled)
596 s.True(responseCreate.CreateClusterConfig.ThickPos)
597 s.True(responseCreate.CreateClusterConfig.EgressGatewayEnabled)
598
599 var responseUpdate struct {
600 UpdateClusterConfig model.ClusterConfig
601 }
602
603 config := model.UpdateClusterConfig{
604 AcRelay: &falseValue,
605 PxeEnabled: &trueValue,
606 BootstrapAck: &falseValue,
607 ThickPos: &falseValue,
608 VpnEnabled: &trueValue,
609 EgressGatewayEnabled: &falseValue,
610 }
611
612 updateClusterConfig := updateClusterConfigMutation(configClusterEdgeID, config)
613 err = ResolverClient.Post(updateClusterConfig, &responseUpdate)
614
615 s.NoError(err)
616 s.False(responseUpdate.UpdateClusterConfig.AcRelay)
617 s.True(responseUpdate.UpdateClusterConfig.PxeEnabled)
618 s.False(responseUpdate.UpdateClusterConfig.BootstrapAck)
619 s.False(responseUpdate.UpdateClusterConfig.ThickPos)
620 s.True(responseUpdate.UpdateClusterConfig.VpnEnabled)
621 s.False(responseUpdate.UpdateClusterConfig.EgressGatewayEnabled)
622
623 var responseGet struct {
624 ClusterConfig *model.ClusterConfig
625 }
626
627 getClusterConfigQuery := getClusterConfigQuery(configClusterEdgeID)
628 err = ResolverClient.Post(getClusterConfigQuery, &responseGet)
629
630 s.NoError(err)
631 s.NotEmpty(responseGet.ClusterConfig)
632 s.False(responseGet.ClusterConfig.AcRelay)
633 s.True(responseGet.ClusterConfig.PxeEnabled)
634 s.False(responseGet.ClusterConfig.BootstrapAck)
635 s.False(responseGet.ClusterConfig.ThickPos)
636 s.True(responseGet.ClusterConfig.VpnEnabled)
637 s.False(responseGet.ClusterConfig.EgressGatewayEnabled)
638 }
639
640 func (s *Suite) TestGetEventsForCluster() {
641 integration.SkipIf(s.Framework)
642
643
644 query := clusterQuery("3396a52c-6a22-4049-9593-5a63b596a200")
645 var response struct{ Cluster *model.Cluster }
646 ResolverClient.MustPost(query, &response)
647 err := ResolverClient.Post(query, &response)
648
649 s.NoError(err)
650 s.NotNil(response.Cluster.Status.Events)
651 s.Equal(2, len(response.Cluster.Status.Events))
652
653 for _, event := range response.Cluster.Status.Events {
654 s.NotEmpty(event.EventEdgeID)
655 s.NotEmpty(event.Name)
656 s.NotNil(event.InvolvedObject)
657 s.NotEmpty(event.InvolvedObject.Kind)
658 s.NotEmpty(event.InvolvedObject.Name)
659 s.NotEmpty(event.Reason)
660 s.NotEmpty(event.Message)
661 s.NotEmpty(event.Source)
662 s.NotEmpty(event.Status)
663 s.NotEmpty(event.ClusterEdgeID)
664 s.NotEmpty(event.CreatedAt)
665 }
666 }
667
668 func siteQuery(clusterEdgeID string) string {
669 args := []graphb.Argument{
670 graphb.ArgumentString("clusterEdgeID", clusterEdgeID),
671 }
672 return MustParse(graphb.Query{
673 Type: graphb.TypeQuery,
674 Fields: []*graphb.Field{
675 {
676 Name: "site",
677 Arguments: args,
678 Fields: []*graphb.Field{
679 graphb.NewField("organizationName"),
680 graphb.NewField("id"),
681 graphb.NewField("status"),
682 graphb.NewField("siteName"),
683 graphb.NewField("enterpriseUnitName"),
684 graphb.NewField("coordinates", graphb.OfFields(
685 "latitude",
686 "longitude",
687 )),
688 graphb.NewField("enterpriseSettings", graphb.OfFields(
689 "enterpriseUnitId",
690 )),
691 graphb.NewField("dayparts", graphb.OfFields(
692 "description",
693 "startTime",
694 "endTime",
695 "name",
696 )),
697 },
698 },
699 },
700 })
701 }
702
703 func updateSiteQuery(clusterEdgeID string) string {
704 args := []graphb.Argument{
705 graphb.ArgumentString("clusterEdgeId", clusterEdgeID),
706 graphb.ArgumentCustomType("site",
707 graphb.ArgumentString("siteName", "test-store"),
708 graphb.ArgumentString("status", "ACTIVE"),
709 graphb.ArgumentString("enterpriseUnitName", "test-enterprise-unit-name"),
710 graphb.ArgumentString("description", "test site description"),
711 graphb.ArgumentCustomType("coordinates",
712 graphb.ArgumentInt("latitude", 90.0),
713 graphb.ArgumentInt("longitude", 180.0),
714 ),
715 ),
716 }
717 return MustParse(graphb.Query{
718 Type: graphb.TypeMutation,
719 Fields: []*graphb.Field{
720 {
721 Name: "updateSite",
722 Arguments: args,
723 Fields: []*graphb.Field{
724 graphb.NewField("organizationName"),
725 graphb.NewField("id"),
726 graphb.NewField("status"),
727 graphb.NewField("siteName"),
728 graphb.NewField("enterpriseUnitName"),
729 graphb.NewField("coordinates", graphb.OfFields(
730 "latitude",
731 "longitude",
732 )),
733 graphb.NewField("enterpriseSettings", graphb.OfFields(
734 "enterpriseUnitId",
735 )),
736 graphb.NewField("dayparts", graphb.OfFields(
737 "description",
738 "startTime",
739 "endTime",
740 "name",
741 )),
742 },
743 },
744 },
745 })
746 }
747
748 func storeStatus(clusterEdgeID string) string {
749 args := []graphb.Argument{
750 graphb.ArgumentString("clusterEdgeId", clusterEdgeID),
751 }
752 return MustParse(graphb.Query{
753 Type: graphb.TypeQuery,
754 Fields: []*graphb.Field{
755 {
756 Name: "storeStatus",
757 Arguments: args,
758 Fields: []*graphb.Field{
759 graphb.NewField("name"),
760 graphb.NewField("bannerEdgeId"),
761 graphb.NewField("status", graphb.OfFields(
762 "status",
763 "message",
764 )),
765 graphb.NewField("kubeVersion"),
766 {
767 Name: "bucketStatus",
768 Fields: []*graphb.Field{
769 graphb.NewField("excludes"),
770 graphb.NewField("bucketName"),
771 graphb.NewField("fluxStatus", graphb.OfFields("name", "error", "lastUpdated", "revision", "statusMessage", "suspended"))},
772 },
773 {
774 Name: "kustomizationStatus",
775 Fields: []*graphb.Field{
776 graphb.NewField("path"),
777 graphb.NewField("source"),
778 graphb.NewField("fluxStatus", graphb.OfFields("name", "error", "lastUpdated", "revision", "statusMessage", "suspended"))},
779 },
780 },
781 },
782 },
783 })
784 }
785
786 func deleteClusterQuery(clusterEdgeID string, deleteBslSite bool) string {
787 args := []graphb.Argument{
788 graphb.ArgumentString("clusterEdgeId", clusterEdgeID),
789 graphb.ArgumentBool("deleteBSLSite", deleteBslSite),
790 }
791 return MustParse(graphb.Query{
792 Type: graphb.TypeMutation,
793 Fields: []*graphb.Field{
794 {
795 Name: "deleteCluster",
796 Arguments: args,
797 },
798 },
799 })
800 }
801
802 func deleteClustersQuery(clusterEdgeIDs []string, deleteBslSite bool) string {
803 args := []graphb.Argument{
804 graphb.ArgumentStringSlice("clusterEdgeIds", clusterEdgeIDs...),
805 graphb.ArgumentBool("deleteBSLSite", deleteBslSite),
806 }
807 return MustParse(graphb.Query{
808 Type: graphb.TypeMutation,
809 Fields: []*graphb.Field{
810 {
811 Name: "deleteClusters",
812 Arguments: args,
813 },
814 },
815 })
816 }
817
818 func deleteClusterNetworkServiceQuery(clusterEdgeID, networkServiceID string) string {
819 args := []graphb.Argument{
820 graphb.ArgumentString("clusterEdgeId", clusterEdgeID),
821 graphb.ArgumentString("networkServiceId", networkServiceID),
822 }
823 return MustParse(graphb.Query{
824 Type: graphb.TypeMutation,
825 Fields: []*graphb.Field{
826 {
827 Name: "deleteClusterNetworkService",
828 Arguments: args,
829 },
830 },
831 })
832 }
833
834 func createNetworkServiceInput(ip, family, serviceType string, priority int) *model.CreateNetworkServiceInfo {
835 return &model.CreateNetworkServiceInfo{
836 IP: ip,
837 Family: family,
838 ServiceType: serviceType,
839 Priority: &priority,
840 }
841 }
842
843 func createClusterNetworkServiceQuery(clusterEdgeID string, clusterNetworkServices []*model.CreateNetworkServiceInfo) string {
844 arguments := make([][]graphb.Argument, 0, len(clusterNetworkServices))
845 for _, networkService := range clusterNetworkServices {
846 newNetworkServiceArgument := graphb.ArgumentCustomTypeSliceElem(
847 graphb.ArgumentString("serviceType", networkService.ServiceType),
848 graphb.ArgumentString("ip", networkService.IP),
849 graphb.ArgumentString("family", networkService.Family),
850 graphb.ArgumentInt("priority", *networkService.Priority),
851 )
852 arguments = append(arguments, newNetworkServiceArgument)
853 }
854
855 args := []graphb.Argument{
856 graphb.ArgumentString("clusterEdgeId", clusterEdgeID),
857 graphb.ArgumentCustomTypeSlice("networkServicesInfo", arguments...),
858 }
859
860 return MustParse(graphb.Query{
861 Type: graphb.TypeMutation,
862 Fields: []*graphb.Field{
863 {
864 Name: "createClusterNetworkServices",
865 Arguments: args,
866 Fields: []*graphb.Field{
867 graphb.NewField("serviceType"),
868 graphb.NewField("ip"),
869 graphb.NewField("family"),
870 graphb.NewField("priority"),
871 },
872 },
873 },
874 })
875 }
876
877 func getClusterNetworkServices(clusterEdgeID string) string {
878 args := []graphb.Argument{
879 graphb.ArgumentString("clusterEdgeId", clusterEdgeID),
880 }
881 return MustParse(graphb.Query{
882 Type: graphb.TypeQuery,
883 Fields: []*graphb.Field{
884 {
885 Name: "cluster",
886 Arguments: args,
887 Fields: []*graphb.Field{
888 {
889 Name: "clusterNetworkServices",
890 Fields: []*graphb.Field{
891 graphb.NewField("networkServiceId"),
892 graphb.NewField("ip"),
893 graphb.NewField("family"),
894 graphb.NewField("serviceType"),
895 graphb.NewField("priority")},
896 },
897 {
898 Name: "clusterEdgeId",
899 },
900 {
901 Name: "name",
902 },
903 },
904 },
905 },
906 })
907 }
908
909 func updateNetworkServiceInput(ip, family, networkServiceID string, priority int) *model.UpdateNetworkServiceInfo {
910 return &model.UpdateNetworkServiceInfo{
911 NetworkServiceID: networkServiceID,
912 IP: ip,
913 Family: family,
914 Priority: &priority,
915 }
916 }
917
918 func updateClusterNetworkServiceQuery(clusterEdgeID string, clusterNetworkServices []*model.UpdateNetworkServiceInfo) string {
919 arguments := make([][]graphb.Argument, 0, len(clusterNetworkServices))
920 for _, networkService := range clusterNetworkServices {
921 newNetworkServiceArgument := graphb.ArgumentCustomTypeSliceElem(
922 graphb.ArgumentString("networkServiceId", networkService.NetworkServiceID),
923 graphb.ArgumentString("ip", networkService.IP),
924 graphb.ArgumentString("family", networkService.Family),
925 graphb.ArgumentInt("priority", *networkService.Priority),
926 )
927 arguments = append(arguments, newNetworkServiceArgument)
928 }
929
930 args := []graphb.Argument{
931 graphb.ArgumentString("clusterEdgeId", clusterEdgeID),
932 graphb.ArgumentCustomTypeSlice("networkServicesInfo", arguments...),
933 }
934
935 return MustParse(graphb.Query{
936 Type: graphb.TypeMutation,
937 Fields: []*graphb.Field{
938 {
939 Name: "updateClusterNetworkServices",
940 Arguments: args,
941 Fields: []*graphb.Field{
942 graphb.NewField("networkServiceId"),
943 graphb.NewField("serviceType"),
944 graphb.NewField("ip"),
945 graphb.NewField("family"),
946 graphb.NewField("priority"),
947 },
948 },
949 },
950 })
951 }
952
953 func updateClusterName(clusterEdgeID string, name string) string {
954 args := []graphb.Argument{
955 graphb.ArgumentString("clusterEdgeId", clusterEdgeID),
956 graphb.ArgumentString("name", name),
957 }
958 return MustParse(graphb.Query{
959 Type: graphb.TypeMutation,
960 Fields: []*graphb.Field{
961 {
962 Name: "updateClusterName",
963 Arguments: args,
964 Fields: []*graphb.Field{
965 graphb.NewField("clusterEdgeId"),
966 graphb.NewField("name"),
967 graphb.NewField("projectId"),
968 graphb.NewField("bannerEdgeId"),
969 graphb.NewField("registered"),
970 graphb.NewField("active"),
971 graphb.NewField("labels", graphb.OfFields(
972 "labelEdgeId",
973 "key",
974 "type",
975 )),
976 graphb.NewField("bslSiteID"),
977 },
978 },
979 },
980 })
981 }
982
983 func updateClusterFleetVersion(clusterEdgeID, fleetVersion string) string {
984 args := []graphb.Argument{
985 graphb.ArgumentString("clusterEdgeId", clusterEdgeID),
986 graphb.ArgumentString("fleetVersion", fleetVersion),
987 }
988 return MustParse(graphb.Query{
989 Type: graphb.TypeMutation,
990 Fields: []*graphb.Field{
991 {
992 Name: "updateClusterFleetVersion",
993 Arguments: args,
994 Fields: []*graphb.Field{
995 graphb.NewField("clusterEdgeId"),
996 graphb.NewField("name"),
997 graphb.NewField("projectId"),
998 graphb.NewField("bannerEdgeId"),
999 graphb.NewField("registered"),
1000 graphb.NewField("active"),
1001 graphb.NewField("labels", graphb.OfFields(
1002 "labelEdgeId",
1003 "key",
1004 "type",
1005 )),
1006 graphb.NewField("bslSiteID"),
1007 graphb.NewField("fleetVersion"),
1008 },
1009 },
1010 },
1011 })
1012 }
1013
1014 func clusterQuery(clusterEdgeID string) string {
1015 return MustParse(graphb.Query{
1016 Type: graphb.TypeQuery,
1017 Fields: []*graphb.Field{
1018 {
1019 Name: "cluster",
1020 Arguments: []graphb.Argument{
1021 graphb.ArgumentString("clusterEdgeId", clusterEdgeID),
1022 },
1023 Fields: []*graphb.Field{
1024 graphb.NewField("clusterEdgeId"),
1025 graphb.NewField("name"),
1026 graphb.NewField("projectId"),
1027 graphb.NewField("bannerEdgeId"),
1028 graphb.NewField("registered"),
1029 graphb.NewField("active"),
1030 graphb.NewField("labels", graphb.OfFields(
1031 "labelEdgeId",
1032 "key",
1033 "type",
1034 )),
1035 graphb.NewField("bslSiteID"),
1036 graphb.NewField("status").SetFields(
1037 graphb.NewField("events").SetFields(
1038 graphb.NewField("involvedObject", graphb.OfFields("kind", "name")),
1039 graphb.NewField("eventEdgeID"),
1040 graphb.NewField("name"),
1041 graphb.NewField("clusterEdgeID"),
1042 graphb.NewField("reason"),
1043 graphb.NewField("message"),
1044 graphb.NewField("status"),
1045 graphb.NewField("source"),
1046 graphb.NewField("createdAt"),
1047 ),
1048 ),
1049 },
1050 },
1051 },
1052 })
1053 }
1054
1055 func clustersQuery(bannerEdgeID string, labels []string) string {
1056 return MustParse(graphb.Query{
1057 Type: graphb.TypeQuery,
1058 Fields: []*graphb.Field{
1059 {
1060 Name: "clusters",
1061 Arguments: []graphb.Argument{
1062 graphb.ArgumentString("bannerEdgeId", bannerEdgeID),
1063 graphb.ArgumentStringSlice("labels", labels...),
1064 },
1065 Fields: []*graphb.Field{
1066 graphb.NewField("clusterEdgeId"),
1067 graphb.NewField("name"),
1068 graphb.NewField("projectId"),
1069 graphb.NewField("bannerEdgeId"),
1070 graphb.NewField("registered"),
1071 graphb.NewField("active"),
1072 graphb.NewField("labels", graphb.OfFields(
1073 "labelEdgeId",
1074 "key",
1075 "type",
1076 )),
1077 graphb.NewField("bslSiteID"),
1078 },
1079 },
1080 },
1081 })
1082 }
1083
1084 func createClusterConfigMutation(clusterEdgeID string, createClusterConfig model.CreateClusterConfig) string {
1085 config := graphb.ArgumentCustomTypeSliceElem(
1086 graphb.ArgumentBool("acRelay", *createClusterConfig.AcRelay),
1087 graphb.ArgumentBool("pxeEnabled", *createClusterConfig.PxeEnabled),
1088 graphb.ArgumentBool("bootstrapAck", *createClusterConfig.BootstrapAck),
1089 graphb.ArgumentBool("vpnEnabled", *createClusterConfig.VpnEnabled),
1090 graphb.ArgumentBool("thickPos", *createClusterConfig.ThickPos),
1091 graphb.ArgumentBool("egressGatewayEnabled", *createClusterConfig.EgressGatewayEnabled),
1092 )
1093 args := []graphb.Argument{
1094 graphb.ArgumentString("clusterEdgeId", clusterEdgeID),
1095 graphb.ArgumentCustomType("createClusterConfig", config...),
1096 }
1097 return MustParse(graphb.Query{
1098 Type: graphb.TypeMutation,
1099 Fields: []*graphb.Field{
1100 {
1101 Name: "createClusterConfig",
1102 Arguments: args,
1103 Fields: []*graphb.Field{
1104 graphb.NewField("clusterEdgeId"),
1105 graphb.NewField("acRelay"),
1106 graphb.NewField("pxeEnabled"),
1107 graphb.NewField("bootstrapAck"),
1108 graphb.NewField("vpnEnabled"),
1109 graphb.NewField("thickPos"),
1110 graphb.NewField("egressGatewayEnabled"),
1111 },
1112 },
1113 },
1114 })
1115 }
1116
1117 func updateClusterConfigMutation(clusterEdgeID string, updateClusterConfig model.UpdateClusterConfig) string {
1118 config := graphb.ArgumentCustomTypeSliceElem(
1119 graphb.ArgumentBool("acRelay", utils.ConvertToBool(updateClusterConfig.AcRelay)),
1120 graphb.ArgumentBool("pxeEnabled", utils.ConvertToBool(updateClusterConfig.PxeEnabled)),
1121 graphb.ArgumentBool("bootstrapAck", utils.ConvertToBool(updateClusterConfig.BootstrapAck)),
1122 graphb.ArgumentBool("vpnEnabled", utils.ConvertToBool(updateClusterConfig.VpnEnabled)),
1123 graphb.ArgumentBool("thickPos", utils.ConvertToBool(updateClusterConfig.ThickPos)),
1124 graphb.ArgumentBool("egressGatewayEnabled", utils.ConvertToBool(updateClusterConfig.EgressGatewayEnabled)),
1125 )
1126 args := []graphb.Argument{
1127 graphb.ArgumentString("clusterEdgeId", clusterEdgeID),
1128 graphb.ArgumentCustomType("updateClusterConfig", config...),
1129 }
1130 return MustParse(graphb.Query{
1131 Type: graphb.TypeMutation,
1132 Fields: []*graphb.Field{
1133 {
1134 Name: "updateClusterConfig",
1135 Arguments: args,
1136 Fields: []*graphb.Field{
1137 graphb.NewField("clusterEdgeId"),
1138 graphb.NewField("acRelay"),
1139 graphb.NewField("pxeEnabled"),
1140 graphb.NewField("bootstrapAck"),
1141 graphb.NewField("vpnEnabled"),
1142 graphb.NewField("thickPos"),
1143 graphb.NewField("egressGatewayEnabled"),
1144 },
1145 },
1146 },
1147 })
1148 }
1149
1150 func getClusterConfigQuery(clusterEdgeID string) string {
1151 args := []graphb.Argument{
1152 graphb.ArgumentString("clusterEdgeId", clusterEdgeID),
1153 }
1154 return MustParse(graphb.Query{
1155 Type: graphb.TypeQuery,
1156 Fields: []*graphb.Field{
1157 {
1158 Name: "clusterConfig",
1159 Arguments: args,
1160 Fields: []*graphb.Field{
1161 graphb.NewField("clusterEdgeId"),
1162 graphb.NewField("acRelay"),
1163 graphb.NewField("pxeEnabled"),
1164 graphb.NewField("bootstrapAck"),
1165 graphb.NewField("vpnEnabled"),
1166 graphb.NewField("thickPos"),
1167 graphb.NewField("egressGatewayEnabled"),
1168 },
1169 },
1170 },
1171 })
1172 }
1173
View as plain text