operations.go raw
1 // Package v3 provides primitives to interact with the openapi HTTP API.
2 //
3 // Code generated by github.com/egoscale/v3/generator version v0.0.1 DO NOT EDIT.
4 package v3
5
6 import (
7 "context"
8 "fmt"
9 "net"
10 "net/http"
11 "net/url"
12 "time"
13 )
14
15 // FindListDeploymentsResponseEntry attempts to find an ListDeploymentsResponseEntry by nameOrID.
16 func (l ListDeploymentsResponse) FindListDeploymentsResponseEntry(nameOrID string) (ListDeploymentsResponseEntry, error) {
17 var result []ListDeploymentsResponseEntry
18 for i, elem := range l.Deployments {
19 if string(elem.Name) == nameOrID || string(elem.ID) == nameOrID {
20 result = append(result, l.Deployments[i])
21 }
22 }
23 if len(result) == 1 {
24 return result[0], nil
25 }
26
27 if len(result) > 1 {
28 return ListDeploymentsResponseEntry{}, fmt.Errorf("%q too many found in ListDeploymentsResponse: %w", nameOrID, ErrConflict)
29 }
30
31 return ListDeploymentsResponseEntry{}, fmt.Errorf("%q not found in ListDeploymentsResponse: %w", nameOrID, ErrNotFound)
32 }
33
34 // [BETA] List Deployments
35 func (c Client) ListDeployments(ctx context.Context) (*ListDeploymentsResponse, error) {
36 path := "/ai/deployment"
37
38 request, err := http.NewRequestWithContext(ctx, "GET", c.serverEndpoint+path, nil)
39 if err != nil {
40 return nil, fmt.Errorf("ListDeployments: new request: %w", err)
41 }
42
43 request.Header.Add("User-Agent", c.getUserAgent())
44
45 if err := c.executeRequestInterceptors(ctx, request); err != nil {
46 return nil, fmt.Errorf("ListDeployments: execute request editors: %w", err)
47 }
48
49 if err := c.signRequest(request); err != nil {
50 return nil, fmt.Errorf("ListDeployments: sign request: %w", err)
51 }
52
53 if c.trace {
54 dumpRequest(request, "list-deployments")
55 }
56
57 response, err := c.httpClient.Do(request)
58 if err != nil {
59 return nil, fmt.Errorf("ListDeployments: http client do: %w", err)
60 }
61
62 if c.trace {
63 dumpResponse(response)
64 }
65
66 if err := handleHTTPErrorResp(response); err != nil {
67 return nil, fmt.Errorf("ListDeployments: http response: %w", err)
68 }
69
70 bodyresp := new(ListDeploymentsResponse)
71 if err := prepareJSONResponse(response, bodyresp); err != nil {
72 return nil, fmt.Errorf("ListDeployments: prepare Json response: %w", err)
73 }
74
75 return bodyresp, nil
76 }
77
78 // Deploy a model on an inference server
79 func (c Client) CreateDeployment(ctx context.Context, req CreateDeploymentRequest) (*Operation, error) {
80 path := "/ai/deployment"
81
82 body, err := prepareJSONBody(req)
83 if err != nil {
84 return nil, fmt.Errorf("CreateDeployment: prepare Json body: %w", err)
85 }
86
87 request, err := http.NewRequestWithContext(ctx, "POST", c.serverEndpoint+path, body)
88 if err != nil {
89 return nil, fmt.Errorf("CreateDeployment: new request: %w", err)
90 }
91
92 request.Header.Add("User-Agent", c.getUserAgent())
93
94 request.Header.Add("Content-Type", "application/json")
95
96 if err := c.executeRequestInterceptors(ctx, request); err != nil {
97 return nil, fmt.Errorf("CreateDeployment: execute request editors: %w", err)
98 }
99
100 if err := c.signRequest(request); err != nil {
101 return nil, fmt.Errorf("CreateDeployment: sign request: %w", err)
102 }
103
104 if c.trace {
105 dumpRequest(request, "create-deployment")
106 }
107
108 response, err := c.httpClient.Do(request)
109 if err != nil {
110 return nil, fmt.Errorf("CreateDeployment: http client do: %w", err)
111 }
112
113 if c.trace {
114 dumpResponse(response)
115 }
116
117 if err := handleHTTPErrorResp(response); err != nil {
118 return nil, fmt.Errorf("CreateDeployment: http response: %w", err)
119 }
120
121 bodyresp := new(Operation)
122 if err := prepareJSONResponse(response, bodyresp); err != nil {
123 return nil, fmt.Errorf("CreateDeployment: prepare Json response: %w", err)
124 }
125
126 return bodyresp, nil
127 }
128
129 // [BETA] Delete Deployment
130 func (c Client) DeleteDeployment(ctx context.Context, id UUID) (*Operation, error) {
131 path := fmt.Sprintf("/ai/deployment/%v", id)
132
133 request, err := http.NewRequestWithContext(ctx, "DELETE", c.serverEndpoint+path, nil)
134 if err != nil {
135 return nil, fmt.Errorf("DeleteDeployment: new request: %w", err)
136 }
137
138 request.Header.Add("User-Agent", c.getUserAgent())
139
140 if err := c.executeRequestInterceptors(ctx, request); err != nil {
141 return nil, fmt.Errorf("DeleteDeployment: execute request editors: %w", err)
142 }
143
144 if err := c.signRequest(request); err != nil {
145 return nil, fmt.Errorf("DeleteDeployment: sign request: %w", err)
146 }
147
148 if c.trace {
149 dumpRequest(request, "delete-deployment")
150 }
151
152 response, err := c.httpClient.Do(request)
153 if err != nil {
154 return nil, fmt.Errorf("DeleteDeployment: http client do: %w", err)
155 }
156
157 if c.trace {
158 dumpResponse(response)
159 }
160
161 if err := handleHTTPErrorResp(response); err != nil {
162 return nil, fmt.Errorf("DeleteDeployment: http response: %w", err)
163 }
164
165 bodyresp := new(Operation)
166 if err := prepareJSONResponse(response, bodyresp); err != nil {
167 return nil, fmt.Errorf("DeleteDeployment: prepare Json response: %w", err)
168 }
169
170 return bodyresp, nil
171 }
172
173 // [BETA] Get Deployment
174 func (c Client) GetDeployment(ctx context.Context, id UUID) (*GetDeploymentResponse, error) {
175 path := fmt.Sprintf("/ai/deployment/%v", id)
176
177 request, err := http.NewRequestWithContext(ctx, "GET", c.serverEndpoint+path, nil)
178 if err != nil {
179 return nil, fmt.Errorf("GetDeployment: new request: %w", err)
180 }
181
182 request.Header.Add("User-Agent", c.getUserAgent())
183
184 if err := c.executeRequestInterceptors(ctx, request); err != nil {
185 return nil, fmt.Errorf("GetDeployment: execute request editors: %w", err)
186 }
187
188 if err := c.signRequest(request); err != nil {
189 return nil, fmt.Errorf("GetDeployment: sign request: %w", err)
190 }
191
192 if c.trace {
193 dumpRequest(request, "get-deployment")
194 }
195
196 response, err := c.httpClient.Do(request)
197 if err != nil {
198 return nil, fmt.Errorf("GetDeployment: http client do: %w", err)
199 }
200
201 if c.trace {
202 dumpResponse(response)
203 }
204
205 if err := handleHTTPErrorResp(response); err != nil {
206 return nil, fmt.Errorf("GetDeployment: http response: %w", err)
207 }
208
209 bodyresp := new(GetDeploymentResponse)
210 if err := prepareJSONResponse(response, bodyresp); err != nil {
211 return nil, fmt.Errorf("GetDeployment: prepare Json response: %w", err)
212 }
213
214 return bodyresp, nil
215 }
216
217 // [BETA] Reveal Deployment API Key
218 func (c Client) RevealDeploymentAPIKey(ctx context.Context, id UUID) (*RevealDeploymentAPIKeyResponse, error) {
219 path := fmt.Sprintf("/ai/deployment/%v/api-key", id)
220
221 request, err := http.NewRequestWithContext(ctx, "GET", c.serverEndpoint+path, nil)
222 if err != nil {
223 return nil, fmt.Errorf("RevealDeploymentAPIKey: new request: %w", err)
224 }
225
226 request.Header.Add("User-Agent", c.getUserAgent())
227
228 if err := c.executeRequestInterceptors(ctx, request); err != nil {
229 return nil, fmt.Errorf("RevealDeploymentAPIKey: execute request editors: %w", err)
230 }
231
232 if err := c.signRequest(request); err != nil {
233 return nil, fmt.Errorf("RevealDeploymentAPIKey: sign request: %w", err)
234 }
235
236 if c.trace {
237 dumpRequest(request, "reveal-deployment-api-key")
238 }
239
240 response, err := c.httpClient.Do(request)
241 if err != nil {
242 return nil, fmt.Errorf("RevealDeploymentAPIKey: http client do: %w", err)
243 }
244
245 if c.trace {
246 dumpResponse(response)
247 }
248
249 if err := handleHTTPErrorResp(response); err != nil {
250 return nil, fmt.Errorf("RevealDeploymentAPIKey: http response: %w", err)
251 }
252
253 bodyresp := new(RevealDeploymentAPIKeyResponse)
254 if err := prepareJSONResponse(response, bodyresp); err != nil {
255 return nil, fmt.Errorf("RevealDeploymentAPIKey: prepare Json response: %w", err)
256 }
257
258 return bodyresp, nil
259 }
260
261 // Return logs for the vLLM deployment (deploy/<release-name>--deployment-vllm). Optional ?stream=true to request streaming (may not be supported).
262 func (c Client) GetDeploymentLogs(ctx context.Context, id UUID) (*GetDeploymentLogsResponse, error) {
263 path := fmt.Sprintf("/ai/deployment/%v/logs", id)
264
265 request, err := http.NewRequestWithContext(ctx, "GET", c.serverEndpoint+path, nil)
266 if err != nil {
267 return nil, fmt.Errorf("GetDeploymentLogs: new request: %w", err)
268 }
269
270 request.Header.Add("User-Agent", c.getUserAgent())
271
272 if err := c.executeRequestInterceptors(ctx, request); err != nil {
273 return nil, fmt.Errorf("GetDeploymentLogs: execute request editors: %w", err)
274 }
275
276 if err := c.signRequest(request); err != nil {
277 return nil, fmt.Errorf("GetDeploymentLogs: sign request: %w", err)
278 }
279
280 if c.trace {
281 dumpRequest(request, "get-deployment-logs")
282 }
283
284 response, err := c.httpClient.Do(request)
285 if err != nil {
286 return nil, fmt.Errorf("GetDeploymentLogs: http client do: %w", err)
287 }
288
289 if c.trace {
290 dumpResponse(response)
291 }
292
293 if err := handleHTTPErrorResp(response); err != nil {
294 return nil, fmt.Errorf("GetDeploymentLogs: http response: %w", err)
295 }
296
297 bodyresp := new(GetDeploymentLogsResponse)
298 if err := prepareJSONResponse(response, bodyresp); err != nil {
299 return nil, fmt.Errorf("GetDeploymentLogs: prepare Json response: %w", err)
300 }
301
302 return bodyresp, nil
303 }
304
305 // [BETA] Scale Deployment
306 func (c Client) ScaleDeployment(ctx context.Context, id UUID, req ScaleDeploymentRequest) (*Operation, error) {
307 path := fmt.Sprintf("/ai/deployment/%v/scale", id)
308
309 body, err := prepareJSONBody(req)
310 if err != nil {
311 return nil, fmt.Errorf("ScaleDeployment: prepare Json body: %w", err)
312 }
313
314 request, err := http.NewRequestWithContext(ctx, "POST", c.serverEndpoint+path, body)
315 if err != nil {
316 return nil, fmt.Errorf("ScaleDeployment: new request: %w", err)
317 }
318
319 request.Header.Add("User-Agent", c.getUserAgent())
320
321 request.Header.Add("Content-Type", "application/json")
322
323 if err := c.executeRequestInterceptors(ctx, request); err != nil {
324 return nil, fmt.Errorf("ScaleDeployment: execute request editors: %w", err)
325 }
326
327 if err := c.signRequest(request); err != nil {
328 return nil, fmt.Errorf("ScaleDeployment: sign request: %w", err)
329 }
330
331 if c.trace {
332 dumpRequest(request, "scale-deployment")
333 }
334
335 response, err := c.httpClient.Do(request)
336 if err != nil {
337 return nil, fmt.Errorf("ScaleDeployment: http client do: %w", err)
338 }
339
340 if c.trace {
341 dumpResponse(response)
342 }
343
344 if err := handleHTTPErrorResp(response); err != nil {
345 return nil, fmt.Errorf("ScaleDeployment: http response: %w", err)
346 }
347
348 bodyresp := new(Operation)
349 if err := prepareJSONResponse(response, bodyresp); err != nil {
350 return nil, fmt.Errorf("ScaleDeployment: prepare Json response: %w", err)
351 }
352
353 return bodyresp, nil
354 }
355
356 // Get list of allowed inference engine parameters with their descriptions, types, allowed values, and defaults
357 func (c Client) GetInferenceEngineHelp(ctx context.Context) (*GetInferenceEngineHelpResponse, error) {
358 path := "/ai/help/inference-engine-parameters"
359
360 request, err := http.NewRequestWithContext(ctx, "GET", c.serverEndpoint+path, nil)
361 if err != nil {
362 return nil, fmt.Errorf("GetInferenceEngineHelp: new request: %w", err)
363 }
364
365 request.Header.Add("User-Agent", c.getUserAgent())
366
367 if err := c.executeRequestInterceptors(ctx, request); err != nil {
368 return nil, fmt.Errorf("GetInferenceEngineHelp: execute request editors: %w", err)
369 }
370
371 if err := c.signRequest(request); err != nil {
372 return nil, fmt.Errorf("GetInferenceEngineHelp: sign request: %w", err)
373 }
374
375 if c.trace {
376 dumpRequest(request, "get-inference-engine-help")
377 }
378
379 response, err := c.httpClient.Do(request)
380 if err != nil {
381 return nil, fmt.Errorf("GetInferenceEngineHelp: http client do: %w", err)
382 }
383
384 if c.trace {
385 dumpResponse(response)
386 }
387
388 if err := handleHTTPErrorResp(response); err != nil {
389 return nil, fmt.Errorf("GetInferenceEngineHelp: http response: %w", err)
390 }
391
392 bodyresp := new(GetInferenceEngineHelpResponse)
393 if err := prepareJSONResponse(response, bodyresp); err != nil {
394 return nil, fmt.Errorf("GetInferenceEngineHelp: prepare Json response: %w", err)
395 }
396
397 return bodyresp, nil
398 }
399
400 // FindListModelsResponseEntry attempts to find an ListModelsResponseEntry by nameOrID.
401 func (l ListModelsResponse) FindListModelsResponseEntry(nameOrID string) (ListModelsResponseEntry, error) {
402 var result []ListModelsResponseEntry
403 for i, elem := range l.Models {
404 if string(elem.Name) == nameOrID || string(elem.ID) == nameOrID {
405 result = append(result, l.Models[i])
406 }
407 }
408 if len(result) == 1 {
409 return result[0], nil
410 }
411
412 if len(result) > 1 {
413 return ListModelsResponseEntry{}, fmt.Errorf("%q too many found in ListModelsResponse: %w", nameOrID, ErrConflict)
414 }
415
416 return ListModelsResponseEntry{}, fmt.Errorf("%q not found in ListModelsResponse: %w", nameOrID, ErrNotFound)
417 }
418
419 // [BETA] List Models
420 func (c Client) ListModels(ctx context.Context) (*ListModelsResponse, error) {
421 path := "/ai/model"
422
423 request, err := http.NewRequestWithContext(ctx, "GET", c.serverEndpoint+path, nil)
424 if err != nil {
425 return nil, fmt.Errorf("ListModels: new request: %w", err)
426 }
427
428 request.Header.Add("User-Agent", c.getUserAgent())
429
430 if err := c.executeRequestInterceptors(ctx, request); err != nil {
431 return nil, fmt.Errorf("ListModels: execute request editors: %w", err)
432 }
433
434 if err := c.signRequest(request); err != nil {
435 return nil, fmt.Errorf("ListModels: sign request: %w", err)
436 }
437
438 if c.trace {
439 dumpRequest(request, "list-models")
440 }
441
442 response, err := c.httpClient.Do(request)
443 if err != nil {
444 return nil, fmt.Errorf("ListModels: http client do: %w", err)
445 }
446
447 if c.trace {
448 dumpResponse(response)
449 }
450
451 if err := handleHTTPErrorResp(response); err != nil {
452 return nil, fmt.Errorf("ListModels: http response: %w", err)
453 }
454
455 bodyresp := new(ListModelsResponse)
456 if err := prepareJSONResponse(response, bodyresp); err != nil {
457 return nil, fmt.Errorf("ListModels: prepare Json response: %w", err)
458 }
459
460 return bodyresp, nil
461 }
462
463 // Model files will be downloaded from Huggingface.
464 // If the model is under a license then you must provide a Huggingface access token for an account that signed the license agreement
465 // If the model is under a license then you must provide a Huggingface access token for an account that signed the license agreement
466 func (c Client) CreateModel(ctx context.Context, req CreateModelRequest) (*Operation, error) {
467 path := "/ai/model"
468
469 body, err := prepareJSONBody(req)
470 if err != nil {
471 return nil, fmt.Errorf("CreateModel: prepare Json body: %w", err)
472 }
473
474 request, err := http.NewRequestWithContext(ctx, "POST", c.serverEndpoint+path, body)
475 if err != nil {
476 return nil, fmt.Errorf("CreateModel: new request: %w", err)
477 }
478
479 request.Header.Add("User-Agent", c.getUserAgent())
480
481 request.Header.Add("Content-Type", "application/json")
482
483 if err := c.executeRequestInterceptors(ctx, request); err != nil {
484 return nil, fmt.Errorf("CreateModel: execute request editors: %w", err)
485 }
486
487 if err := c.signRequest(request); err != nil {
488 return nil, fmt.Errorf("CreateModel: sign request: %w", err)
489 }
490
491 if c.trace {
492 dumpRequest(request, "create-model")
493 }
494
495 response, err := c.httpClient.Do(request)
496 if err != nil {
497 return nil, fmt.Errorf("CreateModel: http client do: %w", err)
498 }
499
500 if c.trace {
501 dumpResponse(response)
502 }
503
504 if err := handleHTTPErrorResp(response); err != nil {
505 return nil, fmt.Errorf("CreateModel: http response: %w", err)
506 }
507
508 bodyresp := new(Operation)
509 if err := prepareJSONResponse(response, bodyresp); err != nil {
510 return nil, fmt.Errorf("CreateModel: prepare Json response: %w", err)
511 }
512
513 return bodyresp, nil
514 }
515
516 // [BETA] Delete Model
517 func (c Client) DeleteModel(ctx context.Context, id UUID) (*Operation, error) {
518 path := fmt.Sprintf("/ai/model/%v", id)
519
520 request, err := http.NewRequestWithContext(ctx, "DELETE", c.serverEndpoint+path, nil)
521 if err != nil {
522 return nil, fmt.Errorf("DeleteModel: new request: %w", err)
523 }
524
525 request.Header.Add("User-Agent", c.getUserAgent())
526
527 if err := c.executeRequestInterceptors(ctx, request); err != nil {
528 return nil, fmt.Errorf("DeleteModel: execute request editors: %w", err)
529 }
530
531 if err := c.signRequest(request); err != nil {
532 return nil, fmt.Errorf("DeleteModel: sign request: %w", err)
533 }
534
535 if c.trace {
536 dumpRequest(request, "delete-model")
537 }
538
539 response, err := c.httpClient.Do(request)
540 if err != nil {
541 return nil, fmt.Errorf("DeleteModel: http client do: %w", err)
542 }
543
544 if c.trace {
545 dumpResponse(response)
546 }
547
548 if err := handleHTTPErrorResp(response); err != nil {
549 return nil, fmt.Errorf("DeleteModel: http response: %w", err)
550 }
551
552 bodyresp := new(Operation)
553 if err := prepareJSONResponse(response, bodyresp); err != nil {
554 return nil, fmt.Errorf("DeleteModel: prepare Json response: %w", err)
555 }
556
557 return bodyresp, nil
558 }
559
560 // [BETA] Get Model
561 func (c Client) GetModel(ctx context.Context, id UUID) (*GetModelResponse, error) {
562 path := fmt.Sprintf("/ai/model/%v", id)
563
564 request, err := http.NewRequestWithContext(ctx, "GET", c.serverEndpoint+path, nil)
565 if err != nil {
566 return nil, fmt.Errorf("GetModel: new request: %w", err)
567 }
568
569 request.Header.Add("User-Agent", c.getUserAgent())
570
571 if err := c.executeRequestInterceptors(ctx, request); err != nil {
572 return nil, fmt.Errorf("GetModel: execute request editors: %w", err)
573 }
574
575 if err := c.signRequest(request); err != nil {
576 return nil, fmt.Errorf("GetModel: sign request: %w", err)
577 }
578
579 if c.trace {
580 dumpRequest(request, "get-model")
581 }
582
583 response, err := c.httpClient.Do(request)
584 if err != nil {
585 return nil, fmt.Errorf("GetModel: http client do: %w", err)
586 }
587
588 if c.trace {
589 dumpResponse(response)
590 }
591
592 if err := handleHTTPErrorResp(response); err != nil {
593 return nil, fmt.Errorf("GetModel: http response: %w", err)
594 }
595
596 bodyresp := new(GetModelResponse)
597 if err := prepareJSONResponse(response, bodyresp); err != nil {
598 return nil, fmt.Errorf("GetModel: prepare Json response: %w", err)
599 }
600
601 return bodyresp, nil
602 }
603
604 type ListAntiAffinityGroupsResponse struct {
605 AntiAffinityGroups []AntiAffinityGroup `json:"anti-affinity-groups,omitempty"`
606 }
607
608 // FindAntiAffinityGroup attempts to find an AntiAffinityGroup by nameOrID.
609 func (l ListAntiAffinityGroupsResponse) FindAntiAffinityGroup(nameOrID string) (AntiAffinityGroup, error) {
610 var result []AntiAffinityGroup
611 for i, elem := range l.AntiAffinityGroups {
612 if string(elem.Name) == nameOrID || string(elem.ID) == nameOrID {
613 result = append(result, l.AntiAffinityGroups[i])
614 }
615 }
616 if len(result) == 1 {
617 return result[0], nil
618 }
619
620 if len(result) > 1 {
621 return AntiAffinityGroup{}, fmt.Errorf("%q too many found in ListAntiAffinityGroupsResponse: %w", nameOrID, ErrConflict)
622 }
623
624 return AntiAffinityGroup{}, fmt.Errorf("%q not found in ListAntiAffinityGroupsResponse: %w", nameOrID, ErrNotFound)
625 }
626
627 // List Anti-affinity Groups
628 func (c Client) ListAntiAffinityGroups(ctx context.Context) (*ListAntiAffinityGroupsResponse, error) {
629 path := "/anti-affinity-group"
630
631 request, err := http.NewRequestWithContext(ctx, "GET", c.serverEndpoint+path, nil)
632 if err != nil {
633 return nil, fmt.Errorf("ListAntiAffinityGroups: new request: %w", err)
634 }
635
636 request.Header.Add("User-Agent", c.getUserAgent())
637
638 if err := c.executeRequestInterceptors(ctx, request); err != nil {
639 return nil, fmt.Errorf("ListAntiAffinityGroups: execute request editors: %w", err)
640 }
641
642 if err := c.signRequest(request); err != nil {
643 return nil, fmt.Errorf("ListAntiAffinityGroups: sign request: %w", err)
644 }
645
646 if c.trace {
647 dumpRequest(request, "list-anti-affinity-groups")
648 }
649
650 response, err := c.httpClient.Do(request)
651 if err != nil {
652 return nil, fmt.Errorf("ListAntiAffinityGroups: http client do: %w", err)
653 }
654
655 if c.trace {
656 dumpResponse(response)
657 }
658
659 if err := handleHTTPErrorResp(response); err != nil {
660 return nil, fmt.Errorf("ListAntiAffinityGroups: http response: %w", err)
661 }
662
663 bodyresp := new(ListAntiAffinityGroupsResponse)
664 if err := prepareJSONResponse(response, bodyresp); err != nil {
665 return nil, fmt.Errorf("ListAntiAffinityGroups: prepare Json response: %w", err)
666 }
667
668 return bodyresp, nil
669 }
670
671 type CreateAntiAffinityGroupRequest struct {
672 // Anti-affinity Group description
673 Description string `json:"description,omitempty" validate:"omitempty,lte=255"`
674 // Anti-affinity Group name
675 Name string `json:"name" validate:"required,gte=1,lte=255"`
676 }
677
678 // Create an Anti-affinity Group
679 func (c Client) CreateAntiAffinityGroup(ctx context.Context, req CreateAntiAffinityGroupRequest) (*Operation, error) {
680 path := "/anti-affinity-group"
681
682 body, err := prepareJSONBody(req)
683 if err != nil {
684 return nil, fmt.Errorf("CreateAntiAffinityGroup: prepare Json body: %w", err)
685 }
686
687 request, err := http.NewRequestWithContext(ctx, "POST", c.serverEndpoint+path, body)
688 if err != nil {
689 return nil, fmt.Errorf("CreateAntiAffinityGroup: new request: %w", err)
690 }
691
692 request.Header.Add("User-Agent", c.getUserAgent())
693
694 request.Header.Add("Content-Type", "application/json")
695
696 if err := c.executeRequestInterceptors(ctx, request); err != nil {
697 return nil, fmt.Errorf("CreateAntiAffinityGroup: execute request editors: %w", err)
698 }
699
700 if err := c.signRequest(request); err != nil {
701 return nil, fmt.Errorf("CreateAntiAffinityGroup: sign request: %w", err)
702 }
703
704 if c.trace {
705 dumpRequest(request, "create-anti-affinity-group")
706 }
707
708 response, err := c.httpClient.Do(request)
709 if err != nil {
710 return nil, fmt.Errorf("CreateAntiAffinityGroup: http client do: %w", err)
711 }
712
713 if c.trace {
714 dumpResponse(response)
715 }
716
717 if err := handleHTTPErrorResp(response); err != nil {
718 return nil, fmt.Errorf("CreateAntiAffinityGroup: http response: %w", err)
719 }
720
721 bodyresp := new(Operation)
722 if err := prepareJSONResponse(response, bodyresp); err != nil {
723 return nil, fmt.Errorf("CreateAntiAffinityGroup: prepare Json response: %w", err)
724 }
725
726 return bodyresp, nil
727 }
728
729 // Delete an Anti-affinity Group
730 func (c Client) DeleteAntiAffinityGroup(ctx context.Context, id UUID) (*Operation, error) {
731 path := fmt.Sprintf("/anti-affinity-group/%v", id)
732
733 request, err := http.NewRequestWithContext(ctx, "DELETE", c.serverEndpoint+path, nil)
734 if err != nil {
735 return nil, fmt.Errorf("DeleteAntiAffinityGroup: new request: %w", err)
736 }
737
738 request.Header.Add("User-Agent", c.getUserAgent())
739
740 if err := c.executeRequestInterceptors(ctx, request); err != nil {
741 return nil, fmt.Errorf("DeleteAntiAffinityGroup: execute request editors: %w", err)
742 }
743
744 if err := c.signRequest(request); err != nil {
745 return nil, fmt.Errorf("DeleteAntiAffinityGroup: sign request: %w", err)
746 }
747
748 if c.trace {
749 dumpRequest(request, "delete-anti-affinity-group")
750 }
751
752 response, err := c.httpClient.Do(request)
753 if err != nil {
754 return nil, fmt.Errorf("DeleteAntiAffinityGroup: http client do: %w", err)
755 }
756
757 if c.trace {
758 dumpResponse(response)
759 }
760
761 if err := handleHTTPErrorResp(response); err != nil {
762 return nil, fmt.Errorf("DeleteAntiAffinityGroup: http response: %w", err)
763 }
764
765 bodyresp := new(Operation)
766 if err := prepareJSONResponse(response, bodyresp); err != nil {
767 return nil, fmt.Errorf("DeleteAntiAffinityGroup: prepare Json response: %w", err)
768 }
769
770 return bodyresp, nil
771 }
772
773 // Retrieve Anti-affinity Group details
774 func (c Client) GetAntiAffinityGroup(ctx context.Context, id UUID) (*AntiAffinityGroup, error) {
775 path := fmt.Sprintf("/anti-affinity-group/%v", id)
776
777 request, err := http.NewRequestWithContext(ctx, "GET", c.serverEndpoint+path, nil)
778 if err != nil {
779 return nil, fmt.Errorf("GetAntiAffinityGroup: new request: %w", err)
780 }
781
782 request.Header.Add("User-Agent", c.getUserAgent())
783
784 if err := c.executeRequestInterceptors(ctx, request); err != nil {
785 return nil, fmt.Errorf("GetAntiAffinityGroup: execute request editors: %w", err)
786 }
787
788 if err := c.signRequest(request); err != nil {
789 return nil, fmt.Errorf("GetAntiAffinityGroup: sign request: %w", err)
790 }
791
792 if c.trace {
793 dumpRequest(request, "get-anti-affinity-group")
794 }
795
796 response, err := c.httpClient.Do(request)
797 if err != nil {
798 return nil, fmt.Errorf("GetAntiAffinityGroup: http client do: %w", err)
799 }
800
801 if c.trace {
802 dumpResponse(response)
803 }
804
805 if err := handleHTTPErrorResp(response); err != nil {
806 return nil, fmt.Errorf("GetAntiAffinityGroup: http response: %w", err)
807 }
808
809 bodyresp := new(AntiAffinityGroup)
810 if err := prepareJSONResponse(response, bodyresp); err != nil {
811 return nil, fmt.Errorf("GetAntiAffinityGroup: prepare Json response: %w", err)
812 }
813
814 return bodyresp, nil
815 }
816
817 type ListAPIKeysResponse struct {
818 APIKeys []IAMAPIKey `json:"api-keys,omitempty"`
819 }
820
821 // FindIAMAPIKey attempts to find an IAMAPIKey by nameOrKey.
822 func (l ListAPIKeysResponse) FindIAMAPIKey(nameOrKey string) (IAMAPIKey, error) {
823 var result []IAMAPIKey
824 for i, elem := range l.APIKeys {
825 if string(elem.Name) == nameOrKey || string(elem.Key) == nameOrKey {
826 result = append(result, l.APIKeys[i])
827 }
828 }
829 if len(result) == 1 {
830 return result[0], nil
831 }
832
833 if len(result) > 1 {
834 return IAMAPIKey{}, fmt.Errorf("%q too many found in ListAPIKeysResponse: %w", nameOrKey, ErrConflict)
835 }
836
837 return IAMAPIKey{}, fmt.Errorf("%q not found in ListAPIKeysResponse: %w", nameOrKey, ErrNotFound)
838 }
839
840 func (c Client) ListAPIKeys(ctx context.Context) (*ListAPIKeysResponse, error) {
841 path := "/api-key"
842
843 request, err := http.NewRequestWithContext(ctx, "GET", c.serverEndpoint+path, nil)
844 if err != nil {
845 return nil, fmt.Errorf("ListAPIKeys: new request: %w", err)
846 }
847
848 request.Header.Add("User-Agent", c.getUserAgent())
849
850 if err := c.executeRequestInterceptors(ctx, request); err != nil {
851 return nil, fmt.Errorf("ListAPIKeys: execute request editors: %w", err)
852 }
853
854 if err := c.signRequest(request); err != nil {
855 return nil, fmt.Errorf("ListAPIKeys: sign request: %w", err)
856 }
857
858 if c.trace {
859 dumpRequest(request, "list-api-keys")
860 }
861
862 response, err := c.httpClient.Do(request)
863 if err != nil {
864 return nil, fmt.Errorf("ListAPIKeys: http client do: %w", err)
865 }
866
867 if c.trace {
868 dumpResponse(response)
869 }
870
871 if err := handleHTTPErrorResp(response); err != nil {
872 return nil, fmt.Errorf("ListAPIKeys: http response: %w", err)
873 }
874
875 bodyresp := new(ListAPIKeysResponse)
876 if err := prepareJSONResponse(response, bodyresp); err != nil {
877 return nil, fmt.Errorf("ListAPIKeys: prepare Json response: %w", err)
878 }
879
880 return bodyresp, nil
881 }
882
883 type CreateAPIKeyRequest struct {
884 // IAM API Key Name
885 Name string `json:"name" validate:"required,gte=1,lte=255"`
886 // IAM API Key Role ID
887 RoleID UUID `json:"role-id" validate:"required"`
888 }
889
890 func (c Client) CreateAPIKey(ctx context.Context, req CreateAPIKeyRequest) (*IAMAPIKeyCreated, error) {
891 path := "/api-key"
892
893 body, err := prepareJSONBody(req)
894 if err != nil {
895 return nil, fmt.Errorf("CreateAPIKey: prepare Json body: %w", err)
896 }
897
898 request, err := http.NewRequestWithContext(ctx, "POST", c.serverEndpoint+path, body)
899 if err != nil {
900 return nil, fmt.Errorf("CreateAPIKey: new request: %w", err)
901 }
902
903 request.Header.Add("User-Agent", c.getUserAgent())
904
905 request.Header.Add("Content-Type", "application/json")
906
907 if err := c.executeRequestInterceptors(ctx, request); err != nil {
908 return nil, fmt.Errorf("CreateAPIKey: execute request editors: %w", err)
909 }
910
911 if err := c.signRequest(request); err != nil {
912 return nil, fmt.Errorf("CreateAPIKey: sign request: %w", err)
913 }
914
915 if c.trace {
916 dumpRequest(request, "create-api-key")
917 }
918
919 response, err := c.httpClient.Do(request)
920 if err != nil {
921 return nil, fmt.Errorf("CreateAPIKey: http client do: %w", err)
922 }
923
924 if c.trace {
925 dumpResponse(response)
926 }
927
928 if err := handleHTTPErrorResp(response); err != nil {
929 return nil, fmt.Errorf("CreateAPIKey: http response: %w", err)
930 }
931
932 bodyresp := new(IAMAPIKeyCreated)
933 if err := prepareJSONResponse(response, bodyresp); err != nil {
934 return nil, fmt.Errorf("CreateAPIKey: prepare Json response: %w", err)
935 }
936
937 return bodyresp, nil
938 }
939
940 func (c Client) DeleteAPIKey(ctx context.Context, id string) (*Operation, error) {
941 path := fmt.Sprintf("/api-key/%v", id)
942
943 request, err := http.NewRequestWithContext(ctx, "DELETE", c.serverEndpoint+path, nil)
944 if err != nil {
945 return nil, fmt.Errorf("DeleteAPIKey: new request: %w", err)
946 }
947
948 request.Header.Add("User-Agent", c.getUserAgent())
949
950 if err := c.executeRequestInterceptors(ctx, request); err != nil {
951 return nil, fmt.Errorf("DeleteAPIKey: execute request editors: %w", err)
952 }
953
954 if err := c.signRequest(request); err != nil {
955 return nil, fmt.Errorf("DeleteAPIKey: sign request: %w", err)
956 }
957
958 if c.trace {
959 dumpRequest(request, "delete-api-key")
960 }
961
962 response, err := c.httpClient.Do(request)
963 if err != nil {
964 return nil, fmt.Errorf("DeleteAPIKey: http client do: %w", err)
965 }
966
967 if c.trace {
968 dumpResponse(response)
969 }
970
971 if err := handleHTTPErrorResp(response); err != nil {
972 return nil, fmt.Errorf("DeleteAPIKey: http response: %w", err)
973 }
974
975 bodyresp := new(Operation)
976 if err := prepareJSONResponse(response, bodyresp); err != nil {
977 return nil, fmt.Errorf("DeleteAPIKey: prepare Json response: %w", err)
978 }
979
980 return bodyresp, nil
981 }
982
983 func (c Client) GetAPIKey(ctx context.Context, id string) (*IAMAPIKey, error) {
984 path := fmt.Sprintf("/api-key/%v", id)
985
986 request, err := http.NewRequestWithContext(ctx, "GET", c.serverEndpoint+path, nil)
987 if err != nil {
988 return nil, fmt.Errorf("GetAPIKey: new request: %w", err)
989 }
990
991 request.Header.Add("User-Agent", c.getUserAgent())
992
993 if err := c.executeRequestInterceptors(ctx, request); err != nil {
994 return nil, fmt.Errorf("GetAPIKey: execute request editors: %w", err)
995 }
996
997 if err := c.signRequest(request); err != nil {
998 return nil, fmt.Errorf("GetAPIKey: sign request: %w", err)
999 }
1000
1001 if c.trace {
1002 dumpRequest(request, "get-api-key")
1003 }
1004
1005 response, err := c.httpClient.Do(request)
1006 if err != nil {
1007 return nil, fmt.Errorf("GetAPIKey: http client do: %w", err)
1008 }
1009
1010 if c.trace {
1011 dumpResponse(response)
1012 }
1013
1014 if err := handleHTTPErrorResp(response); err != nil {
1015 return nil, fmt.Errorf("GetAPIKey: http response: %w", err)
1016 }
1017
1018 bodyresp := new(IAMAPIKey)
1019 if err := prepareJSONResponse(response, bodyresp); err != nil {
1020 return nil, fmt.Errorf("GetAPIKey: prepare Json response: %w", err)
1021 }
1022
1023 return bodyresp, nil
1024 }
1025
1026 type ListBlockStorageVolumesResponse struct {
1027 BlockStorageVolumes []BlockStorageVolume `json:"block-storage-volumes,omitempty"`
1028 }
1029
1030 // FindBlockStorageVolume attempts to find an BlockStorageVolume by nameOrID.
1031 func (l ListBlockStorageVolumesResponse) FindBlockStorageVolume(nameOrID string) (BlockStorageVolume, error) {
1032 var result []BlockStorageVolume
1033 for i, elem := range l.BlockStorageVolumes {
1034 if string(elem.Name) == nameOrID || string(elem.ID) == nameOrID {
1035 result = append(result, l.BlockStorageVolumes[i])
1036 }
1037 }
1038 if len(result) == 1 {
1039 return result[0], nil
1040 }
1041
1042 if len(result) > 1 {
1043 return BlockStorageVolume{}, fmt.Errorf("%q too many found in ListBlockStorageVolumesResponse: %w", nameOrID, ErrConflict)
1044 }
1045
1046 return BlockStorageVolume{}, fmt.Errorf("%q not found in ListBlockStorageVolumesResponse: %w", nameOrID, ErrNotFound)
1047 }
1048
1049 type ListBlockStorageVolumesOpt func(url.Values)
1050
1051 func ListBlockStorageVolumesWithInstanceID(instanceID UUID) ListBlockStorageVolumesOpt {
1052 return func(q url.Values) {
1053 q.Add("instance-id", fmt.Sprint(instanceID))
1054 }
1055 }
1056
1057 // List block storage volumes
1058 func (c Client) ListBlockStorageVolumes(ctx context.Context, opts ...ListBlockStorageVolumesOpt) (*ListBlockStorageVolumesResponse, error) {
1059 path := "/block-storage"
1060
1061 request, err := http.NewRequestWithContext(ctx, "GET", c.serverEndpoint+path, nil)
1062 if err != nil {
1063 return nil, fmt.Errorf("ListBlockStorageVolumes: new request: %w", err)
1064 }
1065
1066 request.Header.Add("User-Agent", c.getUserAgent())
1067
1068 if len(opts) > 0 {
1069 q := request.URL.Query()
1070 for _, opt := range opts {
1071 opt(q)
1072 }
1073 request.URL.RawQuery = q.Encode()
1074 }
1075
1076 if err := c.executeRequestInterceptors(ctx, request); err != nil {
1077 return nil, fmt.Errorf("ListBlockStorageVolumes: execute request editors: %w", err)
1078 }
1079
1080 if err := c.signRequest(request); err != nil {
1081 return nil, fmt.Errorf("ListBlockStorageVolumes: sign request: %w", err)
1082 }
1083
1084 if c.trace {
1085 dumpRequest(request, "list-block-storage-volumes")
1086 }
1087
1088 response, err := c.httpClient.Do(request)
1089 if err != nil {
1090 return nil, fmt.Errorf("ListBlockStorageVolumes: http client do: %w", err)
1091 }
1092
1093 if c.trace {
1094 dumpResponse(response)
1095 }
1096
1097 if err := handleHTTPErrorResp(response); err != nil {
1098 return nil, fmt.Errorf("ListBlockStorageVolumes: http response: %w", err)
1099 }
1100
1101 bodyresp := new(ListBlockStorageVolumesResponse)
1102 if err := prepareJSONResponse(response, bodyresp); err != nil {
1103 return nil, fmt.Errorf("ListBlockStorageVolumes: prepare Json response: %w", err)
1104 }
1105
1106 return bodyresp, nil
1107 }
1108
1109 type CreateBlockStorageVolumeRequest struct {
1110 // Target block storage snapshot
1111 BlockStorageSnapshot *BlockStorageSnapshotTarget `json:"block-storage-snapshot,omitempty"`
1112 Labels Labels `json:"labels,omitempty"`
1113 // Volume name
1114 Name string `json:"name,omitempty" validate:"omitempty,lte=255"`
1115 // Volume size in GiB.
1116 // When a snapshot ID is supplied, this defaults to the size of the source volume, but can be set to a larger value.
1117 Size int64 `json:"size,omitempty" validate:"omitempty,gte=1"`
1118 }
1119
1120 // Create a block storage volume
1121 func (c Client) CreateBlockStorageVolume(ctx context.Context, req CreateBlockStorageVolumeRequest) (*Operation, error) {
1122 path := "/block-storage"
1123
1124 body, err := prepareJSONBody(req)
1125 if err != nil {
1126 return nil, fmt.Errorf("CreateBlockStorageVolume: prepare Json body: %w", err)
1127 }
1128
1129 request, err := http.NewRequestWithContext(ctx, "POST", c.serverEndpoint+path, body)
1130 if err != nil {
1131 return nil, fmt.Errorf("CreateBlockStorageVolume: new request: %w", err)
1132 }
1133
1134 request.Header.Add("User-Agent", c.getUserAgent())
1135
1136 request.Header.Add("Content-Type", "application/json")
1137
1138 if err := c.executeRequestInterceptors(ctx, request); err != nil {
1139 return nil, fmt.Errorf("CreateBlockStorageVolume: execute request editors: %w", err)
1140 }
1141
1142 if err := c.signRequest(request); err != nil {
1143 return nil, fmt.Errorf("CreateBlockStorageVolume: sign request: %w", err)
1144 }
1145
1146 if c.trace {
1147 dumpRequest(request, "create-block-storage-volume")
1148 }
1149
1150 response, err := c.httpClient.Do(request)
1151 if err != nil {
1152 return nil, fmt.Errorf("CreateBlockStorageVolume: http client do: %w", err)
1153 }
1154
1155 if c.trace {
1156 dumpResponse(response)
1157 }
1158
1159 if err := handleHTTPErrorResp(response); err != nil {
1160 return nil, fmt.Errorf("CreateBlockStorageVolume: http response: %w", err)
1161 }
1162
1163 bodyresp := new(Operation)
1164 if err := prepareJSONResponse(response, bodyresp); err != nil {
1165 return nil, fmt.Errorf("CreateBlockStorageVolume: prepare Json response: %w", err)
1166 }
1167
1168 return bodyresp, nil
1169 }
1170
1171 type ListBlockStorageSnapshotsResponse struct {
1172 BlockStorageSnapshots []BlockStorageSnapshot `json:"block-storage-snapshots,omitempty"`
1173 }
1174
1175 // FindBlockStorageSnapshot attempts to find an BlockStorageSnapshot by nameOrID.
1176 func (l ListBlockStorageSnapshotsResponse) FindBlockStorageSnapshot(nameOrID string) (BlockStorageSnapshot, error) {
1177 var result []BlockStorageSnapshot
1178 for i, elem := range l.BlockStorageSnapshots {
1179 if string(elem.Name) == nameOrID || string(elem.ID) == nameOrID {
1180 result = append(result, l.BlockStorageSnapshots[i])
1181 }
1182 }
1183 if len(result) == 1 {
1184 return result[0], nil
1185 }
1186
1187 if len(result) > 1 {
1188 return BlockStorageSnapshot{}, fmt.Errorf("%q too many found in ListBlockStorageSnapshotsResponse: %w", nameOrID, ErrConflict)
1189 }
1190
1191 return BlockStorageSnapshot{}, fmt.Errorf("%q not found in ListBlockStorageSnapshotsResponse: %w", nameOrID, ErrNotFound)
1192 }
1193
1194 // List block storage snapshots
1195 func (c Client) ListBlockStorageSnapshots(ctx context.Context) (*ListBlockStorageSnapshotsResponse, error) {
1196 path := "/block-storage-snapshot"
1197
1198 request, err := http.NewRequestWithContext(ctx, "GET", c.serverEndpoint+path, nil)
1199 if err != nil {
1200 return nil, fmt.Errorf("ListBlockStorageSnapshots: new request: %w", err)
1201 }
1202
1203 request.Header.Add("User-Agent", c.getUserAgent())
1204
1205 if err := c.executeRequestInterceptors(ctx, request); err != nil {
1206 return nil, fmt.Errorf("ListBlockStorageSnapshots: execute request editors: %w", err)
1207 }
1208
1209 if err := c.signRequest(request); err != nil {
1210 return nil, fmt.Errorf("ListBlockStorageSnapshots: sign request: %w", err)
1211 }
1212
1213 if c.trace {
1214 dumpRequest(request, "list-block-storage-snapshots")
1215 }
1216
1217 response, err := c.httpClient.Do(request)
1218 if err != nil {
1219 return nil, fmt.Errorf("ListBlockStorageSnapshots: http client do: %w", err)
1220 }
1221
1222 if c.trace {
1223 dumpResponse(response)
1224 }
1225
1226 if err := handleHTTPErrorResp(response); err != nil {
1227 return nil, fmt.Errorf("ListBlockStorageSnapshots: http response: %w", err)
1228 }
1229
1230 bodyresp := new(ListBlockStorageSnapshotsResponse)
1231 if err := prepareJSONResponse(response, bodyresp); err != nil {
1232 return nil, fmt.Errorf("ListBlockStorageSnapshots: prepare Json response: %w", err)
1233 }
1234
1235 return bodyresp, nil
1236 }
1237
1238 // Delete a block storage snapshot, data will be unrecoverable
1239 func (c Client) DeleteBlockStorageSnapshot(ctx context.Context, id UUID) (*Operation, error) {
1240 path := fmt.Sprintf("/block-storage-snapshot/%v", id)
1241
1242 request, err := http.NewRequestWithContext(ctx, "DELETE", c.serverEndpoint+path, nil)
1243 if err != nil {
1244 return nil, fmt.Errorf("DeleteBlockStorageSnapshot: new request: %w", err)
1245 }
1246
1247 request.Header.Add("User-Agent", c.getUserAgent())
1248
1249 if err := c.executeRequestInterceptors(ctx, request); err != nil {
1250 return nil, fmt.Errorf("DeleteBlockStorageSnapshot: execute request editors: %w", err)
1251 }
1252
1253 if err := c.signRequest(request); err != nil {
1254 return nil, fmt.Errorf("DeleteBlockStorageSnapshot: sign request: %w", err)
1255 }
1256
1257 if c.trace {
1258 dumpRequest(request, "delete-block-storage-snapshot")
1259 }
1260
1261 response, err := c.httpClient.Do(request)
1262 if err != nil {
1263 return nil, fmt.Errorf("DeleteBlockStorageSnapshot: http client do: %w", err)
1264 }
1265
1266 if c.trace {
1267 dumpResponse(response)
1268 }
1269
1270 if err := handleHTTPErrorResp(response); err != nil {
1271 return nil, fmt.Errorf("DeleteBlockStorageSnapshot: http response: %w", err)
1272 }
1273
1274 bodyresp := new(Operation)
1275 if err := prepareJSONResponse(response, bodyresp); err != nil {
1276 return nil, fmt.Errorf("DeleteBlockStorageSnapshot: prepare Json response: %w", err)
1277 }
1278
1279 return bodyresp, nil
1280 }
1281
1282 // Retrieve block storage snapshot details
1283 func (c Client) GetBlockStorageSnapshot(ctx context.Context, id UUID) (*BlockStorageSnapshot, error) {
1284 path := fmt.Sprintf("/block-storage-snapshot/%v", id)
1285
1286 request, err := http.NewRequestWithContext(ctx, "GET", c.serverEndpoint+path, nil)
1287 if err != nil {
1288 return nil, fmt.Errorf("GetBlockStorageSnapshot: new request: %w", err)
1289 }
1290
1291 request.Header.Add("User-Agent", c.getUserAgent())
1292
1293 if err := c.executeRequestInterceptors(ctx, request); err != nil {
1294 return nil, fmt.Errorf("GetBlockStorageSnapshot: execute request editors: %w", err)
1295 }
1296
1297 if err := c.signRequest(request); err != nil {
1298 return nil, fmt.Errorf("GetBlockStorageSnapshot: sign request: %w", err)
1299 }
1300
1301 if c.trace {
1302 dumpRequest(request, "get-block-storage-snapshot")
1303 }
1304
1305 response, err := c.httpClient.Do(request)
1306 if err != nil {
1307 return nil, fmt.Errorf("GetBlockStorageSnapshot: http client do: %w", err)
1308 }
1309
1310 if c.trace {
1311 dumpResponse(response)
1312 }
1313
1314 if err := handleHTTPErrorResp(response); err != nil {
1315 return nil, fmt.Errorf("GetBlockStorageSnapshot: http response: %w", err)
1316 }
1317
1318 bodyresp := new(BlockStorageSnapshot)
1319 if err := prepareJSONResponse(response, bodyresp); err != nil {
1320 return nil, fmt.Errorf("GetBlockStorageSnapshot: prepare Json response: %w", err)
1321 }
1322
1323 return bodyresp, nil
1324 }
1325
1326 type UpdateBlockStorageSnapshotRequest struct {
1327 Labels Labels `json:"labels"`
1328 // Snapshot name
1329 Name *string `json:"name,omitempty" validate:"omitempty,lte=255"`
1330 }
1331
1332 // Update block storage volume snapshot
1333 func (c Client) UpdateBlockStorageSnapshot(ctx context.Context, id UUID, req UpdateBlockStorageSnapshotRequest) (*Operation, error) {
1334 path := fmt.Sprintf("/block-storage-snapshot/%v", id)
1335
1336 body, err := prepareJSONBody(req)
1337 if err != nil {
1338 return nil, fmt.Errorf("UpdateBlockStorageSnapshot: prepare Json body: %w", err)
1339 }
1340
1341 request, err := http.NewRequestWithContext(ctx, "PUT", c.serverEndpoint+path, body)
1342 if err != nil {
1343 return nil, fmt.Errorf("UpdateBlockStorageSnapshot: new request: %w", err)
1344 }
1345
1346 request.Header.Add("User-Agent", c.getUserAgent())
1347
1348 request.Header.Add("Content-Type", "application/json")
1349
1350 if err := c.executeRequestInterceptors(ctx, request); err != nil {
1351 return nil, fmt.Errorf("UpdateBlockStorageSnapshot: execute request editors: %w", err)
1352 }
1353
1354 if err := c.signRequest(request); err != nil {
1355 return nil, fmt.Errorf("UpdateBlockStorageSnapshot: sign request: %w", err)
1356 }
1357
1358 if c.trace {
1359 dumpRequest(request, "update-block-storage-snapshot")
1360 }
1361
1362 response, err := c.httpClient.Do(request)
1363 if err != nil {
1364 return nil, fmt.Errorf("UpdateBlockStorageSnapshot: http client do: %w", err)
1365 }
1366
1367 if c.trace {
1368 dumpResponse(response)
1369 }
1370
1371 if err := handleHTTPErrorResp(response); err != nil {
1372 return nil, fmt.Errorf("UpdateBlockStorageSnapshot: http response: %w", err)
1373 }
1374
1375 bodyresp := new(Operation)
1376 if err := prepareJSONResponse(response, bodyresp); err != nil {
1377 return nil, fmt.Errorf("UpdateBlockStorageSnapshot: prepare Json response: %w", err)
1378 }
1379
1380 return bodyresp, nil
1381 }
1382
1383 // Delete a block storage volume, data will be unrecoverable
1384 func (c Client) DeleteBlockStorageVolume(ctx context.Context, id UUID) (*Operation, error) {
1385 path := fmt.Sprintf("/block-storage/%v", id)
1386
1387 request, err := http.NewRequestWithContext(ctx, "DELETE", c.serverEndpoint+path, nil)
1388 if err != nil {
1389 return nil, fmt.Errorf("DeleteBlockStorageVolume: new request: %w", err)
1390 }
1391
1392 request.Header.Add("User-Agent", c.getUserAgent())
1393
1394 if err := c.executeRequestInterceptors(ctx, request); err != nil {
1395 return nil, fmt.Errorf("DeleteBlockStorageVolume: execute request editors: %w", err)
1396 }
1397
1398 if err := c.signRequest(request); err != nil {
1399 return nil, fmt.Errorf("DeleteBlockStorageVolume: sign request: %w", err)
1400 }
1401
1402 if c.trace {
1403 dumpRequest(request, "delete-block-storage-volume")
1404 }
1405
1406 response, err := c.httpClient.Do(request)
1407 if err != nil {
1408 return nil, fmt.Errorf("DeleteBlockStorageVolume: http client do: %w", err)
1409 }
1410
1411 if c.trace {
1412 dumpResponse(response)
1413 }
1414
1415 if err := handleHTTPErrorResp(response); err != nil {
1416 return nil, fmt.Errorf("DeleteBlockStorageVolume: http response: %w", err)
1417 }
1418
1419 bodyresp := new(Operation)
1420 if err := prepareJSONResponse(response, bodyresp); err != nil {
1421 return nil, fmt.Errorf("DeleteBlockStorageVolume: prepare Json response: %w", err)
1422 }
1423
1424 return bodyresp, nil
1425 }
1426
1427 // Retrieve block storage volume details
1428 func (c Client) GetBlockStorageVolume(ctx context.Context, id UUID) (*BlockStorageVolume, error) {
1429 path := fmt.Sprintf("/block-storage/%v", id)
1430
1431 request, err := http.NewRequestWithContext(ctx, "GET", c.serverEndpoint+path, nil)
1432 if err != nil {
1433 return nil, fmt.Errorf("GetBlockStorageVolume: new request: %w", err)
1434 }
1435
1436 request.Header.Add("User-Agent", c.getUserAgent())
1437
1438 if err := c.executeRequestInterceptors(ctx, request); err != nil {
1439 return nil, fmt.Errorf("GetBlockStorageVolume: execute request editors: %w", err)
1440 }
1441
1442 if err := c.signRequest(request); err != nil {
1443 return nil, fmt.Errorf("GetBlockStorageVolume: sign request: %w", err)
1444 }
1445
1446 if c.trace {
1447 dumpRequest(request, "get-block-storage-volume")
1448 }
1449
1450 response, err := c.httpClient.Do(request)
1451 if err != nil {
1452 return nil, fmt.Errorf("GetBlockStorageVolume: http client do: %w", err)
1453 }
1454
1455 if c.trace {
1456 dumpResponse(response)
1457 }
1458
1459 if err := handleHTTPErrorResp(response); err != nil {
1460 return nil, fmt.Errorf("GetBlockStorageVolume: http response: %w", err)
1461 }
1462
1463 bodyresp := new(BlockStorageVolume)
1464 if err := prepareJSONResponse(response, bodyresp); err != nil {
1465 return nil, fmt.Errorf("GetBlockStorageVolume: prepare Json response: %w", err)
1466 }
1467
1468 return bodyresp, nil
1469 }
1470
1471 type UpdateBlockStorageVolumeRequest struct {
1472 Labels Labels `json:"labels"`
1473 // Volume name
1474 Name *string `json:"name,omitempty" validate:"omitempty,lte=255"`
1475 }
1476
1477 // Update block storage volume
1478 func (c Client) UpdateBlockStorageVolume(ctx context.Context, id UUID, req UpdateBlockStorageVolumeRequest) (*Operation, error) {
1479 path := fmt.Sprintf("/block-storage/%v", id)
1480
1481 body, err := prepareJSONBody(req)
1482 if err != nil {
1483 return nil, fmt.Errorf("UpdateBlockStorageVolume: prepare Json body: %w", err)
1484 }
1485
1486 request, err := http.NewRequestWithContext(ctx, "PUT", c.serverEndpoint+path, body)
1487 if err != nil {
1488 return nil, fmt.Errorf("UpdateBlockStorageVolume: new request: %w", err)
1489 }
1490
1491 request.Header.Add("User-Agent", c.getUserAgent())
1492
1493 request.Header.Add("Content-Type", "application/json")
1494
1495 if err := c.executeRequestInterceptors(ctx, request); err != nil {
1496 return nil, fmt.Errorf("UpdateBlockStorageVolume: execute request editors: %w", err)
1497 }
1498
1499 if err := c.signRequest(request); err != nil {
1500 return nil, fmt.Errorf("UpdateBlockStorageVolume: sign request: %w", err)
1501 }
1502
1503 if c.trace {
1504 dumpRequest(request, "update-block-storage-volume")
1505 }
1506
1507 response, err := c.httpClient.Do(request)
1508 if err != nil {
1509 return nil, fmt.Errorf("UpdateBlockStorageVolume: http client do: %w", err)
1510 }
1511
1512 if c.trace {
1513 dumpResponse(response)
1514 }
1515
1516 if err := handleHTTPErrorResp(response); err != nil {
1517 return nil, fmt.Errorf("UpdateBlockStorageVolume: http response: %w", err)
1518 }
1519
1520 bodyresp := new(Operation)
1521 if err := prepareJSONResponse(response, bodyresp); err != nil {
1522 return nil, fmt.Errorf("UpdateBlockStorageVolume: prepare Json response: %w", err)
1523 }
1524
1525 return bodyresp, nil
1526 }
1527
1528 type AttachBlockStorageVolumeToInstanceRequest struct {
1529 // Target Instance
1530 Instance *InstanceTarget `json:"instance" validate:"required"`
1531 }
1532
1533 // Attach block storage volume to an instance
1534 func (c Client) AttachBlockStorageVolumeToInstance(ctx context.Context, id UUID, req AttachBlockStorageVolumeToInstanceRequest) (*Operation, error) {
1535 path := fmt.Sprintf("/block-storage/%v:attach", id)
1536
1537 body, err := prepareJSONBody(req)
1538 if err != nil {
1539 return nil, fmt.Errorf("AttachBlockStorageVolumeToInstance: prepare Json body: %w", err)
1540 }
1541
1542 request, err := http.NewRequestWithContext(ctx, "PUT", c.serverEndpoint+path, body)
1543 if err != nil {
1544 return nil, fmt.Errorf("AttachBlockStorageVolumeToInstance: new request: %w", err)
1545 }
1546
1547 request.Header.Add("User-Agent", c.getUserAgent())
1548
1549 request.Header.Add("Content-Type", "application/json")
1550
1551 if err := c.executeRequestInterceptors(ctx, request); err != nil {
1552 return nil, fmt.Errorf("AttachBlockStorageVolumeToInstance: execute request editors: %w", err)
1553 }
1554
1555 if err := c.signRequest(request); err != nil {
1556 return nil, fmt.Errorf("AttachBlockStorageVolumeToInstance: sign request: %w", err)
1557 }
1558
1559 if c.trace {
1560 dumpRequest(request, "attach-block-storage-volume-to-instance")
1561 }
1562
1563 response, err := c.httpClient.Do(request)
1564 if err != nil {
1565 return nil, fmt.Errorf("AttachBlockStorageVolumeToInstance: http client do: %w", err)
1566 }
1567
1568 if c.trace {
1569 dumpResponse(response)
1570 }
1571
1572 if err := handleHTTPErrorResp(response); err != nil {
1573 return nil, fmt.Errorf("AttachBlockStorageVolumeToInstance: http response: %w", err)
1574 }
1575
1576 bodyresp := new(Operation)
1577 if err := prepareJSONResponse(response, bodyresp); err != nil {
1578 return nil, fmt.Errorf("AttachBlockStorageVolumeToInstance: prepare Json response: %w", err)
1579 }
1580
1581 return bodyresp, nil
1582 }
1583
1584 type CreateBlockStorageSnapshotRequest struct {
1585 Labels Labels `json:"labels,omitempty"`
1586 // Snapshot name
1587 Name string `json:"name,omitempty" validate:"omitempty,gte=1,lte=255"`
1588 }
1589
1590 // Create a block storage snapshot
1591 func (c Client) CreateBlockStorageSnapshot(ctx context.Context, id UUID, req CreateBlockStorageSnapshotRequest) (*Operation, error) {
1592 path := fmt.Sprintf("/block-storage/%v:create-snapshot", id)
1593
1594 body, err := prepareJSONBody(req)
1595 if err != nil {
1596 return nil, fmt.Errorf("CreateBlockStorageSnapshot: prepare Json body: %w", err)
1597 }
1598
1599 request, err := http.NewRequestWithContext(ctx, "POST", c.serverEndpoint+path, body)
1600 if err != nil {
1601 return nil, fmt.Errorf("CreateBlockStorageSnapshot: new request: %w", err)
1602 }
1603
1604 request.Header.Add("User-Agent", c.getUserAgent())
1605
1606 request.Header.Add("Content-Type", "application/json")
1607
1608 if err := c.executeRequestInterceptors(ctx, request); err != nil {
1609 return nil, fmt.Errorf("CreateBlockStorageSnapshot: execute request editors: %w", err)
1610 }
1611
1612 if err := c.signRequest(request); err != nil {
1613 return nil, fmt.Errorf("CreateBlockStorageSnapshot: sign request: %w", err)
1614 }
1615
1616 if c.trace {
1617 dumpRequest(request, "create-block-storage-snapshot")
1618 }
1619
1620 response, err := c.httpClient.Do(request)
1621 if err != nil {
1622 return nil, fmt.Errorf("CreateBlockStorageSnapshot: http client do: %w", err)
1623 }
1624
1625 if c.trace {
1626 dumpResponse(response)
1627 }
1628
1629 if err := handleHTTPErrorResp(response); err != nil {
1630 return nil, fmt.Errorf("CreateBlockStorageSnapshot: http response: %w", err)
1631 }
1632
1633 bodyresp := new(Operation)
1634 if err := prepareJSONResponse(response, bodyresp); err != nil {
1635 return nil, fmt.Errorf("CreateBlockStorageSnapshot: prepare Json response: %w", err)
1636 }
1637
1638 return bodyresp, nil
1639 }
1640
1641 // Detach block storage volume
1642 func (c Client) DetachBlockStorageVolume(ctx context.Context, id UUID) (*Operation, error) {
1643 path := fmt.Sprintf("/block-storage/%v:detach", id)
1644
1645 request, err := http.NewRequestWithContext(ctx, "PUT", c.serverEndpoint+path, nil)
1646 if err != nil {
1647 return nil, fmt.Errorf("DetachBlockStorageVolume: new request: %w", err)
1648 }
1649
1650 request.Header.Add("User-Agent", c.getUserAgent())
1651
1652 if err := c.executeRequestInterceptors(ctx, request); err != nil {
1653 return nil, fmt.Errorf("DetachBlockStorageVolume: execute request editors: %w", err)
1654 }
1655
1656 if err := c.signRequest(request); err != nil {
1657 return nil, fmt.Errorf("DetachBlockStorageVolume: sign request: %w", err)
1658 }
1659
1660 if c.trace {
1661 dumpRequest(request, "detach-block-storage-volume")
1662 }
1663
1664 response, err := c.httpClient.Do(request)
1665 if err != nil {
1666 return nil, fmt.Errorf("DetachBlockStorageVolume: http client do: %w", err)
1667 }
1668
1669 if c.trace {
1670 dumpResponse(response)
1671 }
1672
1673 if err := handleHTTPErrorResp(response); err != nil {
1674 return nil, fmt.Errorf("DetachBlockStorageVolume: http response: %w", err)
1675 }
1676
1677 bodyresp := new(Operation)
1678 if err := prepareJSONResponse(response, bodyresp); err != nil {
1679 return nil, fmt.Errorf("DetachBlockStorageVolume: prepare Json response: %w", err)
1680 }
1681
1682 return bodyresp, nil
1683 }
1684
1685 type ResizeBlockStorageVolumeRequest struct {
1686 // Volume size in GiB
1687 Size int64 `json:"size" validate:"required,gt=0"`
1688 }
1689
1690 // This operation resizes a Block storage volume. Note: the volume can only grow, cannot be shrunk. Only detached volumes or volumes attached to stopped instances can be resized.
1691 func (c Client) ResizeBlockStorageVolume(ctx context.Context, id UUID, req ResizeBlockStorageVolumeRequest) (*BlockStorageVolume, error) {
1692 path := fmt.Sprintf("/block-storage/%v:resize-volume", id)
1693
1694 body, err := prepareJSONBody(req)
1695 if err != nil {
1696 return nil, fmt.Errorf("ResizeBlockStorageVolume: prepare Json body: %w", err)
1697 }
1698
1699 request, err := http.NewRequestWithContext(ctx, "PUT", c.serverEndpoint+path, body)
1700 if err != nil {
1701 return nil, fmt.Errorf("ResizeBlockStorageVolume: new request: %w", err)
1702 }
1703
1704 request.Header.Add("User-Agent", c.getUserAgent())
1705
1706 request.Header.Add("Content-Type", "application/json")
1707
1708 if err := c.executeRequestInterceptors(ctx, request); err != nil {
1709 return nil, fmt.Errorf("ResizeBlockStorageVolume: execute request editors: %w", err)
1710 }
1711
1712 if err := c.signRequest(request); err != nil {
1713 return nil, fmt.Errorf("ResizeBlockStorageVolume: sign request: %w", err)
1714 }
1715
1716 if c.trace {
1717 dumpRequest(request, "resize-block-storage-volume")
1718 }
1719
1720 response, err := c.httpClient.Do(request)
1721 if err != nil {
1722 return nil, fmt.Errorf("ResizeBlockStorageVolume: http client do: %w", err)
1723 }
1724
1725 if c.trace {
1726 dumpResponse(response)
1727 }
1728
1729 if err := handleHTTPErrorResp(response); err != nil {
1730 return nil, fmt.Errorf("ResizeBlockStorageVolume: http response: %w", err)
1731 }
1732
1733 bodyresp := new(BlockStorageVolume)
1734 if err := prepareJSONResponse(response, bodyresp); err != nil {
1735 return nil, fmt.Errorf("ResizeBlockStorageVolume: prepare Json response: %w", err)
1736 }
1737
1738 return bodyresp, nil
1739 }
1740
1741 type GetConsoleProxyURLResponse struct {
1742 Host string `json:"host,omitempty"`
1743 Path string `json:"path,omitempty"`
1744 URL string `json:"url,omitempty"`
1745 }
1746
1747 // Retrieve signed url valid for 60 seconds to connect via console-proxy websocket to VM VNC console.
1748 func (c Client) GetConsoleProxyURL(ctx context.Context, id UUID) (*GetConsoleProxyURLResponse, error) {
1749 path := fmt.Sprintf("/console/%v", id)
1750
1751 request, err := http.NewRequestWithContext(ctx, "GET", c.serverEndpoint+path, nil)
1752 if err != nil {
1753 return nil, fmt.Errorf("GetConsoleProxyURL: new request: %w", err)
1754 }
1755
1756 request.Header.Add("User-Agent", c.getUserAgent())
1757
1758 if err := c.executeRequestInterceptors(ctx, request); err != nil {
1759 return nil, fmt.Errorf("GetConsoleProxyURL: execute request editors: %w", err)
1760 }
1761
1762 if err := c.signRequest(request); err != nil {
1763 return nil, fmt.Errorf("GetConsoleProxyURL: sign request: %w", err)
1764 }
1765
1766 if c.trace {
1767 dumpRequest(request, "get-console-proxy-url")
1768 }
1769
1770 response, err := c.httpClient.Do(request)
1771 if err != nil {
1772 return nil, fmt.Errorf("GetConsoleProxyURL: http client do: %w", err)
1773 }
1774
1775 if c.trace {
1776 dumpResponse(response)
1777 }
1778
1779 if err := handleHTTPErrorResp(response); err != nil {
1780 return nil, fmt.Errorf("GetConsoleProxyURL: http response: %w", err)
1781 }
1782
1783 bodyresp := new(GetConsoleProxyURLResponse)
1784 if err := prepareJSONResponse(response, bodyresp); err != nil {
1785 return nil, fmt.Errorf("GetConsoleProxyURL: prepare Json response: %w", err)
1786 }
1787
1788 return bodyresp, nil
1789 }
1790
1791 type GetDBAASCACertificateResponse struct {
1792 Certificate string `json:"certificate,omitempty"`
1793 }
1794
1795 // Returns a CA Certificate required to reach a DBaaS service through a TLS-protected connection.
1796 func (c Client) GetDBAASCACertificate(ctx context.Context) (*GetDBAASCACertificateResponse, error) {
1797 path := "/dbaas-ca-certificate"
1798
1799 request, err := http.NewRequestWithContext(ctx, "GET", c.serverEndpoint+path, nil)
1800 if err != nil {
1801 return nil, fmt.Errorf("GetDBAASCACertificate: new request: %w", err)
1802 }
1803
1804 request.Header.Add("User-Agent", c.getUserAgent())
1805
1806 if err := c.executeRequestInterceptors(ctx, request); err != nil {
1807 return nil, fmt.Errorf("GetDBAASCACertificate: execute request editors: %w", err)
1808 }
1809
1810 if err := c.signRequest(request); err != nil {
1811 return nil, fmt.Errorf("GetDBAASCACertificate: sign request: %w", err)
1812 }
1813
1814 if c.trace {
1815 dumpRequest(request, "get-dbaas-ca-certificate")
1816 }
1817
1818 response, err := c.httpClient.Do(request)
1819 if err != nil {
1820 return nil, fmt.Errorf("GetDBAASCACertificate: http client do: %w", err)
1821 }
1822
1823 if c.trace {
1824 dumpResponse(response)
1825 }
1826
1827 if err := handleHTTPErrorResp(response); err != nil {
1828 return nil, fmt.Errorf("GetDBAASCACertificate: http response: %w", err)
1829 }
1830
1831 bodyresp := new(GetDBAASCACertificateResponse)
1832 if err := prepareJSONResponse(response, bodyresp); err != nil {
1833 return nil, fmt.Errorf("GetDBAASCACertificate: prepare Json response: %w", err)
1834 }
1835
1836 return bodyresp, nil
1837 }
1838
1839 // [BETA] Delete DataDog external integration endpoint
1840 func (c Client) DeleteDBAASExternalEndpointDatadog(ctx context.Context, endpointID UUID) (*Operation, error) {
1841 path := fmt.Sprintf("/dbaas-external-endpoint-datadog/%v", endpointID)
1842
1843 request, err := http.NewRequestWithContext(ctx, "DELETE", c.serverEndpoint+path, nil)
1844 if err != nil {
1845 return nil, fmt.Errorf("DeleteDBAASExternalEndpointDatadog: new request: %w", err)
1846 }
1847
1848 request.Header.Add("User-Agent", c.getUserAgent())
1849
1850 if err := c.executeRequestInterceptors(ctx, request); err != nil {
1851 return nil, fmt.Errorf("DeleteDBAASExternalEndpointDatadog: execute request editors: %w", err)
1852 }
1853
1854 if err := c.signRequest(request); err != nil {
1855 return nil, fmt.Errorf("DeleteDBAASExternalEndpointDatadog: sign request: %w", err)
1856 }
1857
1858 if c.trace {
1859 dumpRequest(request, "delete-dbaas-external-endpoint-datadog")
1860 }
1861
1862 response, err := c.httpClient.Do(request)
1863 if err != nil {
1864 return nil, fmt.Errorf("DeleteDBAASExternalEndpointDatadog: http client do: %w", err)
1865 }
1866
1867 if c.trace {
1868 dumpResponse(response)
1869 }
1870
1871 if err := handleHTTPErrorResp(response); err != nil {
1872 return nil, fmt.Errorf("DeleteDBAASExternalEndpointDatadog: http response: %w", err)
1873 }
1874
1875 bodyresp := new(Operation)
1876 if err := prepareJSONResponse(response, bodyresp); err != nil {
1877 return nil, fmt.Errorf("DeleteDBAASExternalEndpointDatadog: prepare Json response: %w", err)
1878 }
1879
1880 return bodyresp, nil
1881 }
1882
1883 // [BETA] Get DataDog external endpoint settings
1884 func (c Client) GetDBAASExternalEndpointDatadog(ctx context.Context, endpointID UUID) (*DBAASExternalEndpointDatadogOutput, error) {
1885 path := fmt.Sprintf("/dbaas-external-endpoint-datadog/%v", endpointID)
1886
1887 request, err := http.NewRequestWithContext(ctx, "GET", c.serverEndpoint+path, nil)
1888 if err != nil {
1889 return nil, fmt.Errorf("GetDBAASExternalEndpointDatadog: new request: %w", err)
1890 }
1891
1892 request.Header.Add("User-Agent", c.getUserAgent())
1893
1894 if err := c.executeRequestInterceptors(ctx, request); err != nil {
1895 return nil, fmt.Errorf("GetDBAASExternalEndpointDatadog: execute request editors: %w", err)
1896 }
1897
1898 if err := c.signRequest(request); err != nil {
1899 return nil, fmt.Errorf("GetDBAASExternalEndpointDatadog: sign request: %w", err)
1900 }
1901
1902 if c.trace {
1903 dumpRequest(request, "get-dbaas-external-endpoint-datadog")
1904 }
1905
1906 response, err := c.httpClient.Do(request)
1907 if err != nil {
1908 return nil, fmt.Errorf("GetDBAASExternalEndpointDatadog: http client do: %w", err)
1909 }
1910
1911 if c.trace {
1912 dumpResponse(response)
1913 }
1914
1915 if err := handleHTTPErrorResp(response); err != nil {
1916 return nil, fmt.Errorf("GetDBAASExternalEndpointDatadog: http response: %w", err)
1917 }
1918
1919 bodyresp := new(DBAASExternalEndpointDatadogOutput)
1920 if err := prepareJSONResponse(response, bodyresp); err != nil {
1921 return nil, fmt.Errorf("GetDBAASExternalEndpointDatadog: prepare Json response: %w", err)
1922 }
1923
1924 return bodyresp, nil
1925 }
1926
1927 // [BETA] Update DataDog external integration endpoint
1928 func (c Client) UpdateDBAASExternalEndpointDatadog(ctx context.Context, endpointID UUID, req DBAASEndpointDatadogInputUpdate) (*Operation, error) {
1929 path := fmt.Sprintf("/dbaas-external-endpoint-datadog/%v", endpointID)
1930
1931 body, err := prepareJSONBody(req)
1932 if err != nil {
1933 return nil, fmt.Errorf("UpdateDBAASExternalEndpointDatadog: prepare Json body: %w", err)
1934 }
1935
1936 request, err := http.NewRequestWithContext(ctx, "PUT", c.serverEndpoint+path, body)
1937 if err != nil {
1938 return nil, fmt.Errorf("UpdateDBAASExternalEndpointDatadog: new request: %w", err)
1939 }
1940
1941 request.Header.Add("User-Agent", c.getUserAgent())
1942
1943 request.Header.Add("Content-Type", "application/json")
1944
1945 if err := c.executeRequestInterceptors(ctx, request); err != nil {
1946 return nil, fmt.Errorf("UpdateDBAASExternalEndpointDatadog: execute request editors: %w", err)
1947 }
1948
1949 if err := c.signRequest(request); err != nil {
1950 return nil, fmt.Errorf("UpdateDBAASExternalEndpointDatadog: sign request: %w", err)
1951 }
1952
1953 if c.trace {
1954 dumpRequest(request, "update-dbaas-external-endpoint-datadog")
1955 }
1956
1957 response, err := c.httpClient.Do(request)
1958 if err != nil {
1959 return nil, fmt.Errorf("UpdateDBAASExternalEndpointDatadog: http client do: %w", err)
1960 }
1961
1962 if c.trace {
1963 dumpResponse(response)
1964 }
1965
1966 if err := handleHTTPErrorResp(response); err != nil {
1967 return nil, fmt.Errorf("UpdateDBAASExternalEndpointDatadog: http response: %w", err)
1968 }
1969
1970 bodyresp := new(Operation)
1971 if err := prepareJSONResponse(response, bodyresp); err != nil {
1972 return nil, fmt.Errorf("UpdateDBAASExternalEndpointDatadog: prepare Json response: %w", err)
1973 }
1974
1975 return bodyresp, nil
1976 }
1977
1978 // [BETA] Create DataDog external integration endpoint
1979 func (c Client) CreateDBAASExternalEndpointDatadog(ctx context.Context, name string, req DBAASEndpointDatadogInputCreate) (*Operation, error) {
1980 path := fmt.Sprintf("/dbaas-external-endpoint-datadog/%v", name)
1981
1982 body, err := prepareJSONBody(req)
1983 if err != nil {
1984 return nil, fmt.Errorf("CreateDBAASExternalEndpointDatadog: prepare Json body: %w", err)
1985 }
1986
1987 request, err := http.NewRequestWithContext(ctx, "POST", c.serverEndpoint+path, body)
1988 if err != nil {
1989 return nil, fmt.Errorf("CreateDBAASExternalEndpointDatadog: new request: %w", err)
1990 }
1991
1992 request.Header.Add("User-Agent", c.getUserAgent())
1993
1994 request.Header.Add("Content-Type", "application/json")
1995
1996 if err := c.executeRequestInterceptors(ctx, request); err != nil {
1997 return nil, fmt.Errorf("CreateDBAASExternalEndpointDatadog: execute request editors: %w", err)
1998 }
1999
2000 if err := c.signRequest(request); err != nil {
2001 return nil, fmt.Errorf("CreateDBAASExternalEndpointDatadog: sign request: %w", err)
2002 }
2003
2004 if c.trace {
2005 dumpRequest(request, "create-dbaas-external-endpoint-datadog")
2006 }
2007
2008 response, err := c.httpClient.Do(request)
2009 if err != nil {
2010 return nil, fmt.Errorf("CreateDBAASExternalEndpointDatadog: http client do: %w", err)
2011 }
2012
2013 if c.trace {
2014 dumpResponse(response)
2015 }
2016
2017 if err := handleHTTPErrorResp(response); err != nil {
2018 return nil, fmt.Errorf("CreateDBAASExternalEndpointDatadog: http response: %w", err)
2019 }
2020
2021 bodyresp := new(Operation)
2022 if err := prepareJSONResponse(response, bodyresp); err != nil {
2023 return nil, fmt.Errorf("CreateDBAASExternalEndpointDatadog: prepare Json response: %w", err)
2024 }
2025
2026 return bodyresp, nil
2027 }
2028
2029 // [BETA] Delete ElasticSearch logs external integration endpoint
2030 func (c Client) DeleteDBAASExternalEndpointElasticsearch(ctx context.Context, endpointID UUID) (*Operation, error) {
2031 path := fmt.Sprintf("/dbaas-external-endpoint-elasticsearch/%v", endpointID)
2032
2033 request, err := http.NewRequestWithContext(ctx, "DELETE", c.serverEndpoint+path, nil)
2034 if err != nil {
2035 return nil, fmt.Errorf("DeleteDBAASExternalEndpointElasticsearch: new request: %w", err)
2036 }
2037
2038 request.Header.Add("User-Agent", c.getUserAgent())
2039
2040 if err := c.executeRequestInterceptors(ctx, request); err != nil {
2041 return nil, fmt.Errorf("DeleteDBAASExternalEndpointElasticsearch: execute request editors: %w", err)
2042 }
2043
2044 if err := c.signRequest(request); err != nil {
2045 return nil, fmt.Errorf("DeleteDBAASExternalEndpointElasticsearch: sign request: %w", err)
2046 }
2047
2048 if c.trace {
2049 dumpRequest(request, "delete-dbaas-external-endpoint-elasticsearch")
2050 }
2051
2052 response, err := c.httpClient.Do(request)
2053 if err != nil {
2054 return nil, fmt.Errorf("DeleteDBAASExternalEndpointElasticsearch: http client do: %w", err)
2055 }
2056
2057 if c.trace {
2058 dumpResponse(response)
2059 }
2060
2061 if err := handleHTTPErrorResp(response); err != nil {
2062 return nil, fmt.Errorf("DeleteDBAASExternalEndpointElasticsearch: http response: %w", err)
2063 }
2064
2065 bodyresp := new(Operation)
2066 if err := prepareJSONResponse(response, bodyresp); err != nil {
2067 return nil, fmt.Errorf("DeleteDBAASExternalEndpointElasticsearch: prepare Json response: %w", err)
2068 }
2069
2070 return bodyresp, nil
2071 }
2072
2073 // [BETA] Get ElasticSearch Logs external integration endpoint settings
2074 func (c Client) GetDBAASExternalEndpointElasticsearch(ctx context.Context, endpointID UUID) (*DBAASEndpointElasticsearchOutput, error) {
2075 path := fmt.Sprintf("/dbaas-external-endpoint-elasticsearch/%v", endpointID)
2076
2077 request, err := http.NewRequestWithContext(ctx, "GET", c.serverEndpoint+path, nil)
2078 if err != nil {
2079 return nil, fmt.Errorf("GetDBAASExternalEndpointElasticsearch: new request: %w", err)
2080 }
2081
2082 request.Header.Add("User-Agent", c.getUserAgent())
2083
2084 if err := c.executeRequestInterceptors(ctx, request); err != nil {
2085 return nil, fmt.Errorf("GetDBAASExternalEndpointElasticsearch: execute request editors: %w", err)
2086 }
2087
2088 if err := c.signRequest(request); err != nil {
2089 return nil, fmt.Errorf("GetDBAASExternalEndpointElasticsearch: sign request: %w", err)
2090 }
2091
2092 if c.trace {
2093 dumpRequest(request, "get-dbaas-external-endpoint-elasticsearch")
2094 }
2095
2096 response, err := c.httpClient.Do(request)
2097 if err != nil {
2098 return nil, fmt.Errorf("GetDBAASExternalEndpointElasticsearch: http client do: %w", err)
2099 }
2100
2101 if c.trace {
2102 dumpResponse(response)
2103 }
2104
2105 if err := handleHTTPErrorResp(response); err != nil {
2106 return nil, fmt.Errorf("GetDBAASExternalEndpointElasticsearch: http response: %w", err)
2107 }
2108
2109 bodyresp := new(DBAASEndpointElasticsearchOutput)
2110 if err := prepareJSONResponse(response, bodyresp); err != nil {
2111 return nil, fmt.Errorf("GetDBAASExternalEndpointElasticsearch: prepare Json response: %w", err)
2112 }
2113
2114 return bodyresp, nil
2115 }
2116
2117 // [BETA] Update ElasticSearch Logs external integration endpoint
2118 func (c Client) UpdateDBAASExternalEndpointElasticsearch(ctx context.Context, endpointID UUID, req DBAASEndpointElasticsearchInputUpdate) (*Operation, error) {
2119 path := fmt.Sprintf("/dbaas-external-endpoint-elasticsearch/%v", endpointID)
2120
2121 body, err := prepareJSONBody(req)
2122 if err != nil {
2123 return nil, fmt.Errorf("UpdateDBAASExternalEndpointElasticsearch: prepare Json body: %w", err)
2124 }
2125
2126 request, err := http.NewRequestWithContext(ctx, "PUT", c.serverEndpoint+path, body)
2127 if err != nil {
2128 return nil, fmt.Errorf("UpdateDBAASExternalEndpointElasticsearch: new request: %w", err)
2129 }
2130
2131 request.Header.Add("User-Agent", c.getUserAgent())
2132
2133 request.Header.Add("Content-Type", "application/json")
2134
2135 if err := c.executeRequestInterceptors(ctx, request); err != nil {
2136 return nil, fmt.Errorf("UpdateDBAASExternalEndpointElasticsearch: execute request editors: %w", err)
2137 }
2138
2139 if err := c.signRequest(request); err != nil {
2140 return nil, fmt.Errorf("UpdateDBAASExternalEndpointElasticsearch: sign request: %w", err)
2141 }
2142
2143 if c.trace {
2144 dumpRequest(request, "update-dbaas-external-endpoint-elasticsearch")
2145 }
2146
2147 response, err := c.httpClient.Do(request)
2148 if err != nil {
2149 return nil, fmt.Errorf("UpdateDBAASExternalEndpointElasticsearch: http client do: %w", err)
2150 }
2151
2152 if c.trace {
2153 dumpResponse(response)
2154 }
2155
2156 if err := handleHTTPErrorResp(response); err != nil {
2157 return nil, fmt.Errorf("UpdateDBAASExternalEndpointElasticsearch: http response: %w", err)
2158 }
2159
2160 bodyresp := new(Operation)
2161 if err := prepareJSONResponse(response, bodyresp); err != nil {
2162 return nil, fmt.Errorf("UpdateDBAASExternalEndpointElasticsearch: prepare Json response: %w", err)
2163 }
2164
2165 return bodyresp, nil
2166 }
2167
2168 // [BETA] Create ElasticSearch Logs external integration endpoint
2169 func (c Client) CreateDBAASExternalEndpointElasticsearch(ctx context.Context, name string, req DBAASEndpointElasticsearchInputCreate) (*Operation, error) {
2170 path := fmt.Sprintf("/dbaas-external-endpoint-elasticsearch/%v", name)
2171
2172 body, err := prepareJSONBody(req)
2173 if err != nil {
2174 return nil, fmt.Errorf("CreateDBAASExternalEndpointElasticsearch: prepare Json body: %w", err)
2175 }
2176
2177 request, err := http.NewRequestWithContext(ctx, "POST", c.serverEndpoint+path, body)
2178 if err != nil {
2179 return nil, fmt.Errorf("CreateDBAASExternalEndpointElasticsearch: new request: %w", err)
2180 }
2181
2182 request.Header.Add("User-Agent", c.getUserAgent())
2183
2184 request.Header.Add("Content-Type", "application/json")
2185
2186 if err := c.executeRequestInterceptors(ctx, request); err != nil {
2187 return nil, fmt.Errorf("CreateDBAASExternalEndpointElasticsearch: execute request editors: %w", err)
2188 }
2189
2190 if err := c.signRequest(request); err != nil {
2191 return nil, fmt.Errorf("CreateDBAASExternalEndpointElasticsearch: sign request: %w", err)
2192 }
2193
2194 if c.trace {
2195 dumpRequest(request, "create-dbaas-external-endpoint-elasticsearch")
2196 }
2197
2198 response, err := c.httpClient.Do(request)
2199 if err != nil {
2200 return nil, fmt.Errorf("CreateDBAASExternalEndpointElasticsearch: http client do: %w", err)
2201 }
2202
2203 if c.trace {
2204 dumpResponse(response)
2205 }
2206
2207 if err := handleHTTPErrorResp(response); err != nil {
2208 return nil, fmt.Errorf("CreateDBAASExternalEndpointElasticsearch: http response: %w", err)
2209 }
2210
2211 bodyresp := new(Operation)
2212 if err := prepareJSONResponse(response, bodyresp); err != nil {
2213 return nil, fmt.Errorf("CreateDBAASExternalEndpointElasticsearch: prepare Json response: %w", err)
2214 }
2215
2216 return bodyresp, nil
2217 }
2218
2219 // [BETA] Delete OpenSearch logs external integration endpoint
2220 func (c Client) DeleteDBAASExternalEndpointOpensearch(ctx context.Context, endpointID UUID) (*Operation, error) {
2221 path := fmt.Sprintf("/dbaas-external-endpoint-opensearch/%v", endpointID)
2222
2223 request, err := http.NewRequestWithContext(ctx, "DELETE", c.serverEndpoint+path, nil)
2224 if err != nil {
2225 return nil, fmt.Errorf("DeleteDBAASExternalEndpointOpensearch: new request: %w", err)
2226 }
2227
2228 request.Header.Add("User-Agent", c.getUserAgent())
2229
2230 if err := c.executeRequestInterceptors(ctx, request); err != nil {
2231 return nil, fmt.Errorf("DeleteDBAASExternalEndpointOpensearch: execute request editors: %w", err)
2232 }
2233
2234 if err := c.signRequest(request); err != nil {
2235 return nil, fmt.Errorf("DeleteDBAASExternalEndpointOpensearch: sign request: %w", err)
2236 }
2237
2238 if c.trace {
2239 dumpRequest(request, "delete-dbaas-external-endpoint-opensearch")
2240 }
2241
2242 response, err := c.httpClient.Do(request)
2243 if err != nil {
2244 return nil, fmt.Errorf("DeleteDBAASExternalEndpointOpensearch: http client do: %w", err)
2245 }
2246
2247 if c.trace {
2248 dumpResponse(response)
2249 }
2250
2251 if err := handleHTTPErrorResp(response); err != nil {
2252 return nil, fmt.Errorf("DeleteDBAASExternalEndpointOpensearch: http response: %w", err)
2253 }
2254
2255 bodyresp := new(Operation)
2256 if err := prepareJSONResponse(response, bodyresp); err != nil {
2257 return nil, fmt.Errorf("DeleteDBAASExternalEndpointOpensearch: prepare Json response: %w", err)
2258 }
2259
2260 return bodyresp, nil
2261 }
2262
2263 // [BETA] Get OpenSearch Logs external integration endpoint settings
2264 func (c Client) GetDBAASExternalEndpointOpensearch(ctx context.Context, endpointID UUID) (*DBAASEndpointOpensearchOutput, error) {
2265 path := fmt.Sprintf("/dbaas-external-endpoint-opensearch/%v", endpointID)
2266
2267 request, err := http.NewRequestWithContext(ctx, "GET", c.serverEndpoint+path, nil)
2268 if err != nil {
2269 return nil, fmt.Errorf("GetDBAASExternalEndpointOpensearch: new request: %w", err)
2270 }
2271
2272 request.Header.Add("User-Agent", c.getUserAgent())
2273
2274 if err := c.executeRequestInterceptors(ctx, request); err != nil {
2275 return nil, fmt.Errorf("GetDBAASExternalEndpointOpensearch: execute request editors: %w", err)
2276 }
2277
2278 if err := c.signRequest(request); err != nil {
2279 return nil, fmt.Errorf("GetDBAASExternalEndpointOpensearch: sign request: %w", err)
2280 }
2281
2282 if c.trace {
2283 dumpRequest(request, "get-dbaas-external-endpoint-opensearch")
2284 }
2285
2286 response, err := c.httpClient.Do(request)
2287 if err != nil {
2288 return nil, fmt.Errorf("GetDBAASExternalEndpointOpensearch: http client do: %w", err)
2289 }
2290
2291 if c.trace {
2292 dumpResponse(response)
2293 }
2294
2295 if err := handleHTTPErrorResp(response); err != nil {
2296 return nil, fmt.Errorf("GetDBAASExternalEndpointOpensearch: http response: %w", err)
2297 }
2298
2299 bodyresp := new(DBAASEndpointOpensearchOutput)
2300 if err := prepareJSONResponse(response, bodyresp); err != nil {
2301 return nil, fmt.Errorf("GetDBAASExternalEndpointOpensearch: prepare Json response: %w", err)
2302 }
2303
2304 return bodyresp, nil
2305 }
2306
2307 // [BETA] Update OpenSearch Logs external integration endpoint
2308 func (c Client) UpdateDBAASExternalEndpointOpensearch(ctx context.Context, endpointID UUID, req DBAASEndpointOpensearchInputUpdate) (*Operation, error) {
2309 path := fmt.Sprintf("/dbaas-external-endpoint-opensearch/%v", endpointID)
2310
2311 body, err := prepareJSONBody(req)
2312 if err != nil {
2313 return nil, fmt.Errorf("UpdateDBAASExternalEndpointOpensearch: prepare Json body: %w", err)
2314 }
2315
2316 request, err := http.NewRequestWithContext(ctx, "PUT", c.serverEndpoint+path, body)
2317 if err != nil {
2318 return nil, fmt.Errorf("UpdateDBAASExternalEndpointOpensearch: new request: %w", err)
2319 }
2320
2321 request.Header.Add("User-Agent", c.getUserAgent())
2322
2323 request.Header.Add("Content-Type", "application/json")
2324
2325 if err := c.executeRequestInterceptors(ctx, request); err != nil {
2326 return nil, fmt.Errorf("UpdateDBAASExternalEndpointOpensearch: execute request editors: %w", err)
2327 }
2328
2329 if err := c.signRequest(request); err != nil {
2330 return nil, fmt.Errorf("UpdateDBAASExternalEndpointOpensearch: sign request: %w", err)
2331 }
2332
2333 if c.trace {
2334 dumpRequest(request, "update-dbaas-external-endpoint-opensearch")
2335 }
2336
2337 response, err := c.httpClient.Do(request)
2338 if err != nil {
2339 return nil, fmt.Errorf("UpdateDBAASExternalEndpointOpensearch: http client do: %w", err)
2340 }
2341
2342 if c.trace {
2343 dumpResponse(response)
2344 }
2345
2346 if err := handleHTTPErrorResp(response); err != nil {
2347 return nil, fmt.Errorf("UpdateDBAASExternalEndpointOpensearch: http response: %w", err)
2348 }
2349
2350 bodyresp := new(Operation)
2351 if err := prepareJSONResponse(response, bodyresp); err != nil {
2352 return nil, fmt.Errorf("UpdateDBAASExternalEndpointOpensearch: prepare Json response: %w", err)
2353 }
2354
2355 return bodyresp, nil
2356 }
2357
2358 // [BETA] Create OpenSearch Logs external integration endpoint
2359 func (c Client) CreateDBAASExternalEndpointOpensearch(ctx context.Context, name string, req DBAASEndpointOpensearchInputCreate) (*Operation, error) {
2360 path := fmt.Sprintf("/dbaas-external-endpoint-opensearch/%v", name)
2361
2362 body, err := prepareJSONBody(req)
2363 if err != nil {
2364 return nil, fmt.Errorf("CreateDBAASExternalEndpointOpensearch: prepare Json body: %w", err)
2365 }
2366
2367 request, err := http.NewRequestWithContext(ctx, "POST", c.serverEndpoint+path, body)
2368 if err != nil {
2369 return nil, fmt.Errorf("CreateDBAASExternalEndpointOpensearch: new request: %w", err)
2370 }
2371
2372 request.Header.Add("User-Agent", c.getUserAgent())
2373
2374 request.Header.Add("Content-Type", "application/json")
2375
2376 if err := c.executeRequestInterceptors(ctx, request); err != nil {
2377 return nil, fmt.Errorf("CreateDBAASExternalEndpointOpensearch: execute request editors: %w", err)
2378 }
2379
2380 if err := c.signRequest(request); err != nil {
2381 return nil, fmt.Errorf("CreateDBAASExternalEndpointOpensearch: sign request: %w", err)
2382 }
2383
2384 if c.trace {
2385 dumpRequest(request, "create-dbaas-external-endpoint-opensearch")
2386 }
2387
2388 response, err := c.httpClient.Do(request)
2389 if err != nil {
2390 return nil, fmt.Errorf("CreateDBAASExternalEndpointOpensearch: http client do: %w", err)
2391 }
2392
2393 if c.trace {
2394 dumpResponse(response)
2395 }
2396
2397 if err := handleHTTPErrorResp(response); err != nil {
2398 return nil, fmt.Errorf("CreateDBAASExternalEndpointOpensearch: http response: %w", err)
2399 }
2400
2401 bodyresp := new(Operation)
2402 if err := prepareJSONResponse(response, bodyresp); err != nil {
2403 return nil, fmt.Errorf("CreateDBAASExternalEndpointOpensearch: prepare Json response: %w", err)
2404 }
2405
2406 return bodyresp, nil
2407 }
2408
2409 // [BETA] Delete Prometheus external integration endpoint
2410 func (c Client) DeleteDBAASExternalEndpointPrometheus(ctx context.Context, endpointID UUID) (*Operation, error) {
2411 path := fmt.Sprintf("/dbaas-external-endpoint-prometheus/%v", endpointID)
2412
2413 request, err := http.NewRequestWithContext(ctx, "DELETE", c.serverEndpoint+path, nil)
2414 if err != nil {
2415 return nil, fmt.Errorf("DeleteDBAASExternalEndpointPrometheus: new request: %w", err)
2416 }
2417
2418 request.Header.Add("User-Agent", c.getUserAgent())
2419
2420 if err := c.executeRequestInterceptors(ctx, request); err != nil {
2421 return nil, fmt.Errorf("DeleteDBAASExternalEndpointPrometheus: execute request editors: %w", err)
2422 }
2423
2424 if err := c.signRequest(request); err != nil {
2425 return nil, fmt.Errorf("DeleteDBAASExternalEndpointPrometheus: sign request: %w", err)
2426 }
2427
2428 if c.trace {
2429 dumpRequest(request, "delete-dbaas-external-endpoint-prometheus")
2430 }
2431
2432 response, err := c.httpClient.Do(request)
2433 if err != nil {
2434 return nil, fmt.Errorf("DeleteDBAASExternalEndpointPrometheus: http client do: %w", err)
2435 }
2436
2437 if c.trace {
2438 dumpResponse(response)
2439 }
2440
2441 if err := handleHTTPErrorResp(response); err != nil {
2442 return nil, fmt.Errorf("DeleteDBAASExternalEndpointPrometheus: http response: %w", err)
2443 }
2444
2445 bodyresp := new(Operation)
2446 if err := prepareJSONResponse(response, bodyresp); err != nil {
2447 return nil, fmt.Errorf("DeleteDBAASExternalEndpointPrometheus: prepare Json response: %w", err)
2448 }
2449
2450 return bodyresp, nil
2451 }
2452
2453 // [BETA] Get Prometheus external integration endpoint settings
2454 func (c Client) GetDBAASExternalEndpointPrometheus(ctx context.Context, endpointID UUID) (*DBAASEndpointExternalPrometheusOutput, error) {
2455 path := fmt.Sprintf("/dbaas-external-endpoint-prometheus/%v", endpointID)
2456
2457 request, err := http.NewRequestWithContext(ctx, "GET", c.serverEndpoint+path, nil)
2458 if err != nil {
2459 return nil, fmt.Errorf("GetDBAASExternalEndpointPrometheus: new request: %w", err)
2460 }
2461
2462 request.Header.Add("User-Agent", c.getUserAgent())
2463
2464 if err := c.executeRequestInterceptors(ctx, request); err != nil {
2465 return nil, fmt.Errorf("GetDBAASExternalEndpointPrometheus: execute request editors: %w", err)
2466 }
2467
2468 if err := c.signRequest(request); err != nil {
2469 return nil, fmt.Errorf("GetDBAASExternalEndpointPrometheus: sign request: %w", err)
2470 }
2471
2472 if c.trace {
2473 dumpRequest(request, "get-dbaas-external-endpoint-prometheus")
2474 }
2475
2476 response, err := c.httpClient.Do(request)
2477 if err != nil {
2478 return nil, fmt.Errorf("GetDBAASExternalEndpointPrometheus: http client do: %w", err)
2479 }
2480
2481 if c.trace {
2482 dumpResponse(response)
2483 }
2484
2485 if err := handleHTTPErrorResp(response); err != nil {
2486 return nil, fmt.Errorf("GetDBAASExternalEndpointPrometheus: http response: %w", err)
2487 }
2488
2489 bodyresp := new(DBAASEndpointExternalPrometheusOutput)
2490 if err := prepareJSONResponse(response, bodyresp); err != nil {
2491 return nil, fmt.Errorf("GetDBAASExternalEndpointPrometheus: prepare Json response: %w", err)
2492 }
2493
2494 return bodyresp, nil
2495 }
2496
2497 // [BETA] Update Prometheus external integration endpoint
2498 func (c Client) UpdateDBAASExternalEndpointPrometheus(ctx context.Context, endpointID UUID, req DBAASEndpointPrometheusPayload) (*Operation, error) {
2499 path := fmt.Sprintf("/dbaas-external-endpoint-prometheus/%v", endpointID)
2500
2501 body, err := prepareJSONBody(req)
2502 if err != nil {
2503 return nil, fmt.Errorf("UpdateDBAASExternalEndpointPrometheus: prepare Json body: %w", err)
2504 }
2505
2506 request, err := http.NewRequestWithContext(ctx, "PUT", c.serverEndpoint+path, body)
2507 if err != nil {
2508 return nil, fmt.Errorf("UpdateDBAASExternalEndpointPrometheus: new request: %w", err)
2509 }
2510
2511 request.Header.Add("User-Agent", c.getUserAgent())
2512
2513 request.Header.Add("Content-Type", "application/json")
2514
2515 if err := c.executeRequestInterceptors(ctx, request); err != nil {
2516 return nil, fmt.Errorf("UpdateDBAASExternalEndpointPrometheus: execute request editors: %w", err)
2517 }
2518
2519 if err := c.signRequest(request); err != nil {
2520 return nil, fmt.Errorf("UpdateDBAASExternalEndpointPrometheus: sign request: %w", err)
2521 }
2522
2523 if c.trace {
2524 dumpRequest(request, "update-dbaas-external-endpoint-prometheus")
2525 }
2526
2527 response, err := c.httpClient.Do(request)
2528 if err != nil {
2529 return nil, fmt.Errorf("UpdateDBAASExternalEndpointPrometheus: http client do: %w", err)
2530 }
2531
2532 if c.trace {
2533 dumpResponse(response)
2534 }
2535
2536 if err := handleHTTPErrorResp(response); err != nil {
2537 return nil, fmt.Errorf("UpdateDBAASExternalEndpointPrometheus: http response: %w", err)
2538 }
2539
2540 bodyresp := new(Operation)
2541 if err := prepareJSONResponse(response, bodyresp); err != nil {
2542 return nil, fmt.Errorf("UpdateDBAASExternalEndpointPrometheus: prepare Json response: %w", err)
2543 }
2544
2545 return bodyresp, nil
2546 }
2547
2548 // [BETA] Create Prometheus external integration endpoint
2549 func (c Client) CreateDBAASExternalEndpointPrometheus(ctx context.Context, name string, req DBAASEndpointPrometheusPayload) (*Operation, error) {
2550 path := fmt.Sprintf("/dbaas-external-endpoint-prometheus/%v", name)
2551
2552 body, err := prepareJSONBody(req)
2553 if err != nil {
2554 return nil, fmt.Errorf("CreateDBAASExternalEndpointPrometheus: prepare Json body: %w", err)
2555 }
2556
2557 request, err := http.NewRequestWithContext(ctx, "POST", c.serverEndpoint+path, body)
2558 if err != nil {
2559 return nil, fmt.Errorf("CreateDBAASExternalEndpointPrometheus: new request: %w", err)
2560 }
2561
2562 request.Header.Add("User-Agent", c.getUserAgent())
2563
2564 request.Header.Add("Content-Type", "application/json")
2565
2566 if err := c.executeRequestInterceptors(ctx, request); err != nil {
2567 return nil, fmt.Errorf("CreateDBAASExternalEndpointPrometheus: execute request editors: %w", err)
2568 }
2569
2570 if err := c.signRequest(request); err != nil {
2571 return nil, fmt.Errorf("CreateDBAASExternalEndpointPrometheus: sign request: %w", err)
2572 }
2573
2574 if c.trace {
2575 dumpRequest(request, "create-dbaas-external-endpoint-prometheus")
2576 }
2577
2578 response, err := c.httpClient.Do(request)
2579 if err != nil {
2580 return nil, fmt.Errorf("CreateDBAASExternalEndpointPrometheus: http client do: %w", err)
2581 }
2582
2583 if c.trace {
2584 dumpResponse(response)
2585 }
2586
2587 if err := handleHTTPErrorResp(response); err != nil {
2588 return nil, fmt.Errorf("CreateDBAASExternalEndpointPrometheus: http response: %w", err)
2589 }
2590
2591 bodyresp := new(Operation)
2592 if err := prepareJSONResponse(response, bodyresp); err != nil {
2593 return nil, fmt.Errorf("CreateDBAASExternalEndpointPrometheus: prepare Json response: %w", err)
2594 }
2595
2596 return bodyresp, nil
2597 }
2598
2599 // [BETA] Delete RSyslog external integration endpoint
2600 func (c Client) DeleteDBAASExternalEndpointRsyslog(ctx context.Context, endpointID UUID) (*Operation, error) {
2601 path := fmt.Sprintf("/dbaas-external-endpoint-rsyslog/%v", endpointID)
2602
2603 request, err := http.NewRequestWithContext(ctx, "DELETE", c.serverEndpoint+path, nil)
2604 if err != nil {
2605 return nil, fmt.Errorf("DeleteDBAASExternalEndpointRsyslog: new request: %w", err)
2606 }
2607
2608 request.Header.Add("User-Agent", c.getUserAgent())
2609
2610 if err := c.executeRequestInterceptors(ctx, request); err != nil {
2611 return nil, fmt.Errorf("DeleteDBAASExternalEndpointRsyslog: execute request editors: %w", err)
2612 }
2613
2614 if err := c.signRequest(request); err != nil {
2615 return nil, fmt.Errorf("DeleteDBAASExternalEndpointRsyslog: sign request: %w", err)
2616 }
2617
2618 if c.trace {
2619 dumpRequest(request, "delete-dbaas-external-endpoint-rsyslog")
2620 }
2621
2622 response, err := c.httpClient.Do(request)
2623 if err != nil {
2624 return nil, fmt.Errorf("DeleteDBAASExternalEndpointRsyslog: http client do: %w", err)
2625 }
2626
2627 if c.trace {
2628 dumpResponse(response)
2629 }
2630
2631 if err := handleHTTPErrorResp(response); err != nil {
2632 return nil, fmt.Errorf("DeleteDBAASExternalEndpointRsyslog: http response: %w", err)
2633 }
2634
2635 bodyresp := new(Operation)
2636 if err := prepareJSONResponse(response, bodyresp); err != nil {
2637 return nil, fmt.Errorf("DeleteDBAASExternalEndpointRsyslog: prepare Json response: %w", err)
2638 }
2639
2640 return bodyresp, nil
2641 }
2642
2643 // [BETA] Get RSyslog external integration endpoint settings
2644 func (c Client) GetDBAASExternalEndpointRsyslog(ctx context.Context, endpointID UUID) (*DBAASExternalEndpointRsyslogOutput, error) {
2645 path := fmt.Sprintf("/dbaas-external-endpoint-rsyslog/%v", endpointID)
2646
2647 request, err := http.NewRequestWithContext(ctx, "GET", c.serverEndpoint+path, nil)
2648 if err != nil {
2649 return nil, fmt.Errorf("GetDBAASExternalEndpointRsyslog: new request: %w", err)
2650 }
2651
2652 request.Header.Add("User-Agent", c.getUserAgent())
2653
2654 if err := c.executeRequestInterceptors(ctx, request); err != nil {
2655 return nil, fmt.Errorf("GetDBAASExternalEndpointRsyslog: execute request editors: %w", err)
2656 }
2657
2658 if err := c.signRequest(request); err != nil {
2659 return nil, fmt.Errorf("GetDBAASExternalEndpointRsyslog: sign request: %w", err)
2660 }
2661
2662 if c.trace {
2663 dumpRequest(request, "get-dbaas-external-endpoint-rsyslog")
2664 }
2665
2666 response, err := c.httpClient.Do(request)
2667 if err != nil {
2668 return nil, fmt.Errorf("GetDBAASExternalEndpointRsyslog: http client do: %w", err)
2669 }
2670
2671 if c.trace {
2672 dumpResponse(response)
2673 }
2674
2675 if err := handleHTTPErrorResp(response); err != nil {
2676 return nil, fmt.Errorf("GetDBAASExternalEndpointRsyslog: http response: %w", err)
2677 }
2678
2679 bodyresp := new(DBAASExternalEndpointRsyslogOutput)
2680 if err := prepareJSONResponse(response, bodyresp); err != nil {
2681 return nil, fmt.Errorf("GetDBAASExternalEndpointRsyslog: prepare Json response: %w", err)
2682 }
2683
2684 return bodyresp, nil
2685 }
2686
2687 // [BETA] Update RSyslog external integration endpoint
2688 func (c Client) UpdateDBAASExternalEndpointRsyslog(ctx context.Context, endpointID UUID, req DBAASEndpointRsyslogInputUpdate) (*Operation, error) {
2689 path := fmt.Sprintf("/dbaas-external-endpoint-rsyslog/%v", endpointID)
2690
2691 body, err := prepareJSONBody(req)
2692 if err != nil {
2693 return nil, fmt.Errorf("UpdateDBAASExternalEndpointRsyslog: prepare Json body: %w", err)
2694 }
2695
2696 request, err := http.NewRequestWithContext(ctx, "PUT", c.serverEndpoint+path, body)
2697 if err != nil {
2698 return nil, fmt.Errorf("UpdateDBAASExternalEndpointRsyslog: new request: %w", err)
2699 }
2700
2701 request.Header.Add("User-Agent", c.getUserAgent())
2702
2703 request.Header.Add("Content-Type", "application/json")
2704
2705 if err := c.executeRequestInterceptors(ctx, request); err != nil {
2706 return nil, fmt.Errorf("UpdateDBAASExternalEndpointRsyslog: execute request editors: %w", err)
2707 }
2708
2709 if err := c.signRequest(request); err != nil {
2710 return nil, fmt.Errorf("UpdateDBAASExternalEndpointRsyslog: sign request: %w", err)
2711 }
2712
2713 if c.trace {
2714 dumpRequest(request, "update-dbaas-external-endpoint-rsyslog")
2715 }
2716
2717 response, err := c.httpClient.Do(request)
2718 if err != nil {
2719 return nil, fmt.Errorf("UpdateDBAASExternalEndpointRsyslog: http client do: %w", err)
2720 }
2721
2722 if c.trace {
2723 dumpResponse(response)
2724 }
2725
2726 if err := handleHTTPErrorResp(response); err != nil {
2727 return nil, fmt.Errorf("UpdateDBAASExternalEndpointRsyslog: http response: %w", err)
2728 }
2729
2730 bodyresp := new(Operation)
2731 if err := prepareJSONResponse(response, bodyresp); err != nil {
2732 return nil, fmt.Errorf("UpdateDBAASExternalEndpointRsyslog: prepare Json response: %w", err)
2733 }
2734
2735 return bodyresp, nil
2736 }
2737
2738 // [BETA] Create RSyslog external integration endpoint
2739 func (c Client) CreateDBAASExternalEndpointRsyslog(ctx context.Context, name string, req DBAASEndpointRsyslogInputCreate) (*Operation, error) {
2740 path := fmt.Sprintf("/dbaas-external-endpoint-rsyslog/%v", name)
2741
2742 body, err := prepareJSONBody(req)
2743 if err != nil {
2744 return nil, fmt.Errorf("CreateDBAASExternalEndpointRsyslog: prepare Json body: %w", err)
2745 }
2746
2747 request, err := http.NewRequestWithContext(ctx, "POST", c.serverEndpoint+path, body)
2748 if err != nil {
2749 return nil, fmt.Errorf("CreateDBAASExternalEndpointRsyslog: new request: %w", err)
2750 }
2751
2752 request.Header.Add("User-Agent", c.getUserAgent())
2753
2754 request.Header.Add("Content-Type", "application/json")
2755
2756 if err := c.executeRequestInterceptors(ctx, request); err != nil {
2757 return nil, fmt.Errorf("CreateDBAASExternalEndpointRsyslog: execute request editors: %w", err)
2758 }
2759
2760 if err := c.signRequest(request); err != nil {
2761 return nil, fmt.Errorf("CreateDBAASExternalEndpointRsyslog: sign request: %w", err)
2762 }
2763
2764 if c.trace {
2765 dumpRequest(request, "create-dbaas-external-endpoint-rsyslog")
2766 }
2767
2768 response, err := c.httpClient.Do(request)
2769 if err != nil {
2770 return nil, fmt.Errorf("CreateDBAASExternalEndpointRsyslog: http client do: %w", err)
2771 }
2772
2773 if c.trace {
2774 dumpResponse(response)
2775 }
2776
2777 if err := handleHTTPErrorResp(response); err != nil {
2778 return nil, fmt.Errorf("CreateDBAASExternalEndpointRsyslog: http response: %w", err)
2779 }
2780
2781 bodyresp := new(Operation)
2782 if err := prepareJSONResponse(response, bodyresp); err != nil {
2783 return nil, fmt.Errorf("CreateDBAASExternalEndpointRsyslog: prepare Json response: %w", err)
2784 }
2785
2786 return bodyresp, nil
2787 }
2788
2789 type ListDBAASExternalEndpointTypesResponseEndpointTypes struct {
2790 ServiceTypes []string `json:"service-types,omitempty"`
2791 Title string `json:"title,omitempty"`
2792 Type EnumExternalEndpointTypes `json:"type,omitempty"`
2793 }
2794
2795 type ListDBAASExternalEndpointTypesResponse struct {
2796 EndpointTypes []ListDBAASExternalEndpointTypesResponseEndpointTypes `json:"endpoint-types,omitempty"`
2797 }
2798
2799 // [BETA] List available external endpoint types and their schemas for DBaaS external integrations
2800 func (c Client) ListDBAASExternalEndpointTypes(ctx context.Context) (*ListDBAASExternalEndpointTypesResponse, error) {
2801 path := "/dbaas-external-endpoint-types"
2802
2803 request, err := http.NewRequestWithContext(ctx, "GET", c.serverEndpoint+path, nil)
2804 if err != nil {
2805 return nil, fmt.Errorf("ListDBAASExternalEndpointTypes: new request: %w", err)
2806 }
2807
2808 request.Header.Add("User-Agent", c.getUserAgent())
2809
2810 if err := c.executeRequestInterceptors(ctx, request); err != nil {
2811 return nil, fmt.Errorf("ListDBAASExternalEndpointTypes: execute request editors: %w", err)
2812 }
2813
2814 if err := c.signRequest(request); err != nil {
2815 return nil, fmt.Errorf("ListDBAASExternalEndpointTypes: sign request: %w", err)
2816 }
2817
2818 if c.trace {
2819 dumpRequest(request, "list-dbaas-external-endpoint-types")
2820 }
2821
2822 response, err := c.httpClient.Do(request)
2823 if err != nil {
2824 return nil, fmt.Errorf("ListDBAASExternalEndpointTypes: http client do: %w", err)
2825 }
2826
2827 if c.trace {
2828 dumpResponse(response)
2829 }
2830
2831 if err := handleHTTPErrorResp(response); err != nil {
2832 return nil, fmt.Errorf("ListDBAASExternalEndpointTypes: http response: %w", err)
2833 }
2834
2835 bodyresp := new(ListDBAASExternalEndpointTypesResponse)
2836 if err := prepareJSONResponse(response, bodyresp); err != nil {
2837 return nil, fmt.Errorf("ListDBAASExternalEndpointTypes: prepare Json response: %w", err)
2838 }
2839
2840 return bodyresp, nil
2841 }
2842
2843 type AttachDBAASServiceToEndpointRequest struct {
2844 // External endpoint id
2845 DestEndpointID UUID `json:"dest-endpoint-id" validate:"required"`
2846 Type EnumExternalEndpointTypes `json:"type" validate:"required"`
2847 }
2848
2849 // [BETA] Create a new DBaaS connection between a DBaaS service and an external service
2850 func (c Client) AttachDBAASServiceToEndpoint(ctx context.Context, sourceServiceName string, req AttachDBAASServiceToEndpointRequest) (*Operation, error) {
2851 path := fmt.Sprintf("/dbaas-external-endpoint/%v/attach", sourceServiceName)
2852
2853 body, err := prepareJSONBody(req)
2854 if err != nil {
2855 return nil, fmt.Errorf("AttachDBAASServiceToEndpoint: prepare Json body: %w", err)
2856 }
2857
2858 request, err := http.NewRequestWithContext(ctx, "PUT", c.serverEndpoint+path, body)
2859 if err != nil {
2860 return nil, fmt.Errorf("AttachDBAASServiceToEndpoint: new request: %w", err)
2861 }
2862
2863 request.Header.Add("User-Agent", c.getUserAgent())
2864
2865 request.Header.Add("Content-Type", "application/json")
2866
2867 if err := c.executeRequestInterceptors(ctx, request); err != nil {
2868 return nil, fmt.Errorf("AttachDBAASServiceToEndpoint: execute request editors: %w", err)
2869 }
2870
2871 if err := c.signRequest(request); err != nil {
2872 return nil, fmt.Errorf("AttachDBAASServiceToEndpoint: sign request: %w", err)
2873 }
2874
2875 if c.trace {
2876 dumpRequest(request, "attach-dbaas-service-to-endpoint")
2877 }
2878
2879 response, err := c.httpClient.Do(request)
2880 if err != nil {
2881 return nil, fmt.Errorf("AttachDBAASServiceToEndpoint: http client do: %w", err)
2882 }
2883
2884 if c.trace {
2885 dumpResponse(response)
2886 }
2887
2888 if err := handleHTTPErrorResp(response); err != nil {
2889 return nil, fmt.Errorf("AttachDBAASServiceToEndpoint: http response: %w", err)
2890 }
2891
2892 bodyresp := new(Operation)
2893 if err := prepareJSONResponse(response, bodyresp); err != nil {
2894 return nil, fmt.Errorf("AttachDBAASServiceToEndpoint: prepare Json response: %w", err)
2895 }
2896
2897 return bodyresp, nil
2898 }
2899
2900 type DetachDBAASServiceFromEndpointRequest struct {
2901 // External Integration ID
2902 IntegrationID UUID `json:"integration-id" validate:"required"`
2903 }
2904
2905 // [BETA] Detach a DBaaS external integration from a service
2906 func (c Client) DetachDBAASServiceFromEndpoint(ctx context.Context, sourceServiceName string, req DetachDBAASServiceFromEndpointRequest) (*Operation, error) {
2907 path := fmt.Sprintf("/dbaas-external-endpoint/%v/detach", sourceServiceName)
2908
2909 body, err := prepareJSONBody(req)
2910 if err != nil {
2911 return nil, fmt.Errorf("DetachDBAASServiceFromEndpoint: prepare Json body: %w", err)
2912 }
2913
2914 request, err := http.NewRequestWithContext(ctx, "PUT", c.serverEndpoint+path, body)
2915 if err != nil {
2916 return nil, fmt.Errorf("DetachDBAASServiceFromEndpoint: new request: %w", err)
2917 }
2918
2919 request.Header.Add("User-Agent", c.getUserAgent())
2920
2921 request.Header.Add("Content-Type", "application/json")
2922
2923 if err := c.executeRequestInterceptors(ctx, request); err != nil {
2924 return nil, fmt.Errorf("DetachDBAASServiceFromEndpoint: execute request editors: %w", err)
2925 }
2926
2927 if err := c.signRequest(request); err != nil {
2928 return nil, fmt.Errorf("DetachDBAASServiceFromEndpoint: sign request: %w", err)
2929 }
2930
2931 if c.trace {
2932 dumpRequest(request, "detach-dbaas-service-from-endpoint")
2933 }
2934
2935 response, err := c.httpClient.Do(request)
2936 if err != nil {
2937 return nil, fmt.Errorf("DetachDBAASServiceFromEndpoint: http client do: %w", err)
2938 }
2939
2940 if c.trace {
2941 dumpResponse(response)
2942 }
2943
2944 if err := handleHTTPErrorResp(response); err != nil {
2945 return nil, fmt.Errorf("DetachDBAASServiceFromEndpoint: http response: %w", err)
2946 }
2947
2948 bodyresp := new(Operation)
2949 if err := prepareJSONResponse(response, bodyresp); err != nil {
2950 return nil, fmt.Errorf("DetachDBAASServiceFromEndpoint: prepare Json response: %w", err)
2951 }
2952
2953 return bodyresp, nil
2954 }
2955
2956 type ListDBAASExternalEndpointsResponse struct {
2957 DBAASEndpoints []DBAASExternalEndpoint `json:"dbaas-endpoints,omitempty"`
2958 }
2959
2960 // FindDBAASExternalEndpoint attempts to find an DBAASExternalEndpoint by nameOrID.
2961 func (l ListDBAASExternalEndpointsResponse) FindDBAASExternalEndpoint(nameOrID string) (DBAASExternalEndpoint, error) {
2962 var result []DBAASExternalEndpoint
2963 for i, elem := range l.DBAASEndpoints {
2964 if string(elem.Name) == nameOrID || string(elem.ID) == nameOrID {
2965 result = append(result, l.DBAASEndpoints[i])
2966 }
2967 }
2968 if len(result) == 1 {
2969 return result[0], nil
2970 }
2971
2972 if len(result) > 1 {
2973 return DBAASExternalEndpoint{}, fmt.Errorf("%q too many found in ListDBAASExternalEndpointsResponse: %w", nameOrID, ErrConflict)
2974 }
2975
2976 return DBAASExternalEndpoint{}, fmt.Errorf("%q not found in ListDBAASExternalEndpointsResponse: %w", nameOrID, ErrNotFound)
2977 }
2978
2979 // [BETA] List available external endpoints for integrations
2980 func (c Client) ListDBAASExternalEndpoints(ctx context.Context) (*ListDBAASExternalEndpointsResponse, error) {
2981 path := "/dbaas-external-endpoints"
2982
2983 request, err := http.NewRequestWithContext(ctx, "GET", c.serverEndpoint+path, nil)
2984 if err != nil {
2985 return nil, fmt.Errorf("ListDBAASExternalEndpoints: new request: %w", err)
2986 }
2987
2988 request.Header.Add("User-Agent", c.getUserAgent())
2989
2990 if err := c.executeRequestInterceptors(ctx, request); err != nil {
2991 return nil, fmt.Errorf("ListDBAASExternalEndpoints: execute request editors: %w", err)
2992 }
2993
2994 if err := c.signRequest(request); err != nil {
2995 return nil, fmt.Errorf("ListDBAASExternalEndpoints: sign request: %w", err)
2996 }
2997
2998 if c.trace {
2999 dumpRequest(request, "list-dbaas-external-endpoints")
3000 }
3001
3002 response, err := c.httpClient.Do(request)
3003 if err != nil {
3004 return nil, fmt.Errorf("ListDBAASExternalEndpoints: http client do: %w", err)
3005 }
3006
3007 if c.trace {
3008 dumpResponse(response)
3009 }
3010
3011 if err := handleHTTPErrorResp(response); err != nil {
3012 return nil, fmt.Errorf("ListDBAASExternalEndpoints: http response: %w", err)
3013 }
3014
3015 bodyresp := new(ListDBAASExternalEndpointsResponse)
3016 if err := prepareJSONResponse(response, bodyresp); err != nil {
3017 return nil, fmt.Errorf("ListDBAASExternalEndpoints: prepare Json response: %w", err)
3018 }
3019
3020 return bodyresp, nil
3021 }
3022
3023 type GetDBAASExternalIntegrationSettingsDatadogResponse struct {
3024 Settings *DBAASIntegrationSettingsDatadog `json:"settings,omitempty"`
3025 }
3026
3027 // [BETA] Get Datadog integration settings
3028 func (c Client) GetDBAASExternalIntegrationSettingsDatadog(ctx context.Context, integrationID UUID) (*GetDBAASExternalIntegrationSettingsDatadogResponse, error) {
3029 path := fmt.Sprintf("/dbaas-external-integration-settings-datadog/%v", integrationID)
3030
3031 request, err := http.NewRequestWithContext(ctx, "GET", c.serverEndpoint+path, nil)
3032 if err != nil {
3033 return nil, fmt.Errorf("GetDBAASExternalIntegrationSettingsDatadog: new request: %w", err)
3034 }
3035
3036 request.Header.Add("User-Agent", c.getUserAgent())
3037
3038 if err := c.executeRequestInterceptors(ctx, request); err != nil {
3039 return nil, fmt.Errorf("GetDBAASExternalIntegrationSettingsDatadog: execute request editors: %w", err)
3040 }
3041
3042 if err := c.signRequest(request); err != nil {
3043 return nil, fmt.Errorf("GetDBAASExternalIntegrationSettingsDatadog: sign request: %w", err)
3044 }
3045
3046 if c.trace {
3047 dumpRequest(request, "get-dbaas-external-integration-settings-datadog")
3048 }
3049
3050 response, err := c.httpClient.Do(request)
3051 if err != nil {
3052 return nil, fmt.Errorf("GetDBAASExternalIntegrationSettingsDatadog: http client do: %w", err)
3053 }
3054
3055 if c.trace {
3056 dumpResponse(response)
3057 }
3058
3059 if err := handleHTTPErrorResp(response); err != nil {
3060 return nil, fmt.Errorf("GetDBAASExternalIntegrationSettingsDatadog: http response: %w", err)
3061 }
3062
3063 bodyresp := new(GetDBAASExternalIntegrationSettingsDatadogResponse)
3064 if err := prepareJSONResponse(response, bodyresp); err != nil {
3065 return nil, fmt.Errorf("GetDBAASExternalIntegrationSettingsDatadog: prepare Json response: %w", err)
3066 }
3067
3068 return bodyresp, nil
3069 }
3070
3071 type UpdateDBAASExternalIntegrationSettingsDatadogRequest struct {
3072 Settings *DBAASIntegrationSettingsDatadog `json:"settings,omitempty"`
3073 }
3074
3075 // [BETA] Manage Datadog integration settings
3076 func (c Client) UpdateDBAASExternalIntegrationSettingsDatadog(ctx context.Context, integrationID UUID, req UpdateDBAASExternalIntegrationSettingsDatadogRequest) (*Operation, error) {
3077 path := fmt.Sprintf("/dbaas-external-integration-settings-datadog/%v", integrationID)
3078
3079 body, err := prepareJSONBody(req)
3080 if err != nil {
3081 return nil, fmt.Errorf("UpdateDBAASExternalIntegrationSettingsDatadog: prepare Json body: %w", err)
3082 }
3083
3084 request, err := http.NewRequestWithContext(ctx, "POST", c.serverEndpoint+path, body)
3085 if err != nil {
3086 return nil, fmt.Errorf("UpdateDBAASExternalIntegrationSettingsDatadog: new request: %w", err)
3087 }
3088
3089 request.Header.Add("User-Agent", c.getUserAgent())
3090
3091 request.Header.Add("Content-Type", "application/json")
3092
3093 if err := c.executeRequestInterceptors(ctx, request); err != nil {
3094 return nil, fmt.Errorf("UpdateDBAASExternalIntegrationSettingsDatadog: execute request editors: %w", err)
3095 }
3096
3097 if err := c.signRequest(request); err != nil {
3098 return nil, fmt.Errorf("UpdateDBAASExternalIntegrationSettingsDatadog: sign request: %w", err)
3099 }
3100
3101 if c.trace {
3102 dumpRequest(request, "update-dbaas-external-integration-settings-datadog")
3103 }
3104
3105 response, err := c.httpClient.Do(request)
3106 if err != nil {
3107 return nil, fmt.Errorf("UpdateDBAASExternalIntegrationSettingsDatadog: http client do: %w", err)
3108 }
3109
3110 if c.trace {
3111 dumpResponse(response)
3112 }
3113
3114 if err := handleHTTPErrorResp(response); err != nil {
3115 return nil, fmt.Errorf("UpdateDBAASExternalIntegrationSettingsDatadog: http response: %w", err)
3116 }
3117
3118 bodyresp := new(Operation)
3119 if err := prepareJSONResponse(response, bodyresp); err != nil {
3120 return nil, fmt.Errorf("UpdateDBAASExternalIntegrationSettingsDatadog: prepare Json response: %w", err)
3121 }
3122
3123 return bodyresp, nil
3124 }
3125
3126 // [BETA] Get a DBaaS external integration
3127 func (c Client) GetDBAASExternalIntegration(ctx context.Context, integrationID UUID) (*DBAASExternalIntegration, error) {
3128 path := fmt.Sprintf("/dbaas-external-integration/%v", integrationID)
3129
3130 request, err := http.NewRequestWithContext(ctx, "GET", c.serverEndpoint+path, nil)
3131 if err != nil {
3132 return nil, fmt.Errorf("GetDBAASExternalIntegration: new request: %w", err)
3133 }
3134
3135 request.Header.Add("User-Agent", c.getUserAgent())
3136
3137 if err := c.executeRequestInterceptors(ctx, request); err != nil {
3138 return nil, fmt.Errorf("GetDBAASExternalIntegration: execute request editors: %w", err)
3139 }
3140
3141 if err := c.signRequest(request); err != nil {
3142 return nil, fmt.Errorf("GetDBAASExternalIntegration: sign request: %w", err)
3143 }
3144
3145 if c.trace {
3146 dumpRequest(request, "get-dbaas-external-integration")
3147 }
3148
3149 response, err := c.httpClient.Do(request)
3150 if err != nil {
3151 return nil, fmt.Errorf("GetDBAASExternalIntegration: http client do: %w", err)
3152 }
3153
3154 if c.trace {
3155 dumpResponse(response)
3156 }
3157
3158 if err := handleHTTPErrorResp(response); err != nil {
3159 return nil, fmt.Errorf("GetDBAASExternalIntegration: http response: %w", err)
3160 }
3161
3162 bodyresp := new(DBAASExternalIntegration)
3163 if err := prepareJSONResponse(response, bodyresp); err != nil {
3164 return nil, fmt.Errorf("GetDBAASExternalIntegration: prepare Json response: %w", err)
3165 }
3166
3167 return bodyresp, nil
3168 }
3169
3170 type ListDBAASExternalIntegrationsResponse struct {
3171 ExternalIntegrations []DBAASExternalIntegration `json:"external-integrations,omitempty"`
3172 }
3173
3174 // [BETA] List all DBaaS connections between services and external endpoints
3175 func (c Client) ListDBAASExternalIntegrations(ctx context.Context, serviceName string) (*ListDBAASExternalIntegrationsResponse, error) {
3176 path := fmt.Sprintf("/dbaas-external-integrations/%v", serviceName)
3177
3178 request, err := http.NewRequestWithContext(ctx, "GET", c.serverEndpoint+path, nil)
3179 if err != nil {
3180 return nil, fmt.Errorf("ListDBAASExternalIntegrations: new request: %w", err)
3181 }
3182
3183 request.Header.Add("User-Agent", c.getUserAgent())
3184
3185 if err := c.executeRequestInterceptors(ctx, request); err != nil {
3186 return nil, fmt.Errorf("ListDBAASExternalIntegrations: execute request editors: %w", err)
3187 }
3188
3189 if err := c.signRequest(request); err != nil {
3190 return nil, fmt.Errorf("ListDBAASExternalIntegrations: sign request: %w", err)
3191 }
3192
3193 if c.trace {
3194 dumpRequest(request, "list-dbaas-external-integrations")
3195 }
3196
3197 response, err := c.httpClient.Do(request)
3198 if err != nil {
3199 return nil, fmt.Errorf("ListDBAASExternalIntegrations: http client do: %w", err)
3200 }
3201
3202 if c.trace {
3203 dumpResponse(response)
3204 }
3205
3206 if err := handleHTTPErrorResp(response); err != nil {
3207 return nil, fmt.Errorf("ListDBAASExternalIntegrations: http response: %w", err)
3208 }
3209
3210 bodyresp := new(ListDBAASExternalIntegrationsResponse)
3211 if err := prepareJSONResponse(response, bodyresp); err != nil {
3212 return nil, fmt.Errorf("ListDBAASExternalIntegrations: prepare Json response: %w", err)
3213 }
3214
3215 return bodyresp, nil
3216 }
3217
3218 func (c Client) DeleteDBAASServiceGrafana(ctx context.Context, name string) (*Operation, error) {
3219 path := fmt.Sprintf("/dbaas-grafana/%v", name)
3220
3221 request, err := http.NewRequestWithContext(ctx, "DELETE", c.serverEndpoint+path, nil)
3222 if err != nil {
3223 return nil, fmt.Errorf("DeleteDBAASServiceGrafana: new request: %w", err)
3224 }
3225
3226 request.Header.Add("User-Agent", c.getUserAgent())
3227
3228 if err := c.executeRequestInterceptors(ctx, request); err != nil {
3229 return nil, fmt.Errorf("DeleteDBAASServiceGrafana: execute request editors: %w", err)
3230 }
3231
3232 if err := c.signRequest(request); err != nil {
3233 return nil, fmt.Errorf("DeleteDBAASServiceGrafana: sign request: %w", err)
3234 }
3235
3236 if c.trace {
3237 dumpRequest(request, "delete-dbaas-service-grafana")
3238 }
3239
3240 response, err := c.httpClient.Do(request)
3241 if err != nil {
3242 return nil, fmt.Errorf("DeleteDBAASServiceGrafana: http client do: %w", err)
3243 }
3244
3245 if c.trace {
3246 dumpResponse(response)
3247 }
3248
3249 if err := handleHTTPErrorResp(response); err != nil {
3250 return nil, fmt.Errorf("DeleteDBAASServiceGrafana: http response: %w", err)
3251 }
3252
3253 bodyresp := new(Operation)
3254 if err := prepareJSONResponse(response, bodyresp); err != nil {
3255 return nil, fmt.Errorf("DeleteDBAASServiceGrafana: prepare Json response: %w", err)
3256 }
3257
3258 return bodyresp, nil
3259 }
3260
3261 func (c Client) GetDBAASServiceGrafana(ctx context.Context, name string) (*DBAASServiceGrafana, error) {
3262 path := fmt.Sprintf("/dbaas-grafana/%v", name)
3263
3264 request, err := http.NewRequestWithContext(ctx, "GET", c.serverEndpoint+path, nil)
3265 if err != nil {
3266 return nil, fmt.Errorf("GetDBAASServiceGrafana: new request: %w", err)
3267 }
3268
3269 request.Header.Add("User-Agent", c.getUserAgent())
3270
3271 if err := c.executeRequestInterceptors(ctx, request); err != nil {
3272 return nil, fmt.Errorf("GetDBAASServiceGrafana: execute request editors: %w", err)
3273 }
3274
3275 if err := c.signRequest(request); err != nil {
3276 return nil, fmt.Errorf("GetDBAASServiceGrafana: sign request: %w", err)
3277 }
3278
3279 if c.trace {
3280 dumpRequest(request, "get-dbaas-service-grafana")
3281 }
3282
3283 response, err := c.httpClient.Do(request)
3284 if err != nil {
3285 return nil, fmt.Errorf("GetDBAASServiceGrafana: http client do: %w", err)
3286 }
3287
3288 if c.trace {
3289 dumpResponse(response)
3290 }
3291
3292 if err := handleHTTPErrorResp(response); err != nil {
3293 return nil, fmt.Errorf("GetDBAASServiceGrafana: http response: %w", err)
3294 }
3295
3296 bodyresp := new(DBAASServiceGrafana)
3297 if err := prepareJSONResponse(response, bodyresp); err != nil {
3298 return nil, fmt.Errorf("GetDBAASServiceGrafana: prepare Json response: %w", err)
3299 }
3300
3301 return bodyresp, nil
3302 }
3303
3304 type CreateDBAASServiceGrafanaRequestMaintenanceDow string
3305
3306 const (
3307 CreateDBAASServiceGrafanaRequestMaintenanceDowSaturday CreateDBAASServiceGrafanaRequestMaintenanceDow = "saturday"
3308 CreateDBAASServiceGrafanaRequestMaintenanceDowTuesday CreateDBAASServiceGrafanaRequestMaintenanceDow = "tuesday"
3309 CreateDBAASServiceGrafanaRequestMaintenanceDowNever CreateDBAASServiceGrafanaRequestMaintenanceDow = "never"
3310 CreateDBAASServiceGrafanaRequestMaintenanceDowWednesday CreateDBAASServiceGrafanaRequestMaintenanceDow = "wednesday"
3311 CreateDBAASServiceGrafanaRequestMaintenanceDowSunday CreateDBAASServiceGrafanaRequestMaintenanceDow = "sunday"
3312 CreateDBAASServiceGrafanaRequestMaintenanceDowFriday CreateDBAASServiceGrafanaRequestMaintenanceDow = "friday"
3313 CreateDBAASServiceGrafanaRequestMaintenanceDowMonday CreateDBAASServiceGrafanaRequestMaintenanceDow = "monday"
3314 CreateDBAASServiceGrafanaRequestMaintenanceDowThursday CreateDBAASServiceGrafanaRequestMaintenanceDow = "thursday"
3315 )
3316
3317 // Automatic maintenance settings
3318 type CreateDBAASServiceGrafanaRequestMaintenance struct {
3319 // Day of week for installing updates
3320 Dow CreateDBAASServiceGrafanaRequestMaintenanceDow `json:"dow" validate:"required"`
3321 // Time for installing updates, UTC
3322 Time string `json:"time" validate:"required,gte=8,lte=8"`
3323 }
3324
3325 type CreateDBAASServiceGrafanaRequest struct {
3326 ForkFromService DBAASServiceName `json:"fork-from-service,omitempty" validate:"omitempty,gte=0,lte=63"`
3327 // Grafana settings
3328 GrafanaSettings *JSONSchemaGrafana `json:"grafana-settings,omitempty"`
3329 // Allowed CIDR address blocks for incoming connections
3330 IPFilter []string `json:"ip-filter,omitempty"`
3331 // Automatic maintenance settings
3332 Maintenance *CreateDBAASServiceGrafanaRequestMaintenance `json:"maintenance,omitempty"`
3333 // Subscription plan
3334 Plan string `json:"plan" validate:"required,gte=1,lte=128"`
3335 // Service is protected against termination and powering off
3336 TerminationProtection *bool `json:"termination-protection,omitempty"`
3337 }
3338
3339 // Create a DBaaS Grafana service
3340 func (c Client) CreateDBAASServiceGrafana(ctx context.Context, name string, req CreateDBAASServiceGrafanaRequest) (*Operation, error) {
3341 path := fmt.Sprintf("/dbaas-grafana/%v", name)
3342
3343 body, err := prepareJSONBody(req)
3344 if err != nil {
3345 return nil, fmt.Errorf("CreateDBAASServiceGrafana: prepare Json body: %w", err)
3346 }
3347
3348 request, err := http.NewRequestWithContext(ctx, "POST", c.serverEndpoint+path, body)
3349 if err != nil {
3350 return nil, fmt.Errorf("CreateDBAASServiceGrafana: new request: %w", err)
3351 }
3352
3353 request.Header.Add("User-Agent", c.getUserAgent())
3354
3355 request.Header.Add("Content-Type", "application/json")
3356
3357 if err := c.executeRequestInterceptors(ctx, request); err != nil {
3358 return nil, fmt.Errorf("CreateDBAASServiceGrafana: execute request editors: %w", err)
3359 }
3360
3361 if err := c.signRequest(request); err != nil {
3362 return nil, fmt.Errorf("CreateDBAASServiceGrafana: sign request: %w", err)
3363 }
3364
3365 if c.trace {
3366 dumpRequest(request, "create-dbaas-service-grafana")
3367 }
3368
3369 response, err := c.httpClient.Do(request)
3370 if err != nil {
3371 return nil, fmt.Errorf("CreateDBAASServiceGrafana: http client do: %w", err)
3372 }
3373
3374 if c.trace {
3375 dumpResponse(response)
3376 }
3377
3378 if err := handleHTTPErrorResp(response); err != nil {
3379 return nil, fmt.Errorf("CreateDBAASServiceGrafana: http response: %w", err)
3380 }
3381
3382 bodyresp := new(Operation)
3383 if err := prepareJSONResponse(response, bodyresp); err != nil {
3384 return nil, fmt.Errorf("CreateDBAASServiceGrafana: prepare Json response: %w", err)
3385 }
3386
3387 return bodyresp, nil
3388 }
3389
3390 type UpdateDBAASServiceGrafanaRequestMaintenanceDow string
3391
3392 const (
3393 UpdateDBAASServiceGrafanaRequestMaintenanceDowSaturday UpdateDBAASServiceGrafanaRequestMaintenanceDow = "saturday"
3394 UpdateDBAASServiceGrafanaRequestMaintenanceDowTuesday UpdateDBAASServiceGrafanaRequestMaintenanceDow = "tuesday"
3395 UpdateDBAASServiceGrafanaRequestMaintenanceDowNever UpdateDBAASServiceGrafanaRequestMaintenanceDow = "never"
3396 UpdateDBAASServiceGrafanaRequestMaintenanceDowWednesday UpdateDBAASServiceGrafanaRequestMaintenanceDow = "wednesday"
3397 UpdateDBAASServiceGrafanaRequestMaintenanceDowSunday UpdateDBAASServiceGrafanaRequestMaintenanceDow = "sunday"
3398 UpdateDBAASServiceGrafanaRequestMaintenanceDowFriday UpdateDBAASServiceGrafanaRequestMaintenanceDow = "friday"
3399 UpdateDBAASServiceGrafanaRequestMaintenanceDowMonday UpdateDBAASServiceGrafanaRequestMaintenanceDow = "monday"
3400 UpdateDBAASServiceGrafanaRequestMaintenanceDowThursday UpdateDBAASServiceGrafanaRequestMaintenanceDow = "thursday"
3401 )
3402
3403 // Automatic maintenance settings
3404 type UpdateDBAASServiceGrafanaRequestMaintenance struct {
3405 // Day of week for installing updates
3406 Dow UpdateDBAASServiceGrafanaRequestMaintenanceDow `json:"dow" validate:"required"`
3407 // Time for installing updates, UTC
3408 Time string `json:"time" validate:"required,gte=8,lte=8"`
3409 }
3410
3411 type UpdateDBAASServiceGrafanaRequest struct {
3412 // Grafana settings
3413 GrafanaSettings *JSONSchemaGrafana `json:"grafana-settings,omitempty"`
3414 // Allowed CIDR address blocks for incoming connections
3415 IPFilter []string `json:"ip-filter,omitempty"`
3416 // Automatic maintenance settings
3417 Maintenance *UpdateDBAASServiceGrafanaRequestMaintenance `json:"maintenance,omitempty"`
3418 // Subscription plan
3419 Plan string `json:"plan,omitempty" validate:"omitempty,gte=1,lte=128"`
3420 // Service is protected against termination and powering off
3421 TerminationProtection *bool `json:"termination-protection,omitempty"`
3422 }
3423
3424 func (c Client) UpdateDBAASServiceGrafana(ctx context.Context, name string, req UpdateDBAASServiceGrafanaRequest) (*Operation, error) {
3425 path := fmt.Sprintf("/dbaas-grafana/%v", name)
3426
3427 body, err := prepareJSONBody(req)
3428 if err != nil {
3429 return nil, fmt.Errorf("UpdateDBAASServiceGrafana: prepare Json body: %w", err)
3430 }
3431
3432 request, err := http.NewRequestWithContext(ctx, "PUT", c.serverEndpoint+path, body)
3433 if err != nil {
3434 return nil, fmt.Errorf("UpdateDBAASServiceGrafana: new request: %w", err)
3435 }
3436
3437 request.Header.Add("User-Agent", c.getUserAgent())
3438
3439 request.Header.Add("Content-Type", "application/json")
3440
3441 if err := c.executeRequestInterceptors(ctx, request); err != nil {
3442 return nil, fmt.Errorf("UpdateDBAASServiceGrafana: execute request editors: %w", err)
3443 }
3444
3445 if err := c.signRequest(request); err != nil {
3446 return nil, fmt.Errorf("UpdateDBAASServiceGrafana: sign request: %w", err)
3447 }
3448
3449 if c.trace {
3450 dumpRequest(request, "update-dbaas-service-grafana")
3451 }
3452
3453 response, err := c.httpClient.Do(request)
3454 if err != nil {
3455 return nil, fmt.Errorf("UpdateDBAASServiceGrafana: http client do: %w", err)
3456 }
3457
3458 if c.trace {
3459 dumpResponse(response)
3460 }
3461
3462 if err := handleHTTPErrorResp(response); err != nil {
3463 return nil, fmt.Errorf("UpdateDBAASServiceGrafana: http response: %w", err)
3464 }
3465
3466 bodyresp := new(Operation)
3467 if err := prepareJSONResponse(response, bodyresp); err != nil {
3468 return nil, fmt.Errorf("UpdateDBAASServiceGrafana: prepare Json response: %w", err)
3469 }
3470
3471 return bodyresp, nil
3472 }
3473
3474 func (c Client) StartDBAASGrafanaMaintenance(ctx context.Context, name string) (*Operation, error) {
3475 path := fmt.Sprintf("/dbaas-grafana/%v/maintenance/start", name)
3476
3477 request, err := http.NewRequestWithContext(ctx, "PUT", c.serverEndpoint+path, nil)
3478 if err != nil {
3479 return nil, fmt.Errorf("StartDBAASGrafanaMaintenance: new request: %w", err)
3480 }
3481
3482 request.Header.Add("User-Agent", c.getUserAgent())
3483
3484 if err := c.executeRequestInterceptors(ctx, request); err != nil {
3485 return nil, fmt.Errorf("StartDBAASGrafanaMaintenance: execute request editors: %w", err)
3486 }
3487
3488 if err := c.signRequest(request); err != nil {
3489 return nil, fmt.Errorf("StartDBAASGrafanaMaintenance: sign request: %w", err)
3490 }
3491
3492 if c.trace {
3493 dumpRequest(request, "start-dbaas-grafana-maintenance")
3494 }
3495
3496 response, err := c.httpClient.Do(request)
3497 if err != nil {
3498 return nil, fmt.Errorf("StartDBAASGrafanaMaintenance: http client do: %w", err)
3499 }
3500
3501 if c.trace {
3502 dumpResponse(response)
3503 }
3504
3505 if err := handleHTTPErrorResp(response); err != nil {
3506 return nil, fmt.Errorf("StartDBAASGrafanaMaintenance: http response: %w", err)
3507 }
3508
3509 bodyresp := new(Operation)
3510 if err := prepareJSONResponse(response, bodyresp); err != nil {
3511 return nil, fmt.Errorf("StartDBAASGrafanaMaintenance: prepare Json response: %w", err)
3512 }
3513
3514 return bodyresp, nil
3515 }
3516
3517 type ResetDBAASGrafanaUserPasswordRequest struct {
3518 Password DBAASUserPassword `json:"password,omitempty" validate:"omitempty,gte=8,lte=256"`
3519 }
3520
3521 // If no password is provided one will be generated automatically.
3522 func (c Client) ResetDBAASGrafanaUserPassword(ctx context.Context, serviceName string, username string, req ResetDBAASGrafanaUserPasswordRequest) (*Operation, error) {
3523 path := fmt.Sprintf("/dbaas-grafana/%v/user/%v/password/reset", serviceName, username)
3524
3525 body, err := prepareJSONBody(req)
3526 if err != nil {
3527 return nil, fmt.Errorf("ResetDBAASGrafanaUserPassword: prepare Json body: %w", err)
3528 }
3529
3530 request, err := http.NewRequestWithContext(ctx, "PUT", c.serverEndpoint+path, body)
3531 if err != nil {
3532 return nil, fmt.Errorf("ResetDBAASGrafanaUserPassword: new request: %w", err)
3533 }
3534
3535 request.Header.Add("User-Agent", c.getUserAgent())
3536
3537 request.Header.Add("Content-Type", "application/json")
3538
3539 if err := c.executeRequestInterceptors(ctx, request); err != nil {
3540 return nil, fmt.Errorf("ResetDBAASGrafanaUserPassword: execute request editors: %w", err)
3541 }
3542
3543 if err := c.signRequest(request); err != nil {
3544 return nil, fmt.Errorf("ResetDBAASGrafanaUserPassword: sign request: %w", err)
3545 }
3546
3547 if c.trace {
3548 dumpRequest(request, "reset-dbaas-grafana-user-password")
3549 }
3550
3551 response, err := c.httpClient.Do(request)
3552 if err != nil {
3553 return nil, fmt.Errorf("ResetDBAASGrafanaUserPassword: http client do: %w", err)
3554 }
3555
3556 if c.trace {
3557 dumpResponse(response)
3558 }
3559
3560 if err := handleHTTPErrorResp(response); err != nil {
3561 return nil, fmt.Errorf("ResetDBAASGrafanaUserPassword: http response: %w", err)
3562 }
3563
3564 bodyresp := new(Operation)
3565 if err := prepareJSONResponse(response, bodyresp); err != nil {
3566 return nil, fmt.Errorf("ResetDBAASGrafanaUserPassword: prepare Json response: %w", err)
3567 }
3568
3569 return bodyresp, nil
3570 }
3571
3572 func (c Client) RevealDBAASGrafanaUserPassword(ctx context.Context, serviceName string, username string) (*DBAASUserGrafanaSecrets, error) {
3573 path := fmt.Sprintf("/dbaas-grafana/%v/user/%v/password/reveal", serviceName, username)
3574
3575 request, err := http.NewRequestWithContext(ctx, "GET", c.serverEndpoint+path, nil)
3576 if err != nil {
3577 return nil, fmt.Errorf("RevealDBAASGrafanaUserPassword: new request: %w", err)
3578 }
3579
3580 request.Header.Add("User-Agent", c.getUserAgent())
3581
3582 if err := c.executeRequestInterceptors(ctx, request); err != nil {
3583 return nil, fmt.Errorf("RevealDBAASGrafanaUserPassword: execute request editors: %w", err)
3584 }
3585
3586 if err := c.signRequest(request); err != nil {
3587 return nil, fmt.Errorf("RevealDBAASGrafanaUserPassword: sign request: %w", err)
3588 }
3589
3590 if c.trace {
3591 dumpRequest(request, "reveal-dbaas-grafana-user-password")
3592 }
3593
3594 response, err := c.httpClient.Do(request)
3595 if err != nil {
3596 return nil, fmt.Errorf("RevealDBAASGrafanaUserPassword: http client do: %w", err)
3597 }
3598
3599 if c.trace {
3600 dumpResponse(response)
3601 }
3602
3603 if err := handleHTTPErrorResp(response); err != nil {
3604 return nil, fmt.Errorf("RevealDBAASGrafanaUserPassword: http response: %w", err)
3605 }
3606
3607 bodyresp := new(DBAASUserGrafanaSecrets)
3608 if err := prepareJSONResponse(response, bodyresp); err != nil {
3609 return nil, fmt.Errorf("RevealDBAASGrafanaUserPassword: prepare Json response: %w", err)
3610 }
3611
3612 return bodyresp, nil
3613 }
3614
3615 type CreateDBAASIntegrationRequest struct {
3616 DestService DBAASServiceName `json:"dest-service" validate:"required,gte=0,lte=63"`
3617 IntegrationType EnumIntegrationTypes `json:"integration-type" validate:"required"`
3618 // Integration settings
3619 Settings map[string]any `json:"settings,omitempty"`
3620 SourceService DBAASServiceName `json:"source-service" validate:"required,gte=0,lte=63"`
3621 }
3622
3623 // [BETA] Create a new DBaaS integration between two services
3624 func (c Client) CreateDBAASIntegration(ctx context.Context, req CreateDBAASIntegrationRequest) (*Operation, error) {
3625 path := "/dbaas-integration"
3626
3627 body, err := prepareJSONBody(req)
3628 if err != nil {
3629 return nil, fmt.Errorf("CreateDBAASIntegration: prepare Json body: %w", err)
3630 }
3631
3632 request, err := http.NewRequestWithContext(ctx, "POST", c.serverEndpoint+path, body)
3633 if err != nil {
3634 return nil, fmt.Errorf("CreateDBAASIntegration: new request: %w", err)
3635 }
3636
3637 request.Header.Add("User-Agent", c.getUserAgent())
3638
3639 request.Header.Add("Content-Type", "application/json")
3640
3641 if err := c.executeRequestInterceptors(ctx, request); err != nil {
3642 return nil, fmt.Errorf("CreateDBAASIntegration: execute request editors: %w", err)
3643 }
3644
3645 if err := c.signRequest(request); err != nil {
3646 return nil, fmt.Errorf("CreateDBAASIntegration: sign request: %w", err)
3647 }
3648
3649 if c.trace {
3650 dumpRequest(request, "create-dbaas-integration")
3651 }
3652
3653 response, err := c.httpClient.Do(request)
3654 if err != nil {
3655 return nil, fmt.Errorf("CreateDBAASIntegration: http client do: %w", err)
3656 }
3657
3658 if c.trace {
3659 dumpResponse(response)
3660 }
3661
3662 if err := handleHTTPErrorResp(response); err != nil {
3663 return nil, fmt.Errorf("CreateDBAASIntegration: http response: %w", err)
3664 }
3665
3666 bodyresp := new(Operation)
3667 if err := prepareJSONResponse(response, bodyresp); err != nil {
3668 return nil, fmt.Errorf("CreateDBAASIntegration: prepare Json response: %w", err)
3669 }
3670
3671 return bodyresp, nil
3672 }
3673
3674 // The JSON schema representing the settings for the given integration type, source, and destination service types.
3675 type ListDBAASIntegrationSettingsResponseSettings struct {
3676 AdditionalProperties *bool `json:"additionalProperties,omitempty"`
3677 Properties map[string]any `json:"properties,omitempty"`
3678 Title string `json:"title,omitempty"`
3679 Type string `json:"type,omitempty"`
3680 }
3681
3682 type ListDBAASIntegrationSettingsResponse struct {
3683 // The JSON schema representing the settings for the given integration type, source, and destination service types.
3684 Settings *ListDBAASIntegrationSettingsResponseSettings `json:"settings,omitempty"`
3685 }
3686
3687 // [BETA] Get DBaaS integration settings
3688 func (c Client) ListDBAASIntegrationSettings(ctx context.Context, integrationType string, sourceType string, destType string) (*ListDBAASIntegrationSettingsResponse, error) {
3689 path := fmt.Sprintf("/dbaas-integration-settings/%v/%v/%v", integrationType, sourceType, destType)
3690
3691 request, err := http.NewRequestWithContext(ctx, "GET", c.serverEndpoint+path, nil)
3692 if err != nil {
3693 return nil, fmt.Errorf("ListDBAASIntegrationSettings: new request: %w", err)
3694 }
3695
3696 request.Header.Add("User-Agent", c.getUserAgent())
3697
3698 if err := c.executeRequestInterceptors(ctx, request); err != nil {
3699 return nil, fmt.Errorf("ListDBAASIntegrationSettings: execute request editors: %w", err)
3700 }
3701
3702 if err := c.signRequest(request); err != nil {
3703 return nil, fmt.Errorf("ListDBAASIntegrationSettings: sign request: %w", err)
3704 }
3705
3706 if c.trace {
3707 dumpRequest(request, "list-dbaas-integration-settings")
3708 }
3709
3710 response, err := c.httpClient.Do(request)
3711 if err != nil {
3712 return nil, fmt.Errorf("ListDBAASIntegrationSettings: http client do: %w", err)
3713 }
3714
3715 if c.trace {
3716 dumpResponse(response)
3717 }
3718
3719 if err := handleHTTPErrorResp(response); err != nil {
3720 return nil, fmt.Errorf("ListDBAASIntegrationSettings: http response: %w", err)
3721 }
3722
3723 bodyresp := new(ListDBAASIntegrationSettingsResponse)
3724 if err := prepareJSONResponse(response, bodyresp); err != nil {
3725 return nil, fmt.Errorf("ListDBAASIntegrationSettings: prepare Json response: %w", err)
3726 }
3727
3728 return bodyresp, nil
3729 }
3730
3731 type ListDBAASIntegrationTypesResponse struct {
3732 DBAASIntegrationTypes []DBAASIntegrationType `json:"dbaas-integration-types,omitempty"`
3733 }
3734
3735 // [BETA] Get DBaaS integration types
3736 func (c Client) ListDBAASIntegrationTypes(ctx context.Context) (*ListDBAASIntegrationTypesResponse, error) {
3737 path := "/dbaas-integration-types"
3738
3739 request, err := http.NewRequestWithContext(ctx, "GET", c.serverEndpoint+path, nil)
3740 if err != nil {
3741 return nil, fmt.Errorf("ListDBAASIntegrationTypes: new request: %w", err)
3742 }
3743
3744 request.Header.Add("User-Agent", c.getUserAgent())
3745
3746 if err := c.executeRequestInterceptors(ctx, request); err != nil {
3747 return nil, fmt.Errorf("ListDBAASIntegrationTypes: execute request editors: %w", err)
3748 }
3749
3750 if err := c.signRequest(request); err != nil {
3751 return nil, fmt.Errorf("ListDBAASIntegrationTypes: sign request: %w", err)
3752 }
3753
3754 if c.trace {
3755 dumpRequest(request, "list-dbaas-integration-types")
3756 }
3757
3758 response, err := c.httpClient.Do(request)
3759 if err != nil {
3760 return nil, fmt.Errorf("ListDBAASIntegrationTypes: http client do: %w", err)
3761 }
3762
3763 if c.trace {
3764 dumpResponse(response)
3765 }
3766
3767 if err := handleHTTPErrorResp(response); err != nil {
3768 return nil, fmt.Errorf("ListDBAASIntegrationTypes: http response: %w", err)
3769 }
3770
3771 bodyresp := new(ListDBAASIntegrationTypesResponse)
3772 if err := prepareJSONResponse(response, bodyresp); err != nil {
3773 return nil, fmt.Errorf("ListDBAASIntegrationTypes: prepare Json response: %w", err)
3774 }
3775
3776 return bodyresp, nil
3777 }
3778
3779 // [BETA] Delete a DBaaS Integration
3780 func (c Client) DeleteDBAASIntegration(ctx context.Context, id UUID) (*Operation, error) {
3781 path := fmt.Sprintf("/dbaas-integration/%v", id)
3782
3783 request, err := http.NewRequestWithContext(ctx, "DELETE", c.serverEndpoint+path, nil)
3784 if err != nil {
3785 return nil, fmt.Errorf("DeleteDBAASIntegration: new request: %w", err)
3786 }
3787
3788 request.Header.Add("User-Agent", c.getUserAgent())
3789
3790 if err := c.executeRequestInterceptors(ctx, request); err != nil {
3791 return nil, fmt.Errorf("DeleteDBAASIntegration: execute request editors: %w", err)
3792 }
3793
3794 if err := c.signRequest(request); err != nil {
3795 return nil, fmt.Errorf("DeleteDBAASIntegration: sign request: %w", err)
3796 }
3797
3798 if c.trace {
3799 dumpRequest(request, "delete-dbaas-integration")
3800 }
3801
3802 response, err := c.httpClient.Do(request)
3803 if err != nil {
3804 return nil, fmt.Errorf("DeleteDBAASIntegration: http client do: %w", err)
3805 }
3806
3807 if c.trace {
3808 dumpResponse(response)
3809 }
3810
3811 if err := handleHTTPErrorResp(response); err != nil {
3812 return nil, fmt.Errorf("DeleteDBAASIntegration: http response: %w", err)
3813 }
3814
3815 bodyresp := new(Operation)
3816 if err := prepareJSONResponse(response, bodyresp); err != nil {
3817 return nil, fmt.Errorf("DeleteDBAASIntegration: prepare Json response: %w", err)
3818 }
3819
3820 return bodyresp, nil
3821 }
3822
3823 // [BETA] Get a DBaaS Integration
3824 func (c Client) GetDBAASIntegration(ctx context.Context, id UUID) (*DBAASIntegration, error) {
3825 path := fmt.Sprintf("/dbaas-integration/%v", id)
3826
3827 request, err := http.NewRequestWithContext(ctx, "GET", c.serverEndpoint+path, nil)
3828 if err != nil {
3829 return nil, fmt.Errorf("GetDBAASIntegration: new request: %w", err)
3830 }
3831
3832 request.Header.Add("User-Agent", c.getUserAgent())
3833
3834 if err := c.executeRequestInterceptors(ctx, request); err != nil {
3835 return nil, fmt.Errorf("GetDBAASIntegration: execute request editors: %w", err)
3836 }
3837
3838 if err := c.signRequest(request); err != nil {
3839 return nil, fmt.Errorf("GetDBAASIntegration: sign request: %w", err)
3840 }
3841
3842 if c.trace {
3843 dumpRequest(request, "get-dbaas-integration")
3844 }
3845
3846 response, err := c.httpClient.Do(request)
3847 if err != nil {
3848 return nil, fmt.Errorf("GetDBAASIntegration: http client do: %w", err)
3849 }
3850
3851 if c.trace {
3852 dumpResponse(response)
3853 }
3854
3855 if err := handleHTTPErrorResp(response); err != nil {
3856 return nil, fmt.Errorf("GetDBAASIntegration: http response: %w", err)
3857 }
3858
3859 bodyresp := new(DBAASIntegration)
3860 if err := prepareJSONResponse(response, bodyresp); err != nil {
3861 return nil, fmt.Errorf("GetDBAASIntegration: prepare Json response: %w", err)
3862 }
3863
3864 return bodyresp, nil
3865 }
3866
3867 type UpdateDBAASIntegrationRequest struct {
3868 // Integration settings
3869 Settings map[string]any `json:"settings" validate:"required"`
3870 }
3871
3872 // [BETA] Update a existing DBaaS integration
3873 func (c Client) UpdateDBAASIntegration(ctx context.Context, id UUID, req UpdateDBAASIntegrationRequest) (*Operation, error) {
3874 path := fmt.Sprintf("/dbaas-integration/%v", id)
3875
3876 body, err := prepareJSONBody(req)
3877 if err != nil {
3878 return nil, fmt.Errorf("UpdateDBAASIntegration: prepare Json body: %w", err)
3879 }
3880
3881 request, err := http.NewRequestWithContext(ctx, "PUT", c.serverEndpoint+path, body)
3882 if err != nil {
3883 return nil, fmt.Errorf("UpdateDBAASIntegration: new request: %w", err)
3884 }
3885
3886 request.Header.Add("User-Agent", c.getUserAgent())
3887
3888 request.Header.Add("Content-Type", "application/json")
3889
3890 if err := c.executeRequestInterceptors(ctx, request); err != nil {
3891 return nil, fmt.Errorf("UpdateDBAASIntegration: execute request editors: %w", err)
3892 }
3893
3894 if err := c.signRequest(request); err != nil {
3895 return nil, fmt.Errorf("UpdateDBAASIntegration: sign request: %w", err)
3896 }
3897
3898 if c.trace {
3899 dumpRequest(request, "update-dbaas-integration")
3900 }
3901
3902 response, err := c.httpClient.Do(request)
3903 if err != nil {
3904 return nil, fmt.Errorf("UpdateDBAASIntegration: http client do: %w", err)
3905 }
3906
3907 if c.trace {
3908 dumpResponse(response)
3909 }
3910
3911 if err := handleHTTPErrorResp(response); err != nil {
3912 return nil, fmt.Errorf("UpdateDBAASIntegration: http response: %w", err)
3913 }
3914
3915 bodyresp := new(Operation)
3916 if err := prepareJSONResponse(response, bodyresp); err != nil {
3917 return nil, fmt.Errorf("UpdateDBAASIntegration: prepare Json response: %w", err)
3918 }
3919
3920 return bodyresp, nil
3921 }
3922
3923 func (c Client) DeleteDBAASServiceKafka(ctx context.Context, name string) (*Operation, error) {
3924 path := fmt.Sprintf("/dbaas-kafka/%v", name)
3925
3926 request, err := http.NewRequestWithContext(ctx, "DELETE", c.serverEndpoint+path, nil)
3927 if err != nil {
3928 return nil, fmt.Errorf("DeleteDBAASServiceKafka: new request: %w", err)
3929 }
3930
3931 request.Header.Add("User-Agent", c.getUserAgent())
3932
3933 if err := c.executeRequestInterceptors(ctx, request); err != nil {
3934 return nil, fmt.Errorf("DeleteDBAASServiceKafka: execute request editors: %w", err)
3935 }
3936
3937 if err := c.signRequest(request); err != nil {
3938 return nil, fmt.Errorf("DeleteDBAASServiceKafka: sign request: %w", err)
3939 }
3940
3941 if c.trace {
3942 dumpRequest(request, "delete-dbaas-service-kafka")
3943 }
3944
3945 response, err := c.httpClient.Do(request)
3946 if err != nil {
3947 return nil, fmt.Errorf("DeleteDBAASServiceKafka: http client do: %w", err)
3948 }
3949
3950 if c.trace {
3951 dumpResponse(response)
3952 }
3953
3954 if err := handleHTTPErrorResp(response); err != nil {
3955 return nil, fmt.Errorf("DeleteDBAASServiceKafka: http response: %w", err)
3956 }
3957
3958 bodyresp := new(Operation)
3959 if err := prepareJSONResponse(response, bodyresp); err != nil {
3960 return nil, fmt.Errorf("DeleteDBAASServiceKafka: prepare Json response: %w", err)
3961 }
3962
3963 return bodyresp, nil
3964 }
3965
3966 func (c Client) GetDBAASServiceKafka(ctx context.Context, name string) (*DBAASServiceKafka, error) {
3967 path := fmt.Sprintf("/dbaas-kafka/%v", name)
3968
3969 request, err := http.NewRequestWithContext(ctx, "GET", c.serverEndpoint+path, nil)
3970 if err != nil {
3971 return nil, fmt.Errorf("GetDBAASServiceKafka: new request: %w", err)
3972 }
3973
3974 request.Header.Add("User-Agent", c.getUserAgent())
3975
3976 if err := c.executeRequestInterceptors(ctx, request); err != nil {
3977 return nil, fmt.Errorf("GetDBAASServiceKafka: execute request editors: %w", err)
3978 }
3979
3980 if err := c.signRequest(request); err != nil {
3981 return nil, fmt.Errorf("GetDBAASServiceKafka: sign request: %w", err)
3982 }
3983
3984 if c.trace {
3985 dumpRequest(request, "get-dbaas-service-kafka")
3986 }
3987
3988 response, err := c.httpClient.Do(request)
3989 if err != nil {
3990 return nil, fmt.Errorf("GetDBAASServiceKafka: http client do: %w", err)
3991 }
3992
3993 if c.trace {
3994 dumpResponse(response)
3995 }
3996
3997 if err := handleHTTPErrorResp(response); err != nil {
3998 return nil, fmt.Errorf("GetDBAASServiceKafka: http response: %w", err)
3999 }
4000
4001 bodyresp := new(DBAASServiceKafka)
4002 if err := prepareJSONResponse(response, bodyresp); err != nil {
4003 return nil, fmt.Errorf("GetDBAASServiceKafka: prepare Json response: %w", err)
4004 }
4005
4006 return bodyresp, nil
4007 }
4008
4009 // Kafka authentication methods
4010 type CreateDBAASServiceKafkaRequestAuthenticationMethods struct {
4011 // Enable certificate/SSL authentication
4012 Certificate *bool `json:"certificate,omitempty"`
4013 // Enable SASL authentication
4014 Sasl *bool `json:"sasl,omitempty"`
4015 }
4016
4017 type CreateDBAASServiceKafkaRequestMaintenanceDow string
4018
4019 const (
4020 CreateDBAASServiceKafkaRequestMaintenanceDowSaturday CreateDBAASServiceKafkaRequestMaintenanceDow = "saturday"
4021 CreateDBAASServiceKafkaRequestMaintenanceDowTuesday CreateDBAASServiceKafkaRequestMaintenanceDow = "tuesday"
4022 CreateDBAASServiceKafkaRequestMaintenanceDowNever CreateDBAASServiceKafkaRequestMaintenanceDow = "never"
4023 CreateDBAASServiceKafkaRequestMaintenanceDowWednesday CreateDBAASServiceKafkaRequestMaintenanceDow = "wednesday"
4024 CreateDBAASServiceKafkaRequestMaintenanceDowSunday CreateDBAASServiceKafkaRequestMaintenanceDow = "sunday"
4025 CreateDBAASServiceKafkaRequestMaintenanceDowFriday CreateDBAASServiceKafkaRequestMaintenanceDow = "friday"
4026 CreateDBAASServiceKafkaRequestMaintenanceDowMonday CreateDBAASServiceKafkaRequestMaintenanceDow = "monday"
4027 CreateDBAASServiceKafkaRequestMaintenanceDowThursday CreateDBAASServiceKafkaRequestMaintenanceDow = "thursday"
4028 )
4029
4030 // Automatic maintenance settings
4031 type CreateDBAASServiceKafkaRequestMaintenance struct {
4032 // Day of week for installing updates
4033 Dow CreateDBAASServiceKafkaRequestMaintenanceDow `json:"dow" validate:"required"`
4034 // Time for installing updates, UTC
4035 Time string `json:"time" validate:"required,gte=8,lte=8"`
4036 }
4037
4038 type CreateDBAASServiceKafkaRequest struct {
4039 // Kafka authentication methods
4040 AuthenticationMethods *CreateDBAASServiceKafkaRequestAuthenticationMethods `json:"authentication-methods,omitempty"`
4041 // Allow incoming connections from CIDR address block, e.g. '10.20.0.0/16'
4042 IPFilter []string `json:"ip-filter,omitempty"`
4043 // Allow clients to connect to kafka_connect from the public internet for service nodes that are in a project VPC or another type of private network
4044 KafkaConnectEnabled *bool `json:"kafka-connect-enabled,omitempty"`
4045 // Kafka Connect configuration values
4046 KafkaConnectSettings *JSONSchemaKafkaConnect `json:"kafka-connect-settings,omitempty"`
4047 // Enable Kafka-REST service
4048 KafkaRestEnabled *bool `json:"kafka-rest-enabled,omitempty"`
4049 // Kafka REST configuration
4050 KafkaRestSettings *JSONSchemaKafkaRest `json:"kafka-rest-settings,omitempty"`
4051 // Kafka broker configuration values
4052 KafkaSettings *JSONSchemaKafka `json:"kafka-settings,omitempty"`
4053 // Automatic maintenance settings
4054 Maintenance *CreateDBAASServiceKafkaRequestMaintenance `json:"maintenance,omitempty"`
4055 // Subscription plan
4056 Plan string `json:"plan" validate:"required,gte=1,lte=128"`
4057 // Enable Schema-Registry service
4058 SchemaRegistryEnabled *bool `json:"schema-registry-enabled,omitempty"`
4059 // Schema Registry configuration
4060 SchemaRegistrySettings *JSONSchemaSchemaRegistry `json:"schema-registry-settings,omitempty"`
4061 // Service is protected against termination and powering off
4062 TerminationProtection *bool `json:"termination-protection,omitempty"`
4063 // Kafka major version
4064 Version string `json:"version,omitempty" validate:"omitempty,gte=1"`
4065 }
4066
4067 // Create a DBaaS Kafka service
4068 func (c Client) CreateDBAASServiceKafka(ctx context.Context, name string, req CreateDBAASServiceKafkaRequest) (*Operation, error) {
4069 path := fmt.Sprintf("/dbaas-kafka/%v", name)
4070
4071 body, err := prepareJSONBody(req)
4072 if err != nil {
4073 return nil, fmt.Errorf("CreateDBAASServiceKafka: prepare Json body: %w", err)
4074 }
4075
4076 request, err := http.NewRequestWithContext(ctx, "POST", c.serverEndpoint+path, body)
4077 if err != nil {
4078 return nil, fmt.Errorf("CreateDBAASServiceKafka: new request: %w", err)
4079 }
4080
4081 request.Header.Add("User-Agent", c.getUserAgent())
4082
4083 request.Header.Add("Content-Type", "application/json")
4084
4085 if err := c.executeRequestInterceptors(ctx, request); err != nil {
4086 return nil, fmt.Errorf("CreateDBAASServiceKafka: execute request editors: %w", err)
4087 }
4088
4089 if err := c.signRequest(request); err != nil {
4090 return nil, fmt.Errorf("CreateDBAASServiceKafka: sign request: %w", err)
4091 }
4092
4093 if c.trace {
4094 dumpRequest(request, "create-dbaas-service-kafka")
4095 }
4096
4097 response, err := c.httpClient.Do(request)
4098 if err != nil {
4099 return nil, fmt.Errorf("CreateDBAASServiceKafka: http client do: %w", err)
4100 }
4101
4102 if c.trace {
4103 dumpResponse(response)
4104 }
4105
4106 if err := handleHTTPErrorResp(response); err != nil {
4107 return nil, fmt.Errorf("CreateDBAASServiceKafka: http response: %w", err)
4108 }
4109
4110 bodyresp := new(Operation)
4111 if err := prepareJSONResponse(response, bodyresp); err != nil {
4112 return nil, fmt.Errorf("CreateDBAASServiceKafka: prepare Json response: %w", err)
4113 }
4114
4115 return bodyresp, nil
4116 }
4117
4118 // Kafka authentication methods
4119 type UpdateDBAASServiceKafkaRequestAuthenticationMethods struct {
4120 // Enable certificate/SSL authentication
4121 Certificate *bool `json:"certificate,omitempty"`
4122 // Enable SASL authentication
4123 Sasl *bool `json:"sasl,omitempty"`
4124 }
4125
4126 type UpdateDBAASServiceKafkaRequestMaintenanceDow string
4127
4128 const (
4129 UpdateDBAASServiceKafkaRequestMaintenanceDowSaturday UpdateDBAASServiceKafkaRequestMaintenanceDow = "saturday"
4130 UpdateDBAASServiceKafkaRequestMaintenanceDowTuesday UpdateDBAASServiceKafkaRequestMaintenanceDow = "tuesday"
4131 UpdateDBAASServiceKafkaRequestMaintenanceDowNever UpdateDBAASServiceKafkaRequestMaintenanceDow = "never"
4132 UpdateDBAASServiceKafkaRequestMaintenanceDowWednesday UpdateDBAASServiceKafkaRequestMaintenanceDow = "wednesday"
4133 UpdateDBAASServiceKafkaRequestMaintenanceDowSunday UpdateDBAASServiceKafkaRequestMaintenanceDow = "sunday"
4134 UpdateDBAASServiceKafkaRequestMaintenanceDowFriday UpdateDBAASServiceKafkaRequestMaintenanceDow = "friday"
4135 UpdateDBAASServiceKafkaRequestMaintenanceDowMonday UpdateDBAASServiceKafkaRequestMaintenanceDow = "monday"
4136 UpdateDBAASServiceKafkaRequestMaintenanceDowThursday UpdateDBAASServiceKafkaRequestMaintenanceDow = "thursday"
4137 )
4138
4139 // Automatic maintenance settings
4140 type UpdateDBAASServiceKafkaRequestMaintenance struct {
4141 // Day of week for installing updates
4142 Dow UpdateDBAASServiceKafkaRequestMaintenanceDow `json:"dow" validate:"required"`
4143 // Time for installing updates, UTC
4144 Time string `json:"time" validate:"required,gte=8,lte=8"`
4145 }
4146
4147 type UpdateDBAASServiceKafkaRequest struct {
4148 // Kafka authentication methods
4149 AuthenticationMethods *UpdateDBAASServiceKafkaRequestAuthenticationMethods `json:"authentication-methods,omitempty"`
4150 // Allow incoming connections from CIDR address block, e.g. '10.20.0.0/16'
4151 IPFilter []string `json:"ip-filter,omitempty"`
4152 // Allow clients to connect to kafka_connect from the public internet for service nodes that are in a project VPC or another type of private network
4153 KafkaConnectEnabled *bool `json:"kafka-connect-enabled,omitempty"`
4154 // Kafka Connect configuration values
4155 KafkaConnectSettings *JSONSchemaKafkaConnect `json:"kafka-connect-settings,omitempty"`
4156 // Enable Kafka-REST service
4157 KafkaRestEnabled *bool `json:"kafka-rest-enabled,omitempty"`
4158 // Kafka REST configuration
4159 KafkaRestSettings *JSONSchemaKafkaRest `json:"kafka-rest-settings,omitempty"`
4160 // Kafka broker configuration values
4161 KafkaSettings *JSONSchemaKafka `json:"kafka-settings,omitempty"`
4162 // Automatic maintenance settings
4163 Maintenance *UpdateDBAASServiceKafkaRequestMaintenance `json:"maintenance,omitempty"`
4164 // Subscription plan
4165 Plan string `json:"plan,omitempty" validate:"omitempty,gte=1,lte=128"`
4166 // Enable Schema-Registry service
4167 SchemaRegistryEnabled *bool `json:"schema-registry-enabled,omitempty"`
4168 // Schema Registry configuration
4169 SchemaRegistrySettings *JSONSchemaSchemaRegistry `json:"schema-registry-settings,omitempty"`
4170 // Service is protected against termination and powering off
4171 TerminationProtection *bool `json:"termination-protection,omitempty"`
4172 // Kafka major version
4173 Version string `json:"version,omitempty" validate:"omitempty,gte=1"`
4174 }
4175
4176 // Update a DBaaS Kafka service
4177 func (c Client) UpdateDBAASServiceKafka(ctx context.Context, name string, req UpdateDBAASServiceKafkaRequest) (*Operation, error) {
4178 path := fmt.Sprintf("/dbaas-kafka/%v", name)
4179
4180 body, err := prepareJSONBody(req)
4181 if err != nil {
4182 return nil, fmt.Errorf("UpdateDBAASServiceKafka: prepare Json body: %w", err)
4183 }
4184
4185 request, err := http.NewRequestWithContext(ctx, "PUT", c.serverEndpoint+path, body)
4186 if err != nil {
4187 return nil, fmt.Errorf("UpdateDBAASServiceKafka: new request: %w", err)
4188 }
4189
4190 request.Header.Add("User-Agent", c.getUserAgent())
4191
4192 request.Header.Add("Content-Type", "application/json")
4193
4194 if err := c.executeRequestInterceptors(ctx, request); err != nil {
4195 return nil, fmt.Errorf("UpdateDBAASServiceKafka: execute request editors: %w", err)
4196 }
4197
4198 if err := c.signRequest(request); err != nil {
4199 return nil, fmt.Errorf("UpdateDBAASServiceKafka: sign request: %w", err)
4200 }
4201
4202 if c.trace {
4203 dumpRequest(request, "update-dbaas-service-kafka")
4204 }
4205
4206 response, err := c.httpClient.Do(request)
4207 if err != nil {
4208 return nil, fmt.Errorf("UpdateDBAASServiceKafka: http client do: %w", err)
4209 }
4210
4211 if c.trace {
4212 dumpResponse(response)
4213 }
4214
4215 if err := handleHTTPErrorResp(response); err != nil {
4216 return nil, fmt.Errorf("UpdateDBAASServiceKafka: http response: %w", err)
4217 }
4218
4219 bodyresp := new(Operation)
4220 if err := prepareJSONResponse(response, bodyresp); err != nil {
4221 return nil, fmt.Errorf("UpdateDBAASServiceKafka: prepare Json response: %w", err)
4222 }
4223
4224 return bodyresp, nil
4225 }
4226
4227 func (c Client) GetDBAASKafkaAclConfig(ctx context.Context, name string) (*DBAASKafkaAcls, error) {
4228 path := fmt.Sprintf("/dbaas-kafka/%v/acl-config", name)
4229
4230 request, err := http.NewRequestWithContext(ctx, "GET", c.serverEndpoint+path, nil)
4231 if err != nil {
4232 return nil, fmt.Errorf("GetDBAASKafkaAclConfig: new request: %w", err)
4233 }
4234
4235 request.Header.Add("User-Agent", c.getUserAgent())
4236
4237 if err := c.executeRequestInterceptors(ctx, request); err != nil {
4238 return nil, fmt.Errorf("GetDBAASKafkaAclConfig: execute request editors: %w", err)
4239 }
4240
4241 if err := c.signRequest(request); err != nil {
4242 return nil, fmt.Errorf("GetDBAASKafkaAclConfig: sign request: %w", err)
4243 }
4244
4245 if c.trace {
4246 dumpRequest(request, "get-dbaas-kafka-acl-config")
4247 }
4248
4249 response, err := c.httpClient.Do(request)
4250 if err != nil {
4251 return nil, fmt.Errorf("GetDBAASKafkaAclConfig: http client do: %w", err)
4252 }
4253
4254 if c.trace {
4255 dumpResponse(response)
4256 }
4257
4258 if err := handleHTTPErrorResp(response); err != nil {
4259 return nil, fmt.Errorf("GetDBAASKafkaAclConfig: http response: %w", err)
4260 }
4261
4262 bodyresp := new(DBAASKafkaAcls)
4263 if err := prepareJSONResponse(response, bodyresp); err != nil {
4264 return nil, fmt.Errorf("GetDBAASKafkaAclConfig: prepare Json response: %w", err)
4265 }
4266
4267 return bodyresp, nil
4268 }
4269
4270 func (c Client) StartDBAASKafkaMaintenance(ctx context.Context, name string) (*Operation, error) {
4271 path := fmt.Sprintf("/dbaas-kafka/%v/maintenance/start", name)
4272
4273 request, err := http.NewRequestWithContext(ctx, "PUT", c.serverEndpoint+path, nil)
4274 if err != nil {
4275 return nil, fmt.Errorf("StartDBAASKafkaMaintenance: new request: %w", err)
4276 }
4277
4278 request.Header.Add("User-Agent", c.getUserAgent())
4279
4280 if err := c.executeRequestInterceptors(ctx, request); err != nil {
4281 return nil, fmt.Errorf("StartDBAASKafkaMaintenance: execute request editors: %w", err)
4282 }
4283
4284 if err := c.signRequest(request); err != nil {
4285 return nil, fmt.Errorf("StartDBAASKafkaMaintenance: sign request: %w", err)
4286 }
4287
4288 if c.trace {
4289 dumpRequest(request, "start-dbaas-kafka-maintenance")
4290 }
4291
4292 response, err := c.httpClient.Do(request)
4293 if err != nil {
4294 return nil, fmt.Errorf("StartDBAASKafkaMaintenance: http client do: %w", err)
4295 }
4296
4297 if c.trace {
4298 dumpResponse(response)
4299 }
4300
4301 if err := handleHTTPErrorResp(response); err != nil {
4302 return nil, fmt.Errorf("StartDBAASKafkaMaintenance: http response: %w", err)
4303 }
4304
4305 bodyresp := new(Operation)
4306 if err := prepareJSONResponse(response, bodyresp); err != nil {
4307 return nil, fmt.Errorf("StartDBAASKafkaMaintenance: prepare Json response: %w", err)
4308 }
4309
4310 return bodyresp, nil
4311 }
4312
4313 func (c Client) CreateDBAASKafkaSchemaRegistryAclConfig(ctx context.Context, name string, req DBAASKafkaSchemaRegistryAclEntry) (*Operation, error) {
4314 path := fmt.Sprintf("/dbaas-kafka/%v/schema-registry/acl-config", name)
4315
4316 body, err := prepareJSONBody(req)
4317 if err != nil {
4318 return nil, fmt.Errorf("CreateDBAASKafkaSchemaRegistryAclConfig: prepare Json body: %w", err)
4319 }
4320
4321 request, err := http.NewRequestWithContext(ctx, "POST", c.serverEndpoint+path, body)
4322 if err != nil {
4323 return nil, fmt.Errorf("CreateDBAASKafkaSchemaRegistryAclConfig: new request: %w", err)
4324 }
4325
4326 request.Header.Add("User-Agent", c.getUserAgent())
4327
4328 request.Header.Add("Content-Type", "application/json")
4329
4330 if err := c.executeRequestInterceptors(ctx, request); err != nil {
4331 return nil, fmt.Errorf("CreateDBAASKafkaSchemaRegistryAclConfig: execute request editors: %w", err)
4332 }
4333
4334 if err := c.signRequest(request); err != nil {
4335 return nil, fmt.Errorf("CreateDBAASKafkaSchemaRegistryAclConfig: sign request: %w", err)
4336 }
4337
4338 if c.trace {
4339 dumpRequest(request, "create-dbaas-kafka-schema-registry-acl-config")
4340 }
4341
4342 response, err := c.httpClient.Do(request)
4343 if err != nil {
4344 return nil, fmt.Errorf("CreateDBAASKafkaSchemaRegistryAclConfig: http client do: %w", err)
4345 }
4346
4347 if c.trace {
4348 dumpResponse(response)
4349 }
4350
4351 if err := handleHTTPErrorResp(response); err != nil {
4352 return nil, fmt.Errorf("CreateDBAASKafkaSchemaRegistryAclConfig: http response: %w", err)
4353 }
4354
4355 bodyresp := new(Operation)
4356 if err := prepareJSONResponse(response, bodyresp); err != nil {
4357 return nil, fmt.Errorf("CreateDBAASKafkaSchemaRegistryAclConfig: prepare Json response: %w", err)
4358 }
4359
4360 return bodyresp, nil
4361 }
4362
4363 func (c Client) DeleteDBAASKafkaSchemaRegistryAclConfig(ctx context.Context, name string, aclID string) (*Operation, error) {
4364 path := fmt.Sprintf("/dbaas-kafka/%v/schema-registry/acl-config/%v", name, aclID)
4365
4366 request, err := http.NewRequestWithContext(ctx, "DELETE", c.serverEndpoint+path, nil)
4367 if err != nil {
4368 return nil, fmt.Errorf("DeleteDBAASKafkaSchemaRegistryAclConfig: new request: %w", err)
4369 }
4370
4371 request.Header.Add("User-Agent", c.getUserAgent())
4372
4373 if err := c.executeRequestInterceptors(ctx, request); err != nil {
4374 return nil, fmt.Errorf("DeleteDBAASKafkaSchemaRegistryAclConfig: execute request editors: %w", err)
4375 }
4376
4377 if err := c.signRequest(request); err != nil {
4378 return nil, fmt.Errorf("DeleteDBAASKafkaSchemaRegistryAclConfig: sign request: %w", err)
4379 }
4380
4381 if c.trace {
4382 dumpRequest(request, "delete-dbaas-kafka-schema-registry-acl-config")
4383 }
4384
4385 response, err := c.httpClient.Do(request)
4386 if err != nil {
4387 return nil, fmt.Errorf("DeleteDBAASKafkaSchemaRegistryAclConfig: http client do: %w", err)
4388 }
4389
4390 if c.trace {
4391 dumpResponse(response)
4392 }
4393
4394 if err := handleHTTPErrorResp(response); err != nil {
4395 return nil, fmt.Errorf("DeleteDBAASKafkaSchemaRegistryAclConfig: http response: %w", err)
4396 }
4397
4398 bodyresp := new(Operation)
4399 if err := prepareJSONResponse(response, bodyresp); err != nil {
4400 return nil, fmt.Errorf("DeleteDBAASKafkaSchemaRegistryAclConfig: prepare Json response: %w", err)
4401 }
4402
4403 return bodyresp, nil
4404 }
4405
4406 func (c Client) CreateDBAASKafkaTopicAclConfig(ctx context.Context, name string, req DBAASKafkaTopicAclEntry) (*Operation, error) {
4407 path := fmt.Sprintf("/dbaas-kafka/%v/topic/acl-config", name)
4408
4409 body, err := prepareJSONBody(req)
4410 if err != nil {
4411 return nil, fmt.Errorf("CreateDBAASKafkaTopicAclConfig: prepare Json body: %w", err)
4412 }
4413
4414 request, err := http.NewRequestWithContext(ctx, "POST", c.serverEndpoint+path, body)
4415 if err != nil {
4416 return nil, fmt.Errorf("CreateDBAASKafkaTopicAclConfig: new request: %w", err)
4417 }
4418
4419 request.Header.Add("User-Agent", c.getUserAgent())
4420
4421 request.Header.Add("Content-Type", "application/json")
4422
4423 if err := c.executeRequestInterceptors(ctx, request); err != nil {
4424 return nil, fmt.Errorf("CreateDBAASKafkaTopicAclConfig: execute request editors: %w", err)
4425 }
4426
4427 if err := c.signRequest(request); err != nil {
4428 return nil, fmt.Errorf("CreateDBAASKafkaTopicAclConfig: sign request: %w", err)
4429 }
4430
4431 if c.trace {
4432 dumpRequest(request, "create-dbaas-kafka-topic-acl-config")
4433 }
4434
4435 response, err := c.httpClient.Do(request)
4436 if err != nil {
4437 return nil, fmt.Errorf("CreateDBAASKafkaTopicAclConfig: http client do: %w", err)
4438 }
4439
4440 if c.trace {
4441 dumpResponse(response)
4442 }
4443
4444 if err := handleHTTPErrorResp(response); err != nil {
4445 return nil, fmt.Errorf("CreateDBAASKafkaTopicAclConfig: http response: %w", err)
4446 }
4447
4448 bodyresp := new(Operation)
4449 if err := prepareJSONResponse(response, bodyresp); err != nil {
4450 return nil, fmt.Errorf("CreateDBAASKafkaTopicAclConfig: prepare Json response: %w", err)
4451 }
4452
4453 return bodyresp, nil
4454 }
4455
4456 func (c Client) DeleteDBAASKafkaTopicAclConfig(ctx context.Context, name string, aclID string) (*Operation, error) {
4457 path := fmt.Sprintf("/dbaas-kafka/%v/topic/acl-config/%v", name, aclID)
4458
4459 request, err := http.NewRequestWithContext(ctx, "DELETE", c.serverEndpoint+path, nil)
4460 if err != nil {
4461 return nil, fmt.Errorf("DeleteDBAASKafkaTopicAclConfig: new request: %w", err)
4462 }
4463
4464 request.Header.Add("User-Agent", c.getUserAgent())
4465
4466 if err := c.executeRequestInterceptors(ctx, request); err != nil {
4467 return nil, fmt.Errorf("DeleteDBAASKafkaTopicAclConfig: execute request editors: %w", err)
4468 }
4469
4470 if err := c.signRequest(request); err != nil {
4471 return nil, fmt.Errorf("DeleteDBAASKafkaTopicAclConfig: sign request: %w", err)
4472 }
4473
4474 if c.trace {
4475 dumpRequest(request, "delete-dbaas-kafka-topic-acl-config")
4476 }
4477
4478 response, err := c.httpClient.Do(request)
4479 if err != nil {
4480 return nil, fmt.Errorf("DeleteDBAASKafkaTopicAclConfig: http client do: %w", err)
4481 }
4482
4483 if c.trace {
4484 dumpResponse(response)
4485 }
4486
4487 if err := handleHTTPErrorResp(response); err != nil {
4488 return nil, fmt.Errorf("DeleteDBAASKafkaTopicAclConfig: http response: %w", err)
4489 }
4490
4491 bodyresp := new(Operation)
4492 if err := prepareJSONResponse(response, bodyresp); err != nil {
4493 return nil, fmt.Errorf("DeleteDBAASKafkaTopicAclConfig: prepare Json response: %w", err)
4494 }
4495
4496 return bodyresp, nil
4497 }
4498
4499 func (c Client) RevealDBAASKafkaConnectPassword(ctx context.Context, serviceName string) (*DBAASUserKafkaConnectSecrets, error) {
4500 path := fmt.Sprintf("/dbaas-kafka/%v/connect/password/reveal", serviceName)
4501
4502 request, err := http.NewRequestWithContext(ctx, "GET", c.serverEndpoint+path, nil)
4503 if err != nil {
4504 return nil, fmt.Errorf("RevealDBAASKafkaConnectPassword: new request: %w", err)
4505 }
4506
4507 request.Header.Add("User-Agent", c.getUserAgent())
4508
4509 if err := c.executeRequestInterceptors(ctx, request); err != nil {
4510 return nil, fmt.Errorf("RevealDBAASKafkaConnectPassword: execute request editors: %w", err)
4511 }
4512
4513 if err := c.signRequest(request); err != nil {
4514 return nil, fmt.Errorf("RevealDBAASKafkaConnectPassword: sign request: %w", err)
4515 }
4516
4517 if c.trace {
4518 dumpRequest(request, "reveal-dbaas-kafka-connect-password")
4519 }
4520
4521 response, err := c.httpClient.Do(request)
4522 if err != nil {
4523 return nil, fmt.Errorf("RevealDBAASKafkaConnectPassword: http client do: %w", err)
4524 }
4525
4526 if c.trace {
4527 dumpResponse(response)
4528 }
4529
4530 if err := handleHTTPErrorResp(response); err != nil {
4531 return nil, fmt.Errorf("RevealDBAASKafkaConnectPassword: http response: %w", err)
4532 }
4533
4534 bodyresp := new(DBAASUserKafkaConnectSecrets)
4535 if err := prepareJSONResponse(response, bodyresp); err != nil {
4536 return nil, fmt.Errorf("RevealDBAASKafkaConnectPassword: prepare Json response: %w", err)
4537 }
4538
4539 return bodyresp, nil
4540 }
4541
4542 type CreateDBAASKafkaUserRequest struct {
4543 Username DBAASUserUsername `json:"username" validate:"required,gte=1,lte=64"`
4544 }
4545
4546 func (c Client) CreateDBAASKafkaUser(ctx context.Context, serviceName string, req CreateDBAASKafkaUserRequest) (*Operation, error) {
4547 path := fmt.Sprintf("/dbaas-kafka/%v/user", serviceName)
4548
4549 body, err := prepareJSONBody(req)
4550 if err != nil {
4551 return nil, fmt.Errorf("CreateDBAASKafkaUser: prepare Json body: %w", err)
4552 }
4553
4554 request, err := http.NewRequestWithContext(ctx, "POST", c.serverEndpoint+path, body)
4555 if err != nil {
4556 return nil, fmt.Errorf("CreateDBAASKafkaUser: new request: %w", err)
4557 }
4558
4559 request.Header.Add("User-Agent", c.getUserAgent())
4560
4561 request.Header.Add("Content-Type", "application/json")
4562
4563 if err := c.executeRequestInterceptors(ctx, request); err != nil {
4564 return nil, fmt.Errorf("CreateDBAASKafkaUser: execute request editors: %w", err)
4565 }
4566
4567 if err := c.signRequest(request); err != nil {
4568 return nil, fmt.Errorf("CreateDBAASKafkaUser: sign request: %w", err)
4569 }
4570
4571 if c.trace {
4572 dumpRequest(request, "create-dbaas-kafka-user")
4573 }
4574
4575 response, err := c.httpClient.Do(request)
4576 if err != nil {
4577 return nil, fmt.Errorf("CreateDBAASKafkaUser: http client do: %w", err)
4578 }
4579
4580 if c.trace {
4581 dumpResponse(response)
4582 }
4583
4584 if err := handleHTTPErrorResp(response); err != nil {
4585 return nil, fmt.Errorf("CreateDBAASKafkaUser: http response: %w", err)
4586 }
4587
4588 bodyresp := new(Operation)
4589 if err := prepareJSONResponse(response, bodyresp); err != nil {
4590 return nil, fmt.Errorf("CreateDBAASKafkaUser: prepare Json response: %w", err)
4591 }
4592
4593 return bodyresp, nil
4594 }
4595
4596 func (c Client) DeleteDBAASKafkaUser(ctx context.Context, serviceName string, username string) (*Operation, error) {
4597 path := fmt.Sprintf("/dbaas-kafka/%v/user/%v", serviceName, username)
4598
4599 request, err := http.NewRequestWithContext(ctx, "DELETE", c.serverEndpoint+path, nil)
4600 if err != nil {
4601 return nil, fmt.Errorf("DeleteDBAASKafkaUser: new request: %w", err)
4602 }
4603
4604 request.Header.Add("User-Agent", c.getUserAgent())
4605
4606 if err := c.executeRequestInterceptors(ctx, request); err != nil {
4607 return nil, fmt.Errorf("DeleteDBAASKafkaUser: execute request editors: %w", err)
4608 }
4609
4610 if err := c.signRequest(request); err != nil {
4611 return nil, fmt.Errorf("DeleteDBAASKafkaUser: sign request: %w", err)
4612 }
4613
4614 if c.trace {
4615 dumpRequest(request, "delete-dbaas-kafka-user")
4616 }
4617
4618 response, err := c.httpClient.Do(request)
4619 if err != nil {
4620 return nil, fmt.Errorf("DeleteDBAASKafkaUser: http client do: %w", err)
4621 }
4622
4623 if c.trace {
4624 dumpResponse(response)
4625 }
4626
4627 if err := handleHTTPErrorResp(response); err != nil {
4628 return nil, fmt.Errorf("DeleteDBAASKafkaUser: http response: %w", err)
4629 }
4630
4631 bodyresp := new(Operation)
4632 if err := prepareJSONResponse(response, bodyresp); err != nil {
4633 return nil, fmt.Errorf("DeleteDBAASKafkaUser: prepare Json response: %w", err)
4634 }
4635
4636 return bodyresp, nil
4637 }
4638
4639 type ResetDBAASKafkaUserPasswordRequest struct {
4640 Password DBAASUserPassword `json:"password,omitempty" validate:"omitempty,gte=8,lte=256"`
4641 }
4642
4643 // If no password is provided one will be generated automatically.
4644 func (c Client) ResetDBAASKafkaUserPassword(ctx context.Context, serviceName string, username string, req ResetDBAASKafkaUserPasswordRequest) (*Operation, error) {
4645 path := fmt.Sprintf("/dbaas-kafka/%v/user/%v/password/reset", serviceName, username)
4646
4647 body, err := prepareJSONBody(req)
4648 if err != nil {
4649 return nil, fmt.Errorf("ResetDBAASKafkaUserPassword: prepare Json body: %w", err)
4650 }
4651
4652 request, err := http.NewRequestWithContext(ctx, "PUT", c.serverEndpoint+path, body)
4653 if err != nil {
4654 return nil, fmt.Errorf("ResetDBAASKafkaUserPassword: new request: %w", err)
4655 }
4656
4657 request.Header.Add("User-Agent", c.getUserAgent())
4658
4659 request.Header.Add("Content-Type", "application/json")
4660
4661 if err := c.executeRequestInterceptors(ctx, request); err != nil {
4662 return nil, fmt.Errorf("ResetDBAASKafkaUserPassword: execute request editors: %w", err)
4663 }
4664
4665 if err := c.signRequest(request); err != nil {
4666 return nil, fmt.Errorf("ResetDBAASKafkaUserPassword: sign request: %w", err)
4667 }
4668
4669 if c.trace {
4670 dumpRequest(request, "reset-dbaas-kafka-user-password")
4671 }
4672
4673 response, err := c.httpClient.Do(request)
4674 if err != nil {
4675 return nil, fmt.Errorf("ResetDBAASKafkaUserPassword: http client do: %w", err)
4676 }
4677
4678 if c.trace {
4679 dumpResponse(response)
4680 }
4681
4682 if err := handleHTTPErrorResp(response); err != nil {
4683 return nil, fmt.Errorf("ResetDBAASKafkaUserPassword: http response: %w", err)
4684 }
4685
4686 bodyresp := new(Operation)
4687 if err := prepareJSONResponse(response, bodyresp); err != nil {
4688 return nil, fmt.Errorf("ResetDBAASKafkaUserPassword: prepare Json response: %w", err)
4689 }
4690
4691 return bodyresp, nil
4692 }
4693
4694 func (c Client) RevealDBAASKafkaUserPassword(ctx context.Context, serviceName string, username string) (*DBAASUserKafkaSecrets, error) {
4695 path := fmt.Sprintf("/dbaas-kafka/%v/user/%v/password/reveal", serviceName, username)
4696
4697 request, err := http.NewRequestWithContext(ctx, "GET", c.serverEndpoint+path, nil)
4698 if err != nil {
4699 return nil, fmt.Errorf("RevealDBAASKafkaUserPassword: new request: %w", err)
4700 }
4701
4702 request.Header.Add("User-Agent", c.getUserAgent())
4703
4704 if err := c.executeRequestInterceptors(ctx, request); err != nil {
4705 return nil, fmt.Errorf("RevealDBAASKafkaUserPassword: execute request editors: %w", err)
4706 }
4707
4708 if err := c.signRequest(request); err != nil {
4709 return nil, fmt.Errorf("RevealDBAASKafkaUserPassword: sign request: %w", err)
4710 }
4711
4712 if c.trace {
4713 dumpRequest(request, "reveal-dbaas-kafka-user-password")
4714 }
4715
4716 response, err := c.httpClient.Do(request)
4717 if err != nil {
4718 return nil, fmt.Errorf("RevealDBAASKafkaUserPassword: http client do: %w", err)
4719 }
4720
4721 if c.trace {
4722 dumpResponse(response)
4723 }
4724
4725 if err := handleHTTPErrorResp(response); err != nil {
4726 return nil, fmt.Errorf("RevealDBAASKafkaUserPassword: http response: %w", err)
4727 }
4728
4729 bodyresp := new(DBAASUserKafkaSecrets)
4730 if err := prepareJSONResponse(response, bodyresp); err != nil {
4731 return nil, fmt.Errorf("RevealDBAASKafkaUserPassword: prepare Json response: %w", err)
4732 }
4733
4734 return bodyresp, nil
4735 }
4736
4737 // Get a DBaaS migration status
4738 func (c Client) GetDBAASMigrationStatus(ctx context.Context, name string) (*DBAASMigrationStatus, error) {
4739 path := fmt.Sprintf("/dbaas-migration-status/%v", name)
4740
4741 request, err := http.NewRequestWithContext(ctx, "GET", c.serverEndpoint+path, nil)
4742 if err != nil {
4743 return nil, fmt.Errorf("GetDBAASMigrationStatus: new request: %w", err)
4744 }
4745
4746 request.Header.Add("User-Agent", c.getUserAgent())
4747
4748 if err := c.executeRequestInterceptors(ctx, request); err != nil {
4749 return nil, fmt.Errorf("GetDBAASMigrationStatus: execute request editors: %w", err)
4750 }
4751
4752 if err := c.signRequest(request); err != nil {
4753 return nil, fmt.Errorf("GetDBAASMigrationStatus: sign request: %w", err)
4754 }
4755
4756 if c.trace {
4757 dumpRequest(request, "get-dbaas-migration-status")
4758 }
4759
4760 response, err := c.httpClient.Do(request)
4761 if err != nil {
4762 return nil, fmt.Errorf("GetDBAASMigrationStatus: http client do: %w", err)
4763 }
4764
4765 if c.trace {
4766 dumpResponse(response)
4767 }
4768
4769 if err := handleHTTPErrorResp(response); err != nil {
4770 return nil, fmt.Errorf("GetDBAASMigrationStatus: http response: %w", err)
4771 }
4772
4773 bodyresp := new(DBAASMigrationStatus)
4774 if err := prepareJSONResponse(response, bodyresp); err != nil {
4775 return nil, fmt.Errorf("GetDBAASMigrationStatus: prepare Json response: %w", err)
4776 }
4777
4778 return bodyresp, nil
4779 }
4780
4781 func (c Client) DeleteDBAASServiceMysql(ctx context.Context, name string) (*Operation, error) {
4782 path := fmt.Sprintf("/dbaas-mysql/%v", name)
4783
4784 request, err := http.NewRequestWithContext(ctx, "DELETE", c.serverEndpoint+path, nil)
4785 if err != nil {
4786 return nil, fmt.Errorf("DeleteDBAASServiceMysql: new request: %w", err)
4787 }
4788
4789 request.Header.Add("User-Agent", c.getUserAgent())
4790
4791 if err := c.executeRequestInterceptors(ctx, request); err != nil {
4792 return nil, fmt.Errorf("DeleteDBAASServiceMysql: execute request editors: %w", err)
4793 }
4794
4795 if err := c.signRequest(request); err != nil {
4796 return nil, fmt.Errorf("DeleteDBAASServiceMysql: sign request: %w", err)
4797 }
4798
4799 if c.trace {
4800 dumpRequest(request, "delete-dbaas-service-mysql")
4801 }
4802
4803 response, err := c.httpClient.Do(request)
4804 if err != nil {
4805 return nil, fmt.Errorf("DeleteDBAASServiceMysql: http client do: %w", err)
4806 }
4807
4808 if c.trace {
4809 dumpResponse(response)
4810 }
4811
4812 if err := handleHTTPErrorResp(response); err != nil {
4813 return nil, fmt.Errorf("DeleteDBAASServiceMysql: http response: %w", err)
4814 }
4815
4816 bodyresp := new(Operation)
4817 if err := prepareJSONResponse(response, bodyresp); err != nil {
4818 return nil, fmt.Errorf("DeleteDBAASServiceMysql: prepare Json response: %w", err)
4819 }
4820
4821 return bodyresp, nil
4822 }
4823
4824 // Get a DBaaS MySQL service
4825 func (c Client) GetDBAASServiceMysql(ctx context.Context, name string) (*DBAASServiceMysql, error) {
4826 path := fmt.Sprintf("/dbaas-mysql/%v", name)
4827
4828 request, err := http.NewRequestWithContext(ctx, "GET", c.serverEndpoint+path, nil)
4829 if err != nil {
4830 return nil, fmt.Errorf("GetDBAASServiceMysql: new request: %w", err)
4831 }
4832
4833 request.Header.Add("User-Agent", c.getUserAgent())
4834
4835 if err := c.executeRequestInterceptors(ctx, request); err != nil {
4836 return nil, fmt.Errorf("GetDBAASServiceMysql: execute request editors: %w", err)
4837 }
4838
4839 if err := c.signRequest(request); err != nil {
4840 return nil, fmt.Errorf("GetDBAASServiceMysql: sign request: %w", err)
4841 }
4842
4843 if c.trace {
4844 dumpRequest(request, "get-dbaas-service-mysql")
4845 }
4846
4847 response, err := c.httpClient.Do(request)
4848 if err != nil {
4849 return nil, fmt.Errorf("GetDBAASServiceMysql: http client do: %w", err)
4850 }
4851
4852 if c.trace {
4853 dumpResponse(response)
4854 }
4855
4856 if err := handleHTTPErrorResp(response); err != nil {
4857 return nil, fmt.Errorf("GetDBAASServiceMysql: http response: %w", err)
4858 }
4859
4860 bodyresp := new(DBAASServiceMysql)
4861 if err := prepareJSONResponse(response, bodyresp); err != nil {
4862 return nil, fmt.Errorf("GetDBAASServiceMysql: prepare Json response: %w", err)
4863 }
4864
4865 return bodyresp, nil
4866 }
4867
4868 type CreateDBAASServiceMysqlRequestBackupSchedule struct {
4869 // The hour of day (in UTC) when backup for the service is started. New backup is only started if previous backup has already completed.
4870 BackupHour *int64 `json:"backup-hour,omitempty" validate:"omitempty,gte=0,lte=23"`
4871 // The minute of an hour when backup for the service is started. New backup is only started if previous backup has already completed.
4872 BackupMinute *int64 `json:"backup-minute,omitempty" validate:"omitempty,gte=0,lte=59"`
4873 }
4874
4875 type CreateDBAASServiceMysqlRequestIntegrationsType string
4876
4877 const (
4878 CreateDBAASServiceMysqlRequestIntegrationsTypeReadReplica CreateDBAASServiceMysqlRequestIntegrationsType = "read_replica"
4879 )
4880
4881 type CreateDBAASServiceMysqlRequestIntegrations struct {
4882 DestService DBAASServiceName `json:"dest-service,omitempty" validate:"omitempty,gte=0,lte=63"`
4883 // Integration settings
4884 Settings map[string]any `json:"settings,omitempty"`
4885 SourceService DBAASServiceName `json:"source-service,omitempty" validate:"omitempty,gte=0,lte=63"`
4886 // Integration type
4887 Type CreateDBAASServiceMysqlRequestIntegrationsType `json:"type" validate:"required"`
4888 }
4889
4890 type CreateDBAASServiceMysqlRequestMaintenanceDow string
4891
4892 const (
4893 CreateDBAASServiceMysqlRequestMaintenanceDowSaturday CreateDBAASServiceMysqlRequestMaintenanceDow = "saturday"
4894 CreateDBAASServiceMysqlRequestMaintenanceDowTuesday CreateDBAASServiceMysqlRequestMaintenanceDow = "tuesday"
4895 CreateDBAASServiceMysqlRequestMaintenanceDowNever CreateDBAASServiceMysqlRequestMaintenanceDow = "never"
4896 CreateDBAASServiceMysqlRequestMaintenanceDowWednesday CreateDBAASServiceMysqlRequestMaintenanceDow = "wednesday"
4897 CreateDBAASServiceMysqlRequestMaintenanceDowSunday CreateDBAASServiceMysqlRequestMaintenanceDow = "sunday"
4898 CreateDBAASServiceMysqlRequestMaintenanceDowFriday CreateDBAASServiceMysqlRequestMaintenanceDow = "friday"
4899 CreateDBAASServiceMysqlRequestMaintenanceDowMonday CreateDBAASServiceMysqlRequestMaintenanceDow = "monday"
4900 CreateDBAASServiceMysqlRequestMaintenanceDowThursday CreateDBAASServiceMysqlRequestMaintenanceDow = "thursday"
4901 )
4902
4903 // Automatic maintenance settings
4904 type CreateDBAASServiceMysqlRequestMaintenance struct {
4905 // Day of week for installing updates
4906 Dow CreateDBAASServiceMysqlRequestMaintenanceDow `json:"dow" validate:"required"`
4907 // Time for installing updates, UTC
4908 Time string `json:"time" validate:"required,gte=8,lte=8"`
4909 }
4910
4911 // Migrate data from existing server
4912 type CreateDBAASServiceMysqlRequestMigration struct {
4913 // Database name for bootstrapping the initial connection
4914 Dbname string `json:"dbname,omitempty" validate:"omitempty,gte=1,lte=63"`
4915 // Hostname or IP address of the server where to migrate data from
4916 Host string `json:"host" validate:"required,gte=1,lte=255"`
4917 // Comma-separated list of databases, which should be ignored during migration (supported by MySQL only at the moment)
4918 IgnoreDbs string `json:"ignore-dbs,omitempty" validate:"omitempty,gte=1,lte=2048"`
4919 Method EnumMigrationMethod `json:"method,omitempty"`
4920 // Password for authentication with the server where to migrate data from
4921 Password string `json:"password,omitempty" validate:"omitempty,gte=1,lte=255"`
4922 // Port number of the server where to migrate data from
4923 Port int64 `json:"port" validate:"required,gte=1,lte=65535"`
4924 // The server where to migrate data from is secured with SSL
4925 SSL *bool `json:"ssl,omitempty"`
4926 // User name for authentication with the server where to migrate data from
4927 Username string `json:"username,omitempty" validate:"omitempty,gte=1,lte=255"`
4928 }
4929
4930 type CreateDBAASServiceMysqlRequest struct {
4931 // Custom password for admin user. Defaults to random string. This must be set only when a new service is being created.
4932 AdminPassword string `json:"admin-password,omitempty" validate:"omitempty,gte=8,lte=256"`
4933 // Custom username for admin user. This must be set only when a new service is being created.
4934 AdminUsername string `json:"admin-username,omitempty" validate:"omitempty,gte=1,lte=64"`
4935 BackupSchedule *CreateDBAASServiceMysqlRequestBackupSchedule `json:"backup-schedule,omitempty"`
4936 // The minimum amount of time in seconds to keep binlog entries before deletion. This may be extended for services that require binlog entries for longer than the default for example if using the MySQL Debezium Kafka connector.
4937 BinlogRetentionPeriod int64 `json:"binlog-retention-period,omitempty" validate:"omitempty,gte=600,lte=86400"`
4938 ForkFromService DBAASServiceName `json:"fork-from-service,omitempty" validate:"omitempty,gte=0,lte=63"`
4939 // Service integrations to be enabled when creating the service.
4940 Integrations []CreateDBAASServiceMysqlRequestIntegrations `json:"integrations,omitempty"`
4941 // Allow incoming connections from CIDR address block, e.g. '10.20.0.0/16'
4942 IPFilter []string `json:"ip-filter,omitempty"`
4943 // Automatic maintenance settings
4944 Maintenance *CreateDBAASServiceMysqlRequestMaintenance `json:"maintenance,omitempty"`
4945 // Migrate data from existing server
4946 Migration *CreateDBAASServiceMysqlRequestMigration `json:"migration,omitempty"`
4947 // mysql.conf configuration values
4948 MysqlSettings *JSONSchemaMysql `json:"mysql-settings,omitempty"`
4949 // Subscription plan
4950 Plan string `json:"plan" validate:"required,gte=1,lte=128"`
4951 // ISO time of a backup to recover from for services that support arbitrary times
4952 RecoveryBackupTime string `json:"recovery-backup-time,omitempty" validate:"omitempty,gte=1"`
4953 // Service is protected against termination and powering off
4954 TerminationProtection *bool `json:"termination-protection,omitempty"`
4955 // MySQL major version
4956 Version string `json:"version,omitempty" validate:"omitempty,gte=1"`
4957 }
4958
4959 // Create a DBaaS MySQL service
4960 func (c Client) CreateDBAASServiceMysql(ctx context.Context, name string, req CreateDBAASServiceMysqlRequest) (*Operation, error) {
4961 path := fmt.Sprintf("/dbaas-mysql/%v", name)
4962
4963 body, err := prepareJSONBody(req)
4964 if err != nil {
4965 return nil, fmt.Errorf("CreateDBAASServiceMysql: prepare Json body: %w", err)
4966 }
4967
4968 request, err := http.NewRequestWithContext(ctx, "POST", c.serverEndpoint+path, body)
4969 if err != nil {
4970 return nil, fmt.Errorf("CreateDBAASServiceMysql: new request: %w", err)
4971 }
4972
4973 request.Header.Add("User-Agent", c.getUserAgent())
4974
4975 request.Header.Add("Content-Type", "application/json")
4976
4977 if err := c.executeRequestInterceptors(ctx, request); err != nil {
4978 return nil, fmt.Errorf("CreateDBAASServiceMysql: execute request editors: %w", err)
4979 }
4980
4981 if err := c.signRequest(request); err != nil {
4982 return nil, fmt.Errorf("CreateDBAASServiceMysql: sign request: %w", err)
4983 }
4984
4985 if c.trace {
4986 dumpRequest(request, "create-dbaas-service-mysql")
4987 }
4988
4989 response, err := c.httpClient.Do(request)
4990 if err != nil {
4991 return nil, fmt.Errorf("CreateDBAASServiceMysql: http client do: %w", err)
4992 }
4993
4994 if c.trace {
4995 dumpResponse(response)
4996 }
4997
4998 if err := handleHTTPErrorResp(response); err != nil {
4999 return nil, fmt.Errorf("CreateDBAASServiceMysql: http response: %w", err)
5000 }
5001
5002 bodyresp := new(Operation)
5003 if err := prepareJSONResponse(response, bodyresp); err != nil {
5004 return nil, fmt.Errorf("CreateDBAASServiceMysql: prepare Json response: %w", err)
5005 }
5006
5007 return bodyresp, nil
5008 }
5009
5010 type UpdateDBAASServiceMysqlRequestBackupSchedule struct {
5011 // The hour of day (in UTC) when backup for the service is started. New backup is only started if previous backup has already completed.
5012 BackupHour *int64 `json:"backup-hour,omitempty" validate:"omitempty,gte=0,lte=23"`
5013 // The minute of an hour when backup for the service is started. New backup is only started if previous backup has already completed.
5014 BackupMinute *int64 `json:"backup-minute,omitempty" validate:"omitempty,gte=0,lte=59"`
5015 }
5016
5017 type UpdateDBAASServiceMysqlRequestMaintenanceDow string
5018
5019 const (
5020 UpdateDBAASServiceMysqlRequestMaintenanceDowSaturday UpdateDBAASServiceMysqlRequestMaintenanceDow = "saturday"
5021 UpdateDBAASServiceMysqlRequestMaintenanceDowTuesday UpdateDBAASServiceMysqlRequestMaintenanceDow = "tuesday"
5022 UpdateDBAASServiceMysqlRequestMaintenanceDowNever UpdateDBAASServiceMysqlRequestMaintenanceDow = "never"
5023 UpdateDBAASServiceMysqlRequestMaintenanceDowWednesday UpdateDBAASServiceMysqlRequestMaintenanceDow = "wednesday"
5024 UpdateDBAASServiceMysqlRequestMaintenanceDowSunday UpdateDBAASServiceMysqlRequestMaintenanceDow = "sunday"
5025 UpdateDBAASServiceMysqlRequestMaintenanceDowFriday UpdateDBAASServiceMysqlRequestMaintenanceDow = "friday"
5026 UpdateDBAASServiceMysqlRequestMaintenanceDowMonday UpdateDBAASServiceMysqlRequestMaintenanceDow = "monday"
5027 UpdateDBAASServiceMysqlRequestMaintenanceDowThursday UpdateDBAASServiceMysqlRequestMaintenanceDow = "thursday"
5028 )
5029
5030 // Automatic maintenance settings
5031 type UpdateDBAASServiceMysqlRequestMaintenance struct {
5032 // Day of week for installing updates
5033 Dow UpdateDBAASServiceMysqlRequestMaintenanceDow `json:"dow" validate:"required"`
5034 // Time for installing updates, UTC
5035 Time string `json:"time" validate:"required,gte=8,lte=8"`
5036 }
5037
5038 // Migrate data from existing server
5039 type UpdateDBAASServiceMysqlRequestMigration struct {
5040 // Database name for bootstrapping the initial connection
5041 Dbname string `json:"dbname,omitempty" validate:"omitempty,gte=1,lte=63"`
5042 // Hostname or IP address of the server where to migrate data from
5043 Host string `json:"host" validate:"required,gte=1,lte=255"`
5044 // Comma-separated list of databases, which should be ignored during migration (supported by MySQL only at the moment)
5045 IgnoreDbs string `json:"ignore-dbs,omitempty" validate:"omitempty,gte=1,lte=2048"`
5046 Method EnumMigrationMethod `json:"method,omitempty"`
5047 // Password for authentication with the server where to migrate data from
5048 Password string `json:"password,omitempty" validate:"omitempty,gte=1,lte=255"`
5049 // Port number of the server where to migrate data from
5050 Port int64 `json:"port" validate:"required,gte=1,lte=65535"`
5051 // The server where to migrate data from is secured with SSL
5052 SSL *bool `json:"ssl,omitempty"`
5053 // User name for authentication with the server where to migrate data from
5054 Username string `json:"username,omitempty" validate:"omitempty,gte=1,lte=255"`
5055 }
5056
5057 type UpdateDBAASServiceMysqlRequest struct {
5058 BackupSchedule *UpdateDBAASServiceMysqlRequestBackupSchedule `json:"backup-schedule,omitempty"`
5059 // The minimum amount of time in seconds to keep binlog entries before deletion. This may be extended for services that require binlog entries for longer than the default for example if using the MySQL Debezium Kafka connector.
5060 BinlogRetentionPeriod int64 `json:"binlog-retention-period,omitempty" validate:"omitempty,gte=600,lte=86400"`
5061 // Allow incoming connections from CIDR address block, e.g. '10.20.0.0/16'
5062 IPFilter []string `json:"ip-filter,omitempty"`
5063 // Automatic maintenance settings
5064 Maintenance *UpdateDBAASServiceMysqlRequestMaintenance `json:"maintenance,omitempty"`
5065 // Migrate data from existing server
5066 Migration *UpdateDBAASServiceMysqlRequestMigration `json:"migration,omitempty"`
5067 // mysql.conf configuration values
5068 MysqlSettings *JSONSchemaMysql `json:"mysql-settings,omitempty"`
5069 // Subscription plan
5070 Plan string `json:"plan,omitempty" validate:"omitempty,gte=1,lte=128"`
5071 // Service is protected against termination and powering off
5072 TerminationProtection *bool `json:"termination-protection,omitempty"`
5073 }
5074
5075 // Update a DBaaS MySQL service
5076 func (c Client) UpdateDBAASServiceMysql(ctx context.Context, name string, req UpdateDBAASServiceMysqlRequest) (*Operation, error) {
5077 path := fmt.Sprintf("/dbaas-mysql/%v", name)
5078
5079 body, err := prepareJSONBody(req)
5080 if err != nil {
5081 return nil, fmt.Errorf("UpdateDBAASServiceMysql: prepare Json body: %w", err)
5082 }
5083
5084 request, err := http.NewRequestWithContext(ctx, "PUT", c.serverEndpoint+path, body)
5085 if err != nil {
5086 return nil, fmt.Errorf("UpdateDBAASServiceMysql: new request: %w", err)
5087 }
5088
5089 request.Header.Add("User-Agent", c.getUserAgent())
5090
5091 request.Header.Add("Content-Type", "application/json")
5092
5093 if err := c.executeRequestInterceptors(ctx, request); err != nil {
5094 return nil, fmt.Errorf("UpdateDBAASServiceMysql: execute request editors: %w", err)
5095 }
5096
5097 if err := c.signRequest(request); err != nil {
5098 return nil, fmt.Errorf("UpdateDBAASServiceMysql: sign request: %w", err)
5099 }
5100
5101 if c.trace {
5102 dumpRequest(request, "update-dbaas-service-mysql")
5103 }
5104
5105 response, err := c.httpClient.Do(request)
5106 if err != nil {
5107 return nil, fmt.Errorf("UpdateDBAASServiceMysql: http client do: %w", err)
5108 }
5109
5110 if c.trace {
5111 dumpResponse(response)
5112 }
5113
5114 if err := handleHTTPErrorResp(response); err != nil {
5115 return nil, fmt.Errorf("UpdateDBAASServiceMysql: http response: %w", err)
5116 }
5117
5118 bodyresp := new(Operation)
5119 if err := prepareJSONResponse(response, bodyresp); err != nil {
5120 return nil, fmt.Errorf("UpdateDBAASServiceMysql: prepare Json response: %w", err)
5121 }
5122
5123 return bodyresp, nil
5124 }
5125
5126 func (c Client) EnableDBAASMysqlWrites(ctx context.Context, name string) (*Operation, error) {
5127 path := fmt.Sprintf("/dbaas-mysql/%v/enable/writes", name)
5128
5129 request, err := http.NewRequestWithContext(ctx, "PUT", c.serverEndpoint+path, nil)
5130 if err != nil {
5131 return nil, fmt.Errorf("EnableDBAASMysqlWrites: new request: %w", err)
5132 }
5133
5134 request.Header.Add("User-Agent", c.getUserAgent())
5135
5136 if err := c.executeRequestInterceptors(ctx, request); err != nil {
5137 return nil, fmt.Errorf("EnableDBAASMysqlWrites: execute request editors: %w", err)
5138 }
5139
5140 if err := c.signRequest(request); err != nil {
5141 return nil, fmt.Errorf("EnableDBAASMysqlWrites: sign request: %w", err)
5142 }
5143
5144 if c.trace {
5145 dumpRequest(request, "enable-dbaas-mysql-writes")
5146 }
5147
5148 response, err := c.httpClient.Do(request)
5149 if err != nil {
5150 return nil, fmt.Errorf("EnableDBAASMysqlWrites: http client do: %w", err)
5151 }
5152
5153 if c.trace {
5154 dumpResponse(response)
5155 }
5156
5157 if err := handleHTTPErrorResp(response); err != nil {
5158 return nil, fmt.Errorf("EnableDBAASMysqlWrites: http response: %w", err)
5159 }
5160
5161 bodyresp := new(Operation)
5162 if err := prepareJSONResponse(response, bodyresp); err != nil {
5163 return nil, fmt.Errorf("EnableDBAASMysqlWrites: prepare Json response: %w", err)
5164 }
5165
5166 return bodyresp, nil
5167 }
5168
5169 func (c Client) StartDBAASMysqlMaintenance(ctx context.Context, name string) (*Operation, error) {
5170 path := fmt.Sprintf("/dbaas-mysql/%v/maintenance/start", name)
5171
5172 request, err := http.NewRequestWithContext(ctx, "PUT", c.serverEndpoint+path, nil)
5173 if err != nil {
5174 return nil, fmt.Errorf("StartDBAASMysqlMaintenance: new request: %w", err)
5175 }
5176
5177 request.Header.Add("User-Agent", c.getUserAgent())
5178
5179 if err := c.executeRequestInterceptors(ctx, request); err != nil {
5180 return nil, fmt.Errorf("StartDBAASMysqlMaintenance: execute request editors: %w", err)
5181 }
5182
5183 if err := c.signRequest(request); err != nil {
5184 return nil, fmt.Errorf("StartDBAASMysqlMaintenance: sign request: %w", err)
5185 }
5186
5187 if c.trace {
5188 dumpRequest(request, "start-dbaas-mysql-maintenance")
5189 }
5190
5191 response, err := c.httpClient.Do(request)
5192 if err != nil {
5193 return nil, fmt.Errorf("StartDBAASMysqlMaintenance: http client do: %w", err)
5194 }
5195
5196 if c.trace {
5197 dumpResponse(response)
5198 }
5199
5200 if err := handleHTTPErrorResp(response); err != nil {
5201 return nil, fmt.Errorf("StartDBAASMysqlMaintenance: http response: %w", err)
5202 }
5203
5204 bodyresp := new(Operation)
5205 if err := prepareJSONResponse(response, bodyresp); err != nil {
5206 return nil, fmt.Errorf("StartDBAASMysqlMaintenance: prepare Json response: %w", err)
5207 }
5208
5209 return bodyresp, nil
5210 }
5211
5212 func (c Client) StopDBAASMysqlMigration(ctx context.Context, name string) (*Operation, error) {
5213 path := fmt.Sprintf("/dbaas-mysql/%v/migration/stop", name)
5214
5215 request, err := http.NewRequestWithContext(ctx, "POST", c.serverEndpoint+path, nil)
5216 if err != nil {
5217 return nil, fmt.Errorf("StopDBAASMysqlMigration: new request: %w", err)
5218 }
5219
5220 request.Header.Add("User-Agent", c.getUserAgent())
5221
5222 if err := c.executeRequestInterceptors(ctx, request); err != nil {
5223 return nil, fmt.Errorf("StopDBAASMysqlMigration: execute request editors: %w", err)
5224 }
5225
5226 if err := c.signRequest(request); err != nil {
5227 return nil, fmt.Errorf("StopDBAASMysqlMigration: sign request: %w", err)
5228 }
5229
5230 if c.trace {
5231 dumpRequest(request, "stop-dbaas-mysql-migration")
5232 }
5233
5234 response, err := c.httpClient.Do(request)
5235 if err != nil {
5236 return nil, fmt.Errorf("StopDBAASMysqlMigration: http client do: %w", err)
5237 }
5238
5239 if c.trace {
5240 dumpResponse(response)
5241 }
5242
5243 if err := handleHTTPErrorResp(response); err != nil {
5244 return nil, fmt.Errorf("StopDBAASMysqlMigration: http response: %w", err)
5245 }
5246
5247 bodyresp := new(Operation)
5248 if err := prepareJSONResponse(response, bodyresp); err != nil {
5249 return nil, fmt.Errorf("StopDBAASMysqlMigration: prepare Json response: %w", err)
5250 }
5251
5252 return bodyresp, nil
5253 }
5254
5255 type CreateDBAASMysqlDatabaseRequest struct {
5256 DatabaseName DBAASDatabaseName `json:"database-name" validate:"required,gte=1,lte=40"`
5257 }
5258
5259 func (c Client) CreateDBAASMysqlDatabase(ctx context.Context, serviceName string, req CreateDBAASMysqlDatabaseRequest) (*Operation, error) {
5260 path := fmt.Sprintf("/dbaas-mysql/%v/database", serviceName)
5261
5262 body, err := prepareJSONBody(req)
5263 if err != nil {
5264 return nil, fmt.Errorf("CreateDBAASMysqlDatabase: prepare Json body: %w", err)
5265 }
5266
5267 request, err := http.NewRequestWithContext(ctx, "POST", c.serverEndpoint+path, body)
5268 if err != nil {
5269 return nil, fmt.Errorf("CreateDBAASMysqlDatabase: new request: %w", err)
5270 }
5271
5272 request.Header.Add("User-Agent", c.getUserAgent())
5273
5274 request.Header.Add("Content-Type", "application/json")
5275
5276 if err := c.executeRequestInterceptors(ctx, request); err != nil {
5277 return nil, fmt.Errorf("CreateDBAASMysqlDatabase: execute request editors: %w", err)
5278 }
5279
5280 if err := c.signRequest(request); err != nil {
5281 return nil, fmt.Errorf("CreateDBAASMysqlDatabase: sign request: %w", err)
5282 }
5283
5284 if c.trace {
5285 dumpRequest(request, "create-dbaas-mysql-database")
5286 }
5287
5288 response, err := c.httpClient.Do(request)
5289 if err != nil {
5290 return nil, fmt.Errorf("CreateDBAASMysqlDatabase: http client do: %w", err)
5291 }
5292
5293 if c.trace {
5294 dumpResponse(response)
5295 }
5296
5297 if err := handleHTTPErrorResp(response); err != nil {
5298 return nil, fmt.Errorf("CreateDBAASMysqlDatabase: http response: %w", err)
5299 }
5300
5301 bodyresp := new(Operation)
5302 if err := prepareJSONResponse(response, bodyresp); err != nil {
5303 return nil, fmt.Errorf("CreateDBAASMysqlDatabase: prepare Json response: %w", err)
5304 }
5305
5306 return bodyresp, nil
5307 }
5308
5309 func (c Client) DeleteDBAASMysqlDatabase(ctx context.Context, serviceName string, databaseName string) (*Operation, error) {
5310 path := fmt.Sprintf("/dbaas-mysql/%v/database/%v", serviceName, databaseName)
5311
5312 request, err := http.NewRequestWithContext(ctx, "DELETE", c.serverEndpoint+path, nil)
5313 if err != nil {
5314 return nil, fmt.Errorf("DeleteDBAASMysqlDatabase: new request: %w", err)
5315 }
5316
5317 request.Header.Add("User-Agent", c.getUserAgent())
5318
5319 if err := c.executeRequestInterceptors(ctx, request); err != nil {
5320 return nil, fmt.Errorf("DeleteDBAASMysqlDatabase: execute request editors: %w", err)
5321 }
5322
5323 if err := c.signRequest(request); err != nil {
5324 return nil, fmt.Errorf("DeleteDBAASMysqlDatabase: sign request: %w", err)
5325 }
5326
5327 if c.trace {
5328 dumpRequest(request, "delete-dbaas-mysql-database")
5329 }
5330
5331 response, err := c.httpClient.Do(request)
5332 if err != nil {
5333 return nil, fmt.Errorf("DeleteDBAASMysqlDatabase: http client do: %w", err)
5334 }
5335
5336 if c.trace {
5337 dumpResponse(response)
5338 }
5339
5340 if err := handleHTTPErrorResp(response); err != nil {
5341 return nil, fmt.Errorf("DeleteDBAASMysqlDatabase: http response: %w", err)
5342 }
5343
5344 bodyresp := new(Operation)
5345 if err := prepareJSONResponse(response, bodyresp); err != nil {
5346 return nil, fmt.Errorf("DeleteDBAASMysqlDatabase: prepare Json response: %w", err)
5347 }
5348
5349 return bodyresp, nil
5350 }
5351
5352 type CreateDBAASMysqlUserRequest struct {
5353 Authentication EnumMysqlAuthenticationPlugin `json:"authentication,omitempty"`
5354 Username DBAASUserUsername `json:"username" validate:"required,gte=1,lte=64"`
5355 }
5356
5357 func (c Client) CreateDBAASMysqlUser(ctx context.Context, serviceName string, req CreateDBAASMysqlUserRequest) (*Operation, error) {
5358 path := fmt.Sprintf("/dbaas-mysql/%v/user", serviceName)
5359
5360 body, err := prepareJSONBody(req)
5361 if err != nil {
5362 return nil, fmt.Errorf("CreateDBAASMysqlUser: prepare Json body: %w", err)
5363 }
5364
5365 request, err := http.NewRequestWithContext(ctx, "POST", c.serverEndpoint+path, body)
5366 if err != nil {
5367 return nil, fmt.Errorf("CreateDBAASMysqlUser: new request: %w", err)
5368 }
5369
5370 request.Header.Add("User-Agent", c.getUserAgent())
5371
5372 request.Header.Add("Content-Type", "application/json")
5373
5374 if err := c.executeRequestInterceptors(ctx, request); err != nil {
5375 return nil, fmt.Errorf("CreateDBAASMysqlUser: execute request editors: %w", err)
5376 }
5377
5378 if err := c.signRequest(request); err != nil {
5379 return nil, fmt.Errorf("CreateDBAASMysqlUser: sign request: %w", err)
5380 }
5381
5382 if c.trace {
5383 dumpRequest(request, "create-dbaas-mysql-user")
5384 }
5385
5386 response, err := c.httpClient.Do(request)
5387 if err != nil {
5388 return nil, fmt.Errorf("CreateDBAASMysqlUser: http client do: %w", err)
5389 }
5390
5391 if c.trace {
5392 dumpResponse(response)
5393 }
5394
5395 if err := handleHTTPErrorResp(response); err != nil {
5396 return nil, fmt.Errorf("CreateDBAASMysqlUser: http response: %w", err)
5397 }
5398
5399 bodyresp := new(Operation)
5400 if err := prepareJSONResponse(response, bodyresp); err != nil {
5401 return nil, fmt.Errorf("CreateDBAASMysqlUser: prepare Json response: %w", err)
5402 }
5403
5404 return bodyresp, nil
5405 }
5406
5407 func (c Client) DeleteDBAASMysqlUser(ctx context.Context, serviceName string, username string) (*Operation, error) {
5408 path := fmt.Sprintf("/dbaas-mysql/%v/user/%v", serviceName, username)
5409
5410 request, err := http.NewRequestWithContext(ctx, "DELETE", c.serverEndpoint+path, nil)
5411 if err != nil {
5412 return nil, fmt.Errorf("DeleteDBAASMysqlUser: new request: %w", err)
5413 }
5414
5415 request.Header.Add("User-Agent", c.getUserAgent())
5416
5417 if err := c.executeRequestInterceptors(ctx, request); err != nil {
5418 return nil, fmt.Errorf("DeleteDBAASMysqlUser: execute request editors: %w", err)
5419 }
5420
5421 if err := c.signRequest(request); err != nil {
5422 return nil, fmt.Errorf("DeleteDBAASMysqlUser: sign request: %w", err)
5423 }
5424
5425 if c.trace {
5426 dumpRequest(request, "delete-dbaas-mysql-user")
5427 }
5428
5429 response, err := c.httpClient.Do(request)
5430 if err != nil {
5431 return nil, fmt.Errorf("DeleteDBAASMysqlUser: http client do: %w", err)
5432 }
5433
5434 if c.trace {
5435 dumpResponse(response)
5436 }
5437
5438 if err := handleHTTPErrorResp(response); err != nil {
5439 return nil, fmt.Errorf("DeleteDBAASMysqlUser: http response: %w", err)
5440 }
5441
5442 bodyresp := new(Operation)
5443 if err := prepareJSONResponse(response, bodyresp); err != nil {
5444 return nil, fmt.Errorf("DeleteDBAASMysqlUser: prepare Json response: %w", err)
5445 }
5446
5447 return bodyresp, nil
5448 }
5449
5450 type ResetDBAASMysqlUserPasswordRequest struct {
5451 Authentication EnumMysqlAuthenticationPlugin `json:"authentication,omitempty"`
5452 Password DBAASUserPassword `json:"password,omitempty" validate:"omitempty,gte=8,lte=256"`
5453 }
5454
5455 // If no password is provided one will be generated automatically.
5456 func (c Client) ResetDBAASMysqlUserPassword(ctx context.Context, serviceName string, username string, req ResetDBAASMysqlUserPasswordRequest) (*Operation, error) {
5457 path := fmt.Sprintf("/dbaas-mysql/%v/user/%v/password/reset", serviceName, username)
5458
5459 body, err := prepareJSONBody(req)
5460 if err != nil {
5461 return nil, fmt.Errorf("ResetDBAASMysqlUserPassword: prepare Json body: %w", err)
5462 }
5463
5464 request, err := http.NewRequestWithContext(ctx, "PUT", c.serverEndpoint+path, body)
5465 if err != nil {
5466 return nil, fmt.Errorf("ResetDBAASMysqlUserPassword: new request: %w", err)
5467 }
5468
5469 request.Header.Add("User-Agent", c.getUserAgent())
5470
5471 request.Header.Add("Content-Type", "application/json")
5472
5473 if err := c.executeRequestInterceptors(ctx, request); err != nil {
5474 return nil, fmt.Errorf("ResetDBAASMysqlUserPassword: execute request editors: %w", err)
5475 }
5476
5477 if err := c.signRequest(request); err != nil {
5478 return nil, fmt.Errorf("ResetDBAASMysqlUserPassword: sign request: %w", err)
5479 }
5480
5481 if c.trace {
5482 dumpRequest(request, "reset-dbaas-mysql-user-password")
5483 }
5484
5485 response, err := c.httpClient.Do(request)
5486 if err != nil {
5487 return nil, fmt.Errorf("ResetDBAASMysqlUserPassword: http client do: %w", err)
5488 }
5489
5490 if c.trace {
5491 dumpResponse(response)
5492 }
5493
5494 if err := handleHTTPErrorResp(response); err != nil {
5495 return nil, fmt.Errorf("ResetDBAASMysqlUserPassword: http response: %w", err)
5496 }
5497
5498 bodyresp := new(Operation)
5499 if err := prepareJSONResponse(response, bodyresp); err != nil {
5500 return nil, fmt.Errorf("ResetDBAASMysqlUserPassword: prepare Json response: %w", err)
5501 }
5502
5503 return bodyresp, nil
5504 }
5505
5506 func (c Client) RevealDBAASMysqlUserPassword(ctx context.Context, serviceName string, username string) (*DBAASUserMysqlSecrets, error) {
5507 path := fmt.Sprintf("/dbaas-mysql/%v/user/%v/password/reveal", serviceName, username)
5508
5509 request, err := http.NewRequestWithContext(ctx, "GET", c.serverEndpoint+path, nil)
5510 if err != nil {
5511 return nil, fmt.Errorf("RevealDBAASMysqlUserPassword: new request: %w", err)
5512 }
5513
5514 request.Header.Add("User-Agent", c.getUserAgent())
5515
5516 if err := c.executeRequestInterceptors(ctx, request); err != nil {
5517 return nil, fmt.Errorf("RevealDBAASMysqlUserPassword: execute request editors: %w", err)
5518 }
5519
5520 if err := c.signRequest(request); err != nil {
5521 return nil, fmt.Errorf("RevealDBAASMysqlUserPassword: sign request: %w", err)
5522 }
5523
5524 if c.trace {
5525 dumpRequest(request, "reveal-dbaas-mysql-user-password")
5526 }
5527
5528 response, err := c.httpClient.Do(request)
5529 if err != nil {
5530 return nil, fmt.Errorf("RevealDBAASMysqlUserPassword: http client do: %w", err)
5531 }
5532
5533 if c.trace {
5534 dumpResponse(response)
5535 }
5536
5537 if err := handleHTTPErrorResp(response); err != nil {
5538 return nil, fmt.Errorf("RevealDBAASMysqlUserPassword: http response: %w", err)
5539 }
5540
5541 bodyresp := new(DBAASUserMysqlSecrets)
5542 if err := prepareJSONResponse(response, bodyresp); err != nil {
5543 return nil, fmt.Errorf("RevealDBAASMysqlUserPassword: prepare Json response: %w", err)
5544 }
5545
5546 return bodyresp, nil
5547 }
5548
5549 func (c Client) DeleteDBAASServiceOpensearch(ctx context.Context, name string) (*Operation, error) {
5550 path := fmt.Sprintf("/dbaas-opensearch/%v", name)
5551
5552 request, err := http.NewRequestWithContext(ctx, "DELETE", c.serverEndpoint+path, nil)
5553 if err != nil {
5554 return nil, fmt.Errorf("DeleteDBAASServiceOpensearch: new request: %w", err)
5555 }
5556
5557 request.Header.Add("User-Agent", c.getUserAgent())
5558
5559 if err := c.executeRequestInterceptors(ctx, request); err != nil {
5560 return nil, fmt.Errorf("DeleteDBAASServiceOpensearch: execute request editors: %w", err)
5561 }
5562
5563 if err := c.signRequest(request); err != nil {
5564 return nil, fmt.Errorf("DeleteDBAASServiceOpensearch: sign request: %w", err)
5565 }
5566
5567 if c.trace {
5568 dumpRequest(request, "delete-dbaas-service-opensearch")
5569 }
5570
5571 response, err := c.httpClient.Do(request)
5572 if err != nil {
5573 return nil, fmt.Errorf("DeleteDBAASServiceOpensearch: http client do: %w", err)
5574 }
5575
5576 if c.trace {
5577 dumpResponse(response)
5578 }
5579
5580 if err := handleHTTPErrorResp(response); err != nil {
5581 return nil, fmt.Errorf("DeleteDBAASServiceOpensearch: http response: %w", err)
5582 }
5583
5584 bodyresp := new(Operation)
5585 if err := prepareJSONResponse(response, bodyresp); err != nil {
5586 return nil, fmt.Errorf("DeleteDBAASServiceOpensearch: prepare Json response: %w", err)
5587 }
5588
5589 return bodyresp, nil
5590 }
5591
5592 // Get a DBaaS OpenSearch service
5593 func (c Client) GetDBAASServiceOpensearch(ctx context.Context, name string) (*DBAASServiceOpensearch, error) {
5594 path := fmt.Sprintf("/dbaas-opensearch/%v", name)
5595
5596 request, err := http.NewRequestWithContext(ctx, "GET", c.serverEndpoint+path, nil)
5597 if err != nil {
5598 return nil, fmt.Errorf("GetDBAASServiceOpensearch: new request: %w", err)
5599 }
5600
5601 request.Header.Add("User-Agent", c.getUserAgent())
5602
5603 if err := c.executeRequestInterceptors(ctx, request); err != nil {
5604 return nil, fmt.Errorf("GetDBAASServiceOpensearch: execute request editors: %w", err)
5605 }
5606
5607 if err := c.signRequest(request); err != nil {
5608 return nil, fmt.Errorf("GetDBAASServiceOpensearch: sign request: %w", err)
5609 }
5610
5611 if c.trace {
5612 dumpRequest(request, "get-dbaas-service-opensearch")
5613 }
5614
5615 response, err := c.httpClient.Do(request)
5616 if err != nil {
5617 return nil, fmt.Errorf("GetDBAASServiceOpensearch: http client do: %w", err)
5618 }
5619
5620 if c.trace {
5621 dumpResponse(response)
5622 }
5623
5624 if err := handleHTTPErrorResp(response); err != nil {
5625 return nil, fmt.Errorf("GetDBAASServiceOpensearch: http response: %w", err)
5626 }
5627
5628 bodyresp := new(DBAASServiceOpensearch)
5629 if err := prepareJSONResponse(response, bodyresp); err != nil {
5630 return nil, fmt.Errorf("GetDBAASServiceOpensearch: prepare Json response: %w", err)
5631 }
5632
5633 return bodyresp, nil
5634 }
5635
5636 type CreateDBAASServiceOpensearchRequestIndexPatternsSortingAlgorithm string
5637
5638 const (
5639 CreateDBAASServiceOpensearchRequestIndexPatternsSortingAlgorithmAlphabetical CreateDBAASServiceOpensearchRequestIndexPatternsSortingAlgorithm = "alphabetical"
5640 CreateDBAASServiceOpensearchRequestIndexPatternsSortingAlgorithmCreationDate CreateDBAASServiceOpensearchRequestIndexPatternsSortingAlgorithm = "creation_date"
5641 )
5642
5643 type CreateDBAASServiceOpensearchRequestIndexPatterns struct {
5644 // Maximum number of indexes to keep
5645 MaxIndexCount *int64 `json:"max-index-count,omitempty" validate:"omitempty,gte=0"`
5646 // fnmatch pattern
5647 Pattern string `json:"pattern,omitempty" validate:"omitempty,lte=1024"`
5648 // Deletion sorting algorithm
5649 SortingAlgorithm CreateDBAASServiceOpensearchRequestIndexPatternsSortingAlgorithm `json:"sorting-algorithm,omitempty"`
5650 }
5651
5652 // Template settings for all new indexes
5653 type CreateDBAASServiceOpensearchRequestIndexTemplate struct {
5654 // The maximum number of nested JSON objects that a single document can contain across all nested types. This limit helps to prevent out of memory errors when a document contains too many nested objects. Default is 10000.
5655 MappingNestedObjectsLimit *int64 `json:"mapping-nested-objects-limit,omitempty" validate:"omitempty,gte=0,lte=100000"`
5656 // The number of replicas each primary shard has.
5657 NumberOfReplicas *int64 `json:"number-of-replicas,omitempty" validate:"omitempty,gte=0,lte=29"`
5658 // The number of primary shards that an index should have.
5659 NumberOfShards int64 `json:"number-of-shards,omitempty" validate:"omitempty,gte=1,lte=1024"`
5660 }
5661
5662 type CreateDBAASServiceOpensearchRequestMaintenanceDow string
5663
5664 const (
5665 CreateDBAASServiceOpensearchRequestMaintenanceDowSaturday CreateDBAASServiceOpensearchRequestMaintenanceDow = "saturday"
5666 CreateDBAASServiceOpensearchRequestMaintenanceDowTuesday CreateDBAASServiceOpensearchRequestMaintenanceDow = "tuesday"
5667 CreateDBAASServiceOpensearchRequestMaintenanceDowNever CreateDBAASServiceOpensearchRequestMaintenanceDow = "never"
5668 CreateDBAASServiceOpensearchRequestMaintenanceDowWednesday CreateDBAASServiceOpensearchRequestMaintenanceDow = "wednesday"
5669 CreateDBAASServiceOpensearchRequestMaintenanceDowSunday CreateDBAASServiceOpensearchRequestMaintenanceDow = "sunday"
5670 CreateDBAASServiceOpensearchRequestMaintenanceDowFriday CreateDBAASServiceOpensearchRequestMaintenanceDow = "friday"
5671 CreateDBAASServiceOpensearchRequestMaintenanceDowMonday CreateDBAASServiceOpensearchRequestMaintenanceDow = "monday"
5672 CreateDBAASServiceOpensearchRequestMaintenanceDowThursday CreateDBAASServiceOpensearchRequestMaintenanceDow = "thursday"
5673 )
5674
5675 // Automatic maintenance settings
5676 type CreateDBAASServiceOpensearchRequestMaintenance struct {
5677 // Day of week for installing updates
5678 Dow CreateDBAASServiceOpensearchRequestMaintenanceDow `json:"dow" validate:"required"`
5679 // Time for installing updates, UTC
5680 Time string `json:"time" validate:"required,gte=8,lte=8"`
5681 }
5682
5683 // OpenSearch Dashboards settings
5684 type CreateDBAASServiceOpensearchRequestOpensearchDashboards struct {
5685 // Enable or disable OpenSearch Dashboards (default: true)
5686 Enabled *bool `json:"enabled,omitempty"`
5687 // Limits the maximum amount of memory (in MiB) the OpenSearch Dashboards process can use. This sets the max_old_space_size option of the nodejs running the OpenSearch Dashboards. Note: the memory reserved by OpenSearch Dashboards is not available for OpenSearch. (default: 128)
5688 MaxOldSpaceSize int64 `json:"max-old-space-size,omitempty" validate:"omitempty,gte=64,lte=1024"`
5689 // Timeout in milliseconds for requests made by OpenSearch Dashboards towards OpenSearch (default: 30000)
5690 OpensearchRequestTimeout int64 `json:"opensearch-request-timeout,omitempty" validate:"omitempty,gte=5000,lte=120000"`
5691 }
5692
5693 type CreateDBAASServiceOpensearchRequest struct {
5694 ForkFromService DBAASServiceName `json:"fork-from-service,omitempty" validate:"omitempty,gte=0,lte=63"`
5695 // Allows you to create glob style patterns and set a max number of indexes matching this pattern you want to keep. Creating indexes exceeding this value will cause the oldest one to get deleted. You could for example create a pattern looking like 'logs.?' and then create index logs.1, logs.2 etc, it will delete logs.1 once you create logs.6. Do note 'logs.?' does not apply to logs.10. Note: Setting max_index_count to 0 will do nothing and the pattern gets ignored.
5696 IndexPatterns []CreateDBAASServiceOpensearchRequestIndexPatterns `json:"index-patterns,omitempty"`
5697 // Template settings for all new indexes
5698 IndexTemplate *CreateDBAASServiceOpensearchRequestIndexTemplate `json:"index-template,omitempty"`
5699 // Allow incoming connections from CIDR address block, e.g. '10.20.0.0/16'
5700 IPFilter []string `json:"ip-filter,omitempty"`
5701 // Aiven automation resets index.refresh_interval to default value for every index to be sure that indices are always visible to search. If it doesn't fit your case, you can disable this by setting up this flag to true.
5702 KeepIndexRefreshInterval *bool `json:"keep-index-refresh-interval,omitempty"`
5703 // Automatic maintenance settings
5704 Maintenance *CreateDBAASServiceOpensearchRequestMaintenance `json:"maintenance,omitempty"`
5705 // Maximum number of indexes to keep before deleting the oldest one
5706 MaxIndexCount *int64 `json:"max-index-count,omitempty" validate:"omitempty,gte=0"`
5707 // OpenSearch Dashboards settings
5708 OpensearchDashboards *CreateDBAASServiceOpensearchRequestOpensearchDashboards `json:"opensearch-dashboards,omitempty"`
5709 // OpenSearch settings
5710 OpensearchSettings *JSONSchemaOpensearch `json:"opensearch-settings,omitempty"`
5711 // Subscription plan
5712 Plan string `json:"plan" validate:"required,gte=1,lte=128"`
5713 // Name of a backup to recover from for services that support backup names
5714 RecoveryBackupName string `json:"recovery-backup-name,omitempty" validate:"omitempty,gte=1"`
5715 // Service is protected against termination and powering off
5716 TerminationProtection *bool `json:"termination-protection,omitempty"`
5717 // OpenSearch major version
5718 Version string `json:"version,omitempty" validate:"omitempty,gte=1"`
5719 }
5720
5721 // Create a DBaaS OpenSearch service
5722 func (c Client) CreateDBAASServiceOpensearch(ctx context.Context, name string, req CreateDBAASServiceOpensearchRequest) (*Operation, error) {
5723 path := fmt.Sprintf("/dbaas-opensearch/%v", name)
5724
5725 body, err := prepareJSONBody(req)
5726 if err != nil {
5727 return nil, fmt.Errorf("CreateDBAASServiceOpensearch: prepare Json body: %w", err)
5728 }
5729
5730 request, err := http.NewRequestWithContext(ctx, "POST", c.serverEndpoint+path, body)
5731 if err != nil {
5732 return nil, fmt.Errorf("CreateDBAASServiceOpensearch: new request: %w", err)
5733 }
5734
5735 request.Header.Add("User-Agent", c.getUserAgent())
5736
5737 request.Header.Add("Content-Type", "application/json")
5738
5739 if err := c.executeRequestInterceptors(ctx, request); err != nil {
5740 return nil, fmt.Errorf("CreateDBAASServiceOpensearch: execute request editors: %w", err)
5741 }
5742
5743 if err := c.signRequest(request); err != nil {
5744 return nil, fmt.Errorf("CreateDBAASServiceOpensearch: sign request: %w", err)
5745 }
5746
5747 if c.trace {
5748 dumpRequest(request, "create-dbaas-service-opensearch")
5749 }
5750
5751 response, err := c.httpClient.Do(request)
5752 if err != nil {
5753 return nil, fmt.Errorf("CreateDBAASServiceOpensearch: http client do: %w", err)
5754 }
5755
5756 if c.trace {
5757 dumpResponse(response)
5758 }
5759
5760 if err := handleHTTPErrorResp(response); err != nil {
5761 return nil, fmt.Errorf("CreateDBAASServiceOpensearch: http response: %w", err)
5762 }
5763
5764 bodyresp := new(Operation)
5765 if err := prepareJSONResponse(response, bodyresp); err != nil {
5766 return nil, fmt.Errorf("CreateDBAASServiceOpensearch: prepare Json response: %w", err)
5767 }
5768
5769 return bodyresp, nil
5770 }
5771
5772 type UpdateDBAASServiceOpensearchRequestIndexPatternsSortingAlgorithm string
5773
5774 const (
5775 UpdateDBAASServiceOpensearchRequestIndexPatternsSortingAlgorithmAlphabetical UpdateDBAASServiceOpensearchRequestIndexPatternsSortingAlgorithm = "alphabetical"
5776 UpdateDBAASServiceOpensearchRequestIndexPatternsSortingAlgorithmCreationDate UpdateDBAASServiceOpensearchRequestIndexPatternsSortingAlgorithm = "creation_date"
5777 )
5778
5779 type UpdateDBAASServiceOpensearchRequestIndexPatterns struct {
5780 // Maximum number of indexes to keep
5781 MaxIndexCount *int64 `json:"max-index-count,omitempty" validate:"omitempty,gte=0"`
5782 // fnmatch pattern
5783 Pattern string `json:"pattern,omitempty" validate:"omitempty,lte=1024"`
5784 // Deletion sorting algorithm
5785 SortingAlgorithm UpdateDBAASServiceOpensearchRequestIndexPatternsSortingAlgorithm `json:"sorting-algorithm,omitempty"`
5786 }
5787
5788 // Template settings for all new indexes
5789 type UpdateDBAASServiceOpensearchRequestIndexTemplate struct {
5790 // The maximum number of nested JSON objects that a single document can contain across all nested types. This limit helps to prevent out of memory errors when a document contains too many nested objects. Default is 10000.
5791 MappingNestedObjectsLimit *int64 `json:"mapping-nested-objects-limit,omitempty" validate:"omitempty,gte=0,lte=100000"`
5792 // The number of replicas each primary shard has.
5793 NumberOfReplicas *int64 `json:"number-of-replicas,omitempty" validate:"omitempty,gte=0,lte=29"`
5794 // The number of primary shards that an index should have.
5795 NumberOfShards int64 `json:"number-of-shards,omitempty" validate:"omitempty,gte=1,lte=1024"`
5796 }
5797
5798 type UpdateDBAASServiceOpensearchRequestMaintenanceDow string
5799
5800 const (
5801 UpdateDBAASServiceOpensearchRequestMaintenanceDowSaturday UpdateDBAASServiceOpensearchRequestMaintenanceDow = "saturday"
5802 UpdateDBAASServiceOpensearchRequestMaintenanceDowTuesday UpdateDBAASServiceOpensearchRequestMaintenanceDow = "tuesday"
5803 UpdateDBAASServiceOpensearchRequestMaintenanceDowNever UpdateDBAASServiceOpensearchRequestMaintenanceDow = "never"
5804 UpdateDBAASServiceOpensearchRequestMaintenanceDowWednesday UpdateDBAASServiceOpensearchRequestMaintenanceDow = "wednesday"
5805 UpdateDBAASServiceOpensearchRequestMaintenanceDowSunday UpdateDBAASServiceOpensearchRequestMaintenanceDow = "sunday"
5806 UpdateDBAASServiceOpensearchRequestMaintenanceDowFriday UpdateDBAASServiceOpensearchRequestMaintenanceDow = "friday"
5807 UpdateDBAASServiceOpensearchRequestMaintenanceDowMonday UpdateDBAASServiceOpensearchRequestMaintenanceDow = "monday"
5808 UpdateDBAASServiceOpensearchRequestMaintenanceDowThursday UpdateDBAASServiceOpensearchRequestMaintenanceDow = "thursday"
5809 )
5810
5811 // Automatic maintenance settings
5812 type UpdateDBAASServiceOpensearchRequestMaintenance struct {
5813 // Day of week for installing updates
5814 Dow UpdateDBAASServiceOpensearchRequestMaintenanceDow `json:"dow" validate:"required"`
5815 // Time for installing updates, UTC
5816 Time string `json:"time" validate:"required,gte=8,lte=8"`
5817 }
5818
5819 // OpenSearch Dashboards settings
5820 type UpdateDBAASServiceOpensearchRequestOpensearchDashboards struct {
5821 // Enable or disable OpenSearch Dashboards (default: true)
5822 Enabled *bool `json:"enabled,omitempty"`
5823 // Limits the maximum amount of memory (in MiB) the OpenSearch Dashboards process can use. This sets the max_old_space_size option of the nodejs running the OpenSearch Dashboards. Note: the memory reserved by OpenSearch Dashboards is not available for OpenSearch. (default: 128)
5824 MaxOldSpaceSize int64 `json:"max-old-space-size,omitempty" validate:"omitempty,gte=64,lte=1024"`
5825 // Timeout in milliseconds for requests made by OpenSearch Dashboards towards OpenSearch (default: 30000)
5826 OpensearchRequestTimeout int64 `json:"opensearch-request-timeout,omitempty" validate:"omitempty,gte=5000,lte=120000"`
5827 }
5828
5829 type UpdateDBAASServiceOpensearchRequest struct {
5830 // Allows you to create glob style patterns and set a max number of indexes matching this pattern you want to keep. Creating indexes exceeding this value will cause the oldest one to get deleted. You could for example create a pattern looking like 'logs.?' and then create index logs.1, logs.2 etc, it will delete logs.1 once you create logs.6. Do note 'logs.?' does not apply to logs.10. Note: Setting max_index_count to 0 will do nothing and the pattern gets ignored.
5831 IndexPatterns []UpdateDBAASServiceOpensearchRequestIndexPatterns `json:"index-patterns,omitempty"`
5832 // Template settings for all new indexes
5833 IndexTemplate *UpdateDBAASServiceOpensearchRequestIndexTemplate `json:"index-template,omitempty"`
5834 // Allow incoming connections from CIDR address block, e.g. '10.20.0.0/16'
5835 IPFilter []string `json:"ip-filter,omitempty"`
5836 // Aiven automation resets index.refresh_interval to default value for every index to be sure that indices are always visible to search. If it doesn't fit your case, you can disable this by setting up this flag to true.
5837 KeepIndexRefreshInterval *bool `json:"keep-index-refresh-interval,omitempty"`
5838 // Automatic maintenance settings
5839 Maintenance *UpdateDBAASServiceOpensearchRequestMaintenance `json:"maintenance,omitempty"`
5840 // Maximum number of indexes to keep before deleting the oldest one
5841 MaxIndexCount *int64 `json:"max-index-count,omitempty" validate:"omitempty,gte=0"`
5842 // OpenSearch Dashboards settings
5843 OpensearchDashboards *UpdateDBAASServiceOpensearchRequestOpensearchDashboards `json:"opensearch-dashboards,omitempty"`
5844 // OpenSearch settings
5845 OpensearchSettings *JSONSchemaOpensearch `json:"opensearch-settings,omitempty"`
5846 // Subscription plan
5847 Plan string `json:"plan,omitempty" validate:"omitempty,gte=1,lte=128"`
5848 // Service is protected against termination and powering off
5849 TerminationProtection *bool `json:"termination-protection,omitempty"`
5850 // Version
5851 Version string `json:"version,omitempty"`
5852 }
5853
5854 // Update a DBaaS OpenSearch service
5855 func (c Client) UpdateDBAASServiceOpensearch(ctx context.Context, name string, req UpdateDBAASServiceOpensearchRequest) (*Operation, error) {
5856 path := fmt.Sprintf("/dbaas-opensearch/%v", name)
5857
5858 body, err := prepareJSONBody(req)
5859 if err != nil {
5860 return nil, fmt.Errorf("UpdateDBAASServiceOpensearch: prepare Json body: %w", err)
5861 }
5862
5863 request, err := http.NewRequestWithContext(ctx, "PUT", c.serverEndpoint+path, body)
5864 if err != nil {
5865 return nil, fmt.Errorf("UpdateDBAASServiceOpensearch: new request: %w", err)
5866 }
5867
5868 request.Header.Add("User-Agent", c.getUserAgent())
5869
5870 request.Header.Add("Content-Type", "application/json")
5871
5872 if err := c.executeRequestInterceptors(ctx, request); err != nil {
5873 return nil, fmt.Errorf("UpdateDBAASServiceOpensearch: execute request editors: %w", err)
5874 }
5875
5876 if err := c.signRequest(request); err != nil {
5877 return nil, fmt.Errorf("UpdateDBAASServiceOpensearch: sign request: %w", err)
5878 }
5879
5880 if c.trace {
5881 dumpRequest(request, "update-dbaas-service-opensearch")
5882 }
5883
5884 response, err := c.httpClient.Do(request)
5885 if err != nil {
5886 return nil, fmt.Errorf("UpdateDBAASServiceOpensearch: http client do: %w", err)
5887 }
5888
5889 if c.trace {
5890 dumpResponse(response)
5891 }
5892
5893 if err := handleHTTPErrorResp(response); err != nil {
5894 return nil, fmt.Errorf("UpdateDBAASServiceOpensearch: http response: %w", err)
5895 }
5896
5897 bodyresp := new(Operation)
5898 if err := prepareJSONResponse(response, bodyresp); err != nil {
5899 return nil, fmt.Errorf("UpdateDBAASServiceOpensearch: prepare Json response: %w", err)
5900 }
5901
5902 return bodyresp, nil
5903 }
5904
5905 func (c Client) GetDBAASOpensearchAclConfig(ctx context.Context, name string) (*DBAASOpensearchAclConfig, error) {
5906 path := fmt.Sprintf("/dbaas-opensearch/%v/acl-config", name)
5907
5908 request, err := http.NewRequestWithContext(ctx, "GET", c.serverEndpoint+path, nil)
5909 if err != nil {
5910 return nil, fmt.Errorf("GetDBAASOpensearchAclConfig: new request: %w", err)
5911 }
5912
5913 request.Header.Add("User-Agent", c.getUserAgent())
5914
5915 if err := c.executeRequestInterceptors(ctx, request); err != nil {
5916 return nil, fmt.Errorf("GetDBAASOpensearchAclConfig: execute request editors: %w", err)
5917 }
5918
5919 if err := c.signRequest(request); err != nil {
5920 return nil, fmt.Errorf("GetDBAASOpensearchAclConfig: sign request: %w", err)
5921 }
5922
5923 if c.trace {
5924 dumpRequest(request, "get-dbaas-opensearch-acl-config")
5925 }
5926
5927 response, err := c.httpClient.Do(request)
5928 if err != nil {
5929 return nil, fmt.Errorf("GetDBAASOpensearchAclConfig: http client do: %w", err)
5930 }
5931
5932 if c.trace {
5933 dumpResponse(response)
5934 }
5935
5936 if err := handleHTTPErrorResp(response); err != nil {
5937 return nil, fmt.Errorf("GetDBAASOpensearchAclConfig: http response: %w", err)
5938 }
5939
5940 bodyresp := new(DBAASOpensearchAclConfig)
5941 if err := prepareJSONResponse(response, bodyresp); err != nil {
5942 return nil, fmt.Errorf("GetDBAASOpensearchAclConfig: prepare Json response: %w", err)
5943 }
5944
5945 return bodyresp, nil
5946 }
5947
5948 func (c Client) UpdateDBAASOpensearchAclConfig(ctx context.Context, name string, req DBAASOpensearchAclConfig) (*Operation, error) {
5949 path := fmt.Sprintf("/dbaas-opensearch/%v/acl-config", name)
5950
5951 body, err := prepareJSONBody(req)
5952 if err != nil {
5953 return nil, fmt.Errorf("UpdateDBAASOpensearchAclConfig: prepare Json body: %w", err)
5954 }
5955
5956 request, err := http.NewRequestWithContext(ctx, "PUT", c.serverEndpoint+path, body)
5957 if err != nil {
5958 return nil, fmt.Errorf("UpdateDBAASOpensearchAclConfig: new request: %w", err)
5959 }
5960
5961 request.Header.Add("User-Agent", c.getUserAgent())
5962
5963 request.Header.Add("Content-Type", "application/json")
5964
5965 if err := c.executeRequestInterceptors(ctx, request); err != nil {
5966 return nil, fmt.Errorf("UpdateDBAASOpensearchAclConfig: execute request editors: %w", err)
5967 }
5968
5969 if err := c.signRequest(request); err != nil {
5970 return nil, fmt.Errorf("UpdateDBAASOpensearchAclConfig: sign request: %w", err)
5971 }
5972
5973 if c.trace {
5974 dumpRequest(request, "update-dbaas-opensearch-acl-config")
5975 }
5976
5977 response, err := c.httpClient.Do(request)
5978 if err != nil {
5979 return nil, fmt.Errorf("UpdateDBAASOpensearchAclConfig: http client do: %w", err)
5980 }
5981
5982 if c.trace {
5983 dumpResponse(response)
5984 }
5985
5986 if err := handleHTTPErrorResp(response); err != nil {
5987 return nil, fmt.Errorf("UpdateDBAASOpensearchAclConfig: http response: %w", err)
5988 }
5989
5990 bodyresp := new(Operation)
5991 if err := prepareJSONResponse(response, bodyresp); err != nil {
5992 return nil, fmt.Errorf("UpdateDBAASOpensearchAclConfig: prepare Json response: %w", err)
5993 }
5994
5995 return bodyresp, nil
5996 }
5997
5998 func (c Client) StartDBAASOpensearchMaintenance(ctx context.Context, name string) (*Operation, error) {
5999 path := fmt.Sprintf("/dbaas-opensearch/%v/maintenance/start", name)
6000
6001 request, err := http.NewRequestWithContext(ctx, "PUT", c.serverEndpoint+path, nil)
6002 if err != nil {
6003 return nil, fmt.Errorf("StartDBAASOpensearchMaintenance: new request: %w", err)
6004 }
6005
6006 request.Header.Add("User-Agent", c.getUserAgent())
6007
6008 if err := c.executeRequestInterceptors(ctx, request); err != nil {
6009 return nil, fmt.Errorf("StartDBAASOpensearchMaintenance: execute request editors: %w", err)
6010 }
6011
6012 if err := c.signRequest(request); err != nil {
6013 return nil, fmt.Errorf("StartDBAASOpensearchMaintenance: sign request: %w", err)
6014 }
6015
6016 if c.trace {
6017 dumpRequest(request, "start-dbaas-opensearch-maintenance")
6018 }
6019
6020 response, err := c.httpClient.Do(request)
6021 if err != nil {
6022 return nil, fmt.Errorf("StartDBAASOpensearchMaintenance: http client do: %w", err)
6023 }
6024
6025 if c.trace {
6026 dumpResponse(response)
6027 }
6028
6029 if err := handleHTTPErrorResp(response); err != nil {
6030 return nil, fmt.Errorf("StartDBAASOpensearchMaintenance: http response: %w", err)
6031 }
6032
6033 bodyresp := new(Operation)
6034 if err := prepareJSONResponse(response, bodyresp); err != nil {
6035 return nil, fmt.Errorf("StartDBAASOpensearchMaintenance: prepare Json response: %w", err)
6036 }
6037
6038 return bodyresp, nil
6039 }
6040
6041 type CreateDBAASOpensearchUserRequest struct {
6042 Username DBAASUserUsername `json:"username" validate:"required,gte=1,lte=64"`
6043 }
6044
6045 func (c Client) CreateDBAASOpensearchUser(ctx context.Context, serviceName string, req CreateDBAASOpensearchUserRequest) (*Operation, error) {
6046 path := fmt.Sprintf("/dbaas-opensearch/%v/user", serviceName)
6047
6048 body, err := prepareJSONBody(req)
6049 if err != nil {
6050 return nil, fmt.Errorf("CreateDBAASOpensearchUser: prepare Json body: %w", err)
6051 }
6052
6053 request, err := http.NewRequestWithContext(ctx, "POST", c.serverEndpoint+path, body)
6054 if err != nil {
6055 return nil, fmt.Errorf("CreateDBAASOpensearchUser: new request: %w", err)
6056 }
6057
6058 request.Header.Add("User-Agent", c.getUserAgent())
6059
6060 request.Header.Add("Content-Type", "application/json")
6061
6062 if err := c.executeRequestInterceptors(ctx, request); err != nil {
6063 return nil, fmt.Errorf("CreateDBAASOpensearchUser: execute request editors: %w", err)
6064 }
6065
6066 if err := c.signRequest(request); err != nil {
6067 return nil, fmt.Errorf("CreateDBAASOpensearchUser: sign request: %w", err)
6068 }
6069
6070 if c.trace {
6071 dumpRequest(request, "create-dbaas-opensearch-user")
6072 }
6073
6074 response, err := c.httpClient.Do(request)
6075 if err != nil {
6076 return nil, fmt.Errorf("CreateDBAASOpensearchUser: http client do: %w", err)
6077 }
6078
6079 if c.trace {
6080 dumpResponse(response)
6081 }
6082
6083 if err := handleHTTPErrorResp(response); err != nil {
6084 return nil, fmt.Errorf("CreateDBAASOpensearchUser: http response: %w", err)
6085 }
6086
6087 bodyresp := new(Operation)
6088 if err := prepareJSONResponse(response, bodyresp); err != nil {
6089 return nil, fmt.Errorf("CreateDBAASOpensearchUser: prepare Json response: %w", err)
6090 }
6091
6092 return bodyresp, nil
6093 }
6094
6095 func (c Client) DeleteDBAASOpensearchUser(ctx context.Context, serviceName string, username string) (*Operation, error) {
6096 path := fmt.Sprintf("/dbaas-opensearch/%v/user/%v", serviceName, username)
6097
6098 request, err := http.NewRequestWithContext(ctx, "DELETE", c.serverEndpoint+path, nil)
6099 if err != nil {
6100 return nil, fmt.Errorf("DeleteDBAASOpensearchUser: new request: %w", err)
6101 }
6102
6103 request.Header.Add("User-Agent", c.getUserAgent())
6104
6105 if err := c.executeRequestInterceptors(ctx, request); err != nil {
6106 return nil, fmt.Errorf("DeleteDBAASOpensearchUser: execute request editors: %w", err)
6107 }
6108
6109 if err := c.signRequest(request); err != nil {
6110 return nil, fmt.Errorf("DeleteDBAASOpensearchUser: sign request: %w", err)
6111 }
6112
6113 if c.trace {
6114 dumpRequest(request, "delete-dbaas-opensearch-user")
6115 }
6116
6117 response, err := c.httpClient.Do(request)
6118 if err != nil {
6119 return nil, fmt.Errorf("DeleteDBAASOpensearchUser: http client do: %w", err)
6120 }
6121
6122 if c.trace {
6123 dumpResponse(response)
6124 }
6125
6126 if err := handleHTTPErrorResp(response); err != nil {
6127 return nil, fmt.Errorf("DeleteDBAASOpensearchUser: http response: %w", err)
6128 }
6129
6130 bodyresp := new(Operation)
6131 if err := prepareJSONResponse(response, bodyresp); err != nil {
6132 return nil, fmt.Errorf("DeleteDBAASOpensearchUser: prepare Json response: %w", err)
6133 }
6134
6135 return bodyresp, nil
6136 }
6137
6138 type ResetDBAASOpensearchUserPasswordRequest struct {
6139 Password DBAASUserPassword `json:"password,omitempty" validate:"omitempty,gte=8,lte=256"`
6140 }
6141
6142 // If no password is provided one will be generated automatically.
6143 func (c Client) ResetDBAASOpensearchUserPassword(ctx context.Context, serviceName string, username string, req ResetDBAASOpensearchUserPasswordRequest) (*Operation, error) {
6144 path := fmt.Sprintf("/dbaas-opensearch/%v/user/%v/password/reset", serviceName, username)
6145
6146 body, err := prepareJSONBody(req)
6147 if err != nil {
6148 return nil, fmt.Errorf("ResetDBAASOpensearchUserPassword: prepare Json body: %w", err)
6149 }
6150
6151 request, err := http.NewRequestWithContext(ctx, "PUT", c.serverEndpoint+path, body)
6152 if err != nil {
6153 return nil, fmt.Errorf("ResetDBAASOpensearchUserPassword: new request: %w", err)
6154 }
6155
6156 request.Header.Add("User-Agent", c.getUserAgent())
6157
6158 request.Header.Add("Content-Type", "application/json")
6159
6160 if err := c.executeRequestInterceptors(ctx, request); err != nil {
6161 return nil, fmt.Errorf("ResetDBAASOpensearchUserPassword: execute request editors: %w", err)
6162 }
6163
6164 if err := c.signRequest(request); err != nil {
6165 return nil, fmt.Errorf("ResetDBAASOpensearchUserPassword: sign request: %w", err)
6166 }
6167
6168 if c.trace {
6169 dumpRequest(request, "reset-dbaas-opensearch-user-password")
6170 }
6171
6172 response, err := c.httpClient.Do(request)
6173 if err != nil {
6174 return nil, fmt.Errorf("ResetDBAASOpensearchUserPassword: http client do: %w", err)
6175 }
6176
6177 if c.trace {
6178 dumpResponse(response)
6179 }
6180
6181 if err := handleHTTPErrorResp(response); err != nil {
6182 return nil, fmt.Errorf("ResetDBAASOpensearchUserPassword: http response: %w", err)
6183 }
6184
6185 bodyresp := new(Operation)
6186 if err := prepareJSONResponse(response, bodyresp); err != nil {
6187 return nil, fmt.Errorf("ResetDBAASOpensearchUserPassword: prepare Json response: %w", err)
6188 }
6189
6190 return bodyresp, nil
6191 }
6192
6193 func (c Client) RevealDBAASOpensearchUserPassword(ctx context.Context, serviceName string, username string) (*DBAASUserOpensearchSecrets, error) {
6194 path := fmt.Sprintf("/dbaas-opensearch/%v/user/%v/password/reveal", serviceName, username)
6195
6196 request, err := http.NewRequestWithContext(ctx, "GET", c.serverEndpoint+path, nil)
6197 if err != nil {
6198 return nil, fmt.Errorf("RevealDBAASOpensearchUserPassword: new request: %w", err)
6199 }
6200
6201 request.Header.Add("User-Agent", c.getUserAgent())
6202
6203 if err := c.executeRequestInterceptors(ctx, request); err != nil {
6204 return nil, fmt.Errorf("RevealDBAASOpensearchUserPassword: execute request editors: %w", err)
6205 }
6206
6207 if err := c.signRequest(request); err != nil {
6208 return nil, fmt.Errorf("RevealDBAASOpensearchUserPassword: sign request: %w", err)
6209 }
6210
6211 if c.trace {
6212 dumpRequest(request, "reveal-dbaas-opensearch-user-password")
6213 }
6214
6215 response, err := c.httpClient.Do(request)
6216 if err != nil {
6217 return nil, fmt.Errorf("RevealDBAASOpensearchUserPassword: http client do: %w", err)
6218 }
6219
6220 if c.trace {
6221 dumpResponse(response)
6222 }
6223
6224 if err := handleHTTPErrorResp(response); err != nil {
6225 return nil, fmt.Errorf("RevealDBAASOpensearchUserPassword: http response: %w", err)
6226 }
6227
6228 bodyresp := new(DBAASUserOpensearchSecrets)
6229 if err := prepareJSONResponse(response, bodyresp); err != nil {
6230 return nil, fmt.Errorf("RevealDBAASOpensearchUserPassword: prepare Json response: %w", err)
6231 }
6232
6233 return bodyresp, nil
6234 }
6235
6236 func (c Client) DeleteDBAASServicePG(ctx context.Context, name string) (*Operation, error) {
6237 path := fmt.Sprintf("/dbaas-postgres/%v", name)
6238
6239 request, err := http.NewRequestWithContext(ctx, "DELETE", c.serverEndpoint+path, nil)
6240 if err != nil {
6241 return nil, fmt.Errorf("DeleteDBAASServicePG: new request: %w", err)
6242 }
6243
6244 request.Header.Add("User-Agent", c.getUserAgent())
6245
6246 if err := c.executeRequestInterceptors(ctx, request); err != nil {
6247 return nil, fmt.Errorf("DeleteDBAASServicePG: execute request editors: %w", err)
6248 }
6249
6250 if err := c.signRequest(request); err != nil {
6251 return nil, fmt.Errorf("DeleteDBAASServicePG: sign request: %w", err)
6252 }
6253
6254 if c.trace {
6255 dumpRequest(request, "delete-dbaas-service-pg")
6256 }
6257
6258 response, err := c.httpClient.Do(request)
6259 if err != nil {
6260 return nil, fmt.Errorf("DeleteDBAASServicePG: http client do: %w", err)
6261 }
6262
6263 if c.trace {
6264 dumpResponse(response)
6265 }
6266
6267 if err := handleHTTPErrorResp(response); err != nil {
6268 return nil, fmt.Errorf("DeleteDBAASServicePG: http response: %w", err)
6269 }
6270
6271 bodyresp := new(Operation)
6272 if err := prepareJSONResponse(response, bodyresp); err != nil {
6273 return nil, fmt.Errorf("DeleteDBAASServicePG: prepare Json response: %w", err)
6274 }
6275
6276 return bodyresp, nil
6277 }
6278
6279 // Get a DBaaS PostgreSQL service
6280 func (c Client) GetDBAASServicePG(ctx context.Context, name string) (*DBAASServicePG, error) {
6281 path := fmt.Sprintf("/dbaas-postgres/%v", name)
6282
6283 request, err := http.NewRequestWithContext(ctx, "GET", c.serverEndpoint+path, nil)
6284 if err != nil {
6285 return nil, fmt.Errorf("GetDBAASServicePG: new request: %w", err)
6286 }
6287
6288 request.Header.Add("User-Agent", c.getUserAgent())
6289
6290 if err := c.executeRequestInterceptors(ctx, request); err != nil {
6291 return nil, fmt.Errorf("GetDBAASServicePG: execute request editors: %w", err)
6292 }
6293
6294 if err := c.signRequest(request); err != nil {
6295 return nil, fmt.Errorf("GetDBAASServicePG: sign request: %w", err)
6296 }
6297
6298 if c.trace {
6299 dumpRequest(request, "get-dbaas-service-pg")
6300 }
6301
6302 response, err := c.httpClient.Do(request)
6303 if err != nil {
6304 return nil, fmt.Errorf("GetDBAASServicePG: http client do: %w", err)
6305 }
6306
6307 if c.trace {
6308 dumpResponse(response)
6309 }
6310
6311 if err := handleHTTPErrorResp(response); err != nil {
6312 return nil, fmt.Errorf("GetDBAASServicePG: http response: %w", err)
6313 }
6314
6315 bodyresp := new(DBAASServicePG)
6316 if err := prepareJSONResponse(response, bodyresp); err != nil {
6317 return nil, fmt.Errorf("GetDBAASServicePG: prepare Json response: %w", err)
6318 }
6319
6320 return bodyresp, nil
6321 }
6322
6323 type CreateDBAASServicePGRequestBackupSchedule struct {
6324 // The hour of day (in UTC) when backup for the service is started. New backup is only started if previous backup has already completed.
6325 BackupHour *int64 `json:"backup-hour,omitempty" validate:"omitempty,gte=0,lte=23"`
6326 // The minute of an hour when backup for the service is started. New backup is only started if previous backup has already completed.
6327 BackupMinute *int64 `json:"backup-minute,omitempty" validate:"omitempty,gte=0,lte=59"`
6328 }
6329
6330 type CreateDBAASServicePGRequestIntegrationsType string
6331
6332 const (
6333 CreateDBAASServicePGRequestIntegrationsTypeReadReplica CreateDBAASServicePGRequestIntegrationsType = "read_replica"
6334 )
6335
6336 type CreateDBAASServicePGRequestIntegrations struct {
6337 DestService DBAASServiceName `json:"dest-service,omitempty" validate:"omitempty,gte=0,lte=63"`
6338 // Integration settings
6339 Settings map[string]any `json:"settings,omitempty"`
6340 SourceService DBAASServiceName `json:"source-service,omitempty" validate:"omitempty,gte=0,lte=63"`
6341 // Integration type
6342 Type CreateDBAASServicePGRequestIntegrationsType `json:"type" validate:"required"`
6343 }
6344
6345 type CreateDBAASServicePGRequestMaintenanceDow string
6346
6347 const (
6348 CreateDBAASServicePGRequestMaintenanceDowSaturday CreateDBAASServicePGRequestMaintenanceDow = "saturday"
6349 CreateDBAASServicePGRequestMaintenanceDowTuesday CreateDBAASServicePGRequestMaintenanceDow = "tuesday"
6350 CreateDBAASServicePGRequestMaintenanceDowNever CreateDBAASServicePGRequestMaintenanceDow = "never"
6351 CreateDBAASServicePGRequestMaintenanceDowWednesday CreateDBAASServicePGRequestMaintenanceDow = "wednesday"
6352 CreateDBAASServicePGRequestMaintenanceDowSunday CreateDBAASServicePGRequestMaintenanceDow = "sunday"
6353 CreateDBAASServicePGRequestMaintenanceDowFriday CreateDBAASServicePGRequestMaintenanceDow = "friday"
6354 CreateDBAASServicePGRequestMaintenanceDowMonday CreateDBAASServicePGRequestMaintenanceDow = "monday"
6355 CreateDBAASServicePGRequestMaintenanceDowThursday CreateDBAASServicePGRequestMaintenanceDow = "thursday"
6356 )
6357
6358 // Automatic maintenance settings
6359 type CreateDBAASServicePGRequestMaintenance struct {
6360 // Day of week for installing updates
6361 Dow CreateDBAASServicePGRequestMaintenanceDow `json:"dow" validate:"required"`
6362 // Time for installing updates, UTC
6363 Time string `json:"time" validate:"required,gte=8,lte=8"`
6364 }
6365
6366 // Migrate data from existing server
6367 type CreateDBAASServicePGRequestMigration struct {
6368 // Database name for bootstrapping the initial connection
6369 Dbname string `json:"dbname,omitempty" validate:"omitempty,gte=1,lte=63"`
6370 // Hostname or IP address of the server where to migrate data from
6371 Host string `json:"host" validate:"required,gte=1,lte=255"`
6372 // Comma-separated list of databases, which should be ignored during migration (supported by MySQL only at the moment)
6373 IgnoreDbs string `json:"ignore-dbs,omitempty" validate:"omitempty,gte=1,lte=2048"`
6374 Method EnumMigrationMethod `json:"method,omitempty"`
6375 // Password for authentication with the server where to migrate data from
6376 Password string `json:"password,omitempty" validate:"omitempty,gte=1,lte=255"`
6377 // Port number of the server where to migrate data from
6378 Port int64 `json:"port" validate:"required,gte=1,lte=65535"`
6379 // The server where to migrate data from is secured with SSL
6380 SSL *bool `json:"ssl,omitempty"`
6381 // User name for authentication with the server where to migrate data from
6382 Username string `json:"username,omitempty" validate:"omitempty,gte=1,lte=255"`
6383 }
6384
6385 type CreateDBAASServicePGRequest struct {
6386 // Custom password for admin user. Defaults to random string. This must be set only when a new service is being created.
6387 AdminPassword string `json:"admin-password,omitempty" validate:"omitempty,gte=8,lte=256"`
6388 // Custom username for admin user. This must be set only when a new service is being created.
6389 AdminUsername string `json:"admin-username,omitempty" validate:"omitempty,gte=1,lte=64"`
6390 BackupSchedule *CreateDBAASServicePGRequestBackupSchedule `json:"backup-schedule,omitempty"`
6391 ForkFromService DBAASServiceName `json:"fork-from-service,omitempty" validate:"omitempty,gte=0,lte=63"`
6392 // Service integrations to be enabled when creating the service.
6393 Integrations []CreateDBAASServicePGRequestIntegrations `json:"integrations,omitempty"`
6394 // Allow incoming connections from CIDR address block, e.g. '10.20.0.0/16'
6395 IPFilter []string `json:"ip-filter,omitempty"`
6396 // Automatic maintenance settings
6397 Maintenance *CreateDBAASServicePGRequestMaintenance `json:"maintenance,omitempty"`
6398 // Migrate data from existing server
6399 Migration *CreateDBAASServicePGRequestMigration `json:"migration,omitempty"`
6400 // postgresql.conf configuration values
6401 PGSettings *JSONSchemaPG `json:"pg-settings,omitempty"`
6402 // System-wide settings for pgbouncer.
6403 PgbouncerSettings *JSONSchemaPgbouncer `json:"pgbouncer-settings,omitempty"`
6404 // System-wide settings for pglookout.
6405 PglookoutSettings *JSONSchemaPglookout `json:"pglookout-settings,omitempty"`
6406 // Subscription plan
6407 Plan string `json:"plan" validate:"required,gte=1,lte=128"`
6408 // ISO time of a backup to recover from for services that support arbitrary times
6409 RecoveryBackupTime string `json:"recovery-backup-time,omitempty" validate:"omitempty,gte=1"`
6410 // Percentage of total RAM that the database server uses for shared memory buffers. Valid range is 20-60 (float), which corresponds to 20% - 60%. This setting adjusts the shared_buffers configuration value.
6411 SharedBuffersPercentage int64 `json:"shared-buffers-percentage,omitempty" validate:"omitempty,gte=20,lte=60"`
6412 SynchronousReplication EnumPGSynchronousReplication `json:"synchronous-replication,omitempty"`
6413 // Service is protected against termination and powering off
6414 TerminationProtection *bool `json:"termination-protection,omitempty"`
6415 // System-wide settings for the timescaledb extension
6416 TimescaledbSettings *JSONSchemaTimescaledb `json:"timescaledb-settings,omitempty"`
6417 Variant EnumPGVariant `json:"variant,omitempty"`
6418 Version DBAASPGTargetVersions `json:"version,omitempty"`
6419 // Sets the maximum amount of memory to be used by a query operation (such as a sort or hash table) before writing to temporary disk files, in MB. Default is 1MB + 0.075% of total RAM (up to 32MB).
6420 WorkMem int64 `json:"work-mem,omitempty" validate:"omitempty,gte=1,lte=1024"`
6421 }
6422
6423 func (c Client) CreateDBAASServicePG(ctx context.Context, name string, req CreateDBAASServicePGRequest) (*Operation, error) {
6424 path := fmt.Sprintf("/dbaas-postgres/%v", name)
6425
6426 body, err := prepareJSONBody(req)
6427 if err != nil {
6428 return nil, fmt.Errorf("CreateDBAASServicePG: prepare Json body: %w", err)
6429 }
6430
6431 request, err := http.NewRequestWithContext(ctx, "POST", c.serverEndpoint+path, body)
6432 if err != nil {
6433 return nil, fmt.Errorf("CreateDBAASServicePG: new request: %w", err)
6434 }
6435
6436 request.Header.Add("User-Agent", c.getUserAgent())
6437
6438 request.Header.Add("Content-Type", "application/json")
6439
6440 if err := c.executeRequestInterceptors(ctx, request); err != nil {
6441 return nil, fmt.Errorf("CreateDBAASServicePG: execute request editors: %w", err)
6442 }
6443
6444 if err := c.signRequest(request); err != nil {
6445 return nil, fmt.Errorf("CreateDBAASServicePG: sign request: %w", err)
6446 }
6447
6448 if c.trace {
6449 dumpRequest(request, "create-dbaas-service-pg")
6450 }
6451
6452 response, err := c.httpClient.Do(request)
6453 if err != nil {
6454 return nil, fmt.Errorf("CreateDBAASServicePG: http client do: %w", err)
6455 }
6456
6457 if c.trace {
6458 dumpResponse(response)
6459 }
6460
6461 if err := handleHTTPErrorResp(response); err != nil {
6462 return nil, fmt.Errorf("CreateDBAASServicePG: http response: %w", err)
6463 }
6464
6465 bodyresp := new(Operation)
6466 if err := prepareJSONResponse(response, bodyresp); err != nil {
6467 return nil, fmt.Errorf("CreateDBAASServicePG: prepare Json response: %w", err)
6468 }
6469
6470 return bodyresp, nil
6471 }
6472
6473 type UpdateDBAASServicePGRequestBackupSchedule struct {
6474 // The hour of day (in UTC) when backup for the service is started. New backup is only started if previous backup has already completed.
6475 BackupHour *int64 `json:"backup-hour,omitempty" validate:"omitempty,gte=0,lte=23"`
6476 // The minute of an hour when backup for the service is started. New backup is only started if previous backup has already completed.
6477 BackupMinute *int64 `json:"backup-minute,omitempty" validate:"omitempty,gte=0,lte=59"`
6478 }
6479
6480 type UpdateDBAASServicePGRequestMaintenanceDow string
6481
6482 const (
6483 UpdateDBAASServicePGRequestMaintenanceDowSaturday UpdateDBAASServicePGRequestMaintenanceDow = "saturday"
6484 UpdateDBAASServicePGRequestMaintenanceDowTuesday UpdateDBAASServicePGRequestMaintenanceDow = "tuesday"
6485 UpdateDBAASServicePGRequestMaintenanceDowNever UpdateDBAASServicePGRequestMaintenanceDow = "never"
6486 UpdateDBAASServicePGRequestMaintenanceDowWednesday UpdateDBAASServicePGRequestMaintenanceDow = "wednesday"
6487 UpdateDBAASServicePGRequestMaintenanceDowSunday UpdateDBAASServicePGRequestMaintenanceDow = "sunday"
6488 UpdateDBAASServicePGRequestMaintenanceDowFriday UpdateDBAASServicePGRequestMaintenanceDow = "friday"
6489 UpdateDBAASServicePGRequestMaintenanceDowMonday UpdateDBAASServicePGRequestMaintenanceDow = "monday"
6490 UpdateDBAASServicePGRequestMaintenanceDowThursday UpdateDBAASServicePGRequestMaintenanceDow = "thursday"
6491 )
6492
6493 // Automatic maintenance settings
6494 type UpdateDBAASServicePGRequestMaintenance struct {
6495 // Day of week for installing updates
6496 Dow UpdateDBAASServicePGRequestMaintenanceDow `json:"dow" validate:"required"`
6497 // Time for installing updates, UTC
6498 Time string `json:"time" validate:"required,gte=8,lte=8"`
6499 }
6500
6501 // Migrate data from existing server
6502 type UpdateDBAASServicePGRequestMigration struct {
6503 // Database name for bootstrapping the initial connection
6504 Dbname string `json:"dbname,omitempty" validate:"omitempty,gte=1,lte=63"`
6505 // Hostname or IP address of the server where to migrate data from
6506 Host string `json:"host" validate:"required,gte=1,lte=255"`
6507 // Comma-separated list of databases, which should be ignored during migration (supported by MySQL only at the moment)
6508 IgnoreDbs string `json:"ignore-dbs,omitempty" validate:"omitempty,gte=1,lte=2048"`
6509 Method EnumMigrationMethod `json:"method,omitempty"`
6510 // Password for authentication with the server where to migrate data from
6511 Password string `json:"password,omitempty" validate:"omitempty,gte=1,lte=255"`
6512 // Port number of the server where to migrate data from
6513 Port int64 `json:"port" validate:"required,gte=1,lte=65535"`
6514 // The server where to migrate data from is secured with SSL
6515 SSL *bool `json:"ssl,omitempty"`
6516 // User name for authentication with the server where to migrate data from
6517 Username string `json:"username,omitempty" validate:"omitempty,gte=1,lte=255"`
6518 }
6519
6520 type UpdateDBAASServicePGRequest struct {
6521 BackupSchedule *UpdateDBAASServicePGRequestBackupSchedule `json:"backup-schedule,omitempty"`
6522 // Allow incoming connections from CIDR address block, e.g. '10.20.0.0/16'
6523 IPFilter []string `json:"ip-filter,omitempty"`
6524 // Automatic maintenance settings
6525 Maintenance *UpdateDBAASServicePGRequestMaintenance `json:"maintenance,omitempty"`
6526 // Migrate data from existing server
6527 Migration *UpdateDBAASServicePGRequestMigration `json:"migration,omitempty"`
6528 // postgresql.conf configuration values
6529 PGSettings *JSONSchemaPG `json:"pg-settings,omitempty"`
6530 // System-wide settings for pgbouncer.
6531 PgbouncerSettings *JSONSchemaPgbouncer `json:"pgbouncer-settings,omitempty"`
6532 // System-wide settings for pglookout.
6533 PglookoutSettings *JSONSchemaPglookout `json:"pglookout-settings,omitempty"`
6534 // Subscription plan
6535 Plan string `json:"plan,omitempty" validate:"omitempty,gte=1,lte=128"`
6536 // Percentage of total RAM that the database server uses for shared memory buffers. Valid range is 20-60 (float), which corresponds to 20% - 60%. This setting adjusts the shared_buffers configuration value.
6537 SharedBuffersPercentage int64 `json:"shared-buffers-percentage,omitempty" validate:"omitempty,gte=20,lte=60"`
6538 SynchronousReplication EnumPGSynchronousReplication `json:"synchronous-replication,omitempty"`
6539 // Service is protected against termination and powering off
6540 TerminationProtection *bool `json:"termination-protection,omitempty"`
6541 // System-wide settings for the timescaledb extension
6542 TimescaledbSettings *JSONSchemaTimescaledb `json:"timescaledb-settings,omitempty"`
6543 Variant EnumPGVariant `json:"variant,omitempty"`
6544 // Version
6545 Version string `json:"version,omitempty"`
6546 // Sets the maximum amount of memory to be used by a query operation (such as a sort or hash table) before writing to temporary disk files, in MB. Default is 1MB + 0.075% of total RAM (up to 32MB).
6547 WorkMem int64 `json:"work-mem,omitempty" validate:"omitempty,gte=1,lte=1024"`
6548 }
6549
6550 // Update a DBaaS PostgreSQL service
6551 func (c Client) UpdateDBAASServicePG(ctx context.Context, name string, req UpdateDBAASServicePGRequest) (*Operation, error) {
6552 path := fmt.Sprintf("/dbaas-postgres/%v", name)
6553
6554 body, err := prepareJSONBody(req)
6555 if err != nil {
6556 return nil, fmt.Errorf("UpdateDBAASServicePG: prepare Json body: %w", err)
6557 }
6558
6559 request, err := http.NewRequestWithContext(ctx, "PUT", c.serverEndpoint+path, body)
6560 if err != nil {
6561 return nil, fmt.Errorf("UpdateDBAASServicePG: new request: %w", err)
6562 }
6563
6564 request.Header.Add("User-Agent", c.getUserAgent())
6565
6566 request.Header.Add("Content-Type", "application/json")
6567
6568 if err := c.executeRequestInterceptors(ctx, request); err != nil {
6569 return nil, fmt.Errorf("UpdateDBAASServicePG: execute request editors: %w", err)
6570 }
6571
6572 if err := c.signRequest(request); err != nil {
6573 return nil, fmt.Errorf("UpdateDBAASServicePG: sign request: %w", err)
6574 }
6575
6576 if c.trace {
6577 dumpRequest(request, "update-dbaas-service-pg")
6578 }
6579
6580 response, err := c.httpClient.Do(request)
6581 if err != nil {
6582 return nil, fmt.Errorf("UpdateDBAASServicePG: http client do: %w", err)
6583 }
6584
6585 if c.trace {
6586 dumpResponse(response)
6587 }
6588
6589 if err := handleHTTPErrorResp(response); err != nil {
6590 return nil, fmt.Errorf("UpdateDBAASServicePG: http response: %w", err)
6591 }
6592
6593 bodyresp := new(Operation)
6594 if err := prepareJSONResponse(response, bodyresp); err != nil {
6595 return nil, fmt.Errorf("UpdateDBAASServicePG: prepare Json response: %w", err)
6596 }
6597
6598 return bodyresp, nil
6599 }
6600
6601 func (c Client) StartDBAASPGMaintenance(ctx context.Context, name string) (*Operation, error) {
6602 path := fmt.Sprintf("/dbaas-postgres/%v/maintenance/start", name)
6603
6604 request, err := http.NewRequestWithContext(ctx, "PUT", c.serverEndpoint+path, nil)
6605 if err != nil {
6606 return nil, fmt.Errorf("StartDBAASPGMaintenance: new request: %w", err)
6607 }
6608
6609 request.Header.Add("User-Agent", c.getUserAgent())
6610
6611 if err := c.executeRequestInterceptors(ctx, request); err != nil {
6612 return nil, fmt.Errorf("StartDBAASPGMaintenance: execute request editors: %w", err)
6613 }
6614
6615 if err := c.signRequest(request); err != nil {
6616 return nil, fmt.Errorf("StartDBAASPGMaintenance: sign request: %w", err)
6617 }
6618
6619 if c.trace {
6620 dumpRequest(request, "start-dbaas-pg-maintenance")
6621 }
6622
6623 response, err := c.httpClient.Do(request)
6624 if err != nil {
6625 return nil, fmt.Errorf("StartDBAASPGMaintenance: http client do: %w", err)
6626 }
6627
6628 if c.trace {
6629 dumpResponse(response)
6630 }
6631
6632 if err := handleHTTPErrorResp(response); err != nil {
6633 return nil, fmt.Errorf("StartDBAASPGMaintenance: http response: %w", err)
6634 }
6635
6636 bodyresp := new(Operation)
6637 if err := prepareJSONResponse(response, bodyresp); err != nil {
6638 return nil, fmt.Errorf("StartDBAASPGMaintenance: prepare Json response: %w", err)
6639 }
6640
6641 return bodyresp, nil
6642 }
6643
6644 func (c Client) StopDBAASPGMigration(ctx context.Context, name string) (*Operation, error) {
6645 path := fmt.Sprintf("/dbaas-postgres/%v/migration/stop", name)
6646
6647 request, err := http.NewRequestWithContext(ctx, "POST", c.serverEndpoint+path, nil)
6648 if err != nil {
6649 return nil, fmt.Errorf("StopDBAASPGMigration: new request: %w", err)
6650 }
6651
6652 request.Header.Add("User-Agent", c.getUserAgent())
6653
6654 if err := c.executeRequestInterceptors(ctx, request); err != nil {
6655 return nil, fmt.Errorf("StopDBAASPGMigration: execute request editors: %w", err)
6656 }
6657
6658 if err := c.signRequest(request); err != nil {
6659 return nil, fmt.Errorf("StopDBAASPGMigration: sign request: %w", err)
6660 }
6661
6662 if c.trace {
6663 dumpRequest(request, "stop-dbaas-pg-migration")
6664 }
6665
6666 response, err := c.httpClient.Do(request)
6667 if err != nil {
6668 return nil, fmt.Errorf("StopDBAASPGMigration: http client do: %w", err)
6669 }
6670
6671 if c.trace {
6672 dumpResponse(response)
6673 }
6674
6675 if err := handleHTTPErrorResp(response); err != nil {
6676 return nil, fmt.Errorf("StopDBAASPGMigration: http response: %w", err)
6677 }
6678
6679 bodyresp := new(Operation)
6680 if err := prepareJSONResponse(response, bodyresp); err != nil {
6681 return nil, fmt.Errorf("StopDBAASPGMigration: prepare Json response: %w", err)
6682 }
6683
6684 return bodyresp, nil
6685 }
6686
6687 type CreateDBAASPGConnectionPoolRequest struct {
6688 DatabaseName DBAASDatabaseName `json:"database-name" validate:"required,gte=1,lte=40"`
6689 Mode EnumPGPoolMode `json:"mode,omitempty"`
6690 Name DBAASPGPoolName `json:"name" validate:"required,gte=1,lte=63"`
6691 Size DBAASPGPoolSize `json:"size,omitempty" validate:"omitempty,gte=1,lte=10000"`
6692 Username DBAASPGPoolUsername `json:"username,omitempty" validate:"omitempty,gte=1,lte=64"`
6693 }
6694
6695 // Create a DBaaS PostgreSQL connection pool
6696 func (c Client) CreateDBAASPGConnectionPool(ctx context.Context, serviceName string, req CreateDBAASPGConnectionPoolRequest) (*Operation, error) {
6697 path := fmt.Sprintf("/dbaas-postgres/%v/connection-pool", serviceName)
6698
6699 body, err := prepareJSONBody(req)
6700 if err != nil {
6701 return nil, fmt.Errorf("CreateDBAASPGConnectionPool: prepare Json body: %w", err)
6702 }
6703
6704 request, err := http.NewRequestWithContext(ctx, "POST", c.serverEndpoint+path, body)
6705 if err != nil {
6706 return nil, fmt.Errorf("CreateDBAASPGConnectionPool: new request: %w", err)
6707 }
6708
6709 request.Header.Add("User-Agent", c.getUserAgent())
6710
6711 request.Header.Add("Content-Type", "application/json")
6712
6713 if err := c.executeRequestInterceptors(ctx, request); err != nil {
6714 return nil, fmt.Errorf("CreateDBAASPGConnectionPool: execute request editors: %w", err)
6715 }
6716
6717 if err := c.signRequest(request); err != nil {
6718 return nil, fmt.Errorf("CreateDBAASPGConnectionPool: sign request: %w", err)
6719 }
6720
6721 if c.trace {
6722 dumpRequest(request, "create-dbaas-pg-connection-pool")
6723 }
6724
6725 response, err := c.httpClient.Do(request)
6726 if err != nil {
6727 return nil, fmt.Errorf("CreateDBAASPGConnectionPool: http client do: %w", err)
6728 }
6729
6730 if c.trace {
6731 dumpResponse(response)
6732 }
6733
6734 if err := handleHTTPErrorResp(response); err != nil {
6735 return nil, fmt.Errorf("CreateDBAASPGConnectionPool: http response: %w", err)
6736 }
6737
6738 bodyresp := new(Operation)
6739 if err := prepareJSONResponse(response, bodyresp); err != nil {
6740 return nil, fmt.Errorf("CreateDBAASPGConnectionPool: prepare Json response: %w", err)
6741 }
6742
6743 return bodyresp, nil
6744 }
6745
6746 // Delete a DBaaS PostgreSQL connection pool
6747 func (c Client) DeleteDBAASPGConnectionPool(ctx context.Context, serviceName string, connectionPoolName string) (*Operation, error) {
6748 path := fmt.Sprintf("/dbaas-postgres/%v/connection-pool/%v", serviceName, connectionPoolName)
6749
6750 request, err := http.NewRequestWithContext(ctx, "DELETE", c.serverEndpoint+path, nil)
6751 if err != nil {
6752 return nil, fmt.Errorf("DeleteDBAASPGConnectionPool: new request: %w", err)
6753 }
6754
6755 request.Header.Add("User-Agent", c.getUserAgent())
6756
6757 if err := c.executeRequestInterceptors(ctx, request); err != nil {
6758 return nil, fmt.Errorf("DeleteDBAASPGConnectionPool: execute request editors: %w", err)
6759 }
6760
6761 if err := c.signRequest(request); err != nil {
6762 return nil, fmt.Errorf("DeleteDBAASPGConnectionPool: sign request: %w", err)
6763 }
6764
6765 if c.trace {
6766 dumpRequest(request, "delete-dbaas-pg-connection-pool")
6767 }
6768
6769 response, err := c.httpClient.Do(request)
6770 if err != nil {
6771 return nil, fmt.Errorf("DeleteDBAASPGConnectionPool: http client do: %w", err)
6772 }
6773
6774 if c.trace {
6775 dumpResponse(response)
6776 }
6777
6778 if err := handleHTTPErrorResp(response); err != nil {
6779 return nil, fmt.Errorf("DeleteDBAASPGConnectionPool: http response: %w", err)
6780 }
6781
6782 bodyresp := new(Operation)
6783 if err := prepareJSONResponse(response, bodyresp); err != nil {
6784 return nil, fmt.Errorf("DeleteDBAASPGConnectionPool: prepare Json response: %w", err)
6785 }
6786
6787 return bodyresp, nil
6788 }
6789
6790 type UpdateDBAASPGConnectionPoolRequest struct {
6791 DatabaseName DBAASDatabaseName `json:"database-name,omitempty" validate:"omitempty,gte=1,lte=40"`
6792 Mode EnumPGPoolMode `json:"mode,omitempty"`
6793 Size DBAASPGPoolSize `json:"size,omitempty" validate:"omitempty,gte=1,lte=10000"`
6794 Username DBAASPGPoolUsername `json:"username,omitempty" validate:"omitempty,gte=1,lte=64"`
6795 }
6796
6797 // Update a DBaaS PostgreSQL connection pool
6798 func (c Client) UpdateDBAASPGConnectionPool(ctx context.Context, serviceName string, connectionPoolName string, req UpdateDBAASPGConnectionPoolRequest) (*Operation, error) {
6799 path := fmt.Sprintf("/dbaas-postgres/%v/connection-pool/%v", serviceName, connectionPoolName)
6800
6801 body, err := prepareJSONBody(req)
6802 if err != nil {
6803 return nil, fmt.Errorf("UpdateDBAASPGConnectionPool: prepare Json body: %w", err)
6804 }
6805
6806 request, err := http.NewRequestWithContext(ctx, "PUT", c.serverEndpoint+path, body)
6807 if err != nil {
6808 return nil, fmt.Errorf("UpdateDBAASPGConnectionPool: new request: %w", err)
6809 }
6810
6811 request.Header.Add("User-Agent", c.getUserAgent())
6812
6813 request.Header.Add("Content-Type", "application/json")
6814
6815 if err := c.executeRequestInterceptors(ctx, request); err != nil {
6816 return nil, fmt.Errorf("UpdateDBAASPGConnectionPool: execute request editors: %w", err)
6817 }
6818
6819 if err := c.signRequest(request); err != nil {
6820 return nil, fmt.Errorf("UpdateDBAASPGConnectionPool: sign request: %w", err)
6821 }
6822
6823 if c.trace {
6824 dumpRequest(request, "update-dbaas-pg-connection-pool")
6825 }
6826
6827 response, err := c.httpClient.Do(request)
6828 if err != nil {
6829 return nil, fmt.Errorf("UpdateDBAASPGConnectionPool: http client do: %w", err)
6830 }
6831
6832 if c.trace {
6833 dumpResponse(response)
6834 }
6835
6836 if err := handleHTTPErrorResp(response); err != nil {
6837 return nil, fmt.Errorf("UpdateDBAASPGConnectionPool: http response: %w", err)
6838 }
6839
6840 bodyresp := new(Operation)
6841 if err := prepareJSONResponse(response, bodyresp); err != nil {
6842 return nil, fmt.Errorf("UpdateDBAASPGConnectionPool: prepare Json response: %w", err)
6843 }
6844
6845 return bodyresp, nil
6846 }
6847
6848 type CreateDBAASPGDatabaseRequest struct {
6849 DatabaseName DBAASDatabaseName `json:"database-name" validate:"required,gte=1,lte=40"`
6850 // Default string sort order (LC_COLLATE) for PostgreSQL database
6851 LCCollate string `json:"lc-collate,omitempty" validate:"omitempty,lte=128"`
6852 // Default character classification (LC_CTYPE) for PostgreSQL database
6853 LCCtype string `json:"lc-ctype,omitempty" validate:"omitempty,lte=128"`
6854 }
6855
6856 func (c Client) CreateDBAASPGDatabase(ctx context.Context, serviceName string, req CreateDBAASPGDatabaseRequest) (*Operation, error) {
6857 path := fmt.Sprintf("/dbaas-postgres/%v/database", serviceName)
6858
6859 body, err := prepareJSONBody(req)
6860 if err != nil {
6861 return nil, fmt.Errorf("CreateDBAASPGDatabase: prepare Json body: %w", err)
6862 }
6863
6864 request, err := http.NewRequestWithContext(ctx, "POST", c.serverEndpoint+path, body)
6865 if err != nil {
6866 return nil, fmt.Errorf("CreateDBAASPGDatabase: new request: %w", err)
6867 }
6868
6869 request.Header.Add("User-Agent", c.getUserAgent())
6870
6871 request.Header.Add("Content-Type", "application/json")
6872
6873 if err := c.executeRequestInterceptors(ctx, request); err != nil {
6874 return nil, fmt.Errorf("CreateDBAASPGDatabase: execute request editors: %w", err)
6875 }
6876
6877 if err := c.signRequest(request); err != nil {
6878 return nil, fmt.Errorf("CreateDBAASPGDatabase: sign request: %w", err)
6879 }
6880
6881 if c.trace {
6882 dumpRequest(request, "create-dbaas-pg-database")
6883 }
6884
6885 response, err := c.httpClient.Do(request)
6886 if err != nil {
6887 return nil, fmt.Errorf("CreateDBAASPGDatabase: http client do: %w", err)
6888 }
6889
6890 if c.trace {
6891 dumpResponse(response)
6892 }
6893
6894 if err := handleHTTPErrorResp(response); err != nil {
6895 return nil, fmt.Errorf("CreateDBAASPGDatabase: http response: %w", err)
6896 }
6897
6898 bodyresp := new(Operation)
6899 if err := prepareJSONResponse(response, bodyresp); err != nil {
6900 return nil, fmt.Errorf("CreateDBAASPGDatabase: prepare Json response: %w", err)
6901 }
6902
6903 return bodyresp, nil
6904 }
6905
6906 func (c Client) DeleteDBAASPGDatabase(ctx context.Context, serviceName string, databaseName string) (*Operation, error) {
6907 path := fmt.Sprintf("/dbaas-postgres/%v/database/%v", serviceName, databaseName)
6908
6909 request, err := http.NewRequestWithContext(ctx, "DELETE", c.serverEndpoint+path, nil)
6910 if err != nil {
6911 return nil, fmt.Errorf("DeleteDBAASPGDatabase: new request: %w", err)
6912 }
6913
6914 request.Header.Add("User-Agent", c.getUserAgent())
6915
6916 if err := c.executeRequestInterceptors(ctx, request); err != nil {
6917 return nil, fmt.Errorf("DeleteDBAASPGDatabase: execute request editors: %w", err)
6918 }
6919
6920 if err := c.signRequest(request); err != nil {
6921 return nil, fmt.Errorf("DeleteDBAASPGDatabase: sign request: %w", err)
6922 }
6923
6924 if c.trace {
6925 dumpRequest(request, "delete-dbaas-pg-database")
6926 }
6927
6928 response, err := c.httpClient.Do(request)
6929 if err != nil {
6930 return nil, fmt.Errorf("DeleteDBAASPGDatabase: http client do: %w", err)
6931 }
6932
6933 if c.trace {
6934 dumpResponse(response)
6935 }
6936
6937 if err := handleHTTPErrorResp(response); err != nil {
6938 return nil, fmt.Errorf("DeleteDBAASPGDatabase: http response: %w", err)
6939 }
6940
6941 bodyresp := new(Operation)
6942 if err := prepareJSONResponse(response, bodyresp); err != nil {
6943 return nil, fmt.Errorf("DeleteDBAASPGDatabase: prepare Json response: %w", err)
6944 }
6945
6946 return bodyresp, nil
6947 }
6948
6949 type CreateDBAASPostgresUserRequest struct {
6950 AllowReplication *bool `json:"allow-replication,omitempty"`
6951 Username DBAASUserUsername `json:"username" validate:"required,gte=1,lte=64"`
6952 }
6953
6954 func (c Client) CreateDBAASPostgresUser(ctx context.Context, serviceName string, req CreateDBAASPostgresUserRequest) (*Operation, error) {
6955 path := fmt.Sprintf("/dbaas-postgres/%v/user", serviceName)
6956
6957 body, err := prepareJSONBody(req)
6958 if err != nil {
6959 return nil, fmt.Errorf("CreateDBAASPostgresUser: prepare Json body: %w", err)
6960 }
6961
6962 request, err := http.NewRequestWithContext(ctx, "POST", c.serverEndpoint+path, body)
6963 if err != nil {
6964 return nil, fmt.Errorf("CreateDBAASPostgresUser: new request: %w", err)
6965 }
6966
6967 request.Header.Add("User-Agent", c.getUserAgent())
6968
6969 request.Header.Add("Content-Type", "application/json")
6970
6971 if err := c.executeRequestInterceptors(ctx, request); err != nil {
6972 return nil, fmt.Errorf("CreateDBAASPostgresUser: execute request editors: %w", err)
6973 }
6974
6975 if err := c.signRequest(request); err != nil {
6976 return nil, fmt.Errorf("CreateDBAASPostgresUser: sign request: %w", err)
6977 }
6978
6979 if c.trace {
6980 dumpRequest(request, "create-dbaas-postgres-user")
6981 }
6982
6983 response, err := c.httpClient.Do(request)
6984 if err != nil {
6985 return nil, fmt.Errorf("CreateDBAASPostgresUser: http client do: %w", err)
6986 }
6987
6988 if c.trace {
6989 dumpResponse(response)
6990 }
6991
6992 if err := handleHTTPErrorResp(response); err != nil {
6993 return nil, fmt.Errorf("CreateDBAASPostgresUser: http response: %w", err)
6994 }
6995
6996 bodyresp := new(Operation)
6997 if err := prepareJSONResponse(response, bodyresp); err != nil {
6998 return nil, fmt.Errorf("CreateDBAASPostgresUser: prepare Json response: %w", err)
6999 }
7000
7001 return bodyresp, nil
7002 }
7003
7004 func (c Client) DeleteDBAASPostgresUser(ctx context.Context, serviceName string, username string) (*Operation, error) {
7005 path := fmt.Sprintf("/dbaas-postgres/%v/user/%v", serviceName, username)
7006
7007 request, err := http.NewRequestWithContext(ctx, "DELETE", c.serverEndpoint+path, nil)
7008 if err != nil {
7009 return nil, fmt.Errorf("DeleteDBAASPostgresUser: new request: %w", err)
7010 }
7011
7012 request.Header.Add("User-Agent", c.getUserAgent())
7013
7014 if err := c.executeRequestInterceptors(ctx, request); err != nil {
7015 return nil, fmt.Errorf("DeleteDBAASPostgresUser: execute request editors: %w", err)
7016 }
7017
7018 if err := c.signRequest(request); err != nil {
7019 return nil, fmt.Errorf("DeleteDBAASPostgresUser: sign request: %w", err)
7020 }
7021
7022 if c.trace {
7023 dumpRequest(request, "delete-dbaas-postgres-user")
7024 }
7025
7026 response, err := c.httpClient.Do(request)
7027 if err != nil {
7028 return nil, fmt.Errorf("DeleteDBAASPostgresUser: http client do: %w", err)
7029 }
7030
7031 if c.trace {
7032 dumpResponse(response)
7033 }
7034
7035 if err := handleHTTPErrorResp(response); err != nil {
7036 return nil, fmt.Errorf("DeleteDBAASPostgresUser: http response: %w", err)
7037 }
7038
7039 bodyresp := new(Operation)
7040 if err := prepareJSONResponse(response, bodyresp); err != nil {
7041 return nil, fmt.Errorf("DeleteDBAASPostgresUser: prepare Json response: %w", err)
7042 }
7043
7044 return bodyresp, nil
7045 }
7046
7047 type UpdateDBAASPostgresAllowReplicationRequest struct {
7048 AllowReplication *bool `json:"allow-replication,omitempty"`
7049 }
7050
7051 func (c Client) UpdateDBAASPostgresAllowReplication(ctx context.Context, serviceName string, username string, req UpdateDBAASPostgresAllowReplicationRequest) (*DBAASPostgresUsers, error) {
7052 path := fmt.Sprintf("/dbaas-postgres/%v/user/%v/allow-replication", serviceName, username)
7053
7054 body, err := prepareJSONBody(req)
7055 if err != nil {
7056 return nil, fmt.Errorf("UpdateDBAASPostgresAllowReplication: prepare Json body: %w", err)
7057 }
7058
7059 request, err := http.NewRequestWithContext(ctx, "PUT", c.serverEndpoint+path, body)
7060 if err != nil {
7061 return nil, fmt.Errorf("UpdateDBAASPostgresAllowReplication: new request: %w", err)
7062 }
7063
7064 request.Header.Add("User-Agent", c.getUserAgent())
7065
7066 request.Header.Add("Content-Type", "application/json")
7067
7068 if err := c.executeRequestInterceptors(ctx, request); err != nil {
7069 return nil, fmt.Errorf("UpdateDBAASPostgresAllowReplication: execute request editors: %w", err)
7070 }
7071
7072 if err := c.signRequest(request); err != nil {
7073 return nil, fmt.Errorf("UpdateDBAASPostgresAllowReplication: sign request: %w", err)
7074 }
7075
7076 if c.trace {
7077 dumpRequest(request, "update-dbaas-postgres-allow-replication")
7078 }
7079
7080 response, err := c.httpClient.Do(request)
7081 if err != nil {
7082 return nil, fmt.Errorf("UpdateDBAASPostgresAllowReplication: http client do: %w", err)
7083 }
7084
7085 if c.trace {
7086 dumpResponse(response)
7087 }
7088
7089 if err := handleHTTPErrorResp(response); err != nil {
7090 return nil, fmt.Errorf("UpdateDBAASPostgresAllowReplication: http response: %w", err)
7091 }
7092
7093 bodyresp := new(DBAASPostgresUsers)
7094 if err := prepareJSONResponse(response, bodyresp); err != nil {
7095 return nil, fmt.Errorf("UpdateDBAASPostgresAllowReplication: prepare Json response: %w", err)
7096 }
7097
7098 return bodyresp, nil
7099 }
7100
7101 type ResetDBAASPostgresUserPasswordRequest struct {
7102 Password DBAASUserPassword `json:"password,omitempty" validate:"omitempty,gte=8,lte=256"`
7103 }
7104
7105 // If no password is provided one will be generated automatically.
7106 func (c Client) ResetDBAASPostgresUserPassword(ctx context.Context, serviceName string, username string, req ResetDBAASPostgresUserPasswordRequest) (*Operation, error) {
7107 path := fmt.Sprintf("/dbaas-postgres/%v/user/%v/password/reset", serviceName, username)
7108
7109 body, err := prepareJSONBody(req)
7110 if err != nil {
7111 return nil, fmt.Errorf("ResetDBAASPostgresUserPassword: prepare Json body: %w", err)
7112 }
7113
7114 request, err := http.NewRequestWithContext(ctx, "PUT", c.serverEndpoint+path, body)
7115 if err != nil {
7116 return nil, fmt.Errorf("ResetDBAASPostgresUserPassword: new request: %w", err)
7117 }
7118
7119 request.Header.Add("User-Agent", c.getUserAgent())
7120
7121 request.Header.Add("Content-Type", "application/json")
7122
7123 if err := c.executeRequestInterceptors(ctx, request); err != nil {
7124 return nil, fmt.Errorf("ResetDBAASPostgresUserPassword: execute request editors: %w", err)
7125 }
7126
7127 if err := c.signRequest(request); err != nil {
7128 return nil, fmt.Errorf("ResetDBAASPostgresUserPassword: sign request: %w", err)
7129 }
7130
7131 if c.trace {
7132 dumpRequest(request, "reset-dbaas-postgres-user-password")
7133 }
7134
7135 response, err := c.httpClient.Do(request)
7136 if err != nil {
7137 return nil, fmt.Errorf("ResetDBAASPostgresUserPassword: http client do: %w", err)
7138 }
7139
7140 if c.trace {
7141 dumpResponse(response)
7142 }
7143
7144 if err := handleHTTPErrorResp(response); err != nil {
7145 return nil, fmt.Errorf("ResetDBAASPostgresUserPassword: http response: %w", err)
7146 }
7147
7148 bodyresp := new(Operation)
7149 if err := prepareJSONResponse(response, bodyresp); err != nil {
7150 return nil, fmt.Errorf("ResetDBAASPostgresUserPassword: prepare Json response: %w", err)
7151 }
7152
7153 return bodyresp, nil
7154 }
7155
7156 func (c Client) RevealDBAASPostgresUserPassword(ctx context.Context, serviceName string, username string) (*DBAASUserPostgresSecrets, error) {
7157 path := fmt.Sprintf("/dbaas-postgres/%v/user/%v/password/reveal", serviceName, username)
7158
7159 request, err := http.NewRequestWithContext(ctx, "GET", c.serverEndpoint+path, nil)
7160 if err != nil {
7161 return nil, fmt.Errorf("RevealDBAASPostgresUserPassword: new request: %w", err)
7162 }
7163
7164 request.Header.Add("User-Agent", c.getUserAgent())
7165
7166 if err := c.executeRequestInterceptors(ctx, request); err != nil {
7167 return nil, fmt.Errorf("RevealDBAASPostgresUserPassword: execute request editors: %w", err)
7168 }
7169
7170 if err := c.signRequest(request); err != nil {
7171 return nil, fmt.Errorf("RevealDBAASPostgresUserPassword: sign request: %w", err)
7172 }
7173
7174 if c.trace {
7175 dumpRequest(request, "reveal-dbaas-postgres-user-password")
7176 }
7177
7178 response, err := c.httpClient.Do(request)
7179 if err != nil {
7180 return nil, fmt.Errorf("RevealDBAASPostgresUserPassword: http client do: %w", err)
7181 }
7182
7183 if c.trace {
7184 dumpResponse(response)
7185 }
7186
7187 if err := handleHTTPErrorResp(response); err != nil {
7188 return nil, fmt.Errorf("RevealDBAASPostgresUserPassword: http response: %w", err)
7189 }
7190
7191 bodyresp := new(DBAASUserPostgresSecrets)
7192 if err := prepareJSONResponse(response, bodyresp); err != nil {
7193 return nil, fmt.Errorf("RevealDBAASPostgresUserPassword: prepare Json response: %w", err)
7194 }
7195
7196 return bodyresp, nil
7197 }
7198
7199 type CreateDBAASPGUpgradeCheckRequest struct {
7200 TargetVersion DBAASPGTargetVersions `json:"target-version" validate:"required"`
7201 }
7202
7203 // Check whether you can upgrade Postgres service to a newer version
7204 func (c Client) CreateDBAASPGUpgradeCheck(ctx context.Context, service string, req CreateDBAASPGUpgradeCheckRequest) (*DBAASTask, error) {
7205 path := fmt.Sprintf("/dbaas-postgres/%v/upgrade-check", service)
7206
7207 body, err := prepareJSONBody(req)
7208 if err != nil {
7209 return nil, fmt.Errorf("CreateDBAASPGUpgradeCheck: prepare Json body: %w", err)
7210 }
7211
7212 request, err := http.NewRequestWithContext(ctx, "POST", c.serverEndpoint+path, body)
7213 if err != nil {
7214 return nil, fmt.Errorf("CreateDBAASPGUpgradeCheck: new request: %w", err)
7215 }
7216
7217 request.Header.Add("User-Agent", c.getUserAgent())
7218
7219 request.Header.Add("Content-Type", "application/json")
7220
7221 if err := c.executeRequestInterceptors(ctx, request); err != nil {
7222 return nil, fmt.Errorf("CreateDBAASPGUpgradeCheck: execute request editors: %w", err)
7223 }
7224
7225 if err := c.signRequest(request); err != nil {
7226 return nil, fmt.Errorf("CreateDBAASPGUpgradeCheck: sign request: %w", err)
7227 }
7228
7229 if c.trace {
7230 dumpRequest(request, "create-dbaas-pg-upgrade-check")
7231 }
7232
7233 response, err := c.httpClient.Do(request)
7234 if err != nil {
7235 return nil, fmt.Errorf("CreateDBAASPGUpgradeCheck: http client do: %w", err)
7236 }
7237
7238 if c.trace {
7239 dumpResponse(response)
7240 }
7241
7242 if err := handleHTTPErrorResp(response); err != nil {
7243 return nil, fmt.Errorf("CreateDBAASPGUpgradeCheck: http response: %w", err)
7244 }
7245
7246 bodyresp := new(DBAASTask)
7247 if err := prepareJSONResponse(response, bodyresp); err != nil {
7248 return nil, fmt.Errorf("CreateDBAASPGUpgradeCheck: prepare Json response: %w", err)
7249 }
7250
7251 return bodyresp, nil
7252 }
7253
7254 type ListDBAASServicesResponse struct {
7255 DBAASServices []DBAASServiceCommon `json:"dbaas-services,omitempty"`
7256 }
7257
7258 // FindDBAASServiceCommon attempts to find an DBAASServiceCommon by name.
7259 func (l ListDBAASServicesResponse) FindDBAASServiceCommon(name string) (DBAASServiceCommon, error) {
7260 var result []DBAASServiceCommon
7261 for i, elem := range l.DBAASServices {
7262 if string(elem.Name) == name {
7263 result = append(result, l.DBAASServices[i])
7264 }
7265 }
7266 if len(result) == 1 {
7267 return result[0], nil
7268 }
7269
7270 if len(result) > 1 {
7271 return DBAASServiceCommon{}, fmt.Errorf("%q too many found in ListDBAASServicesResponse: %w", name, ErrConflict)
7272 }
7273
7274 return DBAASServiceCommon{}, fmt.Errorf("%q not found in ListDBAASServicesResponse: %w", name, ErrNotFound)
7275 }
7276
7277 // List DBaaS services
7278 func (c Client) ListDBAASServices(ctx context.Context) (*ListDBAASServicesResponse, error) {
7279 path := "/dbaas-service"
7280
7281 request, err := http.NewRequestWithContext(ctx, "GET", c.serverEndpoint+path, nil)
7282 if err != nil {
7283 return nil, fmt.Errorf("ListDBAASServices: new request: %w", err)
7284 }
7285
7286 request.Header.Add("User-Agent", c.getUserAgent())
7287
7288 if err := c.executeRequestInterceptors(ctx, request); err != nil {
7289 return nil, fmt.Errorf("ListDBAASServices: execute request editors: %w", err)
7290 }
7291
7292 if err := c.signRequest(request); err != nil {
7293 return nil, fmt.Errorf("ListDBAASServices: sign request: %w", err)
7294 }
7295
7296 if c.trace {
7297 dumpRequest(request, "list-dbaas-services")
7298 }
7299
7300 response, err := c.httpClient.Do(request)
7301 if err != nil {
7302 return nil, fmt.Errorf("ListDBAASServices: http client do: %w", err)
7303 }
7304
7305 if c.trace {
7306 dumpResponse(response)
7307 }
7308
7309 if err := handleHTTPErrorResp(response); err != nil {
7310 return nil, fmt.Errorf("ListDBAASServices: http response: %w", err)
7311 }
7312
7313 bodyresp := new(ListDBAASServicesResponse)
7314 if err := prepareJSONResponse(response, bodyresp); err != nil {
7315 return nil, fmt.Errorf("ListDBAASServices: prepare Json response: %w", err)
7316 }
7317
7318 return bodyresp, nil
7319 }
7320
7321 type GetDBAASServiceLogsRequest struct {
7322 // How many log entries to receive at most, up to 500 (default: 100)
7323 Limit int64 `json:"limit,omitempty" validate:"omitempty,gte=1,lte=500"`
7324 // Opaque offset identifier
7325 Offset string `json:"offset,omitempty"`
7326 SortOrder EnumSortOrder `json:"sort-order,omitempty"`
7327 }
7328
7329 // Get logs of DBaaS service
7330 func (c Client) GetDBAASServiceLogs(ctx context.Context, serviceName string, req GetDBAASServiceLogsRequest) (*DBAASServiceLogs, error) {
7331 path := fmt.Sprintf("/dbaas-service-logs/%v", serviceName)
7332
7333 body, err := prepareJSONBody(req)
7334 if err != nil {
7335 return nil, fmt.Errorf("GetDBAASServiceLogs: prepare Json body: %w", err)
7336 }
7337
7338 request, err := http.NewRequestWithContext(ctx, "POST", c.serverEndpoint+path, body)
7339 if err != nil {
7340 return nil, fmt.Errorf("GetDBAASServiceLogs: new request: %w", err)
7341 }
7342
7343 request.Header.Add("User-Agent", c.getUserAgent())
7344
7345 request.Header.Add("Content-Type", "application/json")
7346
7347 if err := c.executeRequestInterceptors(ctx, request); err != nil {
7348 return nil, fmt.Errorf("GetDBAASServiceLogs: execute request editors: %w", err)
7349 }
7350
7351 if err := c.signRequest(request); err != nil {
7352 return nil, fmt.Errorf("GetDBAASServiceLogs: sign request: %w", err)
7353 }
7354
7355 if c.trace {
7356 dumpRequest(request, "get-dbaas-service-logs")
7357 }
7358
7359 response, err := c.httpClient.Do(request)
7360 if err != nil {
7361 return nil, fmt.Errorf("GetDBAASServiceLogs: http client do: %w", err)
7362 }
7363
7364 if c.trace {
7365 dumpResponse(response)
7366 }
7367
7368 if err := handleHTTPErrorResp(response); err != nil {
7369 return nil, fmt.Errorf("GetDBAASServiceLogs: http response: %w", err)
7370 }
7371
7372 bodyresp := new(DBAASServiceLogs)
7373 if err := prepareJSONResponse(response, bodyresp); err != nil {
7374 return nil, fmt.Errorf("GetDBAASServiceLogs: prepare Json response: %w", err)
7375 }
7376
7377 return bodyresp, nil
7378 }
7379
7380 type GetDBAASServiceMetricsResponse struct {
7381 Metrics map[string]any `json:"metrics,omitempty"`
7382 }
7383
7384 type GetDBAASServiceMetricsRequestPeriod string
7385
7386 const (
7387 GetDBAASServiceMetricsRequestPeriodHour GetDBAASServiceMetricsRequestPeriod = "hour"
7388 GetDBAASServiceMetricsRequestPeriodWeek GetDBAASServiceMetricsRequestPeriod = "week"
7389 GetDBAASServiceMetricsRequestPeriodYear GetDBAASServiceMetricsRequestPeriod = "year"
7390 GetDBAASServiceMetricsRequestPeriodMonth GetDBAASServiceMetricsRequestPeriod = "month"
7391 GetDBAASServiceMetricsRequestPeriodDay GetDBAASServiceMetricsRequestPeriod = "day"
7392 )
7393
7394 type GetDBAASServiceMetricsRequest struct {
7395 // Metrics time period (default: hour)
7396 Period GetDBAASServiceMetricsRequestPeriod `json:"period,omitempty"`
7397 }
7398
7399 // Get metrics of DBaaS service
7400 func (c Client) GetDBAASServiceMetrics(ctx context.Context, serviceName string, req GetDBAASServiceMetricsRequest) (*GetDBAASServiceMetricsResponse, error) {
7401 path := fmt.Sprintf("/dbaas-service-metrics/%v", serviceName)
7402
7403 body, err := prepareJSONBody(req)
7404 if err != nil {
7405 return nil, fmt.Errorf("GetDBAASServiceMetrics: prepare Json body: %w", err)
7406 }
7407
7408 request, err := http.NewRequestWithContext(ctx, "POST", c.serverEndpoint+path, body)
7409 if err != nil {
7410 return nil, fmt.Errorf("GetDBAASServiceMetrics: new request: %w", err)
7411 }
7412
7413 request.Header.Add("User-Agent", c.getUserAgent())
7414
7415 request.Header.Add("Content-Type", "application/json")
7416
7417 if err := c.executeRequestInterceptors(ctx, request); err != nil {
7418 return nil, fmt.Errorf("GetDBAASServiceMetrics: execute request editors: %w", err)
7419 }
7420
7421 if err := c.signRequest(request); err != nil {
7422 return nil, fmt.Errorf("GetDBAASServiceMetrics: sign request: %w", err)
7423 }
7424
7425 if c.trace {
7426 dumpRequest(request, "get-dbaas-service-metrics")
7427 }
7428
7429 response, err := c.httpClient.Do(request)
7430 if err != nil {
7431 return nil, fmt.Errorf("GetDBAASServiceMetrics: http client do: %w", err)
7432 }
7433
7434 if c.trace {
7435 dumpResponse(response)
7436 }
7437
7438 if err := handleHTTPErrorResp(response); err != nil {
7439 return nil, fmt.Errorf("GetDBAASServiceMetrics: http response: %w", err)
7440 }
7441
7442 bodyresp := new(GetDBAASServiceMetricsResponse)
7443 if err := prepareJSONResponse(response, bodyresp); err != nil {
7444 return nil, fmt.Errorf("GetDBAASServiceMetrics: prepare Json response: %w", err)
7445 }
7446
7447 return bodyresp, nil
7448 }
7449
7450 type ListDBAASServiceTypesResponse struct {
7451 DBAASServiceTypes []DBAASServiceType `json:"dbaas-service-types,omitempty"`
7452 }
7453
7454 // FindDBAASServiceType attempts to find an DBAASServiceType by name.
7455 func (l ListDBAASServiceTypesResponse) FindDBAASServiceType(name string) (DBAASServiceType, error) {
7456 var result []DBAASServiceType
7457 for i, elem := range l.DBAASServiceTypes {
7458 if string(elem.Name) == name {
7459 result = append(result, l.DBAASServiceTypes[i])
7460 }
7461 }
7462 if len(result) == 1 {
7463 return result[0], nil
7464 }
7465
7466 if len(result) > 1 {
7467 return DBAASServiceType{}, fmt.Errorf("%q too many found in ListDBAASServiceTypesResponse: %w", name, ErrConflict)
7468 }
7469
7470 return DBAASServiceType{}, fmt.Errorf("%q not found in ListDBAASServiceTypesResponse: %w", name, ErrNotFound)
7471 }
7472
7473 // List available service types for DBaaS
7474 func (c Client) ListDBAASServiceTypes(ctx context.Context) (*ListDBAASServiceTypesResponse, error) {
7475 path := "/dbaas-service-type"
7476
7477 request, err := http.NewRequestWithContext(ctx, "GET", c.serverEndpoint+path, nil)
7478 if err != nil {
7479 return nil, fmt.Errorf("ListDBAASServiceTypes: new request: %w", err)
7480 }
7481
7482 request.Header.Add("User-Agent", c.getUserAgent())
7483
7484 if err := c.executeRequestInterceptors(ctx, request); err != nil {
7485 return nil, fmt.Errorf("ListDBAASServiceTypes: execute request editors: %w", err)
7486 }
7487
7488 if err := c.signRequest(request); err != nil {
7489 return nil, fmt.Errorf("ListDBAASServiceTypes: sign request: %w", err)
7490 }
7491
7492 if c.trace {
7493 dumpRequest(request, "list-dbaas-service-types")
7494 }
7495
7496 response, err := c.httpClient.Do(request)
7497 if err != nil {
7498 return nil, fmt.Errorf("ListDBAASServiceTypes: http client do: %w", err)
7499 }
7500
7501 if c.trace {
7502 dumpResponse(response)
7503 }
7504
7505 if err := handleHTTPErrorResp(response); err != nil {
7506 return nil, fmt.Errorf("ListDBAASServiceTypes: http response: %w", err)
7507 }
7508
7509 bodyresp := new(ListDBAASServiceTypesResponse)
7510 if err := prepareJSONResponse(response, bodyresp); err != nil {
7511 return nil, fmt.Errorf("ListDBAASServiceTypes: prepare Json response: %w", err)
7512 }
7513
7514 return bodyresp, nil
7515 }
7516
7517 // Get a DBaaS service type
7518 func (c Client) GetDBAASServiceType(ctx context.Context, serviceTypeName string) (*DBAASServiceType, error) {
7519 path := fmt.Sprintf("/dbaas-service-type/%v", serviceTypeName)
7520
7521 request, err := http.NewRequestWithContext(ctx, "GET", c.serverEndpoint+path, nil)
7522 if err != nil {
7523 return nil, fmt.Errorf("GetDBAASServiceType: new request: %w", err)
7524 }
7525
7526 request.Header.Add("User-Agent", c.getUserAgent())
7527
7528 if err := c.executeRequestInterceptors(ctx, request); err != nil {
7529 return nil, fmt.Errorf("GetDBAASServiceType: execute request editors: %w", err)
7530 }
7531
7532 if err := c.signRequest(request); err != nil {
7533 return nil, fmt.Errorf("GetDBAASServiceType: sign request: %w", err)
7534 }
7535
7536 if c.trace {
7537 dumpRequest(request, "get-dbaas-service-type")
7538 }
7539
7540 response, err := c.httpClient.Do(request)
7541 if err != nil {
7542 return nil, fmt.Errorf("GetDBAASServiceType: http client do: %w", err)
7543 }
7544
7545 if c.trace {
7546 dumpResponse(response)
7547 }
7548
7549 if err := handleHTTPErrorResp(response); err != nil {
7550 return nil, fmt.Errorf("GetDBAASServiceType: http response: %w", err)
7551 }
7552
7553 bodyresp := new(DBAASServiceType)
7554 if err := prepareJSONResponse(response, bodyresp); err != nil {
7555 return nil, fmt.Errorf("GetDBAASServiceType: prepare Json response: %w", err)
7556 }
7557
7558 return bodyresp, nil
7559 }
7560
7561 // Delete a DBaaS service
7562 func (c Client) DeleteDBAASService(ctx context.Context, name string) (*Operation, error) {
7563 path := fmt.Sprintf("/dbaas-service/%v", name)
7564
7565 request, err := http.NewRequestWithContext(ctx, "DELETE", c.serverEndpoint+path, nil)
7566 if err != nil {
7567 return nil, fmt.Errorf("DeleteDBAASService: new request: %w", err)
7568 }
7569
7570 request.Header.Add("User-Agent", c.getUserAgent())
7571
7572 if err := c.executeRequestInterceptors(ctx, request); err != nil {
7573 return nil, fmt.Errorf("DeleteDBAASService: execute request editors: %w", err)
7574 }
7575
7576 if err := c.signRequest(request); err != nil {
7577 return nil, fmt.Errorf("DeleteDBAASService: sign request: %w", err)
7578 }
7579
7580 if c.trace {
7581 dumpRequest(request, "delete-dbaas-service")
7582 }
7583
7584 response, err := c.httpClient.Do(request)
7585 if err != nil {
7586 return nil, fmt.Errorf("DeleteDBAASService: http client do: %w", err)
7587 }
7588
7589 if c.trace {
7590 dumpResponse(response)
7591 }
7592
7593 if err := handleHTTPErrorResp(response); err != nil {
7594 return nil, fmt.Errorf("DeleteDBAASService: http response: %w", err)
7595 }
7596
7597 bodyresp := new(Operation)
7598 if err := prepareJSONResponse(response, bodyresp); err != nil {
7599 return nil, fmt.Errorf("DeleteDBAASService: prepare Json response: %w", err)
7600 }
7601
7602 return bodyresp, nil
7603 }
7604
7605 // Grafana configuration values
7606 type GetDBAASSettingsGrafanaResponseSettingsGrafana struct {
7607 AdditionalProperties *bool `json:"additionalProperties,omitempty"`
7608 Properties map[string]any `json:"properties,omitempty"`
7609 Title string `json:"title,omitempty"`
7610 Type string `json:"type,omitempty"`
7611 }
7612
7613 type GetDBAASSettingsGrafanaResponseSettings struct {
7614 // Grafana configuration values
7615 Grafana *GetDBAASSettingsGrafanaResponseSettingsGrafana `json:"grafana,omitempty"`
7616 }
7617
7618 type GetDBAASSettingsGrafanaResponse struct {
7619 Settings *GetDBAASSettingsGrafanaResponseSettings `json:"settings,omitempty"`
7620 }
7621
7622 // Get DBaaS Grafana settings
7623 func (c Client) GetDBAASSettingsGrafana(ctx context.Context) (*GetDBAASSettingsGrafanaResponse, error) {
7624 path := "/dbaas-settings-grafana"
7625
7626 request, err := http.NewRequestWithContext(ctx, "GET", c.serverEndpoint+path, nil)
7627 if err != nil {
7628 return nil, fmt.Errorf("GetDBAASSettingsGrafana: new request: %w", err)
7629 }
7630
7631 request.Header.Add("User-Agent", c.getUserAgent())
7632
7633 if err := c.executeRequestInterceptors(ctx, request); err != nil {
7634 return nil, fmt.Errorf("GetDBAASSettingsGrafana: execute request editors: %w", err)
7635 }
7636
7637 if err := c.signRequest(request); err != nil {
7638 return nil, fmt.Errorf("GetDBAASSettingsGrafana: sign request: %w", err)
7639 }
7640
7641 if c.trace {
7642 dumpRequest(request, "get-dbaas-settings-grafana")
7643 }
7644
7645 response, err := c.httpClient.Do(request)
7646 if err != nil {
7647 return nil, fmt.Errorf("GetDBAASSettingsGrafana: http client do: %w", err)
7648 }
7649
7650 if c.trace {
7651 dumpResponse(response)
7652 }
7653
7654 if err := handleHTTPErrorResp(response); err != nil {
7655 return nil, fmt.Errorf("GetDBAASSettingsGrafana: http response: %w", err)
7656 }
7657
7658 bodyresp := new(GetDBAASSettingsGrafanaResponse)
7659 if err := prepareJSONResponse(response, bodyresp); err != nil {
7660 return nil, fmt.Errorf("GetDBAASSettingsGrafana: prepare Json response: %w", err)
7661 }
7662
7663 return bodyresp, nil
7664 }
7665
7666 // Kafka broker configuration values
7667 type GetDBAASSettingsKafkaResponseSettingsKafka struct {
7668 AdditionalProperties *bool `json:"additionalProperties,omitempty"`
7669 Properties map[string]any `json:"properties,omitempty"`
7670 Title string `json:"title,omitempty"`
7671 Type string `json:"type,omitempty"`
7672 }
7673
7674 // Kafka Connect configuration values
7675 type GetDBAASSettingsKafkaResponseSettingsKafkaConnect struct {
7676 AdditionalProperties *bool `json:"additionalProperties,omitempty"`
7677 Properties map[string]any `json:"properties,omitempty"`
7678 Title string `json:"title,omitempty"`
7679 Type string `json:"type,omitempty"`
7680 }
7681
7682 // Kafka REST configuration
7683 type GetDBAASSettingsKafkaResponseSettingsKafkaRest struct {
7684 AdditionalProperties *bool `json:"additionalProperties,omitempty"`
7685 Properties map[string]any `json:"properties,omitempty"`
7686 Title string `json:"title,omitempty"`
7687 Type string `json:"type,omitempty"`
7688 }
7689
7690 // Schema Registry configuration
7691 type GetDBAASSettingsKafkaResponseSettingsSchemaRegistry struct {
7692 AdditionalProperties *bool `json:"additionalProperties,omitempty"`
7693 Properties map[string]any `json:"properties,omitempty"`
7694 Title string `json:"title,omitempty"`
7695 Type string `json:"type,omitempty"`
7696 }
7697
7698 type GetDBAASSettingsKafkaResponseSettings struct {
7699 // Kafka broker configuration values
7700 Kafka *GetDBAASSettingsKafkaResponseSettingsKafka `json:"kafka,omitempty"`
7701 // Kafka Connect configuration values
7702 KafkaConnect *GetDBAASSettingsKafkaResponseSettingsKafkaConnect `json:"kafka-connect,omitempty"`
7703 // Kafka REST configuration
7704 KafkaRest *GetDBAASSettingsKafkaResponseSettingsKafkaRest `json:"kafka-rest,omitempty"`
7705 // Schema Registry configuration
7706 SchemaRegistry *GetDBAASSettingsKafkaResponseSettingsSchemaRegistry `json:"schema-registry,omitempty"`
7707 }
7708
7709 type GetDBAASSettingsKafkaResponse struct {
7710 Settings *GetDBAASSettingsKafkaResponseSettings `json:"settings,omitempty"`
7711 }
7712
7713 // Get DBaaS Kafka settings
7714 func (c Client) GetDBAASSettingsKafka(ctx context.Context) (*GetDBAASSettingsKafkaResponse, error) {
7715 path := "/dbaas-settings-kafka"
7716
7717 request, err := http.NewRequestWithContext(ctx, "GET", c.serverEndpoint+path, nil)
7718 if err != nil {
7719 return nil, fmt.Errorf("GetDBAASSettingsKafka: new request: %w", err)
7720 }
7721
7722 request.Header.Add("User-Agent", c.getUserAgent())
7723
7724 if err := c.executeRequestInterceptors(ctx, request); err != nil {
7725 return nil, fmt.Errorf("GetDBAASSettingsKafka: execute request editors: %w", err)
7726 }
7727
7728 if err := c.signRequest(request); err != nil {
7729 return nil, fmt.Errorf("GetDBAASSettingsKafka: sign request: %w", err)
7730 }
7731
7732 if c.trace {
7733 dumpRequest(request, "get-dbaas-settings-kafka")
7734 }
7735
7736 response, err := c.httpClient.Do(request)
7737 if err != nil {
7738 return nil, fmt.Errorf("GetDBAASSettingsKafka: http client do: %w", err)
7739 }
7740
7741 if c.trace {
7742 dumpResponse(response)
7743 }
7744
7745 if err := handleHTTPErrorResp(response); err != nil {
7746 return nil, fmt.Errorf("GetDBAASSettingsKafka: http response: %w", err)
7747 }
7748
7749 bodyresp := new(GetDBAASSettingsKafkaResponse)
7750 if err := prepareJSONResponse(response, bodyresp); err != nil {
7751 return nil, fmt.Errorf("GetDBAASSettingsKafka: prepare Json response: %w", err)
7752 }
7753
7754 return bodyresp, nil
7755 }
7756
7757 // mysql.conf configuration values
7758 type GetDBAASSettingsMysqlResponseSettingsMysql struct {
7759 AdditionalProperties *bool `json:"additionalProperties,omitempty"`
7760 Properties map[string]any `json:"properties,omitempty"`
7761 Title string `json:"title,omitempty"`
7762 Type string `json:"type,omitempty"`
7763 }
7764
7765 type GetDBAASSettingsMysqlResponseSettings struct {
7766 // mysql.conf configuration values
7767 Mysql *GetDBAASSettingsMysqlResponseSettingsMysql `json:"mysql,omitempty"`
7768 }
7769
7770 type GetDBAASSettingsMysqlResponse struct {
7771 Settings *GetDBAASSettingsMysqlResponseSettings `json:"settings,omitempty"`
7772 }
7773
7774 // Get DBaaS MySQL settings
7775 func (c Client) GetDBAASSettingsMysql(ctx context.Context) (*GetDBAASSettingsMysqlResponse, error) {
7776 path := "/dbaas-settings-mysql"
7777
7778 request, err := http.NewRequestWithContext(ctx, "GET", c.serverEndpoint+path, nil)
7779 if err != nil {
7780 return nil, fmt.Errorf("GetDBAASSettingsMysql: new request: %w", err)
7781 }
7782
7783 request.Header.Add("User-Agent", c.getUserAgent())
7784
7785 if err := c.executeRequestInterceptors(ctx, request); err != nil {
7786 return nil, fmt.Errorf("GetDBAASSettingsMysql: execute request editors: %w", err)
7787 }
7788
7789 if err := c.signRequest(request); err != nil {
7790 return nil, fmt.Errorf("GetDBAASSettingsMysql: sign request: %w", err)
7791 }
7792
7793 if c.trace {
7794 dumpRequest(request, "get-dbaas-settings-mysql")
7795 }
7796
7797 response, err := c.httpClient.Do(request)
7798 if err != nil {
7799 return nil, fmt.Errorf("GetDBAASSettingsMysql: http client do: %w", err)
7800 }
7801
7802 if c.trace {
7803 dumpResponse(response)
7804 }
7805
7806 if err := handleHTTPErrorResp(response); err != nil {
7807 return nil, fmt.Errorf("GetDBAASSettingsMysql: http response: %w", err)
7808 }
7809
7810 bodyresp := new(GetDBAASSettingsMysqlResponse)
7811 if err := prepareJSONResponse(response, bodyresp); err != nil {
7812 return nil, fmt.Errorf("GetDBAASSettingsMysql: prepare Json response: %w", err)
7813 }
7814
7815 return bodyresp, nil
7816 }
7817
7818 // OpenSearch configuration values
7819 type GetDBAASSettingsOpensearchResponseSettingsOpensearch struct {
7820 AdditionalProperties *bool `json:"additionalProperties,omitempty"`
7821 Properties map[string]any `json:"properties,omitempty"`
7822 Title string `json:"title,omitempty"`
7823 Type string `json:"type,omitempty"`
7824 }
7825
7826 type GetDBAASSettingsOpensearchResponseSettings struct {
7827 // OpenSearch configuration values
7828 Opensearch *GetDBAASSettingsOpensearchResponseSettingsOpensearch `json:"opensearch,omitempty"`
7829 }
7830
7831 type GetDBAASSettingsOpensearchResponse struct {
7832 Settings *GetDBAASSettingsOpensearchResponseSettings `json:"settings,omitempty"`
7833 }
7834
7835 // Get DBaaS OpenSearch settings
7836 func (c Client) GetDBAASSettingsOpensearch(ctx context.Context) (*GetDBAASSettingsOpensearchResponse, error) {
7837 path := "/dbaas-settings-opensearch"
7838
7839 request, err := http.NewRequestWithContext(ctx, "GET", c.serverEndpoint+path, nil)
7840 if err != nil {
7841 return nil, fmt.Errorf("GetDBAASSettingsOpensearch: new request: %w", err)
7842 }
7843
7844 request.Header.Add("User-Agent", c.getUserAgent())
7845
7846 if err := c.executeRequestInterceptors(ctx, request); err != nil {
7847 return nil, fmt.Errorf("GetDBAASSettingsOpensearch: execute request editors: %w", err)
7848 }
7849
7850 if err := c.signRequest(request); err != nil {
7851 return nil, fmt.Errorf("GetDBAASSettingsOpensearch: sign request: %w", err)
7852 }
7853
7854 if c.trace {
7855 dumpRequest(request, "get-dbaas-settings-opensearch")
7856 }
7857
7858 response, err := c.httpClient.Do(request)
7859 if err != nil {
7860 return nil, fmt.Errorf("GetDBAASSettingsOpensearch: http client do: %w", err)
7861 }
7862
7863 if c.trace {
7864 dumpResponse(response)
7865 }
7866
7867 if err := handleHTTPErrorResp(response); err != nil {
7868 return nil, fmt.Errorf("GetDBAASSettingsOpensearch: http response: %w", err)
7869 }
7870
7871 bodyresp := new(GetDBAASSettingsOpensearchResponse)
7872 if err := prepareJSONResponse(response, bodyresp); err != nil {
7873 return nil, fmt.Errorf("GetDBAASSettingsOpensearch: prepare Json response: %w", err)
7874 }
7875
7876 return bodyresp, nil
7877 }
7878
7879 // postgresql.conf configuration values
7880 type GetDBAASSettingsPGResponseSettingsPG struct {
7881 AdditionalProperties *bool `json:"additionalProperties,omitempty"`
7882 Properties map[string]any `json:"properties,omitempty"`
7883 Title string `json:"title,omitempty"`
7884 Type string `json:"type,omitempty"`
7885 }
7886
7887 // PGBouncer connection pooling settings
7888 type GetDBAASSettingsPGResponseSettingsPgbouncer struct {
7889 AdditionalProperties *bool `json:"additionalProperties,omitempty"`
7890 Properties map[string]any `json:"properties,omitempty"`
7891 Title string `json:"title,omitempty"`
7892 Type string `json:"type,omitempty"`
7893 }
7894
7895 // PGLookout settings
7896 type GetDBAASSettingsPGResponseSettingsPglookout struct {
7897 AdditionalProperties *bool `json:"additionalProperties,omitempty"`
7898 Properties map[string]any `json:"properties,omitempty"`
7899 Title string `json:"title,omitempty"`
7900 Type string `json:"type,omitempty"`
7901 }
7902
7903 // TimescaleDB extension configuration values
7904 type GetDBAASSettingsPGResponseSettingsTimescaledb struct {
7905 AdditionalProperties *bool `json:"additionalProperties,omitempty"`
7906 Properties map[string]any `json:"properties,omitempty"`
7907 Title string `json:"title,omitempty"`
7908 Type string `json:"type,omitempty"`
7909 }
7910
7911 type GetDBAASSettingsPGResponseSettings struct {
7912 // postgresql.conf configuration values
7913 PG *GetDBAASSettingsPGResponseSettingsPG `json:"pg,omitempty"`
7914 // PGBouncer connection pooling settings
7915 Pgbouncer *GetDBAASSettingsPGResponseSettingsPgbouncer `json:"pgbouncer,omitempty"`
7916 // PGLookout settings
7917 Pglookout *GetDBAASSettingsPGResponseSettingsPglookout `json:"pglookout,omitempty"`
7918 // TimescaleDB extension configuration values
7919 Timescaledb *GetDBAASSettingsPGResponseSettingsTimescaledb `json:"timescaledb,omitempty"`
7920 }
7921
7922 type GetDBAASSettingsPGResponse struct {
7923 Settings *GetDBAASSettingsPGResponseSettings `json:"settings,omitempty"`
7924 }
7925
7926 // Get DBaaS PostgreSQL settings
7927 func (c Client) GetDBAASSettingsPG(ctx context.Context) (*GetDBAASSettingsPGResponse, error) {
7928 path := "/dbaas-settings-pg"
7929
7930 request, err := http.NewRequestWithContext(ctx, "GET", c.serverEndpoint+path, nil)
7931 if err != nil {
7932 return nil, fmt.Errorf("GetDBAASSettingsPG: new request: %w", err)
7933 }
7934
7935 request.Header.Add("User-Agent", c.getUserAgent())
7936
7937 if err := c.executeRequestInterceptors(ctx, request); err != nil {
7938 return nil, fmt.Errorf("GetDBAASSettingsPG: execute request editors: %w", err)
7939 }
7940
7941 if err := c.signRequest(request); err != nil {
7942 return nil, fmt.Errorf("GetDBAASSettingsPG: sign request: %w", err)
7943 }
7944
7945 if c.trace {
7946 dumpRequest(request, "get-dbaas-settings-pg")
7947 }
7948
7949 response, err := c.httpClient.Do(request)
7950 if err != nil {
7951 return nil, fmt.Errorf("GetDBAASSettingsPG: http client do: %w", err)
7952 }
7953
7954 if c.trace {
7955 dumpResponse(response)
7956 }
7957
7958 if err := handleHTTPErrorResp(response); err != nil {
7959 return nil, fmt.Errorf("GetDBAASSettingsPG: http response: %w", err)
7960 }
7961
7962 bodyresp := new(GetDBAASSettingsPGResponse)
7963 if err := prepareJSONResponse(response, bodyresp); err != nil {
7964 return nil, fmt.Errorf("GetDBAASSettingsPG: prepare Json response: %w", err)
7965 }
7966
7967 return bodyresp, nil
7968 }
7969
7970 // Thanos configuration values
7971 type GetDBAASSettingsThanosResponseSettingsThanos struct {
7972 AdditionalProperties *bool `json:"additionalProperties,omitempty"`
7973 Properties map[string]any `json:"properties,omitempty"`
7974 Title string `json:"title,omitempty"`
7975 Type string `json:"type,omitempty"`
7976 }
7977
7978 type GetDBAASSettingsThanosResponseSettings struct {
7979 // Thanos configuration values
7980 Thanos *GetDBAASSettingsThanosResponseSettingsThanos `json:"thanos,omitempty"`
7981 }
7982
7983 type GetDBAASSettingsThanosResponse struct {
7984 Settings *GetDBAASSettingsThanosResponseSettings `json:"settings,omitempty"`
7985 }
7986
7987 // Get DBaaS Thanos settings
7988 func (c Client) GetDBAASSettingsThanos(ctx context.Context) (*GetDBAASSettingsThanosResponse, error) {
7989 path := "/dbaas-settings-thanos"
7990
7991 request, err := http.NewRequestWithContext(ctx, "GET", c.serverEndpoint+path, nil)
7992 if err != nil {
7993 return nil, fmt.Errorf("GetDBAASSettingsThanos: new request: %w", err)
7994 }
7995
7996 request.Header.Add("User-Agent", c.getUserAgent())
7997
7998 if err := c.executeRequestInterceptors(ctx, request); err != nil {
7999 return nil, fmt.Errorf("GetDBAASSettingsThanos: execute request editors: %w", err)
8000 }
8001
8002 if err := c.signRequest(request); err != nil {
8003 return nil, fmt.Errorf("GetDBAASSettingsThanos: sign request: %w", err)
8004 }
8005
8006 if c.trace {
8007 dumpRequest(request, "get-dbaas-settings-thanos")
8008 }
8009
8010 response, err := c.httpClient.Do(request)
8011 if err != nil {
8012 return nil, fmt.Errorf("GetDBAASSettingsThanos: http client do: %w", err)
8013 }
8014
8015 if c.trace {
8016 dumpResponse(response)
8017 }
8018
8019 if err := handleHTTPErrorResp(response); err != nil {
8020 return nil, fmt.Errorf("GetDBAASSettingsThanos: http response: %w", err)
8021 }
8022
8023 bodyresp := new(GetDBAASSettingsThanosResponse)
8024 if err := prepareJSONResponse(response, bodyresp); err != nil {
8025 return nil, fmt.Errorf("GetDBAASSettingsThanos: prepare Json response: %w", err)
8026 }
8027
8028 return bodyresp, nil
8029 }
8030
8031 // Valkey configuration values
8032 type GetDBAASSettingsValkeyResponseSettingsValkey struct {
8033 AdditionalProperties *bool `json:"additionalProperties,omitempty"`
8034 Properties map[string]any `json:"properties,omitempty"`
8035 Title string `json:"title,omitempty"`
8036 Type string `json:"type,omitempty"`
8037 }
8038
8039 type GetDBAASSettingsValkeyResponseSettings struct {
8040 // Valkey configuration values
8041 Valkey *GetDBAASSettingsValkeyResponseSettingsValkey `json:"valkey,omitempty"`
8042 }
8043
8044 type GetDBAASSettingsValkeyResponse struct {
8045 Settings *GetDBAASSettingsValkeyResponseSettings `json:"settings,omitempty"`
8046 }
8047
8048 // Returns the default settings for Valkey.
8049 func (c Client) GetDBAASSettingsValkey(ctx context.Context) (*GetDBAASSettingsValkeyResponse, error) {
8050 path := "/dbaas-settings-valkey"
8051
8052 request, err := http.NewRequestWithContext(ctx, "GET", c.serverEndpoint+path, nil)
8053 if err != nil {
8054 return nil, fmt.Errorf("GetDBAASSettingsValkey: new request: %w", err)
8055 }
8056
8057 request.Header.Add("User-Agent", c.getUserAgent())
8058
8059 if err := c.executeRequestInterceptors(ctx, request); err != nil {
8060 return nil, fmt.Errorf("GetDBAASSettingsValkey: execute request editors: %w", err)
8061 }
8062
8063 if err := c.signRequest(request); err != nil {
8064 return nil, fmt.Errorf("GetDBAASSettingsValkey: sign request: %w", err)
8065 }
8066
8067 if c.trace {
8068 dumpRequest(request, "get-dbaas-settings-valkey")
8069 }
8070
8071 response, err := c.httpClient.Do(request)
8072 if err != nil {
8073 return nil, fmt.Errorf("GetDBAASSettingsValkey: http client do: %w", err)
8074 }
8075
8076 if c.trace {
8077 dumpResponse(response)
8078 }
8079
8080 if err := handleHTTPErrorResp(response); err != nil {
8081 return nil, fmt.Errorf("GetDBAASSettingsValkey: http response: %w", err)
8082 }
8083
8084 bodyresp := new(GetDBAASSettingsValkeyResponse)
8085 if err := prepareJSONResponse(response, bodyresp); err != nil {
8086 return nil, fmt.Errorf("GetDBAASSettingsValkey: prepare Json response: %w", err)
8087 }
8088
8089 return bodyresp, nil
8090 }
8091
8092 type CreateDBAASTaskMigrationCheckRequest struct {
8093 // Comma-separated list of databases, which should be ignored during migration (supported by MySQL only at the moment)
8094 IgnoreDbs string `json:"ignore-dbs,omitempty" validate:"omitempty,gte=1,lte=2048"`
8095 Method EnumMigrationMethod `json:"method,omitempty"`
8096 // Service URI of the source MySQL or PostgreSQL database with admin credentials.
8097 SourceServiceURI string `json:"source-service-uri" validate:"required,gte=1,lte=512"`
8098 }
8099
8100 // Create a DBaaS task to check migration
8101 func (c Client) CreateDBAASTaskMigrationCheck(ctx context.Context, service string, req CreateDBAASTaskMigrationCheckRequest) (*Operation, error) {
8102 path := fmt.Sprintf("/dbaas-task-migration-check/%v", service)
8103
8104 body, err := prepareJSONBody(req)
8105 if err != nil {
8106 return nil, fmt.Errorf("CreateDBAASTaskMigrationCheck: prepare Json body: %w", err)
8107 }
8108
8109 request, err := http.NewRequestWithContext(ctx, "POST", c.serverEndpoint+path, body)
8110 if err != nil {
8111 return nil, fmt.Errorf("CreateDBAASTaskMigrationCheck: new request: %w", err)
8112 }
8113
8114 request.Header.Add("User-Agent", c.getUserAgent())
8115
8116 request.Header.Add("Content-Type", "application/json")
8117
8118 if err := c.executeRequestInterceptors(ctx, request); err != nil {
8119 return nil, fmt.Errorf("CreateDBAASTaskMigrationCheck: execute request editors: %w", err)
8120 }
8121
8122 if err := c.signRequest(request); err != nil {
8123 return nil, fmt.Errorf("CreateDBAASTaskMigrationCheck: sign request: %w", err)
8124 }
8125
8126 if c.trace {
8127 dumpRequest(request, "create-dbaas-task-migration-check")
8128 }
8129
8130 response, err := c.httpClient.Do(request)
8131 if err != nil {
8132 return nil, fmt.Errorf("CreateDBAASTaskMigrationCheck: http client do: %w", err)
8133 }
8134
8135 if c.trace {
8136 dumpResponse(response)
8137 }
8138
8139 if err := handleHTTPErrorResp(response); err != nil {
8140 return nil, fmt.Errorf("CreateDBAASTaskMigrationCheck: http response: %w", err)
8141 }
8142
8143 bodyresp := new(Operation)
8144 if err := prepareJSONResponse(response, bodyresp); err != nil {
8145 return nil, fmt.Errorf("CreateDBAASTaskMigrationCheck: prepare Json response: %w", err)
8146 }
8147
8148 return bodyresp, nil
8149 }
8150
8151 // Get a DBaaS task
8152 func (c Client) GetDBAASTask(ctx context.Context, service string, id UUID) (*DBAASTask, error) {
8153 path := fmt.Sprintf("/dbaas-task/%v/%v", service, id)
8154
8155 request, err := http.NewRequestWithContext(ctx, "GET", c.serverEndpoint+path, nil)
8156 if err != nil {
8157 return nil, fmt.Errorf("GetDBAASTask: new request: %w", err)
8158 }
8159
8160 request.Header.Add("User-Agent", c.getUserAgent())
8161
8162 if err := c.executeRequestInterceptors(ctx, request); err != nil {
8163 return nil, fmt.Errorf("GetDBAASTask: execute request editors: %w", err)
8164 }
8165
8166 if err := c.signRequest(request); err != nil {
8167 return nil, fmt.Errorf("GetDBAASTask: sign request: %w", err)
8168 }
8169
8170 if c.trace {
8171 dumpRequest(request, "get-dbaas-task")
8172 }
8173
8174 response, err := c.httpClient.Do(request)
8175 if err != nil {
8176 return nil, fmt.Errorf("GetDBAASTask: http client do: %w", err)
8177 }
8178
8179 if c.trace {
8180 dumpResponse(response)
8181 }
8182
8183 if err := handleHTTPErrorResp(response); err != nil {
8184 return nil, fmt.Errorf("GetDBAASTask: http response: %w", err)
8185 }
8186
8187 bodyresp := new(DBAASTask)
8188 if err := prepareJSONResponse(response, bodyresp); err != nil {
8189 return nil, fmt.Errorf("GetDBAASTask: prepare Json response: %w", err)
8190 }
8191
8192 return bodyresp, nil
8193 }
8194
8195 func (c Client) DeleteDBAASServiceThanos(ctx context.Context, name string) (*Operation, error) {
8196 path := fmt.Sprintf("/dbaas-thanos/%v", name)
8197
8198 request, err := http.NewRequestWithContext(ctx, "DELETE", c.serverEndpoint+path, nil)
8199 if err != nil {
8200 return nil, fmt.Errorf("DeleteDBAASServiceThanos: new request: %w", err)
8201 }
8202
8203 request.Header.Add("User-Agent", c.getUserAgent())
8204
8205 if err := c.executeRequestInterceptors(ctx, request); err != nil {
8206 return nil, fmt.Errorf("DeleteDBAASServiceThanos: execute request editors: %w", err)
8207 }
8208
8209 if err := c.signRequest(request); err != nil {
8210 return nil, fmt.Errorf("DeleteDBAASServiceThanos: sign request: %w", err)
8211 }
8212
8213 if c.trace {
8214 dumpRequest(request, "delete-dbaas-service-thanos")
8215 }
8216
8217 response, err := c.httpClient.Do(request)
8218 if err != nil {
8219 return nil, fmt.Errorf("DeleteDBAASServiceThanos: http client do: %w", err)
8220 }
8221
8222 if c.trace {
8223 dumpResponse(response)
8224 }
8225
8226 if err := handleHTTPErrorResp(response); err != nil {
8227 return nil, fmt.Errorf("DeleteDBAASServiceThanos: http response: %w", err)
8228 }
8229
8230 bodyresp := new(Operation)
8231 if err := prepareJSONResponse(response, bodyresp); err != nil {
8232 return nil, fmt.Errorf("DeleteDBAASServiceThanos: prepare Json response: %w", err)
8233 }
8234
8235 return bodyresp, nil
8236 }
8237
8238 // Get a DBaaS Thanos service
8239 func (c Client) GetDBAASServiceThanos(ctx context.Context, name string) (*DBAASServiceThanos, error) {
8240 path := fmt.Sprintf("/dbaas-thanos/%v", name)
8241
8242 request, err := http.NewRequestWithContext(ctx, "GET", c.serverEndpoint+path, nil)
8243 if err != nil {
8244 return nil, fmt.Errorf("GetDBAASServiceThanos: new request: %w", err)
8245 }
8246
8247 request.Header.Add("User-Agent", c.getUserAgent())
8248
8249 if err := c.executeRequestInterceptors(ctx, request); err != nil {
8250 return nil, fmt.Errorf("GetDBAASServiceThanos: execute request editors: %w", err)
8251 }
8252
8253 if err := c.signRequest(request); err != nil {
8254 return nil, fmt.Errorf("GetDBAASServiceThanos: sign request: %w", err)
8255 }
8256
8257 if c.trace {
8258 dumpRequest(request, "get-dbaas-service-thanos")
8259 }
8260
8261 response, err := c.httpClient.Do(request)
8262 if err != nil {
8263 return nil, fmt.Errorf("GetDBAASServiceThanos: http client do: %w", err)
8264 }
8265
8266 if c.trace {
8267 dumpResponse(response)
8268 }
8269
8270 if err := handleHTTPErrorResp(response); err != nil {
8271 return nil, fmt.Errorf("GetDBAASServiceThanos: http response: %w", err)
8272 }
8273
8274 bodyresp := new(DBAASServiceThanos)
8275 if err := prepareJSONResponse(response, bodyresp); err != nil {
8276 return nil, fmt.Errorf("GetDBAASServiceThanos: prepare Json response: %w", err)
8277 }
8278
8279 return bodyresp, nil
8280 }
8281
8282 type CreateDBAASServiceThanosRequestMaintenanceDow string
8283
8284 const (
8285 CreateDBAASServiceThanosRequestMaintenanceDowSaturday CreateDBAASServiceThanosRequestMaintenanceDow = "saturday"
8286 CreateDBAASServiceThanosRequestMaintenanceDowTuesday CreateDBAASServiceThanosRequestMaintenanceDow = "tuesday"
8287 CreateDBAASServiceThanosRequestMaintenanceDowNever CreateDBAASServiceThanosRequestMaintenanceDow = "never"
8288 CreateDBAASServiceThanosRequestMaintenanceDowWednesday CreateDBAASServiceThanosRequestMaintenanceDow = "wednesday"
8289 CreateDBAASServiceThanosRequestMaintenanceDowSunday CreateDBAASServiceThanosRequestMaintenanceDow = "sunday"
8290 CreateDBAASServiceThanosRequestMaintenanceDowFriday CreateDBAASServiceThanosRequestMaintenanceDow = "friday"
8291 CreateDBAASServiceThanosRequestMaintenanceDowMonday CreateDBAASServiceThanosRequestMaintenanceDow = "monday"
8292 CreateDBAASServiceThanosRequestMaintenanceDowThursday CreateDBAASServiceThanosRequestMaintenanceDow = "thursday"
8293 )
8294
8295 // Automatic maintenance settings
8296 type CreateDBAASServiceThanosRequestMaintenance struct {
8297 // Day of week for installing updates
8298 Dow CreateDBAASServiceThanosRequestMaintenanceDow `json:"dow" validate:"required"`
8299 // Time for installing updates, UTC
8300 Time string `json:"time" validate:"required,gte=8,lte=8"`
8301 }
8302
8303 type CreateDBAASServiceThanosRequest struct {
8304 // Allowed CIDR address blocks for incoming connections
8305 IPFilter []string `json:"ip-filter,omitempty"`
8306 // Automatic maintenance settings
8307 Maintenance *CreateDBAASServiceThanosRequestMaintenance `json:"maintenance,omitempty"`
8308 // Subscription plan
8309 Plan string `json:"plan" validate:"required,gte=1,lte=128"`
8310 // Service is protected against termination and powering off
8311 TerminationProtection *bool `json:"termination-protection,omitempty"`
8312 // Thanos settings
8313 ThanosSettings *JSONSchemaThanos `json:"thanos-settings,omitempty"`
8314 }
8315
8316 // Create a DBaaS Thanos service
8317 func (c Client) CreateDBAASServiceThanos(ctx context.Context, name string, req CreateDBAASServiceThanosRequest) (*Operation, error) {
8318 path := fmt.Sprintf("/dbaas-thanos/%v", name)
8319
8320 body, err := prepareJSONBody(req)
8321 if err != nil {
8322 return nil, fmt.Errorf("CreateDBAASServiceThanos: prepare Json body: %w", err)
8323 }
8324
8325 request, err := http.NewRequestWithContext(ctx, "POST", c.serverEndpoint+path, body)
8326 if err != nil {
8327 return nil, fmt.Errorf("CreateDBAASServiceThanos: new request: %w", err)
8328 }
8329
8330 request.Header.Add("User-Agent", c.getUserAgent())
8331
8332 request.Header.Add("Content-Type", "application/json")
8333
8334 if err := c.executeRequestInterceptors(ctx, request); err != nil {
8335 return nil, fmt.Errorf("CreateDBAASServiceThanos: execute request editors: %w", err)
8336 }
8337
8338 if err := c.signRequest(request); err != nil {
8339 return nil, fmt.Errorf("CreateDBAASServiceThanos: sign request: %w", err)
8340 }
8341
8342 if c.trace {
8343 dumpRequest(request, "create-dbaas-service-thanos")
8344 }
8345
8346 response, err := c.httpClient.Do(request)
8347 if err != nil {
8348 return nil, fmt.Errorf("CreateDBAASServiceThanos: http client do: %w", err)
8349 }
8350
8351 if c.trace {
8352 dumpResponse(response)
8353 }
8354
8355 if err := handleHTTPErrorResp(response); err != nil {
8356 return nil, fmt.Errorf("CreateDBAASServiceThanos: http response: %w", err)
8357 }
8358
8359 bodyresp := new(Operation)
8360 if err := prepareJSONResponse(response, bodyresp); err != nil {
8361 return nil, fmt.Errorf("CreateDBAASServiceThanos: prepare Json response: %w", err)
8362 }
8363
8364 return bodyresp, nil
8365 }
8366
8367 type UpdateDBAASServiceThanosRequestMaintenanceDow string
8368
8369 const (
8370 UpdateDBAASServiceThanosRequestMaintenanceDowSaturday UpdateDBAASServiceThanosRequestMaintenanceDow = "saturday"
8371 UpdateDBAASServiceThanosRequestMaintenanceDowTuesday UpdateDBAASServiceThanosRequestMaintenanceDow = "tuesday"
8372 UpdateDBAASServiceThanosRequestMaintenanceDowNever UpdateDBAASServiceThanosRequestMaintenanceDow = "never"
8373 UpdateDBAASServiceThanosRequestMaintenanceDowWednesday UpdateDBAASServiceThanosRequestMaintenanceDow = "wednesday"
8374 UpdateDBAASServiceThanosRequestMaintenanceDowSunday UpdateDBAASServiceThanosRequestMaintenanceDow = "sunday"
8375 UpdateDBAASServiceThanosRequestMaintenanceDowFriday UpdateDBAASServiceThanosRequestMaintenanceDow = "friday"
8376 UpdateDBAASServiceThanosRequestMaintenanceDowMonday UpdateDBAASServiceThanosRequestMaintenanceDow = "monday"
8377 UpdateDBAASServiceThanosRequestMaintenanceDowThursday UpdateDBAASServiceThanosRequestMaintenanceDow = "thursday"
8378 )
8379
8380 // Automatic maintenance settings
8381 type UpdateDBAASServiceThanosRequestMaintenance struct {
8382 // Day of week for installing updates
8383 Dow UpdateDBAASServiceThanosRequestMaintenanceDow `json:"dow" validate:"required"`
8384 // Time for installing updates, UTC
8385 Time string `json:"time" validate:"required,gte=8,lte=8"`
8386 }
8387
8388 type UpdateDBAASServiceThanosRequest struct {
8389 // Allowed CIDR address blocks for incoming connections
8390 IPFilter []string `json:"ip-filter,omitempty"`
8391 // Automatic maintenance settings
8392 Maintenance *UpdateDBAASServiceThanosRequestMaintenance `json:"maintenance,omitempty"`
8393 // Subscription plan
8394 Plan string `json:"plan,omitempty" validate:"omitempty,gte=1,lte=128"`
8395 // Service is protected against termination and powering off
8396 TerminationProtection *bool `json:"termination-protection,omitempty"`
8397 // Thanos settings
8398 ThanosSettings *JSONSchemaThanos `json:"thanos-settings,omitempty"`
8399 }
8400
8401 // Update a DBaaS Thanos service
8402 func (c Client) UpdateDBAASServiceThanos(ctx context.Context, name string, req UpdateDBAASServiceThanosRequest) (*Operation, error) {
8403 path := fmt.Sprintf("/dbaas-thanos/%v", name)
8404
8405 body, err := prepareJSONBody(req)
8406 if err != nil {
8407 return nil, fmt.Errorf("UpdateDBAASServiceThanos: prepare Json body: %w", err)
8408 }
8409
8410 request, err := http.NewRequestWithContext(ctx, "PUT", c.serverEndpoint+path, body)
8411 if err != nil {
8412 return nil, fmt.Errorf("UpdateDBAASServiceThanos: new request: %w", err)
8413 }
8414
8415 request.Header.Add("User-Agent", c.getUserAgent())
8416
8417 request.Header.Add("Content-Type", "application/json")
8418
8419 if err := c.executeRequestInterceptors(ctx, request); err != nil {
8420 return nil, fmt.Errorf("UpdateDBAASServiceThanos: execute request editors: %w", err)
8421 }
8422
8423 if err := c.signRequest(request); err != nil {
8424 return nil, fmt.Errorf("UpdateDBAASServiceThanos: sign request: %w", err)
8425 }
8426
8427 if c.trace {
8428 dumpRequest(request, "update-dbaas-service-thanos")
8429 }
8430
8431 response, err := c.httpClient.Do(request)
8432 if err != nil {
8433 return nil, fmt.Errorf("UpdateDBAASServiceThanos: http client do: %w", err)
8434 }
8435
8436 if c.trace {
8437 dumpResponse(response)
8438 }
8439
8440 if err := handleHTTPErrorResp(response); err != nil {
8441 return nil, fmt.Errorf("UpdateDBAASServiceThanos: http response: %w", err)
8442 }
8443
8444 bodyresp := new(Operation)
8445 if err := prepareJSONResponse(response, bodyresp); err != nil {
8446 return nil, fmt.Errorf("UpdateDBAASServiceThanos: prepare Json response: %w", err)
8447 }
8448
8449 return bodyresp, nil
8450 }
8451
8452 func (c Client) StartDBAASThanosMaintenance(ctx context.Context, name string) (*Operation, error) {
8453 path := fmt.Sprintf("/dbaas-thanos/%v/maintenance/start", name)
8454
8455 request, err := http.NewRequestWithContext(ctx, "PUT", c.serverEndpoint+path, nil)
8456 if err != nil {
8457 return nil, fmt.Errorf("StartDBAASThanosMaintenance: new request: %w", err)
8458 }
8459
8460 request.Header.Add("User-Agent", c.getUserAgent())
8461
8462 if err := c.executeRequestInterceptors(ctx, request); err != nil {
8463 return nil, fmt.Errorf("StartDBAASThanosMaintenance: execute request editors: %w", err)
8464 }
8465
8466 if err := c.signRequest(request); err != nil {
8467 return nil, fmt.Errorf("StartDBAASThanosMaintenance: sign request: %w", err)
8468 }
8469
8470 if c.trace {
8471 dumpRequest(request, "start-dbaas-thanos-maintenance")
8472 }
8473
8474 response, err := c.httpClient.Do(request)
8475 if err != nil {
8476 return nil, fmt.Errorf("StartDBAASThanosMaintenance: http client do: %w", err)
8477 }
8478
8479 if c.trace {
8480 dumpResponse(response)
8481 }
8482
8483 if err := handleHTTPErrorResp(response); err != nil {
8484 return nil, fmt.Errorf("StartDBAASThanosMaintenance: http response: %w", err)
8485 }
8486
8487 bodyresp := new(Operation)
8488 if err := prepareJSONResponse(response, bodyresp); err != nil {
8489 return nil, fmt.Errorf("StartDBAASThanosMaintenance: prepare Json response: %w", err)
8490 }
8491
8492 return bodyresp, nil
8493 }
8494
8495 func (c Client) RevealDBAASThanosUserPassword(ctx context.Context, serviceName string, username string) (*DBAASUserThanosSecrets, error) {
8496 path := fmt.Sprintf("/dbaas-thanos/%v/user/%v/password/reveal", serviceName, username)
8497
8498 request, err := http.NewRequestWithContext(ctx, "GET", c.serverEndpoint+path, nil)
8499 if err != nil {
8500 return nil, fmt.Errorf("RevealDBAASThanosUserPassword: new request: %w", err)
8501 }
8502
8503 request.Header.Add("User-Agent", c.getUserAgent())
8504
8505 if err := c.executeRequestInterceptors(ctx, request); err != nil {
8506 return nil, fmt.Errorf("RevealDBAASThanosUserPassword: execute request editors: %w", err)
8507 }
8508
8509 if err := c.signRequest(request); err != nil {
8510 return nil, fmt.Errorf("RevealDBAASThanosUserPassword: sign request: %w", err)
8511 }
8512
8513 if c.trace {
8514 dumpRequest(request, "reveal-dbaas-thanos-user-password")
8515 }
8516
8517 response, err := c.httpClient.Do(request)
8518 if err != nil {
8519 return nil, fmt.Errorf("RevealDBAASThanosUserPassword: http client do: %w", err)
8520 }
8521
8522 if c.trace {
8523 dumpResponse(response)
8524 }
8525
8526 if err := handleHTTPErrorResp(response); err != nil {
8527 return nil, fmt.Errorf("RevealDBAASThanosUserPassword: http response: %w", err)
8528 }
8529
8530 bodyresp := new(DBAASUserThanosSecrets)
8531 if err := prepareJSONResponse(response, bodyresp); err != nil {
8532 return nil, fmt.Errorf("RevealDBAASThanosUserPassword: prepare Json response: %w", err)
8533 }
8534
8535 return bodyresp, nil
8536 }
8537
8538 func (c Client) DeleteDBAASServiceValkey(ctx context.Context, name string) (*Operation, error) {
8539 path := fmt.Sprintf("/dbaas-valkey/%v", name)
8540
8541 request, err := http.NewRequestWithContext(ctx, "DELETE", c.serverEndpoint+path, nil)
8542 if err != nil {
8543 return nil, fmt.Errorf("DeleteDBAASServiceValkey: new request: %w", err)
8544 }
8545
8546 request.Header.Add("User-Agent", c.getUserAgent())
8547
8548 if err := c.executeRequestInterceptors(ctx, request); err != nil {
8549 return nil, fmt.Errorf("DeleteDBAASServiceValkey: execute request editors: %w", err)
8550 }
8551
8552 if err := c.signRequest(request); err != nil {
8553 return nil, fmt.Errorf("DeleteDBAASServiceValkey: sign request: %w", err)
8554 }
8555
8556 if c.trace {
8557 dumpRequest(request, "delete-dbaas-service-valkey")
8558 }
8559
8560 response, err := c.httpClient.Do(request)
8561 if err != nil {
8562 return nil, fmt.Errorf("DeleteDBAASServiceValkey: http client do: %w", err)
8563 }
8564
8565 if c.trace {
8566 dumpResponse(response)
8567 }
8568
8569 if err := handleHTTPErrorResp(response); err != nil {
8570 return nil, fmt.Errorf("DeleteDBAASServiceValkey: http response: %w", err)
8571 }
8572
8573 bodyresp := new(Operation)
8574 if err := prepareJSONResponse(response, bodyresp); err != nil {
8575 return nil, fmt.Errorf("DeleteDBAASServiceValkey: prepare Json response: %w", err)
8576 }
8577
8578 return bodyresp, nil
8579 }
8580
8581 // Get a DBaaS Valkey service
8582 func (c Client) GetDBAASServiceValkey(ctx context.Context, name string) (*DBAASServiceValkey, error) {
8583 path := fmt.Sprintf("/dbaas-valkey/%v", name)
8584
8585 request, err := http.NewRequestWithContext(ctx, "GET", c.serverEndpoint+path, nil)
8586 if err != nil {
8587 return nil, fmt.Errorf("GetDBAASServiceValkey: new request: %w", err)
8588 }
8589
8590 request.Header.Add("User-Agent", c.getUserAgent())
8591
8592 if err := c.executeRequestInterceptors(ctx, request); err != nil {
8593 return nil, fmt.Errorf("GetDBAASServiceValkey: execute request editors: %w", err)
8594 }
8595
8596 if err := c.signRequest(request); err != nil {
8597 return nil, fmt.Errorf("GetDBAASServiceValkey: sign request: %w", err)
8598 }
8599
8600 if c.trace {
8601 dumpRequest(request, "get-dbaas-service-valkey")
8602 }
8603
8604 response, err := c.httpClient.Do(request)
8605 if err != nil {
8606 return nil, fmt.Errorf("GetDBAASServiceValkey: http client do: %w", err)
8607 }
8608
8609 if c.trace {
8610 dumpResponse(response)
8611 }
8612
8613 if err := handleHTTPErrorResp(response); err != nil {
8614 return nil, fmt.Errorf("GetDBAASServiceValkey: http response: %w", err)
8615 }
8616
8617 bodyresp := new(DBAASServiceValkey)
8618 if err := prepareJSONResponse(response, bodyresp); err != nil {
8619 return nil, fmt.Errorf("GetDBAASServiceValkey: prepare Json response: %w", err)
8620 }
8621
8622 return bodyresp, nil
8623 }
8624
8625 type CreateDBAASServiceValkeyRequestMaintenanceDow string
8626
8627 const (
8628 CreateDBAASServiceValkeyRequestMaintenanceDowSaturday CreateDBAASServiceValkeyRequestMaintenanceDow = "saturday"
8629 CreateDBAASServiceValkeyRequestMaintenanceDowTuesday CreateDBAASServiceValkeyRequestMaintenanceDow = "tuesday"
8630 CreateDBAASServiceValkeyRequestMaintenanceDowNever CreateDBAASServiceValkeyRequestMaintenanceDow = "never"
8631 CreateDBAASServiceValkeyRequestMaintenanceDowWednesday CreateDBAASServiceValkeyRequestMaintenanceDow = "wednesday"
8632 CreateDBAASServiceValkeyRequestMaintenanceDowSunday CreateDBAASServiceValkeyRequestMaintenanceDow = "sunday"
8633 CreateDBAASServiceValkeyRequestMaintenanceDowFriday CreateDBAASServiceValkeyRequestMaintenanceDow = "friday"
8634 CreateDBAASServiceValkeyRequestMaintenanceDowMonday CreateDBAASServiceValkeyRequestMaintenanceDow = "monday"
8635 CreateDBAASServiceValkeyRequestMaintenanceDowThursday CreateDBAASServiceValkeyRequestMaintenanceDow = "thursday"
8636 )
8637
8638 // Automatic maintenance settings
8639 type CreateDBAASServiceValkeyRequestMaintenance struct {
8640 // Day of week for installing updates
8641 Dow CreateDBAASServiceValkeyRequestMaintenanceDow `json:"dow" validate:"required"`
8642 // Time for installing updates, UTC
8643 Time string `json:"time" validate:"required,gte=8,lte=8"`
8644 }
8645
8646 // Migrate data from existing server
8647 type CreateDBAASServiceValkeyRequestMigration struct {
8648 // Database name for bootstrapping the initial connection
8649 Dbname string `json:"dbname,omitempty" validate:"omitempty,gte=1,lte=63"`
8650 // Hostname or IP address of the server where to migrate data from
8651 Host string `json:"host" validate:"required,gte=1,lte=255"`
8652 // Comma-separated list of databases, which should be ignored during migration (supported by MySQL only at the moment)
8653 IgnoreDbs string `json:"ignore-dbs,omitempty" validate:"omitempty,gte=1,lte=2048"`
8654 Method EnumMigrationMethod `json:"method,omitempty"`
8655 // Password for authentication with the server where to migrate data from
8656 Password string `json:"password,omitempty" validate:"omitempty,gte=1,lte=255"`
8657 // Port number of the server where to migrate data from
8658 Port int64 `json:"port" validate:"required,gte=1,lte=65535"`
8659 // The server where to migrate data from is secured with SSL
8660 SSL *bool `json:"ssl,omitempty"`
8661 // User name for authentication with the server where to migrate data from
8662 Username string `json:"username,omitempty" validate:"omitempty,gte=1,lte=255"`
8663 }
8664
8665 type CreateDBAASServiceValkeyRequest struct {
8666 ForkFromService DBAASServiceName `json:"fork-from-service,omitempty" validate:"omitempty,gte=0,lte=63"`
8667 // Allow incoming connections from CIDR address block, e.g. '10.20.0.0/16'
8668 IPFilter []string `json:"ip-filter,omitempty"`
8669 // Automatic maintenance settings
8670 Maintenance *CreateDBAASServiceValkeyRequestMaintenance `json:"maintenance,omitempty"`
8671 // Migrate data from existing server
8672 Migration *CreateDBAASServiceValkeyRequestMigration `json:"migration,omitempty"`
8673 // Subscription plan
8674 Plan string `json:"plan" validate:"required,gte=1,lte=128"`
8675 // Name of a backup to recover from for services that support backup names
8676 RecoveryBackupName string `json:"recovery-backup-name,omitempty" validate:"omitempty,gte=1"`
8677 // Service is protected against termination and powering off
8678 TerminationProtection *bool `json:"termination-protection,omitempty"`
8679 // Valkey settings
8680 ValkeySettings *JSONSchemaValkey `json:"valkey-settings,omitempty"`
8681 }
8682
8683 // Create a DBaaS Valkey service
8684 func (c Client) CreateDBAASServiceValkey(ctx context.Context, name string, req CreateDBAASServiceValkeyRequest) (*Operation, error) {
8685 path := fmt.Sprintf("/dbaas-valkey/%v", name)
8686
8687 body, err := prepareJSONBody(req)
8688 if err != nil {
8689 return nil, fmt.Errorf("CreateDBAASServiceValkey: prepare Json body: %w", err)
8690 }
8691
8692 request, err := http.NewRequestWithContext(ctx, "POST", c.serverEndpoint+path, body)
8693 if err != nil {
8694 return nil, fmt.Errorf("CreateDBAASServiceValkey: new request: %w", err)
8695 }
8696
8697 request.Header.Add("User-Agent", c.getUserAgent())
8698
8699 request.Header.Add("Content-Type", "application/json")
8700
8701 if err := c.executeRequestInterceptors(ctx, request); err != nil {
8702 return nil, fmt.Errorf("CreateDBAASServiceValkey: execute request editors: %w", err)
8703 }
8704
8705 if err := c.signRequest(request); err != nil {
8706 return nil, fmt.Errorf("CreateDBAASServiceValkey: sign request: %w", err)
8707 }
8708
8709 if c.trace {
8710 dumpRequest(request, "create-dbaas-service-valkey")
8711 }
8712
8713 response, err := c.httpClient.Do(request)
8714 if err != nil {
8715 return nil, fmt.Errorf("CreateDBAASServiceValkey: http client do: %w", err)
8716 }
8717
8718 if c.trace {
8719 dumpResponse(response)
8720 }
8721
8722 if err := handleHTTPErrorResp(response); err != nil {
8723 return nil, fmt.Errorf("CreateDBAASServiceValkey: http response: %w", err)
8724 }
8725
8726 bodyresp := new(Operation)
8727 if err := prepareJSONResponse(response, bodyresp); err != nil {
8728 return nil, fmt.Errorf("CreateDBAASServiceValkey: prepare Json response: %w", err)
8729 }
8730
8731 return bodyresp, nil
8732 }
8733
8734 type UpdateDBAASServiceValkeyRequestMaintenanceDow string
8735
8736 const (
8737 UpdateDBAASServiceValkeyRequestMaintenanceDowSaturday UpdateDBAASServiceValkeyRequestMaintenanceDow = "saturday"
8738 UpdateDBAASServiceValkeyRequestMaintenanceDowTuesday UpdateDBAASServiceValkeyRequestMaintenanceDow = "tuesday"
8739 UpdateDBAASServiceValkeyRequestMaintenanceDowNever UpdateDBAASServiceValkeyRequestMaintenanceDow = "never"
8740 UpdateDBAASServiceValkeyRequestMaintenanceDowWednesday UpdateDBAASServiceValkeyRequestMaintenanceDow = "wednesday"
8741 UpdateDBAASServiceValkeyRequestMaintenanceDowSunday UpdateDBAASServiceValkeyRequestMaintenanceDow = "sunday"
8742 UpdateDBAASServiceValkeyRequestMaintenanceDowFriday UpdateDBAASServiceValkeyRequestMaintenanceDow = "friday"
8743 UpdateDBAASServiceValkeyRequestMaintenanceDowMonday UpdateDBAASServiceValkeyRequestMaintenanceDow = "monday"
8744 UpdateDBAASServiceValkeyRequestMaintenanceDowThursday UpdateDBAASServiceValkeyRequestMaintenanceDow = "thursday"
8745 )
8746
8747 // Automatic maintenance settings
8748 type UpdateDBAASServiceValkeyRequestMaintenance struct {
8749 // Day of week for installing updates
8750 Dow UpdateDBAASServiceValkeyRequestMaintenanceDow `json:"dow" validate:"required"`
8751 // Time for installing updates, UTC
8752 Time string `json:"time" validate:"required,gte=8,lte=8"`
8753 }
8754
8755 // Migrate data from existing server
8756 type UpdateDBAASServiceValkeyRequestMigration struct {
8757 // Database name for bootstrapping the initial connection
8758 Dbname string `json:"dbname,omitempty" validate:"omitempty,gte=1,lte=63"`
8759 // Hostname or IP address of the server where to migrate data from
8760 Host string `json:"host" validate:"required,gte=1,lte=255"`
8761 // Comma-separated list of databases, which should be ignored during migration (supported by MySQL only at the moment)
8762 IgnoreDbs string `json:"ignore-dbs,omitempty" validate:"omitempty,gte=1,lte=2048"`
8763 Method EnumMigrationMethod `json:"method,omitempty"`
8764 // Password for authentication with the server where to migrate data from
8765 Password string `json:"password,omitempty" validate:"omitempty,gte=1,lte=255"`
8766 // Port number of the server where to migrate data from
8767 Port int64 `json:"port" validate:"required,gte=1,lte=65535"`
8768 // The server where to migrate data from is secured with SSL
8769 SSL *bool `json:"ssl,omitempty"`
8770 // User name for authentication with the server where to migrate data from
8771 Username string `json:"username,omitempty" validate:"omitempty,gte=1,lte=255"`
8772 }
8773
8774 type UpdateDBAASServiceValkeyRequest struct {
8775 // Allow incoming connections from CIDR address block, e.g. '10.20.0.0/16'
8776 IPFilter []string `json:"ip-filter,omitempty"`
8777 // Automatic maintenance settings
8778 Maintenance *UpdateDBAASServiceValkeyRequestMaintenance `json:"maintenance,omitempty"`
8779 // Migrate data from existing server
8780 Migration *UpdateDBAASServiceValkeyRequestMigration `json:"migration,omitempty"`
8781 // Subscription plan
8782 Plan string `json:"plan,omitempty" validate:"omitempty,gte=1,lte=128"`
8783 // Service is protected against termination and powering off
8784 TerminationProtection *bool `json:"termination-protection,omitempty"`
8785 // Valkey settings
8786 ValkeySettings *JSONSchemaValkey `json:"valkey-settings,omitempty"`
8787 }
8788
8789 // Update a DBaaS Valkey service
8790 func (c Client) UpdateDBAASServiceValkey(ctx context.Context, name string, req UpdateDBAASServiceValkeyRequest) (*Operation, error) {
8791 path := fmt.Sprintf("/dbaas-valkey/%v", name)
8792
8793 body, err := prepareJSONBody(req)
8794 if err != nil {
8795 return nil, fmt.Errorf("UpdateDBAASServiceValkey: prepare Json body: %w", err)
8796 }
8797
8798 request, err := http.NewRequestWithContext(ctx, "PUT", c.serverEndpoint+path, body)
8799 if err != nil {
8800 return nil, fmt.Errorf("UpdateDBAASServiceValkey: new request: %w", err)
8801 }
8802
8803 request.Header.Add("User-Agent", c.getUserAgent())
8804
8805 request.Header.Add("Content-Type", "application/json")
8806
8807 if err := c.executeRequestInterceptors(ctx, request); err != nil {
8808 return nil, fmt.Errorf("UpdateDBAASServiceValkey: execute request editors: %w", err)
8809 }
8810
8811 if err := c.signRequest(request); err != nil {
8812 return nil, fmt.Errorf("UpdateDBAASServiceValkey: sign request: %w", err)
8813 }
8814
8815 if c.trace {
8816 dumpRequest(request, "update-dbaas-service-valkey")
8817 }
8818
8819 response, err := c.httpClient.Do(request)
8820 if err != nil {
8821 return nil, fmt.Errorf("UpdateDBAASServiceValkey: http client do: %w", err)
8822 }
8823
8824 if c.trace {
8825 dumpResponse(response)
8826 }
8827
8828 if err := handleHTTPErrorResp(response); err != nil {
8829 return nil, fmt.Errorf("UpdateDBAASServiceValkey: http response: %w", err)
8830 }
8831
8832 bodyresp := new(Operation)
8833 if err := prepareJSONResponse(response, bodyresp); err != nil {
8834 return nil, fmt.Errorf("UpdateDBAASServiceValkey: prepare Json response: %w", err)
8835 }
8836
8837 return bodyresp, nil
8838 }
8839
8840 func (c Client) StartDBAASValkeyMaintenance(ctx context.Context, name string) (*Operation, error) {
8841 path := fmt.Sprintf("/dbaas-valkey/%v/maintenance/start", name)
8842
8843 request, err := http.NewRequestWithContext(ctx, "PUT", c.serverEndpoint+path, nil)
8844 if err != nil {
8845 return nil, fmt.Errorf("StartDBAASValkeyMaintenance: new request: %w", err)
8846 }
8847
8848 request.Header.Add("User-Agent", c.getUserAgent())
8849
8850 if err := c.executeRequestInterceptors(ctx, request); err != nil {
8851 return nil, fmt.Errorf("StartDBAASValkeyMaintenance: execute request editors: %w", err)
8852 }
8853
8854 if err := c.signRequest(request); err != nil {
8855 return nil, fmt.Errorf("StartDBAASValkeyMaintenance: sign request: %w", err)
8856 }
8857
8858 if c.trace {
8859 dumpRequest(request, "start-dbaas-valkey-maintenance")
8860 }
8861
8862 response, err := c.httpClient.Do(request)
8863 if err != nil {
8864 return nil, fmt.Errorf("StartDBAASValkeyMaintenance: http client do: %w", err)
8865 }
8866
8867 if c.trace {
8868 dumpResponse(response)
8869 }
8870
8871 if err := handleHTTPErrorResp(response); err != nil {
8872 return nil, fmt.Errorf("StartDBAASValkeyMaintenance: http response: %w", err)
8873 }
8874
8875 bodyresp := new(Operation)
8876 if err := prepareJSONResponse(response, bodyresp); err != nil {
8877 return nil, fmt.Errorf("StartDBAASValkeyMaintenance: prepare Json response: %w", err)
8878 }
8879
8880 return bodyresp, nil
8881 }
8882
8883 func (c Client) StopDBAASValkeyMigration(ctx context.Context, name string) (*Operation, error) {
8884 path := fmt.Sprintf("/dbaas-valkey/%v/migration/stop", name)
8885
8886 request, err := http.NewRequestWithContext(ctx, "POST", c.serverEndpoint+path, nil)
8887 if err != nil {
8888 return nil, fmt.Errorf("StopDBAASValkeyMigration: new request: %w", err)
8889 }
8890
8891 request.Header.Add("User-Agent", c.getUserAgent())
8892
8893 if err := c.executeRequestInterceptors(ctx, request); err != nil {
8894 return nil, fmt.Errorf("StopDBAASValkeyMigration: execute request editors: %w", err)
8895 }
8896
8897 if err := c.signRequest(request); err != nil {
8898 return nil, fmt.Errorf("StopDBAASValkeyMigration: sign request: %w", err)
8899 }
8900
8901 if c.trace {
8902 dumpRequest(request, "stop-dbaas-valkey-migration")
8903 }
8904
8905 response, err := c.httpClient.Do(request)
8906 if err != nil {
8907 return nil, fmt.Errorf("StopDBAASValkeyMigration: http client do: %w", err)
8908 }
8909
8910 if c.trace {
8911 dumpResponse(response)
8912 }
8913
8914 if err := handleHTTPErrorResp(response); err != nil {
8915 return nil, fmt.Errorf("StopDBAASValkeyMigration: http response: %w", err)
8916 }
8917
8918 bodyresp := new(Operation)
8919 if err := prepareJSONResponse(response, bodyresp); err != nil {
8920 return nil, fmt.Errorf("StopDBAASValkeyMigration: prepare Json response: %w", err)
8921 }
8922
8923 return bodyresp, nil
8924 }
8925
8926 type CreateDBAASValkeyUserRequest struct {
8927 Username DBAASUserUsername `json:"username" validate:"required,gte=1,lte=64"`
8928 }
8929
8930 func (c Client) CreateDBAASValkeyUser(ctx context.Context, serviceName string, req CreateDBAASValkeyUserRequest) (*Operation, error) {
8931 path := fmt.Sprintf("/dbaas-valkey/%v/user", serviceName)
8932
8933 body, err := prepareJSONBody(req)
8934 if err != nil {
8935 return nil, fmt.Errorf("CreateDBAASValkeyUser: prepare Json body: %w", err)
8936 }
8937
8938 request, err := http.NewRequestWithContext(ctx, "POST", c.serverEndpoint+path, body)
8939 if err != nil {
8940 return nil, fmt.Errorf("CreateDBAASValkeyUser: new request: %w", err)
8941 }
8942
8943 request.Header.Add("User-Agent", c.getUserAgent())
8944
8945 request.Header.Add("Content-Type", "application/json")
8946
8947 if err := c.executeRequestInterceptors(ctx, request); err != nil {
8948 return nil, fmt.Errorf("CreateDBAASValkeyUser: execute request editors: %w", err)
8949 }
8950
8951 if err := c.signRequest(request); err != nil {
8952 return nil, fmt.Errorf("CreateDBAASValkeyUser: sign request: %w", err)
8953 }
8954
8955 if c.trace {
8956 dumpRequest(request, "create-dbaas-valkey-user")
8957 }
8958
8959 response, err := c.httpClient.Do(request)
8960 if err != nil {
8961 return nil, fmt.Errorf("CreateDBAASValkeyUser: http client do: %w", err)
8962 }
8963
8964 if c.trace {
8965 dumpResponse(response)
8966 }
8967
8968 if err := handleHTTPErrorResp(response); err != nil {
8969 return nil, fmt.Errorf("CreateDBAASValkeyUser: http response: %w", err)
8970 }
8971
8972 bodyresp := new(Operation)
8973 if err := prepareJSONResponse(response, bodyresp); err != nil {
8974 return nil, fmt.Errorf("CreateDBAASValkeyUser: prepare Json response: %w", err)
8975 }
8976
8977 return bodyresp, nil
8978 }
8979
8980 func (c Client) DeleteDBAASValkeyUser(ctx context.Context, serviceName string, username string) (*Operation, error) {
8981 path := fmt.Sprintf("/dbaas-valkey/%v/user/%v", serviceName, username)
8982
8983 request, err := http.NewRequestWithContext(ctx, "DELETE", c.serverEndpoint+path, nil)
8984 if err != nil {
8985 return nil, fmt.Errorf("DeleteDBAASValkeyUser: new request: %w", err)
8986 }
8987
8988 request.Header.Add("User-Agent", c.getUserAgent())
8989
8990 if err := c.executeRequestInterceptors(ctx, request); err != nil {
8991 return nil, fmt.Errorf("DeleteDBAASValkeyUser: execute request editors: %w", err)
8992 }
8993
8994 if err := c.signRequest(request); err != nil {
8995 return nil, fmt.Errorf("DeleteDBAASValkeyUser: sign request: %w", err)
8996 }
8997
8998 if c.trace {
8999 dumpRequest(request, "delete-dbaas-valkey-user")
9000 }
9001
9002 response, err := c.httpClient.Do(request)
9003 if err != nil {
9004 return nil, fmt.Errorf("DeleteDBAASValkeyUser: http client do: %w", err)
9005 }
9006
9007 if c.trace {
9008 dumpResponse(response)
9009 }
9010
9011 if err := handleHTTPErrorResp(response); err != nil {
9012 return nil, fmt.Errorf("DeleteDBAASValkeyUser: http response: %w", err)
9013 }
9014
9015 bodyresp := new(Operation)
9016 if err := prepareJSONResponse(response, bodyresp); err != nil {
9017 return nil, fmt.Errorf("DeleteDBAASValkeyUser: prepare Json response: %w", err)
9018 }
9019
9020 return bodyresp, nil
9021 }
9022
9023 type ResetDBAASValkeyUserPasswordRequest struct {
9024 Password DBAASUserPassword `json:"password,omitempty" validate:"omitempty,gte=8,lte=256"`
9025 }
9026
9027 // If no password is provided one will be generated automatically.
9028 func (c Client) ResetDBAASValkeyUserPassword(ctx context.Context, serviceName string, username string, req ResetDBAASValkeyUserPasswordRequest) (*Operation, error) {
9029 path := fmt.Sprintf("/dbaas-valkey/%v/user/%v/password/reset", serviceName, username)
9030
9031 body, err := prepareJSONBody(req)
9032 if err != nil {
9033 return nil, fmt.Errorf("ResetDBAASValkeyUserPassword: prepare Json body: %w", err)
9034 }
9035
9036 request, err := http.NewRequestWithContext(ctx, "PUT", c.serverEndpoint+path, body)
9037 if err != nil {
9038 return nil, fmt.Errorf("ResetDBAASValkeyUserPassword: new request: %w", err)
9039 }
9040
9041 request.Header.Add("User-Agent", c.getUserAgent())
9042
9043 request.Header.Add("Content-Type", "application/json")
9044
9045 if err := c.executeRequestInterceptors(ctx, request); err != nil {
9046 return nil, fmt.Errorf("ResetDBAASValkeyUserPassword: execute request editors: %w", err)
9047 }
9048
9049 if err := c.signRequest(request); err != nil {
9050 return nil, fmt.Errorf("ResetDBAASValkeyUserPassword: sign request: %w", err)
9051 }
9052
9053 if c.trace {
9054 dumpRequest(request, "reset-dbaas-valkey-user-password")
9055 }
9056
9057 response, err := c.httpClient.Do(request)
9058 if err != nil {
9059 return nil, fmt.Errorf("ResetDBAASValkeyUserPassword: http client do: %w", err)
9060 }
9061
9062 if c.trace {
9063 dumpResponse(response)
9064 }
9065
9066 if err := handleHTTPErrorResp(response); err != nil {
9067 return nil, fmt.Errorf("ResetDBAASValkeyUserPassword: http response: %w", err)
9068 }
9069
9070 bodyresp := new(Operation)
9071 if err := prepareJSONResponse(response, bodyresp); err != nil {
9072 return nil, fmt.Errorf("ResetDBAASValkeyUserPassword: prepare Json response: %w", err)
9073 }
9074
9075 return bodyresp, nil
9076 }
9077
9078 func (c Client) RevealDBAASValkeyUserPassword(ctx context.Context, serviceName string, username string) (*DBAASUserValkeySecrets, error) {
9079 path := fmt.Sprintf("/dbaas-valkey/%v/user/%v/password/reveal", serviceName, username)
9080
9081 request, err := http.NewRequestWithContext(ctx, "GET", c.serverEndpoint+path, nil)
9082 if err != nil {
9083 return nil, fmt.Errorf("RevealDBAASValkeyUserPassword: new request: %w", err)
9084 }
9085
9086 request.Header.Add("User-Agent", c.getUserAgent())
9087
9088 if err := c.executeRequestInterceptors(ctx, request); err != nil {
9089 return nil, fmt.Errorf("RevealDBAASValkeyUserPassword: execute request editors: %w", err)
9090 }
9091
9092 if err := c.signRequest(request); err != nil {
9093 return nil, fmt.Errorf("RevealDBAASValkeyUserPassword: sign request: %w", err)
9094 }
9095
9096 if c.trace {
9097 dumpRequest(request, "reveal-dbaas-valkey-user-password")
9098 }
9099
9100 response, err := c.httpClient.Do(request)
9101 if err != nil {
9102 return nil, fmt.Errorf("RevealDBAASValkeyUserPassword: http client do: %w", err)
9103 }
9104
9105 if c.trace {
9106 dumpResponse(response)
9107 }
9108
9109 if err := handleHTTPErrorResp(response); err != nil {
9110 return nil, fmt.Errorf("RevealDBAASValkeyUserPassword: http response: %w", err)
9111 }
9112
9113 bodyresp := new(DBAASUserValkeySecrets)
9114 if err := prepareJSONResponse(response, bodyresp); err != nil {
9115 return nil, fmt.Errorf("RevealDBAASValkeyUserPassword: prepare Json response: %w", err)
9116 }
9117
9118 return bodyresp, nil
9119 }
9120
9121 type ListDeployTargetsResponse struct {
9122 DeployTargets []DeployTarget `json:"deploy-targets,omitempty"`
9123 }
9124
9125 // FindDeployTarget attempts to find an DeployTarget by nameOrID.
9126 func (l ListDeployTargetsResponse) FindDeployTarget(nameOrID string) (DeployTarget, error) {
9127 var result []DeployTarget
9128 for i, elem := range l.DeployTargets {
9129 if string(elem.Name) == nameOrID || string(elem.ID) == nameOrID {
9130 result = append(result, l.DeployTargets[i])
9131 }
9132 }
9133 if len(result) == 1 {
9134 return result[0], nil
9135 }
9136
9137 if len(result) > 1 {
9138 return DeployTarget{}, fmt.Errorf("%q too many found in ListDeployTargetsResponse: %w", nameOrID, ErrConflict)
9139 }
9140
9141 return DeployTarget{}, fmt.Errorf("%q not found in ListDeployTargetsResponse: %w", nameOrID, ErrNotFound)
9142 }
9143
9144 // List Deploy Targets
9145 func (c Client) ListDeployTargets(ctx context.Context) (*ListDeployTargetsResponse, error) {
9146 path := "/deploy-target"
9147
9148 request, err := http.NewRequestWithContext(ctx, "GET", c.serverEndpoint+path, nil)
9149 if err != nil {
9150 return nil, fmt.Errorf("ListDeployTargets: new request: %w", err)
9151 }
9152
9153 request.Header.Add("User-Agent", c.getUserAgent())
9154
9155 if err := c.executeRequestInterceptors(ctx, request); err != nil {
9156 return nil, fmt.Errorf("ListDeployTargets: execute request editors: %w", err)
9157 }
9158
9159 if err := c.signRequest(request); err != nil {
9160 return nil, fmt.Errorf("ListDeployTargets: sign request: %w", err)
9161 }
9162
9163 if c.trace {
9164 dumpRequest(request, "list-deploy-targets")
9165 }
9166
9167 response, err := c.httpClient.Do(request)
9168 if err != nil {
9169 return nil, fmt.Errorf("ListDeployTargets: http client do: %w", err)
9170 }
9171
9172 if c.trace {
9173 dumpResponse(response)
9174 }
9175
9176 if err := handleHTTPErrorResp(response); err != nil {
9177 return nil, fmt.Errorf("ListDeployTargets: http response: %w", err)
9178 }
9179
9180 bodyresp := new(ListDeployTargetsResponse)
9181 if err := prepareJSONResponse(response, bodyresp); err != nil {
9182 return nil, fmt.Errorf("ListDeployTargets: prepare Json response: %w", err)
9183 }
9184
9185 return bodyresp, nil
9186 }
9187
9188 // Retrieve Deploy Target details
9189 func (c Client) GetDeployTarget(ctx context.Context, id UUID) (*DeployTarget, error) {
9190 path := fmt.Sprintf("/deploy-target/%v", id)
9191
9192 request, err := http.NewRequestWithContext(ctx, "GET", c.serverEndpoint+path, nil)
9193 if err != nil {
9194 return nil, fmt.Errorf("GetDeployTarget: new request: %w", err)
9195 }
9196
9197 request.Header.Add("User-Agent", c.getUserAgent())
9198
9199 if err := c.executeRequestInterceptors(ctx, request); err != nil {
9200 return nil, fmt.Errorf("GetDeployTarget: execute request editors: %w", err)
9201 }
9202
9203 if err := c.signRequest(request); err != nil {
9204 return nil, fmt.Errorf("GetDeployTarget: sign request: %w", err)
9205 }
9206
9207 if c.trace {
9208 dumpRequest(request, "get-deploy-target")
9209 }
9210
9211 response, err := c.httpClient.Do(request)
9212 if err != nil {
9213 return nil, fmt.Errorf("GetDeployTarget: http client do: %w", err)
9214 }
9215
9216 if c.trace {
9217 dumpResponse(response)
9218 }
9219
9220 if err := handleHTTPErrorResp(response); err != nil {
9221 return nil, fmt.Errorf("GetDeployTarget: http response: %w", err)
9222 }
9223
9224 bodyresp := new(DeployTarget)
9225 if err := prepareJSONResponse(response, bodyresp); err != nil {
9226 return nil, fmt.Errorf("GetDeployTarget: prepare Json response: %w", err)
9227 }
9228
9229 return bodyresp, nil
9230 }
9231
9232 type ListDNSDomainsResponse struct {
9233 DNSDomains []DNSDomain `json:"dns-domains,omitempty"`
9234 }
9235
9236 // FindDNSDomain attempts to find an DNSDomain by idOrUnicodeName.
9237 func (l ListDNSDomainsResponse) FindDNSDomain(idOrUnicodeName string) (DNSDomain, error) {
9238 var result []DNSDomain
9239 for i, elem := range l.DNSDomains {
9240 if string(elem.ID) == idOrUnicodeName || string(elem.UnicodeName) == idOrUnicodeName {
9241 result = append(result, l.DNSDomains[i])
9242 }
9243 }
9244 if len(result) == 1 {
9245 return result[0], nil
9246 }
9247
9248 if len(result) > 1 {
9249 return DNSDomain{}, fmt.Errorf("%q too many found in ListDNSDomainsResponse: %w", idOrUnicodeName, ErrConflict)
9250 }
9251
9252 return DNSDomain{}, fmt.Errorf("%q not found in ListDNSDomainsResponse: %w", idOrUnicodeName, ErrNotFound)
9253 }
9254
9255 // List DNS domains
9256 func (c Client) ListDNSDomains(ctx context.Context) (*ListDNSDomainsResponse, error) {
9257 path := "/dns-domain"
9258
9259 request, err := http.NewRequestWithContext(ctx, "GET", c.serverEndpoint+path, nil)
9260 if err != nil {
9261 return nil, fmt.Errorf("ListDNSDomains: new request: %w", err)
9262 }
9263
9264 request.Header.Add("User-Agent", c.getUserAgent())
9265
9266 if err := c.executeRequestInterceptors(ctx, request); err != nil {
9267 return nil, fmt.Errorf("ListDNSDomains: execute request editors: %w", err)
9268 }
9269
9270 if err := c.signRequest(request); err != nil {
9271 return nil, fmt.Errorf("ListDNSDomains: sign request: %w", err)
9272 }
9273
9274 if c.trace {
9275 dumpRequest(request, "list-dns-domains")
9276 }
9277
9278 response, err := c.httpClient.Do(request)
9279 if err != nil {
9280 return nil, fmt.Errorf("ListDNSDomains: http client do: %w", err)
9281 }
9282
9283 if c.trace {
9284 dumpResponse(response)
9285 }
9286
9287 if err := handleHTTPErrorResp(response); err != nil {
9288 return nil, fmt.Errorf("ListDNSDomains: http response: %w", err)
9289 }
9290
9291 bodyresp := new(ListDNSDomainsResponse)
9292 if err := prepareJSONResponse(response, bodyresp); err != nil {
9293 return nil, fmt.Errorf("ListDNSDomains: prepare Json response: %w", err)
9294 }
9295
9296 return bodyresp, nil
9297 }
9298
9299 // DNS Domain
9300 type CreateDNSDomainRequest struct {
9301 // Domain name
9302 UnicodeName string `json:"unicode-name,omitempty"`
9303 }
9304
9305 // Create DNS domain
9306 func (c Client) CreateDNSDomain(ctx context.Context, req CreateDNSDomainRequest) (*Operation, error) {
9307 path := "/dns-domain"
9308
9309 body, err := prepareJSONBody(req)
9310 if err != nil {
9311 return nil, fmt.Errorf("CreateDNSDomain: prepare Json body: %w", err)
9312 }
9313
9314 request, err := http.NewRequestWithContext(ctx, "POST", c.serverEndpoint+path, body)
9315 if err != nil {
9316 return nil, fmt.Errorf("CreateDNSDomain: new request: %w", err)
9317 }
9318
9319 request.Header.Add("User-Agent", c.getUserAgent())
9320
9321 request.Header.Add("Content-Type", "application/json")
9322
9323 if err := c.executeRequestInterceptors(ctx, request); err != nil {
9324 return nil, fmt.Errorf("CreateDNSDomain: execute request editors: %w", err)
9325 }
9326
9327 if err := c.signRequest(request); err != nil {
9328 return nil, fmt.Errorf("CreateDNSDomain: sign request: %w", err)
9329 }
9330
9331 if c.trace {
9332 dumpRequest(request, "create-dns-domain")
9333 }
9334
9335 response, err := c.httpClient.Do(request)
9336 if err != nil {
9337 return nil, fmt.Errorf("CreateDNSDomain: http client do: %w", err)
9338 }
9339
9340 if c.trace {
9341 dumpResponse(response)
9342 }
9343
9344 if err := handleHTTPErrorResp(response); err != nil {
9345 return nil, fmt.Errorf("CreateDNSDomain: http response: %w", err)
9346 }
9347
9348 bodyresp := new(Operation)
9349 if err := prepareJSONResponse(response, bodyresp); err != nil {
9350 return nil, fmt.Errorf("CreateDNSDomain: prepare Json response: %w", err)
9351 }
9352
9353 return bodyresp, nil
9354 }
9355
9356 type ListDNSDomainRecordsResponse struct {
9357 DNSDomainRecords []DNSDomainRecord `json:"dns-domain-records,omitempty"`
9358 }
9359
9360 // FindDNSDomainRecord attempts to find an DNSDomainRecord by nameOrID.
9361 func (l ListDNSDomainRecordsResponse) FindDNSDomainRecord(nameOrID string) (DNSDomainRecord, error) {
9362 var result []DNSDomainRecord
9363 for i, elem := range l.DNSDomainRecords {
9364 if string(elem.Name) == nameOrID || string(elem.ID) == nameOrID {
9365 result = append(result, l.DNSDomainRecords[i])
9366 }
9367 }
9368 if len(result) == 1 {
9369 return result[0], nil
9370 }
9371
9372 if len(result) > 1 {
9373 return DNSDomainRecord{}, fmt.Errorf("%q too many found in ListDNSDomainRecordsResponse: %w", nameOrID, ErrConflict)
9374 }
9375
9376 return DNSDomainRecord{}, fmt.Errorf("%q not found in ListDNSDomainRecordsResponse: %w", nameOrID, ErrNotFound)
9377 }
9378
9379 // List DNS domain records
9380 func (c Client) ListDNSDomainRecords(ctx context.Context, domainID UUID) (*ListDNSDomainRecordsResponse, error) {
9381 path := fmt.Sprintf("/dns-domain/%v/record", domainID)
9382
9383 request, err := http.NewRequestWithContext(ctx, "GET", c.serverEndpoint+path, nil)
9384 if err != nil {
9385 return nil, fmt.Errorf("ListDNSDomainRecords: new request: %w", err)
9386 }
9387
9388 request.Header.Add("User-Agent", c.getUserAgent())
9389
9390 if err := c.executeRequestInterceptors(ctx, request); err != nil {
9391 return nil, fmt.Errorf("ListDNSDomainRecords: execute request editors: %w", err)
9392 }
9393
9394 if err := c.signRequest(request); err != nil {
9395 return nil, fmt.Errorf("ListDNSDomainRecords: sign request: %w", err)
9396 }
9397
9398 if c.trace {
9399 dumpRequest(request, "list-dns-domain-records")
9400 }
9401
9402 response, err := c.httpClient.Do(request)
9403 if err != nil {
9404 return nil, fmt.Errorf("ListDNSDomainRecords: http client do: %w", err)
9405 }
9406
9407 if c.trace {
9408 dumpResponse(response)
9409 }
9410
9411 if err := handleHTTPErrorResp(response); err != nil {
9412 return nil, fmt.Errorf("ListDNSDomainRecords: http response: %w", err)
9413 }
9414
9415 bodyresp := new(ListDNSDomainRecordsResponse)
9416 if err := prepareJSONResponse(response, bodyresp); err != nil {
9417 return nil, fmt.Errorf("ListDNSDomainRecords: prepare Json response: %w", err)
9418 }
9419
9420 return bodyresp, nil
9421 }
9422
9423 type CreateDNSDomainRecordRequestType string
9424
9425 const (
9426 CreateDNSDomainRecordRequestTypeNS CreateDNSDomainRecordRequestType = "NS"
9427 CreateDNSDomainRecordRequestTypeCAA CreateDNSDomainRecordRequestType = "CAA"
9428 CreateDNSDomainRecordRequestTypeNAPTR CreateDNSDomainRecordRequestType = "NAPTR"
9429 CreateDNSDomainRecordRequestTypePOOL CreateDNSDomainRecordRequestType = "POOL"
9430 CreateDNSDomainRecordRequestTypeA CreateDNSDomainRecordRequestType = "A"
9431 CreateDNSDomainRecordRequestTypeHINFO CreateDNSDomainRecordRequestType = "HINFO"
9432 CreateDNSDomainRecordRequestTypeCNAME CreateDNSDomainRecordRequestType = "CNAME"
9433 CreateDNSDomainRecordRequestTypeSSHFP CreateDNSDomainRecordRequestType = "SSHFP"
9434 CreateDNSDomainRecordRequestTypeSRV CreateDNSDomainRecordRequestType = "SRV"
9435 CreateDNSDomainRecordRequestTypeAAAA CreateDNSDomainRecordRequestType = "AAAA"
9436 CreateDNSDomainRecordRequestTypeMX CreateDNSDomainRecordRequestType = "MX"
9437 CreateDNSDomainRecordRequestTypeTXT CreateDNSDomainRecordRequestType = "TXT"
9438 CreateDNSDomainRecordRequestTypeALIAS CreateDNSDomainRecordRequestType = "ALIAS"
9439 CreateDNSDomainRecordRequestTypeURL CreateDNSDomainRecordRequestType = "URL"
9440 )
9441
9442 type CreateDNSDomainRecordRequest struct {
9443 // DNS domain record content
9444 Content string `json:"content" validate:"required"`
9445 // DNS domain record name
9446 Name string `json:"name" validate:"required"`
9447 // DNS domain record priority
9448 Priority int64 `json:"priority,omitempty" validate:"omitempty,gte=0"`
9449 // DNS domain record TTL
9450 Ttl int64 `json:"ttl,omitempty" validate:"omitempty,gte=0"`
9451 // DNS domain record type
9452 Type CreateDNSDomainRecordRequestType `json:"type" validate:"required"`
9453 }
9454
9455 // Create DNS domain record
9456 func (c Client) CreateDNSDomainRecord(ctx context.Context, domainID UUID, req CreateDNSDomainRecordRequest) (*Operation, error) {
9457 path := fmt.Sprintf("/dns-domain/%v/record", domainID)
9458
9459 body, err := prepareJSONBody(req)
9460 if err != nil {
9461 return nil, fmt.Errorf("CreateDNSDomainRecord: prepare Json body: %w", err)
9462 }
9463
9464 request, err := http.NewRequestWithContext(ctx, "POST", c.serverEndpoint+path, body)
9465 if err != nil {
9466 return nil, fmt.Errorf("CreateDNSDomainRecord: new request: %w", err)
9467 }
9468
9469 request.Header.Add("User-Agent", c.getUserAgent())
9470
9471 request.Header.Add("Content-Type", "application/json")
9472
9473 if err := c.executeRequestInterceptors(ctx, request); err != nil {
9474 return nil, fmt.Errorf("CreateDNSDomainRecord: execute request editors: %w", err)
9475 }
9476
9477 if err := c.signRequest(request); err != nil {
9478 return nil, fmt.Errorf("CreateDNSDomainRecord: sign request: %w", err)
9479 }
9480
9481 if c.trace {
9482 dumpRequest(request, "create-dns-domain-record")
9483 }
9484
9485 response, err := c.httpClient.Do(request)
9486 if err != nil {
9487 return nil, fmt.Errorf("CreateDNSDomainRecord: http client do: %w", err)
9488 }
9489
9490 if c.trace {
9491 dumpResponse(response)
9492 }
9493
9494 if err := handleHTTPErrorResp(response); err != nil {
9495 return nil, fmt.Errorf("CreateDNSDomainRecord: http response: %w", err)
9496 }
9497
9498 bodyresp := new(Operation)
9499 if err := prepareJSONResponse(response, bodyresp); err != nil {
9500 return nil, fmt.Errorf("CreateDNSDomainRecord: prepare Json response: %w", err)
9501 }
9502
9503 return bodyresp, nil
9504 }
9505
9506 // Delete DNS domain record
9507 func (c Client) DeleteDNSDomainRecord(ctx context.Context, domainID UUID, recordID UUID) (*Operation, error) {
9508 path := fmt.Sprintf("/dns-domain/%v/record/%v", domainID, recordID)
9509
9510 request, err := http.NewRequestWithContext(ctx, "DELETE", c.serverEndpoint+path, nil)
9511 if err != nil {
9512 return nil, fmt.Errorf("DeleteDNSDomainRecord: new request: %w", err)
9513 }
9514
9515 request.Header.Add("User-Agent", c.getUserAgent())
9516
9517 if err := c.executeRequestInterceptors(ctx, request); err != nil {
9518 return nil, fmt.Errorf("DeleteDNSDomainRecord: execute request editors: %w", err)
9519 }
9520
9521 if err := c.signRequest(request); err != nil {
9522 return nil, fmt.Errorf("DeleteDNSDomainRecord: sign request: %w", err)
9523 }
9524
9525 if c.trace {
9526 dumpRequest(request, "delete-dns-domain-record")
9527 }
9528
9529 response, err := c.httpClient.Do(request)
9530 if err != nil {
9531 return nil, fmt.Errorf("DeleteDNSDomainRecord: http client do: %w", err)
9532 }
9533
9534 if c.trace {
9535 dumpResponse(response)
9536 }
9537
9538 if err := handleHTTPErrorResp(response); err != nil {
9539 return nil, fmt.Errorf("DeleteDNSDomainRecord: http response: %w", err)
9540 }
9541
9542 bodyresp := new(Operation)
9543 if err := prepareJSONResponse(response, bodyresp); err != nil {
9544 return nil, fmt.Errorf("DeleteDNSDomainRecord: prepare Json response: %w", err)
9545 }
9546
9547 return bodyresp, nil
9548 }
9549
9550 // Retrieve DNS domain record details
9551 func (c Client) GetDNSDomainRecord(ctx context.Context, domainID UUID, recordID UUID) (*DNSDomainRecord, error) {
9552 path := fmt.Sprintf("/dns-domain/%v/record/%v", domainID, recordID)
9553
9554 request, err := http.NewRequestWithContext(ctx, "GET", c.serverEndpoint+path, nil)
9555 if err != nil {
9556 return nil, fmt.Errorf("GetDNSDomainRecord: new request: %w", err)
9557 }
9558
9559 request.Header.Add("User-Agent", c.getUserAgent())
9560
9561 if err := c.executeRequestInterceptors(ctx, request); err != nil {
9562 return nil, fmt.Errorf("GetDNSDomainRecord: execute request editors: %w", err)
9563 }
9564
9565 if err := c.signRequest(request); err != nil {
9566 return nil, fmt.Errorf("GetDNSDomainRecord: sign request: %w", err)
9567 }
9568
9569 if c.trace {
9570 dumpRequest(request, "get-dns-domain-record")
9571 }
9572
9573 response, err := c.httpClient.Do(request)
9574 if err != nil {
9575 return nil, fmt.Errorf("GetDNSDomainRecord: http client do: %w", err)
9576 }
9577
9578 if c.trace {
9579 dumpResponse(response)
9580 }
9581
9582 if err := handleHTTPErrorResp(response); err != nil {
9583 return nil, fmt.Errorf("GetDNSDomainRecord: http response: %w", err)
9584 }
9585
9586 bodyresp := new(DNSDomainRecord)
9587 if err := prepareJSONResponse(response, bodyresp); err != nil {
9588 return nil, fmt.Errorf("GetDNSDomainRecord: prepare Json response: %w", err)
9589 }
9590
9591 return bodyresp, nil
9592 }
9593
9594 type UpdateDNSDomainRecordRequest struct {
9595 // DNS domain record content
9596 Content string `json:"content,omitempty"`
9597 // DNS domain record name
9598 Name string `json:"name,omitempty"`
9599 // DNS domain record priority
9600 Priority int64 `json:"priority,omitempty" validate:"omitempty,gt=0"`
9601 // DNS domain record TTL
9602 Ttl int64 `json:"ttl,omitempty" validate:"omitempty,gt=0"`
9603 }
9604
9605 // Update DNS domain record
9606 func (c Client) UpdateDNSDomainRecord(ctx context.Context, domainID UUID, recordID UUID, req UpdateDNSDomainRecordRequest) (*Operation, error) {
9607 path := fmt.Sprintf("/dns-domain/%v/record/%v", domainID, recordID)
9608
9609 body, err := prepareJSONBody(req)
9610 if err != nil {
9611 return nil, fmt.Errorf("UpdateDNSDomainRecord: prepare Json body: %w", err)
9612 }
9613
9614 request, err := http.NewRequestWithContext(ctx, "PUT", c.serverEndpoint+path, body)
9615 if err != nil {
9616 return nil, fmt.Errorf("UpdateDNSDomainRecord: new request: %w", err)
9617 }
9618
9619 request.Header.Add("User-Agent", c.getUserAgent())
9620
9621 request.Header.Add("Content-Type", "application/json")
9622
9623 if err := c.executeRequestInterceptors(ctx, request); err != nil {
9624 return nil, fmt.Errorf("UpdateDNSDomainRecord: execute request editors: %w", err)
9625 }
9626
9627 if err := c.signRequest(request); err != nil {
9628 return nil, fmt.Errorf("UpdateDNSDomainRecord: sign request: %w", err)
9629 }
9630
9631 if c.trace {
9632 dumpRequest(request, "update-dns-domain-record")
9633 }
9634
9635 response, err := c.httpClient.Do(request)
9636 if err != nil {
9637 return nil, fmt.Errorf("UpdateDNSDomainRecord: http client do: %w", err)
9638 }
9639
9640 if c.trace {
9641 dumpResponse(response)
9642 }
9643
9644 if err := handleHTTPErrorResp(response); err != nil {
9645 return nil, fmt.Errorf("UpdateDNSDomainRecord: http response: %w", err)
9646 }
9647
9648 bodyresp := new(Operation)
9649 if err := prepareJSONResponse(response, bodyresp); err != nil {
9650 return nil, fmt.Errorf("UpdateDNSDomainRecord: prepare Json response: %w", err)
9651 }
9652
9653 return bodyresp, nil
9654 }
9655
9656 // Delete DNS Domain
9657 func (c Client) DeleteDNSDomain(ctx context.Context, id UUID) (*Operation, error) {
9658 path := fmt.Sprintf("/dns-domain/%v", id)
9659
9660 request, err := http.NewRequestWithContext(ctx, "DELETE", c.serverEndpoint+path, nil)
9661 if err != nil {
9662 return nil, fmt.Errorf("DeleteDNSDomain: new request: %w", err)
9663 }
9664
9665 request.Header.Add("User-Agent", c.getUserAgent())
9666
9667 if err := c.executeRequestInterceptors(ctx, request); err != nil {
9668 return nil, fmt.Errorf("DeleteDNSDomain: execute request editors: %w", err)
9669 }
9670
9671 if err := c.signRequest(request); err != nil {
9672 return nil, fmt.Errorf("DeleteDNSDomain: sign request: %w", err)
9673 }
9674
9675 if c.trace {
9676 dumpRequest(request, "delete-dns-domain")
9677 }
9678
9679 response, err := c.httpClient.Do(request)
9680 if err != nil {
9681 return nil, fmt.Errorf("DeleteDNSDomain: http client do: %w", err)
9682 }
9683
9684 if c.trace {
9685 dumpResponse(response)
9686 }
9687
9688 if err := handleHTTPErrorResp(response); err != nil {
9689 return nil, fmt.Errorf("DeleteDNSDomain: http response: %w", err)
9690 }
9691
9692 bodyresp := new(Operation)
9693 if err := prepareJSONResponse(response, bodyresp); err != nil {
9694 return nil, fmt.Errorf("DeleteDNSDomain: prepare Json response: %w", err)
9695 }
9696
9697 return bodyresp, nil
9698 }
9699
9700 // Retrieve DNS domain details
9701 func (c Client) GetDNSDomain(ctx context.Context, id UUID) (*DNSDomain, error) {
9702 path := fmt.Sprintf("/dns-domain/%v", id)
9703
9704 request, err := http.NewRequestWithContext(ctx, "GET", c.serverEndpoint+path, nil)
9705 if err != nil {
9706 return nil, fmt.Errorf("GetDNSDomain: new request: %w", err)
9707 }
9708
9709 request.Header.Add("User-Agent", c.getUserAgent())
9710
9711 if err := c.executeRequestInterceptors(ctx, request); err != nil {
9712 return nil, fmt.Errorf("GetDNSDomain: execute request editors: %w", err)
9713 }
9714
9715 if err := c.signRequest(request); err != nil {
9716 return nil, fmt.Errorf("GetDNSDomain: sign request: %w", err)
9717 }
9718
9719 if c.trace {
9720 dumpRequest(request, "get-dns-domain")
9721 }
9722
9723 response, err := c.httpClient.Do(request)
9724 if err != nil {
9725 return nil, fmt.Errorf("GetDNSDomain: http client do: %w", err)
9726 }
9727
9728 if c.trace {
9729 dumpResponse(response)
9730 }
9731
9732 if err := handleHTTPErrorResp(response); err != nil {
9733 return nil, fmt.Errorf("GetDNSDomain: http response: %w", err)
9734 }
9735
9736 bodyresp := new(DNSDomain)
9737 if err := prepareJSONResponse(response, bodyresp); err != nil {
9738 return nil, fmt.Errorf("GetDNSDomain: prepare Json response: %w", err)
9739 }
9740
9741 return bodyresp, nil
9742 }
9743
9744 type GetDNSDomainZoneFileResponse struct {
9745 ZoneFile string `json:"zone-file,omitempty"`
9746 }
9747
9748 // Retrieve DNS domain zone file
9749 func (c Client) GetDNSDomainZoneFile(ctx context.Context, id UUID) (*GetDNSDomainZoneFileResponse, error) {
9750 path := fmt.Sprintf("/dns-domain/%v/zone", id)
9751
9752 request, err := http.NewRequestWithContext(ctx, "GET", c.serverEndpoint+path, nil)
9753 if err != nil {
9754 return nil, fmt.Errorf("GetDNSDomainZoneFile: new request: %w", err)
9755 }
9756
9757 request.Header.Add("User-Agent", c.getUserAgent())
9758
9759 if err := c.executeRequestInterceptors(ctx, request); err != nil {
9760 return nil, fmt.Errorf("GetDNSDomainZoneFile: execute request editors: %w", err)
9761 }
9762
9763 if err := c.signRequest(request); err != nil {
9764 return nil, fmt.Errorf("GetDNSDomainZoneFile: sign request: %w", err)
9765 }
9766
9767 if c.trace {
9768 dumpRequest(request, "get-dns-domain-zone-file")
9769 }
9770
9771 response, err := c.httpClient.Do(request)
9772 if err != nil {
9773 return nil, fmt.Errorf("GetDNSDomainZoneFile: http client do: %w", err)
9774 }
9775
9776 if c.trace {
9777 dumpResponse(response)
9778 }
9779
9780 if err := handleHTTPErrorResp(response); err != nil {
9781 return nil, fmt.Errorf("GetDNSDomainZoneFile: http response: %w", err)
9782 }
9783
9784 bodyresp := new(GetDNSDomainZoneFileResponse)
9785 if err := prepareJSONResponse(response, bodyresp); err != nil {
9786 return nil, fmt.Errorf("GetDNSDomainZoneFile: prepare Json response: %w", err)
9787 }
9788
9789 return bodyresp, nil
9790 }
9791
9792 type ListElasticIPSResponse struct {
9793 ElasticIPS []ElasticIP `json:"elastic-ips,omitempty"`
9794 }
9795
9796 // FindElasticIP attempts to find an ElasticIP by idOrIP.
9797 func (l ListElasticIPSResponse) FindElasticIP(idOrIP string) (ElasticIP, error) {
9798 var result []ElasticIP
9799 for i, elem := range l.ElasticIPS {
9800 if string(elem.ID) == idOrIP || string(elem.IP) == idOrIP {
9801 result = append(result, l.ElasticIPS[i])
9802 }
9803 }
9804 if len(result) == 1 {
9805 return result[0], nil
9806 }
9807
9808 if len(result) > 1 {
9809 return ElasticIP{}, fmt.Errorf("%q too many found in ListElasticIPSResponse: %w", idOrIP, ErrConflict)
9810 }
9811
9812 return ElasticIP{}, fmt.Errorf("%q not found in ListElasticIPSResponse: %w", idOrIP, ErrNotFound)
9813 }
9814
9815 // List Elastic IPs
9816 func (c Client) ListElasticIPS(ctx context.Context) (*ListElasticIPSResponse, error) {
9817 path := "/elastic-ip"
9818
9819 request, err := http.NewRequestWithContext(ctx, "GET", c.serverEndpoint+path, nil)
9820 if err != nil {
9821 return nil, fmt.Errorf("ListElasticIPS: new request: %w", err)
9822 }
9823
9824 request.Header.Add("User-Agent", c.getUserAgent())
9825
9826 if err := c.executeRequestInterceptors(ctx, request); err != nil {
9827 return nil, fmt.Errorf("ListElasticIPS: execute request editors: %w", err)
9828 }
9829
9830 if err := c.signRequest(request); err != nil {
9831 return nil, fmt.Errorf("ListElasticIPS: sign request: %w", err)
9832 }
9833
9834 if c.trace {
9835 dumpRequest(request, "list-elastic-ips")
9836 }
9837
9838 response, err := c.httpClient.Do(request)
9839 if err != nil {
9840 return nil, fmt.Errorf("ListElasticIPS: http client do: %w", err)
9841 }
9842
9843 if c.trace {
9844 dumpResponse(response)
9845 }
9846
9847 if err := handleHTTPErrorResp(response); err != nil {
9848 return nil, fmt.Errorf("ListElasticIPS: http response: %w", err)
9849 }
9850
9851 bodyresp := new(ListElasticIPSResponse)
9852 if err := prepareJSONResponse(response, bodyresp); err != nil {
9853 return nil, fmt.Errorf("ListElasticIPS: prepare Json response: %w", err)
9854 }
9855
9856 return bodyresp, nil
9857 }
9858
9859 type CreateElasticIPRequestAddressfamily string
9860
9861 const (
9862 CreateElasticIPRequestAddressfamilyInet4 CreateElasticIPRequestAddressfamily = "inet4"
9863 CreateElasticIPRequestAddressfamilyInet6 CreateElasticIPRequestAddressfamily = "inet6"
9864 )
9865
9866 type CreateElasticIPRequest struct {
9867 // Elastic IP address family (default: :inet4)
9868 Addressfamily CreateElasticIPRequestAddressfamily `json:"addressfamily,omitempty"`
9869 // Elastic IP description
9870 Description string `json:"description,omitempty" validate:"omitempty,lte=255"`
9871 // Elastic IP address healthcheck
9872 Healthcheck *ElasticIPHealthcheck `json:"healthcheck,omitempty"`
9873 Labels Labels `json:"labels,omitempty"`
9874 }
9875
9876 // Create an Elastic IP
9877 func (c Client) CreateElasticIP(ctx context.Context, req CreateElasticIPRequest) (*Operation, error) {
9878 path := "/elastic-ip"
9879
9880 body, err := prepareJSONBody(req)
9881 if err != nil {
9882 return nil, fmt.Errorf("CreateElasticIP: prepare Json body: %w", err)
9883 }
9884
9885 request, err := http.NewRequestWithContext(ctx, "POST", c.serverEndpoint+path, body)
9886 if err != nil {
9887 return nil, fmt.Errorf("CreateElasticIP: new request: %w", err)
9888 }
9889
9890 request.Header.Add("User-Agent", c.getUserAgent())
9891
9892 request.Header.Add("Content-Type", "application/json")
9893
9894 if err := c.executeRequestInterceptors(ctx, request); err != nil {
9895 return nil, fmt.Errorf("CreateElasticIP: execute request editors: %w", err)
9896 }
9897
9898 if err := c.signRequest(request); err != nil {
9899 return nil, fmt.Errorf("CreateElasticIP: sign request: %w", err)
9900 }
9901
9902 if c.trace {
9903 dumpRequest(request, "create-elastic-ip")
9904 }
9905
9906 response, err := c.httpClient.Do(request)
9907 if err != nil {
9908 return nil, fmt.Errorf("CreateElasticIP: http client do: %w", err)
9909 }
9910
9911 if c.trace {
9912 dumpResponse(response)
9913 }
9914
9915 if err := handleHTTPErrorResp(response); err != nil {
9916 return nil, fmt.Errorf("CreateElasticIP: http response: %w", err)
9917 }
9918
9919 bodyresp := new(Operation)
9920 if err := prepareJSONResponse(response, bodyresp); err != nil {
9921 return nil, fmt.Errorf("CreateElasticIP: prepare Json response: %w", err)
9922 }
9923
9924 return bodyresp, nil
9925 }
9926
9927 // Delete an Elastic IP
9928 func (c Client) DeleteElasticIP(ctx context.Context, id UUID) (*Operation, error) {
9929 path := fmt.Sprintf("/elastic-ip/%v", id)
9930
9931 request, err := http.NewRequestWithContext(ctx, "DELETE", c.serverEndpoint+path, nil)
9932 if err != nil {
9933 return nil, fmt.Errorf("DeleteElasticIP: new request: %w", err)
9934 }
9935
9936 request.Header.Add("User-Agent", c.getUserAgent())
9937
9938 if err := c.executeRequestInterceptors(ctx, request); err != nil {
9939 return nil, fmt.Errorf("DeleteElasticIP: execute request editors: %w", err)
9940 }
9941
9942 if err := c.signRequest(request); err != nil {
9943 return nil, fmt.Errorf("DeleteElasticIP: sign request: %w", err)
9944 }
9945
9946 if c.trace {
9947 dumpRequest(request, "delete-elastic-ip")
9948 }
9949
9950 response, err := c.httpClient.Do(request)
9951 if err != nil {
9952 return nil, fmt.Errorf("DeleteElasticIP: http client do: %w", err)
9953 }
9954
9955 if c.trace {
9956 dumpResponse(response)
9957 }
9958
9959 if err := handleHTTPErrorResp(response); err != nil {
9960 return nil, fmt.Errorf("DeleteElasticIP: http response: %w", err)
9961 }
9962
9963 bodyresp := new(Operation)
9964 if err := prepareJSONResponse(response, bodyresp); err != nil {
9965 return nil, fmt.Errorf("DeleteElasticIP: prepare Json response: %w", err)
9966 }
9967
9968 return bodyresp, nil
9969 }
9970
9971 // Retrieve Elastic IP details
9972 func (c Client) GetElasticIP(ctx context.Context, id UUID) (*ElasticIP, error) {
9973 path := fmt.Sprintf("/elastic-ip/%v", id)
9974
9975 request, err := http.NewRequestWithContext(ctx, "GET", c.serverEndpoint+path, nil)
9976 if err != nil {
9977 return nil, fmt.Errorf("GetElasticIP: new request: %w", err)
9978 }
9979
9980 request.Header.Add("User-Agent", c.getUserAgent())
9981
9982 if err := c.executeRequestInterceptors(ctx, request); err != nil {
9983 return nil, fmt.Errorf("GetElasticIP: execute request editors: %w", err)
9984 }
9985
9986 if err := c.signRequest(request); err != nil {
9987 return nil, fmt.Errorf("GetElasticIP: sign request: %w", err)
9988 }
9989
9990 if c.trace {
9991 dumpRequest(request, "get-elastic-ip")
9992 }
9993
9994 response, err := c.httpClient.Do(request)
9995 if err != nil {
9996 return nil, fmt.Errorf("GetElasticIP: http client do: %w", err)
9997 }
9998
9999 if c.trace {
10000 dumpResponse(response)
10001 }
10002
10003 if err := handleHTTPErrorResp(response); err != nil {
10004 return nil, fmt.Errorf("GetElasticIP: http response: %w", err)
10005 }
10006
10007 bodyresp := new(ElasticIP)
10008 if err := prepareJSONResponse(response, bodyresp); err != nil {
10009 return nil, fmt.Errorf("GetElasticIP: prepare Json response: %w", err)
10010 }
10011
10012 return bodyresp, nil
10013 }
10014
10015 type UpdateElasticIPRequest struct {
10016 // Elastic IP description
10017 Description string `json:"description,omitempty" validate:"omitempty,lte=255"`
10018 // Elastic IP address healthcheck
10019 Healthcheck *ElasticIPHealthcheck `json:"healthcheck,omitempty"`
10020 Labels Labels `json:"labels,omitempty"`
10021 }
10022
10023 // Update an Elastic IP
10024 func (c Client) UpdateElasticIP(ctx context.Context, id UUID, req UpdateElasticIPRequest) (*Operation, error) {
10025 path := fmt.Sprintf("/elastic-ip/%v", id)
10026
10027 body, err := prepareJSONBody(req)
10028 if err != nil {
10029 return nil, fmt.Errorf("UpdateElasticIP: prepare Json body: %w", err)
10030 }
10031
10032 request, err := http.NewRequestWithContext(ctx, "PUT", c.serverEndpoint+path, body)
10033 if err != nil {
10034 return nil, fmt.Errorf("UpdateElasticIP: new request: %w", err)
10035 }
10036
10037 request.Header.Add("User-Agent", c.getUserAgent())
10038
10039 request.Header.Add("Content-Type", "application/json")
10040
10041 if err := c.executeRequestInterceptors(ctx, request); err != nil {
10042 return nil, fmt.Errorf("UpdateElasticIP: execute request editors: %w", err)
10043 }
10044
10045 if err := c.signRequest(request); err != nil {
10046 return nil, fmt.Errorf("UpdateElasticIP: sign request: %w", err)
10047 }
10048
10049 if c.trace {
10050 dumpRequest(request, "update-elastic-ip")
10051 }
10052
10053 response, err := c.httpClient.Do(request)
10054 if err != nil {
10055 return nil, fmt.Errorf("UpdateElasticIP: http client do: %w", err)
10056 }
10057
10058 if c.trace {
10059 dumpResponse(response)
10060 }
10061
10062 if err := handleHTTPErrorResp(response); err != nil {
10063 return nil, fmt.Errorf("UpdateElasticIP: http response: %w", err)
10064 }
10065
10066 bodyresp := new(Operation)
10067 if err := prepareJSONResponse(response, bodyresp); err != nil {
10068 return nil, fmt.Errorf("UpdateElasticIP: prepare Json response: %w", err)
10069 }
10070
10071 return bodyresp, nil
10072 }
10073
10074 type ResetElasticIPFieldField string
10075
10076 const (
10077 ResetElasticIPFieldFieldDescription ResetElasticIPFieldField = "description"
10078 )
10079
10080 // Reset an Elastic IP field to its default value
10081 func (c Client) ResetElasticIPField(ctx context.Context, id UUID, field ResetElasticIPFieldField) (*Operation, error) {
10082 path := fmt.Sprintf("/elastic-ip/%v/%v", id, field)
10083
10084 request, err := http.NewRequestWithContext(ctx, "DELETE", c.serverEndpoint+path, nil)
10085 if err != nil {
10086 return nil, fmt.Errorf("ResetElasticIPField: new request: %w", err)
10087 }
10088
10089 request.Header.Add("User-Agent", c.getUserAgent())
10090
10091 if err := c.executeRequestInterceptors(ctx, request); err != nil {
10092 return nil, fmt.Errorf("ResetElasticIPField: execute request editors: %w", err)
10093 }
10094
10095 if err := c.signRequest(request); err != nil {
10096 return nil, fmt.Errorf("ResetElasticIPField: sign request: %w", err)
10097 }
10098
10099 if c.trace {
10100 dumpRequest(request, "reset-elastic-ip-field")
10101 }
10102
10103 response, err := c.httpClient.Do(request)
10104 if err != nil {
10105 return nil, fmt.Errorf("ResetElasticIPField: http client do: %w", err)
10106 }
10107
10108 if c.trace {
10109 dumpResponse(response)
10110 }
10111
10112 if err := handleHTTPErrorResp(response); err != nil {
10113 return nil, fmt.Errorf("ResetElasticIPField: http response: %w", err)
10114 }
10115
10116 bodyresp := new(Operation)
10117 if err := prepareJSONResponse(response, bodyresp); err != nil {
10118 return nil, fmt.Errorf("ResetElasticIPField: prepare Json response: %w", err)
10119 }
10120
10121 return bodyresp, nil
10122 }
10123
10124 type AttachInstanceToElasticIPRequest struct {
10125 // Target Instance
10126 Instance *InstanceTarget `json:"instance" validate:"required"`
10127 }
10128
10129 // Attach a Compute instance to an Elastic IP
10130 func (c Client) AttachInstanceToElasticIP(ctx context.Context, id UUID, req AttachInstanceToElasticIPRequest) (*Operation, error) {
10131 path := fmt.Sprintf("/elastic-ip/%v:attach", id)
10132
10133 body, err := prepareJSONBody(req)
10134 if err != nil {
10135 return nil, fmt.Errorf("AttachInstanceToElasticIP: prepare Json body: %w", err)
10136 }
10137
10138 request, err := http.NewRequestWithContext(ctx, "PUT", c.serverEndpoint+path, body)
10139 if err != nil {
10140 return nil, fmt.Errorf("AttachInstanceToElasticIP: new request: %w", err)
10141 }
10142
10143 request.Header.Add("User-Agent", c.getUserAgent())
10144
10145 request.Header.Add("Content-Type", "application/json")
10146
10147 if err := c.executeRequestInterceptors(ctx, request); err != nil {
10148 return nil, fmt.Errorf("AttachInstanceToElasticIP: execute request editors: %w", err)
10149 }
10150
10151 if err := c.signRequest(request); err != nil {
10152 return nil, fmt.Errorf("AttachInstanceToElasticIP: sign request: %w", err)
10153 }
10154
10155 if c.trace {
10156 dumpRequest(request, "attach-instance-to-elastic-ip")
10157 }
10158
10159 response, err := c.httpClient.Do(request)
10160 if err != nil {
10161 return nil, fmt.Errorf("AttachInstanceToElasticIP: http client do: %w", err)
10162 }
10163
10164 if c.trace {
10165 dumpResponse(response)
10166 }
10167
10168 if err := handleHTTPErrorResp(response); err != nil {
10169 return nil, fmt.Errorf("AttachInstanceToElasticIP: http response: %w", err)
10170 }
10171
10172 bodyresp := new(Operation)
10173 if err := prepareJSONResponse(response, bodyresp); err != nil {
10174 return nil, fmt.Errorf("AttachInstanceToElasticIP: prepare Json response: %w", err)
10175 }
10176
10177 return bodyresp, nil
10178 }
10179
10180 type DetachInstanceFromElasticIPRequest struct {
10181 // Target Instance
10182 Instance *InstanceTarget `json:"instance" validate:"required"`
10183 }
10184
10185 // Detach a Compute instance from an Elastic IP
10186 func (c Client) DetachInstanceFromElasticIP(ctx context.Context, id UUID, req DetachInstanceFromElasticIPRequest) (*Operation, error) {
10187 path := fmt.Sprintf("/elastic-ip/%v:detach", id)
10188
10189 body, err := prepareJSONBody(req)
10190 if err != nil {
10191 return nil, fmt.Errorf("DetachInstanceFromElasticIP: prepare Json body: %w", err)
10192 }
10193
10194 request, err := http.NewRequestWithContext(ctx, "PUT", c.serverEndpoint+path, body)
10195 if err != nil {
10196 return nil, fmt.Errorf("DetachInstanceFromElasticIP: new request: %w", err)
10197 }
10198
10199 request.Header.Add("User-Agent", c.getUserAgent())
10200
10201 request.Header.Add("Content-Type", "application/json")
10202
10203 if err := c.executeRequestInterceptors(ctx, request); err != nil {
10204 return nil, fmt.Errorf("DetachInstanceFromElasticIP: execute request editors: %w", err)
10205 }
10206
10207 if err := c.signRequest(request); err != nil {
10208 return nil, fmt.Errorf("DetachInstanceFromElasticIP: sign request: %w", err)
10209 }
10210
10211 if c.trace {
10212 dumpRequest(request, "detach-instance-from-elastic-ip")
10213 }
10214
10215 response, err := c.httpClient.Do(request)
10216 if err != nil {
10217 return nil, fmt.Errorf("DetachInstanceFromElasticIP: http client do: %w", err)
10218 }
10219
10220 if c.trace {
10221 dumpResponse(response)
10222 }
10223
10224 if err := handleHTTPErrorResp(response); err != nil {
10225 return nil, fmt.Errorf("DetachInstanceFromElasticIP: http response: %w", err)
10226 }
10227
10228 bodyresp := new(Operation)
10229 if err := prepareJSONResponse(response, bodyresp); err != nil {
10230 return nil, fmt.Errorf("DetachInstanceFromElasticIP: prepare Json response: %w", err)
10231 }
10232
10233 return bodyresp, nil
10234 }
10235
10236 // [BETA] Returns environmental impact reports for an organization
10237 func (c Client) GetEnvImpact(ctx context.Context, period string) (*EnvImpactReport, error) {
10238 path := fmt.Sprintf("/env-impact/%v", period)
10239
10240 request, err := http.NewRequestWithContext(ctx, "GET", c.serverEndpoint+path, nil)
10241 if err != nil {
10242 return nil, fmt.Errorf("GetEnvImpact: new request: %w", err)
10243 }
10244
10245 request.Header.Add("User-Agent", c.getUserAgent())
10246
10247 if err := c.executeRequestInterceptors(ctx, request); err != nil {
10248 return nil, fmt.Errorf("GetEnvImpact: execute request editors: %w", err)
10249 }
10250
10251 if err := c.signRequest(request); err != nil {
10252 return nil, fmt.Errorf("GetEnvImpact: sign request: %w", err)
10253 }
10254
10255 if c.trace {
10256 dumpRequest(request, "get-env-impact")
10257 }
10258
10259 response, err := c.httpClient.Do(request)
10260 if err != nil {
10261 return nil, fmt.Errorf("GetEnvImpact: http client do: %w", err)
10262 }
10263
10264 if c.trace {
10265 dumpResponse(response)
10266 }
10267
10268 if err := handleHTTPErrorResp(response); err != nil {
10269 return nil, fmt.Errorf("GetEnvImpact: http response: %w", err)
10270 }
10271
10272 bodyresp := new(EnvImpactReport)
10273 if err := prepareJSONResponse(response, bodyresp); err != nil {
10274 return nil, fmt.Errorf("GetEnvImpact: prepare Json response: %w", err)
10275 }
10276
10277 return bodyresp, nil
10278 }
10279
10280 type ListEventsOpt func(url.Values)
10281
10282 func ListEventsWithFrom(from time.Time) ListEventsOpt {
10283 return func(q url.Values) {
10284 q.Add("from", from.Format(time.RFC3339))
10285 }
10286 }
10287
10288 func ListEventsWithTo(to time.Time) ListEventsOpt {
10289 return func(q url.Values) {
10290 q.Add("to", to.Format(time.RFC3339))
10291 }
10292 }
10293
10294 // Retrieve Mutation Events for a given date range. Defaults to retrieving Events for the past 24 hours.
10295 // Both a `from` and `to` arguments can be specified to filter Events over a specific period.
10296 // Events will be the the most descriptive possible but not all fields are mandatory
10297 func (c Client) ListEvents(ctx context.Context, opts ...ListEventsOpt) ([]Event, error) {
10298 path := "/event"
10299
10300 request, err := http.NewRequestWithContext(ctx, "GET", c.serverEndpoint+path, nil)
10301 if err != nil {
10302 return nil, fmt.Errorf("ListEvents: new request: %w", err)
10303 }
10304
10305 request.Header.Add("User-Agent", c.getUserAgent())
10306
10307 if len(opts) > 0 {
10308 q := request.URL.Query()
10309 for _, opt := range opts {
10310 opt(q)
10311 }
10312 request.URL.RawQuery = q.Encode()
10313 }
10314
10315 if err := c.executeRequestInterceptors(ctx, request); err != nil {
10316 return nil, fmt.Errorf("ListEvents: execute request editors: %w", err)
10317 }
10318
10319 if err := c.signRequest(request); err != nil {
10320 return nil, fmt.Errorf("ListEvents: sign request: %w", err)
10321 }
10322
10323 if c.trace {
10324 dumpRequest(request, "list-events")
10325 }
10326
10327 response, err := c.httpClient.Do(request)
10328 if err != nil {
10329 return nil, fmt.Errorf("ListEvents: http client do: %w", err)
10330 }
10331
10332 if c.trace {
10333 dumpResponse(response)
10334 }
10335
10336 if err := handleHTTPErrorResp(response); err != nil {
10337 return nil, fmt.Errorf("ListEvents: http response: %w", err)
10338 }
10339
10340 bodyresp := []Event{}
10341 if err := prepareJSONResponse(response, &bodyresp); err != nil {
10342 return nil, fmt.Errorf("ListEvents: prepare Json response: %w", err)
10343 }
10344
10345 return bodyresp, nil
10346 }
10347
10348 // Retrieve IAM Organization Policy
10349 func (c Client) GetIAMOrganizationPolicy(ctx context.Context) (*IAMPolicy, error) {
10350 path := "/iam-organization-policy"
10351
10352 request, err := http.NewRequestWithContext(ctx, "GET", c.serverEndpoint+path, nil)
10353 if err != nil {
10354 return nil, fmt.Errorf("GetIAMOrganizationPolicy: new request: %w", err)
10355 }
10356
10357 request.Header.Add("User-Agent", c.getUserAgent())
10358
10359 if err := c.executeRequestInterceptors(ctx, request); err != nil {
10360 return nil, fmt.Errorf("GetIAMOrganizationPolicy: execute request editors: %w", err)
10361 }
10362
10363 if err := c.signRequest(request); err != nil {
10364 return nil, fmt.Errorf("GetIAMOrganizationPolicy: sign request: %w", err)
10365 }
10366
10367 if c.trace {
10368 dumpRequest(request, "get-iam-organization-policy")
10369 }
10370
10371 response, err := c.httpClient.Do(request)
10372 if err != nil {
10373 return nil, fmt.Errorf("GetIAMOrganizationPolicy: http client do: %w", err)
10374 }
10375
10376 if c.trace {
10377 dumpResponse(response)
10378 }
10379
10380 if err := handleHTTPErrorResp(response); err != nil {
10381 return nil, fmt.Errorf("GetIAMOrganizationPolicy: http response: %w", err)
10382 }
10383
10384 bodyresp := new(IAMPolicy)
10385 if err := prepareJSONResponse(response, bodyresp); err != nil {
10386 return nil, fmt.Errorf("GetIAMOrganizationPolicy: prepare Json response: %w", err)
10387 }
10388
10389 return bodyresp, nil
10390 }
10391
10392 // Update IAM Organization Policy
10393 func (c Client) UpdateIAMOrganizationPolicy(ctx context.Context, req IAMPolicy) (*Operation, error) {
10394 path := "/iam-organization-policy"
10395
10396 body, err := prepareJSONBody(req)
10397 if err != nil {
10398 return nil, fmt.Errorf("UpdateIAMOrganizationPolicy: prepare Json body: %w", err)
10399 }
10400
10401 request, err := http.NewRequestWithContext(ctx, "PUT", c.serverEndpoint+path, body)
10402 if err != nil {
10403 return nil, fmt.Errorf("UpdateIAMOrganizationPolicy: new request: %w", err)
10404 }
10405
10406 request.Header.Add("User-Agent", c.getUserAgent())
10407
10408 request.Header.Add("Content-Type", "application/json")
10409
10410 if err := c.executeRequestInterceptors(ctx, request); err != nil {
10411 return nil, fmt.Errorf("UpdateIAMOrganizationPolicy: execute request editors: %w", err)
10412 }
10413
10414 if err := c.signRequest(request); err != nil {
10415 return nil, fmt.Errorf("UpdateIAMOrganizationPolicy: sign request: %w", err)
10416 }
10417
10418 if c.trace {
10419 dumpRequest(request, "update-iam-organization-policy")
10420 }
10421
10422 response, err := c.httpClient.Do(request)
10423 if err != nil {
10424 return nil, fmt.Errorf("UpdateIAMOrganizationPolicy: http client do: %w", err)
10425 }
10426
10427 if c.trace {
10428 dumpResponse(response)
10429 }
10430
10431 if err := handleHTTPErrorResp(response); err != nil {
10432 return nil, fmt.Errorf("UpdateIAMOrganizationPolicy: http response: %w", err)
10433 }
10434
10435 bodyresp := new(Operation)
10436 if err := prepareJSONResponse(response, bodyresp); err != nil {
10437 return nil, fmt.Errorf("UpdateIAMOrganizationPolicy: prepare Json response: %w", err)
10438 }
10439
10440 return bodyresp, nil
10441 }
10442
10443 // Reset IAM Organization Policy
10444 func (c Client) ResetIAMOrganizationPolicy(ctx context.Context) (*Operation, error) {
10445 path := "/iam-organization-policy:reset"
10446
10447 request, err := http.NewRequestWithContext(ctx, "POST", c.serverEndpoint+path, nil)
10448 if err != nil {
10449 return nil, fmt.Errorf("ResetIAMOrganizationPolicy: new request: %w", err)
10450 }
10451
10452 request.Header.Add("User-Agent", c.getUserAgent())
10453
10454 if err := c.executeRequestInterceptors(ctx, request); err != nil {
10455 return nil, fmt.Errorf("ResetIAMOrganizationPolicy: execute request editors: %w", err)
10456 }
10457
10458 if err := c.signRequest(request); err != nil {
10459 return nil, fmt.Errorf("ResetIAMOrganizationPolicy: sign request: %w", err)
10460 }
10461
10462 if c.trace {
10463 dumpRequest(request, "reset-iam-organization-policy")
10464 }
10465
10466 response, err := c.httpClient.Do(request)
10467 if err != nil {
10468 return nil, fmt.Errorf("ResetIAMOrganizationPolicy: http client do: %w", err)
10469 }
10470
10471 if c.trace {
10472 dumpResponse(response)
10473 }
10474
10475 if err := handleHTTPErrorResp(response); err != nil {
10476 return nil, fmt.Errorf("ResetIAMOrganizationPolicy: http response: %w", err)
10477 }
10478
10479 bodyresp := new(Operation)
10480 if err := prepareJSONResponse(response, bodyresp); err != nil {
10481 return nil, fmt.Errorf("ResetIAMOrganizationPolicy: prepare Json response: %w", err)
10482 }
10483
10484 return bodyresp, nil
10485 }
10486
10487 type ListIAMRolesResponse struct {
10488 IAMRoles []IAMRole `json:"iam-roles,omitempty"`
10489 }
10490
10491 // FindIAMRole attempts to find an IAMRole by nameOrID.
10492 func (l ListIAMRolesResponse) FindIAMRole(nameOrID string) (IAMRole, error) {
10493 var result []IAMRole
10494 for i, elem := range l.IAMRoles {
10495 if string(elem.Name) == nameOrID || string(elem.ID) == nameOrID {
10496 result = append(result, l.IAMRoles[i])
10497 }
10498 }
10499 if len(result) == 1 {
10500 return result[0], nil
10501 }
10502
10503 if len(result) > 1 {
10504 return IAMRole{}, fmt.Errorf("%q too many found in ListIAMRolesResponse: %w", nameOrID, ErrConflict)
10505 }
10506
10507 return IAMRole{}, fmt.Errorf("%q not found in ListIAMRolesResponse: %w", nameOrID, ErrNotFound)
10508 }
10509
10510 // List IAM Roles
10511 func (c Client) ListIAMRoles(ctx context.Context) (*ListIAMRolesResponse, error) {
10512 path := "/iam-role"
10513
10514 request, err := http.NewRequestWithContext(ctx, "GET", c.serverEndpoint+path, nil)
10515 if err != nil {
10516 return nil, fmt.Errorf("ListIAMRoles: new request: %w", err)
10517 }
10518
10519 request.Header.Add("User-Agent", c.getUserAgent())
10520
10521 if err := c.executeRequestInterceptors(ctx, request); err != nil {
10522 return nil, fmt.Errorf("ListIAMRoles: execute request editors: %w", err)
10523 }
10524
10525 if err := c.signRequest(request); err != nil {
10526 return nil, fmt.Errorf("ListIAMRoles: sign request: %w", err)
10527 }
10528
10529 if c.trace {
10530 dumpRequest(request, "list-iam-roles")
10531 }
10532
10533 response, err := c.httpClient.Do(request)
10534 if err != nil {
10535 return nil, fmt.Errorf("ListIAMRoles: http client do: %w", err)
10536 }
10537
10538 if c.trace {
10539 dumpResponse(response)
10540 }
10541
10542 if err := handleHTTPErrorResp(response); err != nil {
10543 return nil, fmt.Errorf("ListIAMRoles: http response: %w", err)
10544 }
10545
10546 bodyresp := new(ListIAMRolesResponse)
10547 if err := prepareJSONResponse(response, bodyresp); err != nil {
10548 return nil, fmt.Errorf("ListIAMRoles: prepare Json response: %w", err)
10549 }
10550
10551 return bodyresp, nil
10552 }
10553
10554 type CreateIAMRoleRequest struct {
10555 // IAM Role description
10556 Description string `json:"description,omitempty" validate:"omitempty,gte=1,lte=255"`
10557 // Sets if the IAM Role Policy is editable or not (default: true). This setting cannot be changed after creation
10558 Editable *bool `json:"editable,omitempty"`
10559 Labels Labels `json:"labels,omitempty"`
10560 // IAM Role name
10561 Name string `json:"name" validate:"required,gte=1,lte=191"`
10562 // IAM Role permissions
10563 Permissions []string `json:"permissions,omitempty"`
10564 // Policy
10565 Policy *IAMPolicy `json:"policy,omitempty"`
10566 }
10567
10568 // Create IAM Role
10569 func (c Client) CreateIAMRole(ctx context.Context, req CreateIAMRoleRequest) (*Operation, error) {
10570 path := "/iam-role"
10571
10572 body, err := prepareJSONBody(req)
10573 if err != nil {
10574 return nil, fmt.Errorf("CreateIAMRole: prepare Json body: %w", err)
10575 }
10576
10577 request, err := http.NewRequestWithContext(ctx, "POST", c.serverEndpoint+path, body)
10578 if err != nil {
10579 return nil, fmt.Errorf("CreateIAMRole: new request: %w", err)
10580 }
10581
10582 request.Header.Add("User-Agent", c.getUserAgent())
10583
10584 request.Header.Add("Content-Type", "application/json")
10585
10586 if err := c.executeRequestInterceptors(ctx, request); err != nil {
10587 return nil, fmt.Errorf("CreateIAMRole: execute request editors: %w", err)
10588 }
10589
10590 if err := c.signRequest(request); err != nil {
10591 return nil, fmt.Errorf("CreateIAMRole: sign request: %w", err)
10592 }
10593
10594 if c.trace {
10595 dumpRequest(request, "create-iam-role")
10596 }
10597
10598 response, err := c.httpClient.Do(request)
10599 if err != nil {
10600 return nil, fmt.Errorf("CreateIAMRole: http client do: %w", err)
10601 }
10602
10603 if c.trace {
10604 dumpResponse(response)
10605 }
10606
10607 if err := handleHTTPErrorResp(response); err != nil {
10608 return nil, fmt.Errorf("CreateIAMRole: http response: %w", err)
10609 }
10610
10611 bodyresp := new(Operation)
10612 if err := prepareJSONResponse(response, bodyresp); err != nil {
10613 return nil, fmt.Errorf("CreateIAMRole: prepare Json response: %w", err)
10614 }
10615
10616 return bodyresp, nil
10617 }
10618
10619 // Delete IAM Role
10620 func (c Client) DeleteIAMRole(ctx context.Context, id UUID) (*Operation, error) {
10621 path := fmt.Sprintf("/iam-role/%v", id)
10622
10623 request, err := http.NewRequestWithContext(ctx, "DELETE", c.serverEndpoint+path, nil)
10624 if err != nil {
10625 return nil, fmt.Errorf("DeleteIAMRole: new request: %w", err)
10626 }
10627
10628 request.Header.Add("User-Agent", c.getUserAgent())
10629
10630 if err := c.executeRequestInterceptors(ctx, request); err != nil {
10631 return nil, fmt.Errorf("DeleteIAMRole: execute request editors: %w", err)
10632 }
10633
10634 if err := c.signRequest(request); err != nil {
10635 return nil, fmt.Errorf("DeleteIAMRole: sign request: %w", err)
10636 }
10637
10638 if c.trace {
10639 dumpRequest(request, "delete-iam-role")
10640 }
10641
10642 response, err := c.httpClient.Do(request)
10643 if err != nil {
10644 return nil, fmt.Errorf("DeleteIAMRole: http client do: %w", err)
10645 }
10646
10647 if c.trace {
10648 dumpResponse(response)
10649 }
10650
10651 if err := handleHTTPErrorResp(response); err != nil {
10652 return nil, fmt.Errorf("DeleteIAMRole: http response: %w", err)
10653 }
10654
10655 bodyresp := new(Operation)
10656 if err := prepareJSONResponse(response, bodyresp); err != nil {
10657 return nil, fmt.Errorf("DeleteIAMRole: prepare Json response: %w", err)
10658 }
10659
10660 return bodyresp, nil
10661 }
10662
10663 // Retrieve IAM Role
10664 func (c Client) GetIAMRole(ctx context.Context, id UUID) (*IAMRole, error) {
10665 path := fmt.Sprintf("/iam-role/%v", id)
10666
10667 request, err := http.NewRequestWithContext(ctx, "GET", c.serverEndpoint+path, nil)
10668 if err != nil {
10669 return nil, fmt.Errorf("GetIAMRole: new request: %w", err)
10670 }
10671
10672 request.Header.Add("User-Agent", c.getUserAgent())
10673
10674 if err := c.executeRequestInterceptors(ctx, request); err != nil {
10675 return nil, fmt.Errorf("GetIAMRole: execute request editors: %w", err)
10676 }
10677
10678 if err := c.signRequest(request); err != nil {
10679 return nil, fmt.Errorf("GetIAMRole: sign request: %w", err)
10680 }
10681
10682 if c.trace {
10683 dumpRequest(request, "get-iam-role")
10684 }
10685
10686 response, err := c.httpClient.Do(request)
10687 if err != nil {
10688 return nil, fmt.Errorf("GetIAMRole: http client do: %w", err)
10689 }
10690
10691 if c.trace {
10692 dumpResponse(response)
10693 }
10694
10695 if err := handleHTTPErrorResp(response); err != nil {
10696 return nil, fmt.Errorf("GetIAMRole: http response: %w", err)
10697 }
10698
10699 bodyresp := new(IAMRole)
10700 if err := prepareJSONResponse(response, bodyresp); err != nil {
10701 return nil, fmt.Errorf("GetIAMRole: prepare Json response: %w", err)
10702 }
10703
10704 return bodyresp, nil
10705 }
10706
10707 type UpdateIAMRoleRequest struct {
10708 // IAM Role description
10709 Description string `json:"description,omitempty" validate:"omitempty,gte=1,lte=255"`
10710 Labels Labels `json:"labels,omitempty"`
10711 // IAM Role permissions
10712 Permissions []string `json:"permissions,omitempty"`
10713 }
10714
10715 // Update IAM Role
10716 func (c Client) UpdateIAMRole(ctx context.Context, id UUID, req UpdateIAMRoleRequest) (*Operation, error) {
10717 path := fmt.Sprintf("/iam-role/%v", id)
10718
10719 body, err := prepareJSONBody(req)
10720 if err != nil {
10721 return nil, fmt.Errorf("UpdateIAMRole: prepare Json body: %w", err)
10722 }
10723
10724 request, err := http.NewRequestWithContext(ctx, "PUT", c.serverEndpoint+path, body)
10725 if err != nil {
10726 return nil, fmt.Errorf("UpdateIAMRole: new request: %w", err)
10727 }
10728
10729 request.Header.Add("User-Agent", c.getUserAgent())
10730
10731 request.Header.Add("Content-Type", "application/json")
10732
10733 if err := c.executeRequestInterceptors(ctx, request); err != nil {
10734 return nil, fmt.Errorf("UpdateIAMRole: execute request editors: %w", err)
10735 }
10736
10737 if err := c.signRequest(request); err != nil {
10738 return nil, fmt.Errorf("UpdateIAMRole: sign request: %w", err)
10739 }
10740
10741 if c.trace {
10742 dumpRequest(request, "update-iam-role")
10743 }
10744
10745 response, err := c.httpClient.Do(request)
10746 if err != nil {
10747 return nil, fmt.Errorf("UpdateIAMRole: http client do: %w", err)
10748 }
10749
10750 if c.trace {
10751 dumpResponse(response)
10752 }
10753
10754 if err := handleHTTPErrorResp(response); err != nil {
10755 return nil, fmt.Errorf("UpdateIAMRole: http response: %w", err)
10756 }
10757
10758 bodyresp := new(Operation)
10759 if err := prepareJSONResponse(response, bodyresp); err != nil {
10760 return nil, fmt.Errorf("UpdateIAMRole: prepare Json response: %w", err)
10761 }
10762
10763 return bodyresp, nil
10764 }
10765
10766 // Update IAM Role Policy
10767 func (c Client) UpdateIAMRolePolicy(ctx context.Context, id UUID, req IAMPolicy) (*Operation, error) {
10768 path := fmt.Sprintf("/iam-role/%v:policy", id)
10769
10770 body, err := prepareJSONBody(req)
10771 if err != nil {
10772 return nil, fmt.Errorf("UpdateIAMRolePolicy: prepare Json body: %w", err)
10773 }
10774
10775 request, err := http.NewRequestWithContext(ctx, "PUT", c.serverEndpoint+path, body)
10776 if err != nil {
10777 return nil, fmt.Errorf("UpdateIAMRolePolicy: new request: %w", err)
10778 }
10779
10780 request.Header.Add("User-Agent", c.getUserAgent())
10781
10782 request.Header.Add("Content-Type", "application/json")
10783
10784 if err := c.executeRequestInterceptors(ctx, request); err != nil {
10785 return nil, fmt.Errorf("UpdateIAMRolePolicy: execute request editors: %w", err)
10786 }
10787
10788 if err := c.signRequest(request); err != nil {
10789 return nil, fmt.Errorf("UpdateIAMRolePolicy: sign request: %w", err)
10790 }
10791
10792 if c.trace {
10793 dumpRequest(request, "update-iam-role-policy")
10794 }
10795
10796 response, err := c.httpClient.Do(request)
10797 if err != nil {
10798 return nil, fmt.Errorf("UpdateIAMRolePolicy: http client do: %w", err)
10799 }
10800
10801 if c.trace {
10802 dumpResponse(response)
10803 }
10804
10805 if err := handleHTTPErrorResp(response); err != nil {
10806 return nil, fmt.Errorf("UpdateIAMRolePolicy: http response: %w", err)
10807 }
10808
10809 bodyresp := new(Operation)
10810 if err := prepareJSONResponse(response, bodyresp); err != nil {
10811 return nil, fmt.Errorf("UpdateIAMRolePolicy: prepare Json response: %w", err)
10812 }
10813
10814 return bodyresp, nil
10815 }
10816
10817 // Private Network
10818 type ListInstancesResponseInstancesPrivateNetworks struct {
10819 // Private Network ID
10820 ID UUID `json:"id,omitempty"`
10821 // Private Network MAC address
10822 MACAddress string `json:"mac-address,omitempty"`
10823 }
10824
10825 // Instance
10826 type ListInstancesResponseInstances struct {
10827 // Instance creation date
10828 CreatedAT time.Time `json:"created-at,omitempty"`
10829 // Instance ID
10830 ID UUID `json:"id,omitempty"`
10831 // Compute instance type
10832 InstanceType *InstanceType `json:"instance-type,omitempty"`
10833 // Instance IPv6 address
10834 Ipv6Address string `json:"ipv6-address,omitempty"`
10835 Labels Labels `json:"labels,omitempty"`
10836 // Instance MAC address
10837 MACAddress string `json:"mac-address,omitempty"`
10838 // Resource manager
10839 Manager *Manager `json:"manager,omitempty"`
10840 // Instance name
10841 Name string `json:"name,omitempty" validate:"omitempty,gte=1,lte=255"`
10842 // Instance Private Networks
10843 PrivateNetworks []ListInstancesResponseInstancesPrivateNetworks `json:"private-networks,omitempty"`
10844 // Instance public IPv4 address
10845 PublicIP net.IP `json:"public-ip,omitempty"`
10846 PublicIPAssignment PublicIPAssignment `json:"public-ip-assignment,omitempty"`
10847 // Instance Security Groups
10848 SecurityGroups []SecurityGroup `json:"security-groups,omitempty"`
10849 // SSH key
10850 SSHKey *SSHKey `json:"ssh-key,omitempty"`
10851 // Instance SSH Keys
10852 SSHKeys []SSHKey `json:"ssh-keys,omitempty"`
10853 State InstanceState `json:"state,omitempty"`
10854 // Instance template
10855 Template *Template `json:"template,omitempty"`
10856 }
10857
10858 type ListInstancesResponse struct {
10859 Instances []ListInstancesResponseInstances `json:"instances,omitempty"`
10860 }
10861
10862 // FindListInstancesResponseInstances attempts to find an ListInstancesResponseInstances by nameOrID.
10863 func (l ListInstancesResponse) FindListInstancesResponseInstances(nameOrID string) (ListInstancesResponseInstances, error) {
10864 var result []ListInstancesResponseInstances
10865 for i, elem := range l.Instances {
10866 if string(elem.Name) == nameOrID || string(elem.ID) == nameOrID {
10867 result = append(result, l.Instances[i])
10868 }
10869 }
10870 if len(result) == 1 {
10871 return result[0], nil
10872 }
10873
10874 if len(result) > 1 {
10875 return ListInstancesResponseInstances{}, fmt.Errorf("%q too many found in ListInstancesResponse: %w", nameOrID, ErrConflict)
10876 }
10877
10878 return ListInstancesResponseInstances{}, fmt.Errorf("%q not found in ListInstancesResponse: %w", nameOrID, ErrNotFound)
10879 }
10880
10881 type ListInstancesManagerType string
10882
10883 const (
10884 ListInstancesManagerTypeInstancePool ListInstancesManagerType = "instance-pool"
10885 )
10886
10887 type ListInstancesOpt func(url.Values)
10888
10889 func ListInstancesWithManagerID(managerID UUID) ListInstancesOpt {
10890 return func(q url.Values) {
10891 q.Add("manager-id", fmt.Sprint(managerID))
10892 }
10893 }
10894
10895 func ListInstancesWithManagerType(managerType ListInstancesManagerType) ListInstancesOpt {
10896 return func(q url.Values) {
10897 q.Add("manager-type", fmt.Sprint(managerType))
10898 }
10899 }
10900
10901 func ListInstancesWithIPAddress(ipAddress string) ListInstancesOpt {
10902 return func(q url.Values) {
10903 q.Add("ip-address", fmt.Sprint(ipAddress))
10904 }
10905 }
10906
10907 // List Compute instances
10908 func (c Client) ListInstances(ctx context.Context, opts ...ListInstancesOpt) (*ListInstancesResponse, error) {
10909 path := "/instance"
10910
10911 request, err := http.NewRequestWithContext(ctx, "GET", c.serverEndpoint+path, nil)
10912 if err != nil {
10913 return nil, fmt.Errorf("ListInstances: new request: %w", err)
10914 }
10915
10916 request.Header.Add("User-Agent", c.getUserAgent())
10917
10918 if len(opts) > 0 {
10919 q := request.URL.Query()
10920 for _, opt := range opts {
10921 opt(q)
10922 }
10923 request.URL.RawQuery = q.Encode()
10924 }
10925
10926 if err := c.executeRequestInterceptors(ctx, request); err != nil {
10927 return nil, fmt.Errorf("ListInstances: execute request editors: %w", err)
10928 }
10929
10930 if err := c.signRequest(request); err != nil {
10931 return nil, fmt.Errorf("ListInstances: sign request: %w", err)
10932 }
10933
10934 if c.trace {
10935 dumpRequest(request, "list-instances")
10936 }
10937
10938 response, err := c.httpClient.Do(request)
10939 if err != nil {
10940 return nil, fmt.Errorf("ListInstances: http client do: %w", err)
10941 }
10942
10943 if c.trace {
10944 dumpResponse(response)
10945 }
10946
10947 if err := handleHTTPErrorResp(response); err != nil {
10948 return nil, fmt.Errorf("ListInstances: http response: %w", err)
10949 }
10950
10951 bodyresp := new(ListInstancesResponse)
10952 if err := prepareJSONResponse(response, bodyresp); err != nil {
10953 return nil, fmt.Errorf("ListInstances: prepare Json response: %w", err)
10954 }
10955
10956 return bodyresp, nil
10957 }
10958
10959 type CreateInstanceRequest struct {
10960 // Instance Anti-affinity Groups
10961 AntiAffinityGroups []AntiAffinityGroup `json:"anti-affinity-groups,omitempty"`
10962 // Enable application-consistent snapshot for the instance
10963 ApplicationConsistentSnapshotEnabled *bool `json:"application-consistent-snapshot-enabled,omitempty"`
10964 // Start Instance on creation (default: true)
10965 AutoStart *bool `json:"auto-start,omitempty"`
10966 // Deploy target
10967 DeployTarget *DeployTarget `json:"deploy-target,omitempty"`
10968 // Instance disk size in GiB
10969 DiskSize int64 `json:"disk-size" validate:"required,gte=10,lte=51200"`
10970 // Compute instance type
10971 InstanceType *InstanceType `json:"instance-type" validate:"required"`
10972 // Enable IPv6. DEPRECATED: use `public-ip-assignments`.
10973 Ipv6Enabled *bool `json:"ipv6-enabled,omitempty"`
10974 Labels Labels `json:"labels,omitempty"`
10975 // Instance name
10976 Name string `json:"name,omitempty" validate:"omitempty,gte=1,lte=255"`
10977 PublicIPAssignment PublicIPAssignment `json:"public-ip-assignment,omitempty"`
10978 // Enable secure boot
10979 SecurebootEnabled *bool `json:"secureboot-enabled,omitempty"`
10980 // Instance Security Groups
10981 SecurityGroups []SecurityGroup `json:"security-groups,omitempty"`
10982 // SSH key
10983 SSHKey *SSHKey `json:"ssh-key,omitempty"`
10984 // Instance SSH Keys
10985 SSHKeys []SSHKey `json:"ssh-keys,omitempty"`
10986 // Instance template
10987 Template *Template `json:"template" validate:"required"`
10988 // Enable Trusted Platform Module (TPM)
10989 TpmEnabled *bool `json:"tpm-enabled,omitempty"`
10990 // Instance Cloud-init user-data (base64 encoded)
10991 UserData string `json:"user-data,omitempty" validate:"omitempty,gte=1,lte=32768"`
10992 }
10993
10994 // Create a Compute instance
10995 func (c Client) CreateInstance(ctx context.Context, req CreateInstanceRequest) (*Operation, error) {
10996 path := "/instance"
10997
10998 body, err := prepareJSONBody(req)
10999 if err != nil {
11000 return nil, fmt.Errorf("CreateInstance: prepare Json body: %w", err)
11001 }
11002
11003 request, err := http.NewRequestWithContext(ctx, "POST", c.serverEndpoint+path, body)
11004 if err != nil {
11005 return nil, fmt.Errorf("CreateInstance: new request: %w", err)
11006 }
11007
11008 request.Header.Add("User-Agent", c.getUserAgent())
11009
11010 request.Header.Add("Content-Type", "application/json")
11011
11012 if err := c.executeRequestInterceptors(ctx, request); err != nil {
11013 return nil, fmt.Errorf("CreateInstance: execute request editors: %w", err)
11014 }
11015
11016 if err := c.signRequest(request); err != nil {
11017 return nil, fmt.Errorf("CreateInstance: sign request: %w", err)
11018 }
11019
11020 if c.trace {
11021 dumpRequest(request, "create-instance")
11022 }
11023
11024 response, err := c.httpClient.Do(request)
11025 if err != nil {
11026 return nil, fmt.Errorf("CreateInstance: http client do: %w", err)
11027 }
11028
11029 if c.trace {
11030 dumpResponse(response)
11031 }
11032
11033 if err := handleHTTPErrorResp(response); err != nil {
11034 return nil, fmt.Errorf("CreateInstance: http response: %w", err)
11035 }
11036
11037 bodyresp := new(Operation)
11038 if err := prepareJSONResponse(response, bodyresp); err != nil {
11039 return nil, fmt.Errorf("CreateInstance: prepare Json response: %w", err)
11040 }
11041
11042 return bodyresp, nil
11043 }
11044
11045 type ListInstancePoolsResponse struct {
11046 InstancePools []InstancePool `json:"instance-pools,omitempty"`
11047 }
11048
11049 // FindInstancePool attempts to find an InstancePool by nameOrID.
11050 func (l ListInstancePoolsResponse) FindInstancePool(nameOrID string) (InstancePool, error) {
11051 var result []InstancePool
11052 for i, elem := range l.InstancePools {
11053 if string(elem.Name) == nameOrID || string(elem.ID) == nameOrID {
11054 result = append(result, l.InstancePools[i])
11055 }
11056 }
11057 if len(result) == 1 {
11058 return result[0], nil
11059 }
11060
11061 if len(result) > 1 {
11062 return InstancePool{}, fmt.Errorf("%q too many found in ListInstancePoolsResponse: %w", nameOrID, ErrConflict)
11063 }
11064
11065 return InstancePool{}, fmt.Errorf("%q not found in ListInstancePoolsResponse: %w", nameOrID, ErrNotFound)
11066 }
11067
11068 // List Instance Pools
11069 func (c Client) ListInstancePools(ctx context.Context) (*ListInstancePoolsResponse, error) {
11070 path := "/instance-pool"
11071
11072 request, err := http.NewRequestWithContext(ctx, "GET", c.serverEndpoint+path, nil)
11073 if err != nil {
11074 return nil, fmt.Errorf("ListInstancePools: new request: %w", err)
11075 }
11076
11077 request.Header.Add("User-Agent", c.getUserAgent())
11078
11079 if err := c.executeRequestInterceptors(ctx, request); err != nil {
11080 return nil, fmt.Errorf("ListInstancePools: execute request editors: %w", err)
11081 }
11082
11083 if err := c.signRequest(request); err != nil {
11084 return nil, fmt.Errorf("ListInstancePools: sign request: %w", err)
11085 }
11086
11087 if c.trace {
11088 dumpRequest(request, "list-instance-pools")
11089 }
11090
11091 response, err := c.httpClient.Do(request)
11092 if err != nil {
11093 return nil, fmt.Errorf("ListInstancePools: http client do: %w", err)
11094 }
11095
11096 if c.trace {
11097 dumpResponse(response)
11098 }
11099
11100 if err := handleHTTPErrorResp(response); err != nil {
11101 return nil, fmt.Errorf("ListInstancePools: http response: %w", err)
11102 }
11103
11104 bodyresp := new(ListInstancePoolsResponse)
11105 if err := prepareJSONResponse(response, bodyresp); err != nil {
11106 return nil, fmt.Errorf("ListInstancePools: prepare Json response: %w", err)
11107 }
11108
11109 return bodyresp, nil
11110 }
11111
11112 type CreateInstancePoolRequestPublicIPAssignment string
11113
11114 const (
11115 CreateInstancePoolRequestPublicIPAssignmentInet4 CreateInstancePoolRequestPublicIPAssignment = "inet4"
11116 CreateInstancePoolRequestPublicIPAssignmentDual CreateInstancePoolRequestPublicIPAssignment = "dual"
11117 CreateInstancePoolRequestPublicIPAssignmentNone CreateInstancePoolRequestPublicIPAssignment = "none"
11118 )
11119
11120 type CreateInstancePoolRequest struct {
11121 // Instance Pool Anti-affinity Groups
11122 AntiAffinityGroups []AntiAffinityGroup `json:"anti-affinity-groups,omitempty"`
11123 // Enable application consistent snapshots
11124 ApplicationConsistentSnapshotEnabled *bool `json:"application-consistent-snapshot-enabled,omitempty"`
11125 // Deploy target
11126 DeployTarget *DeployTarget `json:"deploy-target,omitempty"`
11127 // Instance Pool description
11128 Description string `json:"description,omitempty" validate:"omitempty,lte=255"`
11129 // Instances disk size in GiB
11130 DiskSize int64 `json:"disk-size" validate:"required,gte=10,lte=51200"`
11131 // Instances Elastic IPs
11132 ElasticIPS []ElasticIP `json:"elastic-ips,omitempty"`
11133 // Prefix to apply to Instances names (default: pool)
11134 InstancePrefix string `json:"instance-prefix,omitempty" validate:"omitempty,gte=1,lte=30"`
11135 // Compute instance type
11136 InstanceType *InstanceType `json:"instance-type" validate:"required"`
11137 // Enable IPv6. DEPRECATED: use `public-ip-assignments`.
11138 Ipv6Enabled *bool `json:"ipv6-enabled,omitempty"`
11139 Labels Labels `json:"labels,omitempty"`
11140 // Minimum number of running Instances
11141 MinAvailable int64 `json:"min-available,omitempty" validate:"omitempty,gte=0"`
11142 // Instance Pool name
11143 Name string `json:"name" validate:"required,gte=1,lte=255"`
11144 // Instance Pool Private Networks
11145 PrivateNetworks []PrivateNetwork `json:"private-networks,omitempty"`
11146 // Determines public IP assignment of the Instances. Type `none` is final and can't be changed later on.
11147 PublicIPAssignment CreateInstancePoolRequestPublicIPAssignment `json:"public-ip-assignment,omitempty"`
11148 // Instance Pool Security Groups
11149 SecurityGroups []SecurityGroup `json:"security-groups,omitempty"`
11150 // Number of Instances
11151 Size int64 `json:"size" validate:"required,gt=0"`
11152 // SSH key
11153 SSHKey *SSHKey `json:"ssh-key,omitempty"`
11154 // Instances SSH Keys
11155 SSHKeys []SSHKey `json:"ssh-keys,omitempty"`
11156 // Instance template
11157 Template *Template `json:"template" validate:"required"`
11158 // Instances Cloud-init user-data
11159 UserData string `json:"user-data,omitempty" validate:"omitempty,gte=1,lte=32768"`
11160 }
11161
11162 // Create an Instance Pool
11163 func (c Client) CreateInstancePool(ctx context.Context, req CreateInstancePoolRequest) (*Operation, error) {
11164 path := "/instance-pool"
11165
11166 body, err := prepareJSONBody(req)
11167 if err != nil {
11168 return nil, fmt.Errorf("CreateInstancePool: prepare Json body: %w", err)
11169 }
11170
11171 request, err := http.NewRequestWithContext(ctx, "POST", c.serverEndpoint+path, body)
11172 if err != nil {
11173 return nil, fmt.Errorf("CreateInstancePool: new request: %w", err)
11174 }
11175
11176 request.Header.Add("User-Agent", c.getUserAgent())
11177
11178 request.Header.Add("Content-Type", "application/json")
11179
11180 if err := c.executeRequestInterceptors(ctx, request); err != nil {
11181 return nil, fmt.Errorf("CreateInstancePool: execute request editors: %w", err)
11182 }
11183
11184 if err := c.signRequest(request); err != nil {
11185 return nil, fmt.Errorf("CreateInstancePool: sign request: %w", err)
11186 }
11187
11188 if c.trace {
11189 dumpRequest(request, "create-instance-pool")
11190 }
11191
11192 response, err := c.httpClient.Do(request)
11193 if err != nil {
11194 return nil, fmt.Errorf("CreateInstancePool: http client do: %w", err)
11195 }
11196
11197 if c.trace {
11198 dumpResponse(response)
11199 }
11200
11201 if err := handleHTTPErrorResp(response); err != nil {
11202 return nil, fmt.Errorf("CreateInstancePool: http response: %w", err)
11203 }
11204
11205 bodyresp := new(Operation)
11206 if err := prepareJSONResponse(response, bodyresp); err != nil {
11207 return nil, fmt.Errorf("CreateInstancePool: prepare Json response: %w", err)
11208 }
11209
11210 return bodyresp, nil
11211 }
11212
11213 // Delete an Instance Pool
11214 func (c Client) DeleteInstancePool(ctx context.Context, id UUID) (*Operation, error) {
11215 path := fmt.Sprintf("/instance-pool/%v", id)
11216
11217 request, err := http.NewRequestWithContext(ctx, "DELETE", c.serverEndpoint+path, nil)
11218 if err != nil {
11219 return nil, fmt.Errorf("DeleteInstancePool: new request: %w", err)
11220 }
11221
11222 request.Header.Add("User-Agent", c.getUserAgent())
11223
11224 if err := c.executeRequestInterceptors(ctx, request); err != nil {
11225 return nil, fmt.Errorf("DeleteInstancePool: execute request editors: %w", err)
11226 }
11227
11228 if err := c.signRequest(request); err != nil {
11229 return nil, fmt.Errorf("DeleteInstancePool: sign request: %w", err)
11230 }
11231
11232 if c.trace {
11233 dumpRequest(request, "delete-instance-pool")
11234 }
11235
11236 response, err := c.httpClient.Do(request)
11237 if err != nil {
11238 return nil, fmt.Errorf("DeleteInstancePool: http client do: %w", err)
11239 }
11240
11241 if c.trace {
11242 dumpResponse(response)
11243 }
11244
11245 if err := handleHTTPErrorResp(response); err != nil {
11246 return nil, fmt.Errorf("DeleteInstancePool: http response: %w", err)
11247 }
11248
11249 bodyresp := new(Operation)
11250 if err := prepareJSONResponse(response, bodyresp); err != nil {
11251 return nil, fmt.Errorf("DeleteInstancePool: prepare Json response: %w", err)
11252 }
11253
11254 return bodyresp, nil
11255 }
11256
11257 // Retrieve Instance Pool details
11258 func (c Client) GetInstancePool(ctx context.Context, id UUID) (*InstancePool, error) {
11259 path := fmt.Sprintf("/instance-pool/%v", id)
11260
11261 request, err := http.NewRequestWithContext(ctx, "GET", c.serverEndpoint+path, nil)
11262 if err != nil {
11263 return nil, fmt.Errorf("GetInstancePool: new request: %w", err)
11264 }
11265
11266 request.Header.Add("User-Agent", c.getUserAgent())
11267
11268 if err := c.executeRequestInterceptors(ctx, request); err != nil {
11269 return nil, fmt.Errorf("GetInstancePool: execute request editors: %w", err)
11270 }
11271
11272 if err := c.signRequest(request); err != nil {
11273 return nil, fmt.Errorf("GetInstancePool: sign request: %w", err)
11274 }
11275
11276 if c.trace {
11277 dumpRequest(request, "get-instance-pool")
11278 }
11279
11280 response, err := c.httpClient.Do(request)
11281 if err != nil {
11282 return nil, fmt.Errorf("GetInstancePool: http client do: %w", err)
11283 }
11284
11285 if c.trace {
11286 dumpResponse(response)
11287 }
11288
11289 if err := handleHTTPErrorResp(response); err != nil {
11290 return nil, fmt.Errorf("GetInstancePool: http response: %w", err)
11291 }
11292
11293 bodyresp := new(InstancePool)
11294 if err := prepareJSONResponse(response, bodyresp); err != nil {
11295 return nil, fmt.Errorf("GetInstancePool: prepare Json response: %w", err)
11296 }
11297
11298 return bodyresp, nil
11299 }
11300
11301 type UpdateInstancePoolRequestPublicIPAssignment string
11302
11303 const (
11304 UpdateInstancePoolRequestPublicIPAssignmentInet4 UpdateInstancePoolRequestPublicIPAssignment = "inet4"
11305 UpdateInstancePoolRequestPublicIPAssignmentDual UpdateInstancePoolRequestPublicIPAssignment = "dual"
11306 )
11307
11308 type UpdateInstancePoolRequest struct {
11309 // Instance Pool Anti-affinity Groups
11310 AntiAffinityGroups []AntiAffinityGroup `json:"anti-affinity-groups"`
11311 // Enable application consistent snapshots
11312 ApplicationConsistentSnapshotEnabled *bool `json:"application-consistent-snapshot-enabled,omitempty"`
11313 // Deploy target
11314 DeployTarget *DeployTarget `json:"deploy-target"`
11315 // Instance Pool description
11316 Description string `json:"description,omitempty" validate:"omitempty,lte=255"`
11317 // Instances disk size in GiB
11318 DiskSize int64 `json:"disk-size,omitempty" validate:"omitempty,gte=10,lte=51200"`
11319 // Instances Elastic IPs
11320 ElasticIPS []ElasticIP `json:"elastic-ips"`
11321 // Prefix to apply to Instances names (default: pool)
11322 InstancePrefix *string `json:"instance-prefix,omitempty"`
11323 // Compute instance type
11324 InstanceType *InstanceType `json:"instance-type,omitempty"`
11325 // Enable IPv6. DEPRECATED: use `public-ip-assignments`.
11326 Ipv6Enabled *bool `json:"ipv6-enabled,omitempty"`
11327 Labels Labels `json:"labels,omitempty"`
11328 // Minimum number of running Instances
11329 MinAvailable *int64 `json:"min-available,omitempty" validate:"omitempty,gte=0"`
11330 // Instance Pool name
11331 Name string `json:"name,omitempty" validate:"omitempty,gte=1,lte=255"`
11332 // Instance Pool Private Networks
11333 PrivateNetworks []PrivateNetwork `json:"private-networks"`
11334 // Determines public IP assignment of the Instances.
11335 PublicIPAssignment UpdateInstancePoolRequestPublicIPAssignment `json:"public-ip-assignment,omitempty"`
11336 // Instance Pool Security Groups
11337 SecurityGroups []SecurityGroup `json:"security-groups"`
11338 // SSH key
11339 SSHKey *SSHKey `json:"ssh-key"`
11340 // Instances SSH keys
11341 SSHKeys []SSHKey `json:"ssh-keys"`
11342 // Instance template
11343 Template *Template `json:"template,omitempty"`
11344 // Instances Cloud-init user-data
11345 UserData *string `json:"user-data,omitempty" validate:"omitempty,gte=1"`
11346 }
11347
11348 // Update an Instance Pool
11349 func (c Client) UpdateInstancePool(ctx context.Context, id UUID, req UpdateInstancePoolRequest) (*Operation, error) {
11350 path := fmt.Sprintf("/instance-pool/%v", id)
11351
11352 body, err := prepareJSONBody(req)
11353 if err != nil {
11354 return nil, fmt.Errorf("UpdateInstancePool: prepare Json body: %w", err)
11355 }
11356
11357 request, err := http.NewRequestWithContext(ctx, "PUT", c.serverEndpoint+path, body)
11358 if err != nil {
11359 return nil, fmt.Errorf("UpdateInstancePool: new request: %w", err)
11360 }
11361
11362 request.Header.Add("User-Agent", c.getUserAgent())
11363
11364 request.Header.Add("Content-Type", "application/json")
11365
11366 if err := c.executeRequestInterceptors(ctx, request); err != nil {
11367 return nil, fmt.Errorf("UpdateInstancePool: execute request editors: %w", err)
11368 }
11369
11370 if err := c.signRequest(request); err != nil {
11371 return nil, fmt.Errorf("UpdateInstancePool: sign request: %w", err)
11372 }
11373
11374 if c.trace {
11375 dumpRequest(request, "update-instance-pool")
11376 }
11377
11378 response, err := c.httpClient.Do(request)
11379 if err != nil {
11380 return nil, fmt.Errorf("UpdateInstancePool: http client do: %w", err)
11381 }
11382
11383 if c.trace {
11384 dumpResponse(response)
11385 }
11386
11387 if err := handleHTTPErrorResp(response); err != nil {
11388 return nil, fmt.Errorf("UpdateInstancePool: http response: %w", err)
11389 }
11390
11391 bodyresp := new(Operation)
11392 if err := prepareJSONResponse(response, bodyresp); err != nil {
11393 return nil, fmt.Errorf("UpdateInstancePool: prepare Json response: %w", err)
11394 }
11395
11396 return bodyresp, nil
11397 }
11398
11399 type ResetInstancePoolFieldField string
11400
11401 const (
11402 ResetInstancePoolFieldFieldAntiAffinityGroups ResetInstancePoolFieldField = "anti-affinity-groups"
11403 ResetInstancePoolFieldFieldDescription ResetInstancePoolFieldField = "description"
11404 ResetInstancePoolFieldFieldLabels ResetInstancePoolFieldField = "labels"
11405 ResetInstancePoolFieldFieldSecurityGroups ResetInstancePoolFieldField = "security-groups"
11406 ResetInstancePoolFieldFieldElasticIPS ResetInstancePoolFieldField = "elastic-ips"
11407 ResetInstancePoolFieldFieldPrivateNetworks ResetInstancePoolFieldField = "private-networks"
11408 ResetInstancePoolFieldFieldSSHKey ResetInstancePoolFieldField = "ssh-key"
11409 ResetInstancePoolFieldFieldUserData ResetInstancePoolFieldField = "user-data"
11410 ResetInstancePoolFieldFieldDeployTarget ResetInstancePoolFieldField = "deploy-target"
11411 ResetInstancePoolFieldFieldIpv6Enabled ResetInstancePoolFieldField = "ipv6-enabled"
11412 )
11413
11414 // Reset an Instance Pool field to its default value
11415 func (c Client) ResetInstancePoolField(ctx context.Context, id UUID, field ResetInstancePoolFieldField) (*Operation, error) {
11416 path := fmt.Sprintf("/instance-pool/%v/%v", id, field)
11417
11418 request, err := http.NewRequestWithContext(ctx, "DELETE", c.serverEndpoint+path, nil)
11419 if err != nil {
11420 return nil, fmt.Errorf("ResetInstancePoolField: new request: %w", err)
11421 }
11422
11423 request.Header.Add("User-Agent", c.getUserAgent())
11424
11425 if err := c.executeRequestInterceptors(ctx, request); err != nil {
11426 return nil, fmt.Errorf("ResetInstancePoolField: execute request editors: %w", err)
11427 }
11428
11429 if err := c.signRequest(request); err != nil {
11430 return nil, fmt.Errorf("ResetInstancePoolField: sign request: %w", err)
11431 }
11432
11433 if c.trace {
11434 dumpRequest(request, "reset-instance-pool-field")
11435 }
11436
11437 response, err := c.httpClient.Do(request)
11438 if err != nil {
11439 return nil, fmt.Errorf("ResetInstancePoolField: http client do: %w", err)
11440 }
11441
11442 if c.trace {
11443 dumpResponse(response)
11444 }
11445
11446 if err := handleHTTPErrorResp(response); err != nil {
11447 return nil, fmt.Errorf("ResetInstancePoolField: http response: %w", err)
11448 }
11449
11450 bodyresp := new(Operation)
11451 if err := prepareJSONResponse(response, bodyresp); err != nil {
11452 return nil, fmt.Errorf("ResetInstancePoolField: prepare Json response: %w", err)
11453 }
11454
11455 return bodyresp, nil
11456 }
11457
11458 type EvictInstancePoolMembersRequest struct {
11459 Instances []UUID `json:"instances,omitempty"`
11460 }
11461
11462 // This operation evicts the specified Compute instances member from the Instance Pool, shrinking it to `<current pool size> - <# evicted members>`.
11463 func (c Client) EvictInstancePoolMembers(ctx context.Context, id UUID, req EvictInstancePoolMembersRequest) (*Operation, error) {
11464 path := fmt.Sprintf("/instance-pool/%v:evict", id)
11465
11466 body, err := prepareJSONBody(req)
11467 if err != nil {
11468 return nil, fmt.Errorf("EvictInstancePoolMembers: prepare Json body: %w", err)
11469 }
11470
11471 request, err := http.NewRequestWithContext(ctx, "PUT", c.serverEndpoint+path, body)
11472 if err != nil {
11473 return nil, fmt.Errorf("EvictInstancePoolMembers: new request: %w", err)
11474 }
11475
11476 request.Header.Add("User-Agent", c.getUserAgent())
11477
11478 request.Header.Add("Content-Type", "application/json")
11479
11480 if err := c.executeRequestInterceptors(ctx, request); err != nil {
11481 return nil, fmt.Errorf("EvictInstancePoolMembers: execute request editors: %w", err)
11482 }
11483
11484 if err := c.signRequest(request); err != nil {
11485 return nil, fmt.Errorf("EvictInstancePoolMembers: sign request: %w", err)
11486 }
11487
11488 if c.trace {
11489 dumpRequest(request, "evict-instance-pool-members")
11490 }
11491
11492 response, err := c.httpClient.Do(request)
11493 if err != nil {
11494 return nil, fmt.Errorf("EvictInstancePoolMembers: http client do: %w", err)
11495 }
11496
11497 if c.trace {
11498 dumpResponse(response)
11499 }
11500
11501 if err := handleHTTPErrorResp(response); err != nil {
11502 return nil, fmt.Errorf("EvictInstancePoolMembers: http response: %w", err)
11503 }
11504
11505 bodyresp := new(Operation)
11506 if err := prepareJSONResponse(response, bodyresp); err != nil {
11507 return nil, fmt.Errorf("EvictInstancePoolMembers: prepare Json response: %w", err)
11508 }
11509
11510 return bodyresp, nil
11511 }
11512
11513 type ScaleInstancePoolRequest struct {
11514 // Number of managed Instances
11515 Size int64 `json:"size" validate:"required,gt=0"`
11516 }
11517
11518 // Scale an Instance Pool
11519 func (c Client) ScaleInstancePool(ctx context.Context, id UUID, req ScaleInstancePoolRequest) (*Operation, error) {
11520 path := fmt.Sprintf("/instance-pool/%v:scale", id)
11521
11522 body, err := prepareJSONBody(req)
11523 if err != nil {
11524 return nil, fmt.Errorf("ScaleInstancePool: prepare Json body: %w", err)
11525 }
11526
11527 request, err := http.NewRequestWithContext(ctx, "PUT", c.serverEndpoint+path, body)
11528 if err != nil {
11529 return nil, fmt.Errorf("ScaleInstancePool: new request: %w", err)
11530 }
11531
11532 request.Header.Add("User-Agent", c.getUserAgent())
11533
11534 request.Header.Add("Content-Type", "application/json")
11535
11536 if err := c.executeRequestInterceptors(ctx, request); err != nil {
11537 return nil, fmt.Errorf("ScaleInstancePool: execute request editors: %w", err)
11538 }
11539
11540 if err := c.signRequest(request); err != nil {
11541 return nil, fmt.Errorf("ScaleInstancePool: sign request: %w", err)
11542 }
11543
11544 if c.trace {
11545 dumpRequest(request, "scale-instance-pool")
11546 }
11547
11548 response, err := c.httpClient.Do(request)
11549 if err != nil {
11550 return nil, fmt.Errorf("ScaleInstancePool: http client do: %w", err)
11551 }
11552
11553 if c.trace {
11554 dumpResponse(response)
11555 }
11556
11557 if err := handleHTTPErrorResp(response); err != nil {
11558 return nil, fmt.Errorf("ScaleInstancePool: http response: %w", err)
11559 }
11560
11561 bodyresp := new(Operation)
11562 if err := prepareJSONResponse(response, bodyresp); err != nil {
11563 return nil, fmt.Errorf("ScaleInstancePool: prepare Json response: %w", err)
11564 }
11565
11566 return bodyresp, nil
11567 }
11568
11569 type ListInstanceTypesResponse struct {
11570 InstanceTypes []InstanceType `json:"instance-types,omitempty"`
11571 }
11572
11573 // FindInstanceType attempts to find an InstanceType by id.
11574 func (l ListInstanceTypesResponse) FindInstanceType(id string) (InstanceType, error) {
11575 var result []InstanceType
11576 for i, elem := range l.InstanceTypes {
11577 if string(elem.ID) == id {
11578 result = append(result, l.InstanceTypes[i])
11579 }
11580 }
11581 if len(result) == 1 {
11582 return result[0], nil
11583 }
11584
11585 if len(result) > 1 {
11586 return InstanceType{}, fmt.Errorf("%q too many found in ListInstanceTypesResponse: %w", id, ErrConflict)
11587 }
11588
11589 return InstanceType{}, fmt.Errorf("%q not found in ListInstanceTypesResponse: %w", id, ErrNotFound)
11590 }
11591
11592 // List Compute instance Types
11593 func (c Client) ListInstanceTypes(ctx context.Context) (*ListInstanceTypesResponse, error) {
11594 path := "/instance-type"
11595
11596 request, err := http.NewRequestWithContext(ctx, "GET", c.serverEndpoint+path, nil)
11597 if err != nil {
11598 return nil, fmt.Errorf("ListInstanceTypes: new request: %w", err)
11599 }
11600
11601 request.Header.Add("User-Agent", c.getUserAgent())
11602
11603 if err := c.executeRequestInterceptors(ctx, request); err != nil {
11604 return nil, fmt.Errorf("ListInstanceTypes: execute request editors: %w", err)
11605 }
11606
11607 if err := c.signRequest(request); err != nil {
11608 return nil, fmt.Errorf("ListInstanceTypes: sign request: %w", err)
11609 }
11610
11611 if c.trace {
11612 dumpRequest(request, "list-instance-types")
11613 }
11614
11615 response, err := c.httpClient.Do(request)
11616 if err != nil {
11617 return nil, fmt.Errorf("ListInstanceTypes: http client do: %w", err)
11618 }
11619
11620 if c.trace {
11621 dumpResponse(response)
11622 }
11623
11624 if err := handleHTTPErrorResp(response); err != nil {
11625 return nil, fmt.Errorf("ListInstanceTypes: http response: %w", err)
11626 }
11627
11628 bodyresp := new(ListInstanceTypesResponse)
11629 if err := prepareJSONResponse(response, bodyresp); err != nil {
11630 return nil, fmt.Errorf("ListInstanceTypes: prepare Json response: %w", err)
11631 }
11632
11633 return bodyresp, nil
11634 }
11635
11636 // Retrieve Instance Type details
11637 func (c Client) GetInstanceType(ctx context.Context, id UUID) (*InstanceType, error) {
11638 path := fmt.Sprintf("/instance-type/%v", id)
11639
11640 request, err := http.NewRequestWithContext(ctx, "GET", c.serverEndpoint+path, nil)
11641 if err != nil {
11642 return nil, fmt.Errorf("GetInstanceType: new request: %w", err)
11643 }
11644
11645 request.Header.Add("User-Agent", c.getUserAgent())
11646
11647 if err := c.executeRequestInterceptors(ctx, request); err != nil {
11648 return nil, fmt.Errorf("GetInstanceType: execute request editors: %w", err)
11649 }
11650
11651 if err := c.signRequest(request); err != nil {
11652 return nil, fmt.Errorf("GetInstanceType: sign request: %w", err)
11653 }
11654
11655 if c.trace {
11656 dumpRequest(request, "get-instance-type")
11657 }
11658
11659 response, err := c.httpClient.Do(request)
11660 if err != nil {
11661 return nil, fmt.Errorf("GetInstanceType: http client do: %w", err)
11662 }
11663
11664 if c.trace {
11665 dumpResponse(response)
11666 }
11667
11668 if err := handleHTTPErrorResp(response); err != nil {
11669 return nil, fmt.Errorf("GetInstanceType: http response: %w", err)
11670 }
11671
11672 bodyresp := new(InstanceType)
11673 if err := prepareJSONResponse(response, bodyresp); err != nil {
11674 return nil, fmt.Errorf("GetInstanceType: prepare Json response: %w", err)
11675 }
11676
11677 return bodyresp, nil
11678 }
11679
11680 // Delete a Compute instance
11681 func (c Client) DeleteInstance(ctx context.Context, id UUID) (*Operation, error) {
11682 path := fmt.Sprintf("/instance/%v", id)
11683
11684 request, err := http.NewRequestWithContext(ctx, "DELETE", c.serverEndpoint+path, nil)
11685 if err != nil {
11686 return nil, fmt.Errorf("DeleteInstance: new request: %w", err)
11687 }
11688
11689 request.Header.Add("User-Agent", c.getUserAgent())
11690
11691 if err := c.executeRequestInterceptors(ctx, request); err != nil {
11692 return nil, fmt.Errorf("DeleteInstance: execute request editors: %w", err)
11693 }
11694
11695 if err := c.signRequest(request); err != nil {
11696 return nil, fmt.Errorf("DeleteInstance: sign request: %w", err)
11697 }
11698
11699 if c.trace {
11700 dumpRequest(request, "delete-instance")
11701 }
11702
11703 response, err := c.httpClient.Do(request)
11704 if err != nil {
11705 return nil, fmt.Errorf("DeleteInstance: http client do: %w", err)
11706 }
11707
11708 if c.trace {
11709 dumpResponse(response)
11710 }
11711
11712 if err := handleHTTPErrorResp(response); err != nil {
11713 return nil, fmt.Errorf("DeleteInstance: http response: %w", err)
11714 }
11715
11716 bodyresp := new(Operation)
11717 if err := prepareJSONResponse(response, bodyresp); err != nil {
11718 return nil, fmt.Errorf("DeleteInstance: prepare Json response: %w", err)
11719 }
11720
11721 return bodyresp, nil
11722 }
11723
11724 // Retrieve Compute instance details
11725 func (c Client) GetInstance(ctx context.Context, id UUID) (*Instance, error) {
11726 path := fmt.Sprintf("/instance/%v", id)
11727
11728 request, err := http.NewRequestWithContext(ctx, "GET", c.serverEndpoint+path, nil)
11729 if err != nil {
11730 return nil, fmt.Errorf("GetInstance: new request: %w", err)
11731 }
11732
11733 request.Header.Add("User-Agent", c.getUserAgent())
11734
11735 if err := c.executeRequestInterceptors(ctx, request); err != nil {
11736 return nil, fmt.Errorf("GetInstance: execute request editors: %w", err)
11737 }
11738
11739 if err := c.signRequest(request); err != nil {
11740 return nil, fmt.Errorf("GetInstance: sign request: %w", err)
11741 }
11742
11743 if c.trace {
11744 dumpRequest(request, "get-instance")
11745 }
11746
11747 response, err := c.httpClient.Do(request)
11748 if err != nil {
11749 return nil, fmt.Errorf("GetInstance: http client do: %w", err)
11750 }
11751
11752 if c.trace {
11753 dumpResponse(response)
11754 }
11755
11756 if err := handleHTTPErrorResp(response); err != nil {
11757 return nil, fmt.Errorf("GetInstance: http response: %w", err)
11758 }
11759
11760 bodyresp := new(Instance)
11761 if err := prepareJSONResponse(response, bodyresp); err != nil {
11762 return nil, fmt.Errorf("GetInstance: prepare Json response: %w", err)
11763 }
11764
11765 return bodyresp, nil
11766 }
11767
11768 type UpdateInstanceRequest struct {
11769 // Enable/Disable Application Consistent Snapshot for Instance
11770 ApplicationConsistentSnapshotEnabled *bool `json:"application-consistent-snapshot-enabled,omitempty"`
11771 Labels Labels `json:"labels"`
11772 // Instance name
11773 Name string `json:"name,omitempty" validate:"omitempty,gte=1,lte=255"`
11774 PublicIPAssignment PublicIPAssignment `json:"public-ip-assignment,omitempty"`
11775 // Instance Cloud-init user-data (base64 encoded)
11776 UserData string `json:"user-data,omitempty" validate:"omitempty,gte=1,lte=32768"`
11777 }
11778
11779 // Update a Compute instance
11780 func (c Client) UpdateInstance(ctx context.Context, id UUID, req UpdateInstanceRequest) (*Operation, error) {
11781 path := fmt.Sprintf("/instance/%v", id)
11782
11783 body, err := prepareJSONBody(req)
11784 if err != nil {
11785 return nil, fmt.Errorf("UpdateInstance: prepare Json body: %w", err)
11786 }
11787
11788 request, err := http.NewRequestWithContext(ctx, "PUT", c.serverEndpoint+path, body)
11789 if err != nil {
11790 return nil, fmt.Errorf("UpdateInstance: new request: %w", err)
11791 }
11792
11793 request.Header.Add("User-Agent", c.getUserAgent())
11794
11795 request.Header.Add("Content-Type", "application/json")
11796
11797 if err := c.executeRequestInterceptors(ctx, request); err != nil {
11798 return nil, fmt.Errorf("UpdateInstance: execute request editors: %w", err)
11799 }
11800
11801 if err := c.signRequest(request); err != nil {
11802 return nil, fmt.Errorf("UpdateInstance: sign request: %w", err)
11803 }
11804
11805 if c.trace {
11806 dumpRequest(request, "update-instance")
11807 }
11808
11809 response, err := c.httpClient.Do(request)
11810 if err != nil {
11811 return nil, fmt.Errorf("UpdateInstance: http client do: %w", err)
11812 }
11813
11814 if c.trace {
11815 dumpResponse(response)
11816 }
11817
11818 if err := handleHTTPErrorResp(response); err != nil {
11819 return nil, fmt.Errorf("UpdateInstance: http response: %w", err)
11820 }
11821
11822 bodyresp := new(Operation)
11823 if err := prepareJSONResponse(response, bodyresp); err != nil {
11824 return nil, fmt.Errorf("UpdateInstance: prepare Json response: %w", err)
11825 }
11826
11827 return bodyresp, nil
11828 }
11829
11830 type ResetInstanceFieldField string
11831
11832 const (
11833 ResetInstanceFieldFieldLabels ResetInstanceFieldField = "labels"
11834 )
11835
11836 // Reset Instance field
11837 func (c Client) ResetInstanceField(ctx context.Context, id UUID, field ResetInstanceFieldField) (*Operation, error) {
11838 path := fmt.Sprintf("/instance/%v/%v", id, field)
11839
11840 request, err := http.NewRequestWithContext(ctx, "DELETE", c.serverEndpoint+path, nil)
11841 if err != nil {
11842 return nil, fmt.Errorf("ResetInstanceField: new request: %w", err)
11843 }
11844
11845 request.Header.Add("User-Agent", c.getUserAgent())
11846
11847 if err := c.executeRequestInterceptors(ctx, request); err != nil {
11848 return nil, fmt.Errorf("ResetInstanceField: execute request editors: %w", err)
11849 }
11850
11851 if err := c.signRequest(request); err != nil {
11852 return nil, fmt.Errorf("ResetInstanceField: sign request: %w", err)
11853 }
11854
11855 if c.trace {
11856 dumpRequest(request, "reset-instance-field")
11857 }
11858
11859 response, err := c.httpClient.Do(request)
11860 if err != nil {
11861 return nil, fmt.Errorf("ResetInstanceField: http client do: %w", err)
11862 }
11863
11864 if c.trace {
11865 dumpResponse(response)
11866 }
11867
11868 if err := handleHTTPErrorResp(response); err != nil {
11869 return nil, fmt.Errorf("ResetInstanceField: http response: %w", err)
11870 }
11871
11872 bodyresp := new(Operation)
11873 if err := prepareJSONResponse(response, bodyresp); err != nil {
11874 return nil, fmt.Errorf("ResetInstanceField: prepare Json response: %w", err)
11875 }
11876
11877 return bodyresp, nil
11878 }
11879
11880 // Set instance destruction protection
11881 func (c Client) AddInstanceProtection(ctx context.Context, id UUID) (*Operation, error) {
11882 path := fmt.Sprintf("/instance/%v:add-protection", id)
11883
11884 request, err := http.NewRequestWithContext(ctx, "PUT", c.serverEndpoint+path, nil)
11885 if err != nil {
11886 return nil, fmt.Errorf("AddInstanceProtection: new request: %w", err)
11887 }
11888
11889 request.Header.Add("User-Agent", c.getUserAgent())
11890
11891 if err := c.executeRequestInterceptors(ctx, request); err != nil {
11892 return nil, fmt.Errorf("AddInstanceProtection: execute request editors: %w", err)
11893 }
11894
11895 if err := c.signRequest(request); err != nil {
11896 return nil, fmt.Errorf("AddInstanceProtection: sign request: %w", err)
11897 }
11898
11899 if c.trace {
11900 dumpRequest(request, "add-instance-protection")
11901 }
11902
11903 response, err := c.httpClient.Do(request)
11904 if err != nil {
11905 return nil, fmt.Errorf("AddInstanceProtection: http client do: %w", err)
11906 }
11907
11908 if c.trace {
11909 dumpResponse(response)
11910 }
11911
11912 if err := handleHTTPErrorResp(response); err != nil {
11913 return nil, fmt.Errorf("AddInstanceProtection: http response: %w", err)
11914 }
11915
11916 bodyresp := new(Operation)
11917 if err := prepareJSONResponse(response, bodyresp); err != nil {
11918 return nil, fmt.Errorf("AddInstanceProtection: prepare Json response: %w", err)
11919 }
11920
11921 return bodyresp, nil
11922 }
11923
11924 // Create a Snapshot of a Compute instance
11925 func (c Client) CreateSnapshot(ctx context.Context, id UUID) (*Operation, error) {
11926 path := fmt.Sprintf("/instance/%v:create-snapshot", id)
11927
11928 request, err := http.NewRequestWithContext(ctx, "POST", c.serverEndpoint+path, nil)
11929 if err != nil {
11930 return nil, fmt.Errorf("CreateSnapshot: new request: %w", err)
11931 }
11932
11933 request.Header.Add("User-Agent", c.getUserAgent())
11934
11935 if err := c.executeRequestInterceptors(ctx, request); err != nil {
11936 return nil, fmt.Errorf("CreateSnapshot: execute request editors: %w", err)
11937 }
11938
11939 if err := c.signRequest(request); err != nil {
11940 return nil, fmt.Errorf("CreateSnapshot: sign request: %w", err)
11941 }
11942
11943 if c.trace {
11944 dumpRequest(request, "create-snapshot")
11945 }
11946
11947 response, err := c.httpClient.Do(request)
11948 if err != nil {
11949 return nil, fmt.Errorf("CreateSnapshot: http client do: %w", err)
11950 }
11951
11952 if c.trace {
11953 dumpResponse(response)
11954 }
11955
11956 if err := handleHTTPErrorResp(response); err != nil {
11957 return nil, fmt.Errorf("CreateSnapshot: http response: %w", err)
11958 }
11959
11960 bodyresp := new(Operation)
11961 if err := prepareJSONResponse(response, bodyresp); err != nil {
11962 return nil, fmt.Errorf("CreateSnapshot: prepare Json response: %w", err)
11963 }
11964
11965 return bodyresp, nil
11966 }
11967
11968 // Enable tpm for the instance.
11969 func (c Client) EnableTpm(ctx context.Context, id UUID) (*Operation, error) {
11970 path := fmt.Sprintf("/instance/%v:enable-tpm", id)
11971
11972 request, err := http.NewRequestWithContext(ctx, "POST", c.serverEndpoint+path, nil)
11973 if err != nil {
11974 return nil, fmt.Errorf("EnableTpm: new request: %w", err)
11975 }
11976
11977 request.Header.Add("User-Agent", c.getUserAgent())
11978
11979 if err := c.executeRequestInterceptors(ctx, request); err != nil {
11980 return nil, fmt.Errorf("EnableTpm: execute request editors: %w", err)
11981 }
11982
11983 if err := c.signRequest(request); err != nil {
11984 return nil, fmt.Errorf("EnableTpm: sign request: %w", err)
11985 }
11986
11987 if c.trace {
11988 dumpRequest(request, "enable-tpm")
11989 }
11990
11991 response, err := c.httpClient.Do(request)
11992 if err != nil {
11993 return nil, fmt.Errorf("EnableTpm: http client do: %w", err)
11994 }
11995
11996 if c.trace {
11997 dumpResponse(response)
11998 }
11999
12000 if err := handleHTTPErrorResp(response); err != nil {
12001 return nil, fmt.Errorf("EnableTpm: http response: %w", err)
12002 }
12003
12004 bodyresp := new(Operation)
12005 if err := prepareJSONResponse(response, bodyresp); err != nil {
12006 return nil, fmt.Errorf("EnableTpm: prepare Json response: %w", err)
12007 }
12008
12009 return bodyresp, nil
12010 }
12011
12012 // Reveal the password used during instance creation or the latest password reset.
12013 // This is only available for VMs created against templates having the `password-enabled`
12014 // property set to `true`.
12015 // creation or resets.
12016 // creation or resets.
12017 func (c Client) RevealInstancePassword(ctx context.Context, id UUID) (*InstancePassword, error) {
12018 path := fmt.Sprintf("/instance/%v:password", id)
12019
12020 request, err := http.NewRequestWithContext(ctx, "GET", c.serverEndpoint+path, nil)
12021 if err != nil {
12022 return nil, fmt.Errorf("RevealInstancePassword: new request: %w", err)
12023 }
12024
12025 request.Header.Add("User-Agent", c.getUserAgent())
12026
12027 if err := c.executeRequestInterceptors(ctx, request); err != nil {
12028 return nil, fmt.Errorf("RevealInstancePassword: execute request editors: %w", err)
12029 }
12030
12031 if err := c.signRequest(request); err != nil {
12032 return nil, fmt.Errorf("RevealInstancePassword: sign request: %w", err)
12033 }
12034
12035 if c.trace {
12036 dumpRequest(request, "reveal-instance-password")
12037 }
12038
12039 response, err := c.httpClient.Do(request)
12040 if err != nil {
12041 return nil, fmt.Errorf("RevealInstancePassword: http client do: %w", err)
12042 }
12043
12044 if c.trace {
12045 dumpResponse(response)
12046 }
12047
12048 if err := handleHTTPErrorResp(response); err != nil {
12049 return nil, fmt.Errorf("RevealInstancePassword: http response: %w", err)
12050 }
12051
12052 bodyresp := new(InstancePassword)
12053 if err := prepareJSONResponse(response, bodyresp); err != nil {
12054 return nil, fmt.Errorf("RevealInstancePassword: prepare Json response: %w", err)
12055 }
12056
12057 return bodyresp, nil
12058 }
12059
12060 // Reboot a Compute instance
12061 func (c Client) RebootInstance(ctx context.Context, id UUID) (*Operation, error) {
12062 path := fmt.Sprintf("/instance/%v:reboot", id)
12063
12064 request, err := http.NewRequestWithContext(ctx, "PUT", c.serverEndpoint+path, nil)
12065 if err != nil {
12066 return nil, fmt.Errorf("RebootInstance: new request: %w", err)
12067 }
12068
12069 request.Header.Add("User-Agent", c.getUserAgent())
12070
12071 if err := c.executeRequestInterceptors(ctx, request); err != nil {
12072 return nil, fmt.Errorf("RebootInstance: execute request editors: %w", err)
12073 }
12074
12075 if err := c.signRequest(request); err != nil {
12076 return nil, fmt.Errorf("RebootInstance: sign request: %w", err)
12077 }
12078
12079 if c.trace {
12080 dumpRequest(request, "reboot-instance")
12081 }
12082
12083 response, err := c.httpClient.Do(request)
12084 if err != nil {
12085 return nil, fmt.Errorf("RebootInstance: http client do: %w", err)
12086 }
12087
12088 if c.trace {
12089 dumpResponse(response)
12090 }
12091
12092 if err := handleHTTPErrorResp(response); err != nil {
12093 return nil, fmt.Errorf("RebootInstance: http response: %w", err)
12094 }
12095
12096 bodyresp := new(Operation)
12097 if err := prepareJSONResponse(response, bodyresp); err != nil {
12098 return nil, fmt.Errorf("RebootInstance: prepare Json response: %w", err)
12099 }
12100
12101 return bodyresp, nil
12102 }
12103
12104 // Remove instance destruction protection
12105 func (c Client) RemoveInstanceProtection(ctx context.Context, id UUID) (*Operation, error) {
12106 path := fmt.Sprintf("/instance/%v:remove-protection", id)
12107
12108 request, err := http.NewRequestWithContext(ctx, "PUT", c.serverEndpoint+path, nil)
12109 if err != nil {
12110 return nil, fmt.Errorf("RemoveInstanceProtection: new request: %w", err)
12111 }
12112
12113 request.Header.Add("User-Agent", c.getUserAgent())
12114
12115 if err := c.executeRequestInterceptors(ctx, request); err != nil {
12116 return nil, fmt.Errorf("RemoveInstanceProtection: execute request editors: %w", err)
12117 }
12118
12119 if err := c.signRequest(request); err != nil {
12120 return nil, fmt.Errorf("RemoveInstanceProtection: sign request: %w", err)
12121 }
12122
12123 if c.trace {
12124 dumpRequest(request, "remove-instance-protection")
12125 }
12126
12127 response, err := c.httpClient.Do(request)
12128 if err != nil {
12129 return nil, fmt.Errorf("RemoveInstanceProtection: http client do: %w", err)
12130 }
12131
12132 if c.trace {
12133 dumpResponse(response)
12134 }
12135
12136 if err := handleHTTPErrorResp(response); err != nil {
12137 return nil, fmt.Errorf("RemoveInstanceProtection: http response: %w", err)
12138 }
12139
12140 bodyresp := new(Operation)
12141 if err := prepareJSONResponse(response, bodyresp); err != nil {
12142 return nil, fmt.Errorf("RemoveInstanceProtection: prepare Json response: %w", err)
12143 }
12144
12145 return bodyresp, nil
12146 }
12147
12148 type ResetInstanceRequest struct {
12149 // Instance disk size in GiB
12150 DiskSize int64 `json:"disk-size,omitempty" validate:"omitempty,gte=10,lte=51200"`
12151 // Instance template
12152 Template *Template `json:"template,omitempty"`
12153 }
12154
12155 // This operation re-installs a Compute instance to a base template. If target template is provided it will be used to recreated instance from. Warning: the operation wipes all data stored on the disk.
12156 func (c Client) ResetInstance(ctx context.Context, id UUID, req ResetInstanceRequest) (*Operation, error) {
12157 path := fmt.Sprintf("/instance/%v:reset", id)
12158
12159 body, err := prepareJSONBody(req)
12160 if err != nil {
12161 return nil, fmt.Errorf("ResetInstance: prepare Json body: %w", err)
12162 }
12163
12164 request, err := http.NewRequestWithContext(ctx, "PUT", c.serverEndpoint+path, body)
12165 if err != nil {
12166 return nil, fmt.Errorf("ResetInstance: new request: %w", err)
12167 }
12168
12169 request.Header.Add("User-Agent", c.getUserAgent())
12170
12171 request.Header.Add("Content-Type", "application/json")
12172
12173 if err := c.executeRequestInterceptors(ctx, request); err != nil {
12174 return nil, fmt.Errorf("ResetInstance: execute request editors: %w", err)
12175 }
12176
12177 if err := c.signRequest(request); err != nil {
12178 return nil, fmt.Errorf("ResetInstance: sign request: %w", err)
12179 }
12180
12181 if c.trace {
12182 dumpRequest(request, "reset-instance")
12183 }
12184
12185 response, err := c.httpClient.Do(request)
12186 if err != nil {
12187 return nil, fmt.Errorf("ResetInstance: http client do: %w", err)
12188 }
12189
12190 if c.trace {
12191 dumpResponse(response)
12192 }
12193
12194 if err := handleHTTPErrorResp(response); err != nil {
12195 return nil, fmt.Errorf("ResetInstance: http response: %w", err)
12196 }
12197
12198 bodyresp := new(Operation)
12199 if err := prepareJSONResponse(response, bodyresp); err != nil {
12200 return nil, fmt.Errorf("ResetInstance: prepare Json response: %w", err)
12201 }
12202
12203 return bodyresp, nil
12204 }
12205
12206 // Reset a compute instance password
12207 func (c Client) ResetInstancePassword(ctx context.Context, id UUID) (*Operation, error) {
12208 path := fmt.Sprintf("/instance/%v:reset-password", id)
12209
12210 request, err := http.NewRequestWithContext(ctx, "PUT", c.serverEndpoint+path, nil)
12211 if err != nil {
12212 return nil, fmt.Errorf("ResetInstancePassword: new request: %w", err)
12213 }
12214
12215 request.Header.Add("User-Agent", c.getUserAgent())
12216
12217 if err := c.executeRequestInterceptors(ctx, request); err != nil {
12218 return nil, fmt.Errorf("ResetInstancePassword: execute request editors: %w", err)
12219 }
12220
12221 if err := c.signRequest(request); err != nil {
12222 return nil, fmt.Errorf("ResetInstancePassword: sign request: %w", err)
12223 }
12224
12225 if c.trace {
12226 dumpRequest(request, "reset-instance-password")
12227 }
12228
12229 response, err := c.httpClient.Do(request)
12230 if err != nil {
12231 return nil, fmt.Errorf("ResetInstancePassword: http client do: %w", err)
12232 }
12233
12234 if c.trace {
12235 dumpResponse(response)
12236 }
12237
12238 if err := handleHTTPErrorResp(response); err != nil {
12239 return nil, fmt.Errorf("ResetInstancePassword: http response: %w", err)
12240 }
12241
12242 bodyresp := new(Operation)
12243 if err := prepareJSONResponse(response, bodyresp); err != nil {
12244 return nil, fmt.Errorf("ResetInstancePassword: prepare Json response: %w", err)
12245 }
12246
12247 return bodyresp, nil
12248 }
12249
12250 type ResizeInstanceDiskRequest struct {
12251 // Instance disk size in GiB
12252 DiskSize int64 `json:"disk-size" validate:"required,gte=10,lte=51200"`
12253 }
12254
12255 // This operation resizes a Compute instance's disk volume. Note: the disk can only grow, cannot be shrunk.
12256 func (c Client) ResizeInstanceDisk(ctx context.Context, id UUID, req ResizeInstanceDiskRequest) (*Operation, error) {
12257 path := fmt.Sprintf("/instance/%v:resize-disk", id)
12258
12259 body, err := prepareJSONBody(req)
12260 if err != nil {
12261 return nil, fmt.Errorf("ResizeInstanceDisk: prepare Json body: %w", err)
12262 }
12263
12264 request, err := http.NewRequestWithContext(ctx, "PUT", c.serverEndpoint+path, body)
12265 if err != nil {
12266 return nil, fmt.Errorf("ResizeInstanceDisk: new request: %w", err)
12267 }
12268
12269 request.Header.Add("User-Agent", c.getUserAgent())
12270
12271 request.Header.Add("Content-Type", "application/json")
12272
12273 if err := c.executeRequestInterceptors(ctx, request); err != nil {
12274 return nil, fmt.Errorf("ResizeInstanceDisk: execute request editors: %w", err)
12275 }
12276
12277 if err := c.signRequest(request); err != nil {
12278 return nil, fmt.Errorf("ResizeInstanceDisk: sign request: %w", err)
12279 }
12280
12281 if c.trace {
12282 dumpRequest(request, "resize-instance-disk")
12283 }
12284
12285 response, err := c.httpClient.Do(request)
12286 if err != nil {
12287 return nil, fmt.Errorf("ResizeInstanceDisk: http client do: %w", err)
12288 }
12289
12290 if c.trace {
12291 dumpResponse(response)
12292 }
12293
12294 if err := handleHTTPErrorResp(response); err != nil {
12295 return nil, fmt.Errorf("ResizeInstanceDisk: http response: %w", err)
12296 }
12297
12298 bodyresp := new(Operation)
12299 if err := prepareJSONResponse(response, bodyresp); err != nil {
12300 return nil, fmt.Errorf("ResizeInstanceDisk: prepare Json response: %w", err)
12301 }
12302
12303 return bodyresp, nil
12304 }
12305
12306 type ScaleInstanceRequest struct {
12307 // Compute instance type
12308 InstanceType *InstanceType `json:"instance-type" validate:"required"`
12309 }
12310
12311 // This operation changes the Compute instance's type. Note: the new Instance Type must be within the same family (e.g. a standard instance cannot be scaled to gpu2 or storage).
12312 func (c Client) ScaleInstance(ctx context.Context, id UUID, req ScaleInstanceRequest) (*Operation, error) {
12313 path := fmt.Sprintf("/instance/%v:scale", id)
12314
12315 body, err := prepareJSONBody(req)
12316 if err != nil {
12317 return nil, fmt.Errorf("ScaleInstance: prepare Json body: %w", err)
12318 }
12319
12320 request, err := http.NewRequestWithContext(ctx, "PUT", c.serverEndpoint+path, body)
12321 if err != nil {
12322 return nil, fmt.Errorf("ScaleInstance: new request: %w", err)
12323 }
12324
12325 request.Header.Add("User-Agent", c.getUserAgent())
12326
12327 request.Header.Add("Content-Type", "application/json")
12328
12329 if err := c.executeRequestInterceptors(ctx, request); err != nil {
12330 return nil, fmt.Errorf("ScaleInstance: execute request editors: %w", err)
12331 }
12332
12333 if err := c.signRequest(request); err != nil {
12334 return nil, fmt.Errorf("ScaleInstance: sign request: %w", err)
12335 }
12336
12337 if c.trace {
12338 dumpRequest(request, "scale-instance")
12339 }
12340
12341 response, err := c.httpClient.Do(request)
12342 if err != nil {
12343 return nil, fmt.Errorf("ScaleInstance: http client do: %w", err)
12344 }
12345
12346 if c.trace {
12347 dumpResponse(response)
12348 }
12349
12350 if err := handleHTTPErrorResp(response); err != nil {
12351 return nil, fmt.Errorf("ScaleInstance: http response: %w", err)
12352 }
12353
12354 bodyresp := new(Operation)
12355 if err := prepareJSONResponse(response, bodyresp); err != nil {
12356 return nil, fmt.Errorf("ScaleInstance: prepare Json response: %w", err)
12357 }
12358
12359 return bodyresp, nil
12360 }
12361
12362 type StartInstanceRequestRescueProfile string
12363
12364 const (
12365 StartInstanceRequestRescueProfileNetbootEfi StartInstanceRequestRescueProfile = "netboot-efi"
12366 StartInstanceRequestRescueProfileNetboot StartInstanceRequestRescueProfile = "netboot"
12367 )
12368
12369 type StartInstanceRequest struct {
12370 // Boot in Rescue Mode, using named profile (supported: netboot, netboot-efi)
12371 RescueProfile StartInstanceRequestRescueProfile `json:"rescue-profile,omitempty"`
12372 }
12373
12374 // This operation starts a virtual machine, potentially using a rescue profile if specified
12375 func (c Client) StartInstance(ctx context.Context, id UUID, req StartInstanceRequest) (*Operation, error) {
12376 path := fmt.Sprintf("/instance/%v:start", id)
12377
12378 body, err := prepareJSONBody(req)
12379 if err != nil {
12380 return nil, fmt.Errorf("StartInstance: prepare Json body: %w", err)
12381 }
12382
12383 request, err := http.NewRequestWithContext(ctx, "PUT", c.serverEndpoint+path, body)
12384 if err != nil {
12385 return nil, fmt.Errorf("StartInstance: new request: %w", err)
12386 }
12387
12388 request.Header.Add("User-Agent", c.getUserAgent())
12389
12390 request.Header.Add("Content-Type", "application/json")
12391
12392 if err := c.executeRequestInterceptors(ctx, request); err != nil {
12393 return nil, fmt.Errorf("StartInstance: execute request editors: %w", err)
12394 }
12395
12396 if err := c.signRequest(request); err != nil {
12397 return nil, fmt.Errorf("StartInstance: sign request: %w", err)
12398 }
12399
12400 if c.trace {
12401 dumpRequest(request, "start-instance")
12402 }
12403
12404 response, err := c.httpClient.Do(request)
12405 if err != nil {
12406 return nil, fmt.Errorf("StartInstance: http client do: %w", err)
12407 }
12408
12409 if c.trace {
12410 dumpResponse(response)
12411 }
12412
12413 if err := handleHTTPErrorResp(response); err != nil {
12414 return nil, fmt.Errorf("StartInstance: http response: %w", err)
12415 }
12416
12417 bodyresp := new(Operation)
12418 if err := prepareJSONResponse(response, bodyresp); err != nil {
12419 return nil, fmt.Errorf("StartInstance: prepare Json response: %w", err)
12420 }
12421
12422 return bodyresp, nil
12423 }
12424
12425 // Stop a Compute instance
12426 func (c Client) StopInstance(ctx context.Context, id UUID) (*Operation, error) {
12427 path := fmt.Sprintf("/instance/%v:stop", id)
12428
12429 request, err := http.NewRequestWithContext(ctx, "PUT", c.serverEndpoint+path, nil)
12430 if err != nil {
12431 return nil, fmt.Errorf("StopInstance: new request: %w", err)
12432 }
12433
12434 request.Header.Add("User-Agent", c.getUserAgent())
12435
12436 if err := c.executeRequestInterceptors(ctx, request); err != nil {
12437 return nil, fmt.Errorf("StopInstance: execute request editors: %w", err)
12438 }
12439
12440 if err := c.signRequest(request); err != nil {
12441 return nil, fmt.Errorf("StopInstance: sign request: %w", err)
12442 }
12443
12444 if c.trace {
12445 dumpRequest(request, "stop-instance")
12446 }
12447
12448 response, err := c.httpClient.Do(request)
12449 if err != nil {
12450 return nil, fmt.Errorf("StopInstance: http client do: %w", err)
12451 }
12452
12453 if c.trace {
12454 dumpResponse(response)
12455 }
12456
12457 if err := handleHTTPErrorResp(response); err != nil {
12458 return nil, fmt.Errorf("StopInstance: http response: %w", err)
12459 }
12460
12461 bodyresp := new(Operation)
12462 if err := prepareJSONResponse(response, bodyresp); err != nil {
12463 return nil, fmt.Errorf("StopInstance: prepare Json response: %w", err)
12464 }
12465
12466 return bodyresp, nil
12467 }
12468
12469 type RevertInstanceToSnapshotRequest struct {
12470 // Snapshot ID
12471 ID UUID `json:"id" validate:"required"`
12472 }
12473
12474 // This operation reverts the snapshot to the Compute instance volume, restoring stored data as it was at the time of the snapshot.
12475 // The Compute instance must be previously stopped.
12476 func (c Client) RevertInstanceToSnapshot(ctx context.Context, instanceID UUID, req RevertInstanceToSnapshotRequest) (*Operation, error) {
12477 path := fmt.Sprintf("/instance/%v:revert-snapshot", instanceID)
12478
12479 body, err := prepareJSONBody(req)
12480 if err != nil {
12481 return nil, fmt.Errorf("RevertInstanceToSnapshot: prepare Json body: %w", err)
12482 }
12483
12484 request, err := http.NewRequestWithContext(ctx, "POST", c.serverEndpoint+path, body)
12485 if err != nil {
12486 return nil, fmt.Errorf("RevertInstanceToSnapshot: new request: %w", err)
12487 }
12488
12489 request.Header.Add("User-Agent", c.getUserAgent())
12490
12491 request.Header.Add("Content-Type", "application/json")
12492
12493 if err := c.executeRequestInterceptors(ctx, request); err != nil {
12494 return nil, fmt.Errorf("RevertInstanceToSnapshot: execute request editors: %w", err)
12495 }
12496
12497 if err := c.signRequest(request); err != nil {
12498 return nil, fmt.Errorf("RevertInstanceToSnapshot: sign request: %w", err)
12499 }
12500
12501 if c.trace {
12502 dumpRequest(request, "revert-instance-to-snapshot")
12503 }
12504
12505 response, err := c.httpClient.Do(request)
12506 if err != nil {
12507 return nil, fmt.Errorf("RevertInstanceToSnapshot: http client do: %w", err)
12508 }
12509
12510 if c.trace {
12511 dumpResponse(response)
12512 }
12513
12514 if err := handleHTTPErrorResp(response); err != nil {
12515 return nil, fmt.Errorf("RevertInstanceToSnapshot: http response: %w", err)
12516 }
12517
12518 bodyresp := new(Operation)
12519 if err := prepareJSONResponse(response, bodyresp); err != nil {
12520 return nil, fmt.Errorf("RevertInstanceToSnapshot: prepare Json response: %w", err)
12521 }
12522
12523 return bodyresp, nil
12524 }
12525
12526 type ListLoadBalancersResponse struct {
12527 LoadBalancers []LoadBalancer `json:"load-balancers,omitempty"`
12528 }
12529
12530 // FindLoadBalancer attempts to find an LoadBalancer by nameOrID.
12531 func (l ListLoadBalancersResponse) FindLoadBalancer(nameOrID string) (LoadBalancer, error) {
12532 var result []LoadBalancer
12533 for i, elem := range l.LoadBalancers {
12534 if string(elem.Name) == nameOrID || string(elem.ID) == nameOrID {
12535 result = append(result, l.LoadBalancers[i])
12536 }
12537 }
12538 if len(result) == 1 {
12539 return result[0], nil
12540 }
12541
12542 if len(result) > 1 {
12543 return LoadBalancer{}, fmt.Errorf("%q too many found in ListLoadBalancersResponse: %w", nameOrID, ErrConflict)
12544 }
12545
12546 return LoadBalancer{}, fmt.Errorf("%q not found in ListLoadBalancersResponse: %w", nameOrID, ErrNotFound)
12547 }
12548
12549 // List Load Balancers
12550 func (c Client) ListLoadBalancers(ctx context.Context) (*ListLoadBalancersResponse, error) {
12551 path := "/load-balancer"
12552
12553 request, err := http.NewRequestWithContext(ctx, "GET", c.serverEndpoint+path, nil)
12554 if err != nil {
12555 return nil, fmt.Errorf("ListLoadBalancers: new request: %w", err)
12556 }
12557
12558 request.Header.Add("User-Agent", c.getUserAgent())
12559
12560 if err := c.executeRequestInterceptors(ctx, request); err != nil {
12561 return nil, fmt.Errorf("ListLoadBalancers: execute request editors: %w", err)
12562 }
12563
12564 if err := c.signRequest(request); err != nil {
12565 return nil, fmt.Errorf("ListLoadBalancers: sign request: %w", err)
12566 }
12567
12568 if c.trace {
12569 dumpRequest(request, "list-load-balancers")
12570 }
12571
12572 response, err := c.httpClient.Do(request)
12573 if err != nil {
12574 return nil, fmt.Errorf("ListLoadBalancers: http client do: %w", err)
12575 }
12576
12577 if c.trace {
12578 dumpResponse(response)
12579 }
12580
12581 if err := handleHTTPErrorResp(response); err != nil {
12582 return nil, fmt.Errorf("ListLoadBalancers: http response: %w", err)
12583 }
12584
12585 bodyresp := new(ListLoadBalancersResponse)
12586 if err := prepareJSONResponse(response, bodyresp); err != nil {
12587 return nil, fmt.Errorf("ListLoadBalancers: prepare Json response: %w", err)
12588 }
12589
12590 return bodyresp, nil
12591 }
12592
12593 type CreateLoadBalancerRequest struct {
12594 // Load Balancer description
12595 Description string `json:"description,omitempty" validate:"omitempty,lte=255"`
12596 Labels Labels `json:"labels,omitempty"`
12597 // Load Balancer name
12598 Name string `json:"name" validate:"required,gte=1,lte=255"`
12599 }
12600
12601 // Create a Load Balancer
12602 func (c Client) CreateLoadBalancer(ctx context.Context, req CreateLoadBalancerRequest) (*Operation, error) {
12603 path := "/load-balancer"
12604
12605 body, err := prepareJSONBody(req)
12606 if err != nil {
12607 return nil, fmt.Errorf("CreateLoadBalancer: prepare Json body: %w", err)
12608 }
12609
12610 request, err := http.NewRequestWithContext(ctx, "POST", c.serverEndpoint+path, body)
12611 if err != nil {
12612 return nil, fmt.Errorf("CreateLoadBalancer: new request: %w", err)
12613 }
12614
12615 request.Header.Add("User-Agent", c.getUserAgent())
12616
12617 request.Header.Add("Content-Type", "application/json")
12618
12619 if err := c.executeRequestInterceptors(ctx, request); err != nil {
12620 return nil, fmt.Errorf("CreateLoadBalancer: execute request editors: %w", err)
12621 }
12622
12623 if err := c.signRequest(request); err != nil {
12624 return nil, fmt.Errorf("CreateLoadBalancer: sign request: %w", err)
12625 }
12626
12627 if c.trace {
12628 dumpRequest(request, "create-load-balancer")
12629 }
12630
12631 response, err := c.httpClient.Do(request)
12632 if err != nil {
12633 return nil, fmt.Errorf("CreateLoadBalancer: http client do: %w", err)
12634 }
12635
12636 if c.trace {
12637 dumpResponse(response)
12638 }
12639
12640 if err := handleHTTPErrorResp(response); err != nil {
12641 return nil, fmt.Errorf("CreateLoadBalancer: http response: %w", err)
12642 }
12643
12644 bodyresp := new(Operation)
12645 if err := prepareJSONResponse(response, bodyresp); err != nil {
12646 return nil, fmt.Errorf("CreateLoadBalancer: prepare Json response: %w", err)
12647 }
12648
12649 return bodyresp, nil
12650 }
12651
12652 // Delete a Load Balancer
12653 func (c Client) DeleteLoadBalancer(ctx context.Context, id UUID) (*Operation, error) {
12654 path := fmt.Sprintf("/load-balancer/%v", id)
12655
12656 request, err := http.NewRequestWithContext(ctx, "DELETE", c.serverEndpoint+path, nil)
12657 if err != nil {
12658 return nil, fmt.Errorf("DeleteLoadBalancer: new request: %w", err)
12659 }
12660
12661 request.Header.Add("User-Agent", c.getUserAgent())
12662
12663 if err := c.executeRequestInterceptors(ctx, request); err != nil {
12664 return nil, fmt.Errorf("DeleteLoadBalancer: execute request editors: %w", err)
12665 }
12666
12667 if err := c.signRequest(request); err != nil {
12668 return nil, fmt.Errorf("DeleteLoadBalancer: sign request: %w", err)
12669 }
12670
12671 if c.trace {
12672 dumpRequest(request, "delete-load-balancer")
12673 }
12674
12675 response, err := c.httpClient.Do(request)
12676 if err != nil {
12677 return nil, fmt.Errorf("DeleteLoadBalancer: http client do: %w", err)
12678 }
12679
12680 if c.trace {
12681 dumpResponse(response)
12682 }
12683
12684 if err := handleHTTPErrorResp(response); err != nil {
12685 return nil, fmt.Errorf("DeleteLoadBalancer: http response: %w", err)
12686 }
12687
12688 bodyresp := new(Operation)
12689 if err := prepareJSONResponse(response, bodyresp); err != nil {
12690 return nil, fmt.Errorf("DeleteLoadBalancer: prepare Json response: %w", err)
12691 }
12692
12693 return bodyresp, nil
12694 }
12695
12696 // Retrieve Load Balancer details
12697 func (c Client) GetLoadBalancer(ctx context.Context, id UUID) (*LoadBalancer, error) {
12698 path := fmt.Sprintf("/load-balancer/%v", id)
12699
12700 request, err := http.NewRequestWithContext(ctx, "GET", c.serverEndpoint+path, nil)
12701 if err != nil {
12702 return nil, fmt.Errorf("GetLoadBalancer: new request: %w", err)
12703 }
12704
12705 request.Header.Add("User-Agent", c.getUserAgent())
12706
12707 if err := c.executeRequestInterceptors(ctx, request); err != nil {
12708 return nil, fmt.Errorf("GetLoadBalancer: execute request editors: %w", err)
12709 }
12710
12711 if err := c.signRequest(request); err != nil {
12712 return nil, fmt.Errorf("GetLoadBalancer: sign request: %w", err)
12713 }
12714
12715 if c.trace {
12716 dumpRequest(request, "get-load-balancer")
12717 }
12718
12719 response, err := c.httpClient.Do(request)
12720 if err != nil {
12721 return nil, fmt.Errorf("GetLoadBalancer: http client do: %w", err)
12722 }
12723
12724 if c.trace {
12725 dumpResponse(response)
12726 }
12727
12728 if err := handleHTTPErrorResp(response); err != nil {
12729 return nil, fmt.Errorf("GetLoadBalancer: http response: %w", err)
12730 }
12731
12732 bodyresp := new(LoadBalancer)
12733 if err := prepareJSONResponse(response, bodyresp); err != nil {
12734 return nil, fmt.Errorf("GetLoadBalancer: prepare Json response: %w", err)
12735 }
12736
12737 return bodyresp, nil
12738 }
12739
12740 type UpdateLoadBalancerRequest struct {
12741 // Load Balancer description
12742 Description string `json:"description,omitempty" validate:"omitempty,lte=255"`
12743 Labels Labels `json:"labels,omitempty"`
12744 // Load Balancer name
12745 Name string `json:"name,omitempty" validate:"omitempty,gte=1,lte=255"`
12746 }
12747
12748 // Update a Load Balancer
12749 func (c Client) UpdateLoadBalancer(ctx context.Context, id UUID, req UpdateLoadBalancerRequest) (*Operation, error) {
12750 path := fmt.Sprintf("/load-balancer/%v", id)
12751
12752 body, err := prepareJSONBody(req)
12753 if err != nil {
12754 return nil, fmt.Errorf("UpdateLoadBalancer: prepare Json body: %w", err)
12755 }
12756
12757 request, err := http.NewRequestWithContext(ctx, "PUT", c.serverEndpoint+path, body)
12758 if err != nil {
12759 return nil, fmt.Errorf("UpdateLoadBalancer: new request: %w", err)
12760 }
12761
12762 request.Header.Add("User-Agent", c.getUserAgent())
12763
12764 request.Header.Add("Content-Type", "application/json")
12765
12766 if err := c.executeRequestInterceptors(ctx, request); err != nil {
12767 return nil, fmt.Errorf("UpdateLoadBalancer: execute request editors: %w", err)
12768 }
12769
12770 if err := c.signRequest(request); err != nil {
12771 return nil, fmt.Errorf("UpdateLoadBalancer: sign request: %w", err)
12772 }
12773
12774 if c.trace {
12775 dumpRequest(request, "update-load-balancer")
12776 }
12777
12778 response, err := c.httpClient.Do(request)
12779 if err != nil {
12780 return nil, fmt.Errorf("UpdateLoadBalancer: http client do: %w", err)
12781 }
12782
12783 if c.trace {
12784 dumpResponse(response)
12785 }
12786
12787 if err := handleHTTPErrorResp(response); err != nil {
12788 return nil, fmt.Errorf("UpdateLoadBalancer: http response: %w", err)
12789 }
12790
12791 bodyresp := new(Operation)
12792 if err := prepareJSONResponse(response, bodyresp); err != nil {
12793 return nil, fmt.Errorf("UpdateLoadBalancer: prepare Json response: %w", err)
12794 }
12795
12796 return bodyresp, nil
12797 }
12798
12799 type AddServiceToLoadBalancerRequestProtocol string
12800
12801 const (
12802 AddServiceToLoadBalancerRequestProtocolTCP AddServiceToLoadBalancerRequestProtocol = "tcp"
12803 AddServiceToLoadBalancerRequestProtocolUDP AddServiceToLoadBalancerRequestProtocol = "udp"
12804 )
12805
12806 type AddServiceToLoadBalancerRequestStrategy string
12807
12808 const (
12809 AddServiceToLoadBalancerRequestStrategyRoundRobin AddServiceToLoadBalancerRequestStrategy = "round-robin"
12810 AddServiceToLoadBalancerRequestStrategyMaglevHash AddServiceToLoadBalancerRequestStrategy = "maglev-hash"
12811 AddServiceToLoadBalancerRequestStrategySourceHash AddServiceToLoadBalancerRequestStrategy = "source-hash"
12812 )
12813
12814 type AddServiceToLoadBalancerRequest struct {
12815 // Load Balancer Service description
12816 Description string `json:"description,omitempty" validate:"omitempty,lte=255"`
12817 // Load Balancer Service healthcheck
12818 Healthcheck *LoadBalancerServiceHealthcheck `json:"healthcheck" validate:"required"`
12819 // Instance Pool
12820 InstancePool *InstancePool `json:"instance-pool" validate:"required"`
12821 // Load Balancer Service name
12822 Name string `json:"name" validate:"required,gte=1,lte=255"`
12823 // Port exposed on the Load Balancer's public IP
12824 Port int64 `json:"port" validate:"required,gte=1,lte=65535"`
12825 // Network traffic protocol
12826 Protocol AddServiceToLoadBalancerRequestProtocol `json:"protocol" validate:"required"`
12827 // Load balancing strategy
12828 Strategy AddServiceToLoadBalancerRequestStrategy `json:"strategy" validate:"required"`
12829 // Port on which the network traffic will be forwarded to on the receiving instance
12830 TargetPort int64 `json:"target-port" validate:"required,gte=1,lte=65535"`
12831 }
12832
12833 // Add a Load Balancer Service
12834 func (c Client) AddServiceToLoadBalancer(ctx context.Context, id UUID, req AddServiceToLoadBalancerRequest) (*Operation, error) {
12835 path := fmt.Sprintf("/load-balancer/%v/service", id)
12836
12837 body, err := prepareJSONBody(req)
12838 if err != nil {
12839 return nil, fmt.Errorf("AddServiceToLoadBalancer: prepare Json body: %w", err)
12840 }
12841
12842 request, err := http.NewRequestWithContext(ctx, "POST", c.serverEndpoint+path, body)
12843 if err != nil {
12844 return nil, fmt.Errorf("AddServiceToLoadBalancer: new request: %w", err)
12845 }
12846
12847 request.Header.Add("User-Agent", c.getUserAgent())
12848
12849 request.Header.Add("Content-Type", "application/json")
12850
12851 if err := c.executeRequestInterceptors(ctx, request); err != nil {
12852 return nil, fmt.Errorf("AddServiceToLoadBalancer: execute request editors: %w", err)
12853 }
12854
12855 if err := c.signRequest(request); err != nil {
12856 return nil, fmt.Errorf("AddServiceToLoadBalancer: sign request: %w", err)
12857 }
12858
12859 if c.trace {
12860 dumpRequest(request, "add-service-to-load-balancer")
12861 }
12862
12863 response, err := c.httpClient.Do(request)
12864 if err != nil {
12865 return nil, fmt.Errorf("AddServiceToLoadBalancer: http client do: %w", err)
12866 }
12867
12868 if c.trace {
12869 dumpResponse(response)
12870 }
12871
12872 if err := handleHTTPErrorResp(response); err != nil {
12873 return nil, fmt.Errorf("AddServiceToLoadBalancer: http response: %w", err)
12874 }
12875
12876 bodyresp := new(Operation)
12877 if err := prepareJSONResponse(response, bodyresp); err != nil {
12878 return nil, fmt.Errorf("AddServiceToLoadBalancer: prepare Json response: %w", err)
12879 }
12880
12881 return bodyresp, nil
12882 }
12883
12884 // Delete a Load Balancer Service
12885 func (c Client) DeleteLoadBalancerService(ctx context.Context, id UUID, serviceID UUID) (*Operation, error) {
12886 path := fmt.Sprintf("/load-balancer/%v/service/%v", id, serviceID)
12887
12888 request, err := http.NewRequestWithContext(ctx, "DELETE", c.serverEndpoint+path, nil)
12889 if err != nil {
12890 return nil, fmt.Errorf("DeleteLoadBalancerService: new request: %w", err)
12891 }
12892
12893 request.Header.Add("User-Agent", c.getUserAgent())
12894
12895 if err := c.executeRequestInterceptors(ctx, request); err != nil {
12896 return nil, fmt.Errorf("DeleteLoadBalancerService: execute request editors: %w", err)
12897 }
12898
12899 if err := c.signRequest(request); err != nil {
12900 return nil, fmt.Errorf("DeleteLoadBalancerService: sign request: %w", err)
12901 }
12902
12903 if c.trace {
12904 dumpRequest(request, "delete-load-balancer-service")
12905 }
12906
12907 response, err := c.httpClient.Do(request)
12908 if err != nil {
12909 return nil, fmt.Errorf("DeleteLoadBalancerService: http client do: %w", err)
12910 }
12911
12912 if c.trace {
12913 dumpResponse(response)
12914 }
12915
12916 if err := handleHTTPErrorResp(response); err != nil {
12917 return nil, fmt.Errorf("DeleteLoadBalancerService: http response: %w", err)
12918 }
12919
12920 bodyresp := new(Operation)
12921 if err := prepareJSONResponse(response, bodyresp); err != nil {
12922 return nil, fmt.Errorf("DeleteLoadBalancerService: prepare Json response: %w", err)
12923 }
12924
12925 return bodyresp, nil
12926 }
12927
12928 // Retrieve Load Balancer Service details
12929 func (c Client) GetLoadBalancerService(ctx context.Context, id UUID, serviceID UUID) (*LoadBalancerService, error) {
12930 path := fmt.Sprintf("/load-balancer/%v/service/%v", id, serviceID)
12931
12932 request, err := http.NewRequestWithContext(ctx, "GET", c.serverEndpoint+path, nil)
12933 if err != nil {
12934 return nil, fmt.Errorf("GetLoadBalancerService: new request: %w", err)
12935 }
12936
12937 request.Header.Add("User-Agent", c.getUserAgent())
12938
12939 if err := c.executeRequestInterceptors(ctx, request); err != nil {
12940 return nil, fmt.Errorf("GetLoadBalancerService: execute request editors: %w", err)
12941 }
12942
12943 if err := c.signRequest(request); err != nil {
12944 return nil, fmt.Errorf("GetLoadBalancerService: sign request: %w", err)
12945 }
12946
12947 if c.trace {
12948 dumpRequest(request, "get-load-balancer-service")
12949 }
12950
12951 response, err := c.httpClient.Do(request)
12952 if err != nil {
12953 return nil, fmt.Errorf("GetLoadBalancerService: http client do: %w", err)
12954 }
12955
12956 if c.trace {
12957 dumpResponse(response)
12958 }
12959
12960 if err := handleHTTPErrorResp(response); err != nil {
12961 return nil, fmt.Errorf("GetLoadBalancerService: http response: %w", err)
12962 }
12963
12964 bodyresp := new(LoadBalancerService)
12965 if err := prepareJSONResponse(response, bodyresp); err != nil {
12966 return nil, fmt.Errorf("GetLoadBalancerService: prepare Json response: %w", err)
12967 }
12968
12969 return bodyresp, nil
12970 }
12971
12972 type UpdateLoadBalancerServiceRequestProtocol string
12973
12974 const (
12975 UpdateLoadBalancerServiceRequestProtocolTCP UpdateLoadBalancerServiceRequestProtocol = "tcp"
12976 UpdateLoadBalancerServiceRequestProtocolUDP UpdateLoadBalancerServiceRequestProtocol = "udp"
12977 )
12978
12979 type UpdateLoadBalancerServiceRequestStrategy string
12980
12981 const (
12982 UpdateLoadBalancerServiceRequestStrategyRoundRobin UpdateLoadBalancerServiceRequestStrategy = "round-robin"
12983 UpdateLoadBalancerServiceRequestStrategyMaglevHash UpdateLoadBalancerServiceRequestStrategy = "maglev-hash"
12984 UpdateLoadBalancerServiceRequestStrategySourceHash UpdateLoadBalancerServiceRequestStrategy = "source-hash"
12985 )
12986
12987 type UpdateLoadBalancerServiceRequest struct {
12988 // Load Balancer Service description
12989 Description string `json:"description,omitempty" validate:"omitempty,lte=255"`
12990 // Load Balancer Service healthcheck
12991 Healthcheck *LoadBalancerServiceHealthcheck `json:"healthcheck,omitempty"`
12992 // Load Balancer Service name
12993 Name string `json:"name,omitempty" validate:"omitempty,lte=255"`
12994 // Port exposed on the Load Balancer's public IP
12995 Port int64 `json:"port,omitempty" validate:"omitempty,gte=1,lte=65535"`
12996 // Network traffic protocol
12997 Protocol UpdateLoadBalancerServiceRequestProtocol `json:"protocol,omitempty"`
12998 // Load balancing strategy
12999 Strategy UpdateLoadBalancerServiceRequestStrategy `json:"strategy,omitempty"`
13000 // Port on which the network traffic will be forwarded to on the receiving instance
13001 TargetPort int64 `json:"target-port,omitempty" validate:"omitempty,gte=1,lte=65535"`
13002 }
13003
13004 // Update a Load Balancer Service
13005 func (c Client) UpdateLoadBalancerService(ctx context.Context, id UUID, serviceID UUID, req UpdateLoadBalancerServiceRequest) (*Operation, error) {
13006 path := fmt.Sprintf("/load-balancer/%v/service/%v", id, serviceID)
13007
13008 body, err := prepareJSONBody(req)
13009 if err != nil {
13010 return nil, fmt.Errorf("UpdateLoadBalancerService: prepare Json body: %w", err)
13011 }
13012
13013 request, err := http.NewRequestWithContext(ctx, "PUT", c.serverEndpoint+path, body)
13014 if err != nil {
13015 return nil, fmt.Errorf("UpdateLoadBalancerService: new request: %w", err)
13016 }
13017
13018 request.Header.Add("User-Agent", c.getUserAgent())
13019
13020 request.Header.Add("Content-Type", "application/json")
13021
13022 if err := c.executeRequestInterceptors(ctx, request); err != nil {
13023 return nil, fmt.Errorf("UpdateLoadBalancerService: execute request editors: %w", err)
13024 }
13025
13026 if err := c.signRequest(request); err != nil {
13027 return nil, fmt.Errorf("UpdateLoadBalancerService: sign request: %w", err)
13028 }
13029
13030 if c.trace {
13031 dumpRequest(request, "update-load-balancer-service")
13032 }
13033
13034 response, err := c.httpClient.Do(request)
13035 if err != nil {
13036 return nil, fmt.Errorf("UpdateLoadBalancerService: http client do: %w", err)
13037 }
13038
13039 if c.trace {
13040 dumpResponse(response)
13041 }
13042
13043 if err := handleHTTPErrorResp(response); err != nil {
13044 return nil, fmt.Errorf("UpdateLoadBalancerService: http response: %w", err)
13045 }
13046
13047 bodyresp := new(Operation)
13048 if err := prepareJSONResponse(response, bodyresp); err != nil {
13049 return nil, fmt.Errorf("UpdateLoadBalancerService: prepare Json response: %w", err)
13050 }
13051
13052 return bodyresp, nil
13053 }
13054
13055 type ResetLoadBalancerServiceFieldField string
13056
13057 const (
13058 ResetLoadBalancerServiceFieldFieldDescription ResetLoadBalancerServiceFieldField = "description"
13059 )
13060
13061 // Reset a Load Balancer Service field to its default value
13062 func (c Client) ResetLoadBalancerServiceField(ctx context.Context, id UUID, serviceID UUID, field ResetLoadBalancerServiceFieldField) (*Operation, error) {
13063 path := fmt.Sprintf("/load-balancer/%v/service/%v/%v", id, serviceID, field)
13064
13065 request, err := http.NewRequestWithContext(ctx, "DELETE", c.serverEndpoint+path, nil)
13066 if err != nil {
13067 return nil, fmt.Errorf("ResetLoadBalancerServiceField: new request: %w", err)
13068 }
13069
13070 request.Header.Add("User-Agent", c.getUserAgent())
13071
13072 if err := c.executeRequestInterceptors(ctx, request); err != nil {
13073 return nil, fmt.Errorf("ResetLoadBalancerServiceField: execute request editors: %w", err)
13074 }
13075
13076 if err := c.signRequest(request); err != nil {
13077 return nil, fmt.Errorf("ResetLoadBalancerServiceField: sign request: %w", err)
13078 }
13079
13080 if c.trace {
13081 dumpRequest(request, "reset-load-balancer-service-field")
13082 }
13083
13084 response, err := c.httpClient.Do(request)
13085 if err != nil {
13086 return nil, fmt.Errorf("ResetLoadBalancerServiceField: http client do: %w", err)
13087 }
13088
13089 if c.trace {
13090 dumpResponse(response)
13091 }
13092
13093 if err := handleHTTPErrorResp(response); err != nil {
13094 return nil, fmt.Errorf("ResetLoadBalancerServiceField: http response: %w", err)
13095 }
13096
13097 bodyresp := new(Operation)
13098 if err := prepareJSONResponse(response, bodyresp); err != nil {
13099 return nil, fmt.Errorf("ResetLoadBalancerServiceField: prepare Json response: %w", err)
13100 }
13101
13102 return bodyresp, nil
13103 }
13104
13105 type ResetLoadBalancerFieldField string
13106
13107 const (
13108 ResetLoadBalancerFieldFieldDescription ResetLoadBalancerFieldField = "description"
13109 ResetLoadBalancerFieldFieldLabels ResetLoadBalancerFieldField = "labels"
13110 )
13111
13112 // Reset a Load Balancer field to its default value
13113 func (c Client) ResetLoadBalancerField(ctx context.Context, id UUID, field ResetLoadBalancerFieldField) (*Operation, error) {
13114 path := fmt.Sprintf("/load-balancer/%v/%v", id, field)
13115
13116 request, err := http.NewRequestWithContext(ctx, "DELETE", c.serverEndpoint+path, nil)
13117 if err != nil {
13118 return nil, fmt.Errorf("ResetLoadBalancerField: new request: %w", err)
13119 }
13120
13121 request.Header.Add("User-Agent", c.getUserAgent())
13122
13123 if err := c.executeRequestInterceptors(ctx, request); err != nil {
13124 return nil, fmt.Errorf("ResetLoadBalancerField: execute request editors: %w", err)
13125 }
13126
13127 if err := c.signRequest(request); err != nil {
13128 return nil, fmt.Errorf("ResetLoadBalancerField: sign request: %w", err)
13129 }
13130
13131 if c.trace {
13132 dumpRequest(request, "reset-load-balancer-field")
13133 }
13134
13135 response, err := c.httpClient.Do(request)
13136 if err != nil {
13137 return nil, fmt.Errorf("ResetLoadBalancerField: http client do: %w", err)
13138 }
13139
13140 if c.trace {
13141 dumpResponse(response)
13142 }
13143
13144 if err := handleHTTPErrorResp(response); err != nil {
13145 return nil, fmt.Errorf("ResetLoadBalancerField: http response: %w", err)
13146 }
13147
13148 bodyresp := new(Operation)
13149 if err := prepareJSONResponse(response, bodyresp); err != nil {
13150 return nil, fmt.Errorf("ResetLoadBalancerField: prepare Json response: %w", err)
13151 }
13152
13153 return bodyresp, nil
13154 }
13155
13156 // Retrieve Operation details
13157 func (c Client) GetOperation(ctx context.Context, id UUID) (*Operation, error) {
13158 path := fmt.Sprintf("/operation/%v", id)
13159
13160 request, err := http.NewRequestWithContext(ctx, "GET", c.serverEndpoint+path, nil)
13161 if err != nil {
13162 return nil, fmt.Errorf("GetOperation: new request: %w", err)
13163 }
13164
13165 request.Header.Add("User-Agent", c.getUserAgent())
13166
13167 if err := c.executeRequestInterceptors(ctx, request); err != nil {
13168 return nil, fmt.Errorf("GetOperation: execute request editors: %w", err)
13169 }
13170
13171 if err := c.signRequest(request); err != nil {
13172 return nil, fmt.Errorf("GetOperation: sign request: %w", err)
13173 }
13174
13175 if c.trace {
13176 dumpRequest(request, "get-operation")
13177 }
13178
13179 response, err := c.httpClient.Do(request)
13180 if err != nil {
13181 return nil, fmt.Errorf("GetOperation: http client do: %w", err)
13182 }
13183
13184 if c.trace {
13185 dumpResponse(response)
13186 }
13187
13188 if err := handleHTTPErrorResp(response); err != nil {
13189 return nil, fmt.Errorf("GetOperation: http response: %w", err)
13190 }
13191
13192 bodyresp := new(Operation)
13193 if err := prepareJSONResponse(response, bodyresp); err != nil {
13194 return nil, fmt.Errorf("GetOperation: prepare Json response: %w", err)
13195 }
13196
13197 return bodyresp, nil
13198 }
13199
13200 // Retrieve an organization
13201 func (c Client) GetOrganization(ctx context.Context) (*Organization, error) {
13202 path := "/organization"
13203
13204 request, err := http.NewRequestWithContext(ctx, "GET", c.serverEndpoint+path, nil)
13205 if err != nil {
13206 return nil, fmt.Errorf("GetOrganization: new request: %w", err)
13207 }
13208
13209 request.Header.Add("User-Agent", c.getUserAgent())
13210
13211 if err := c.executeRequestInterceptors(ctx, request); err != nil {
13212 return nil, fmt.Errorf("GetOrganization: execute request editors: %w", err)
13213 }
13214
13215 if err := c.signRequest(request); err != nil {
13216 return nil, fmt.Errorf("GetOrganization: sign request: %w", err)
13217 }
13218
13219 if c.trace {
13220 dumpRequest(request, "get-organization")
13221 }
13222
13223 response, err := c.httpClient.Do(request)
13224 if err != nil {
13225 return nil, fmt.Errorf("GetOrganization: http client do: %w", err)
13226 }
13227
13228 if c.trace {
13229 dumpResponse(response)
13230 }
13231
13232 if err := handleHTTPErrorResp(response); err != nil {
13233 return nil, fmt.Errorf("GetOrganization: http response: %w", err)
13234 }
13235
13236 bodyresp := new(Organization)
13237 if err := prepareJSONResponse(response, bodyresp); err != nil {
13238 return nil, fmt.Errorf("GetOrganization: prepare Json response: %w", err)
13239 }
13240
13241 return bodyresp, nil
13242 }
13243
13244 type ListPrivateNetworksResponse struct {
13245 PrivateNetworks []PrivateNetwork `json:"private-networks,omitempty"`
13246 }
13247
13248 // FindPrivateNetwork attempts to find an PrivateNetwork by nameOrID.
13249 func (l ListPrivateNetworksResponse) FindPrivateNetwork(nameOrID string) (PrivateNetwork, error) {
13250 var result []PrivateNetwork
13251 for i, elem := range l.PrivateNetworks {
13252 if string(elem.Name) == nameOrID || string(elem.ID) == nameOrID {
13253 result = append(result, l.PrivateNetworks[i])
13254 }
13255 }
13256 if len(result) == 1 {
13257 return result[0], nil
13258 }
13259
13260 if len(result) > 1 {
13261 return PrivateNetwork{}, fmt.Errorf("%q too many found in ListPrivateNetworksResponse: %w", nameOrID, ErrConflict)
13262 }
13263
13264 return PrivateNetwork{}, fmt.Errorf("%q not found in ListPrivateNetworksResponse: %w", nameOrID, ErrNotFound)
13265 }
13266
13267 // List Private Networks
13268 func (c Client) ListPrivateNetworks(ctx context.Context) (*ListPrivateNetworksResponse, error) {
13269 path := "/private-network"
13270
13271 request, err := http.NewRequestWithContext(ctx, "GET", c.serverEndpoint+path, nil)
13272 if err != nil {
13273 return nil, fmt.Errorf("ListPrivateNetworks: new request: %w", err)
13274 }
13275
13276 request.Header.Add("User-Agent", c.getUserAgent())
13277
13278 if err := c.executeRequestInterceptors(ctx, request); err != nil {
13279 return nil, fmt.Errorf("ListPrivateNetworks: execute request editors: %w", err)
13280 }
13281
13282 if err := c.signRequest(request); err != nil {
13283 return nil, fmt.Errorf("ListPrivateNetworks: sign request: %w", err)
13284 }
13285
13286 if c.trace {
13287 dumpRequest(request, "list-private-networks")
13288 }
13289
13290 response, err := c.httpClient.Do(request)
13291 if err != nil {
13292 return nil, fmt.Errorf("ListPrivateNetworks: http client do: %w", err)
13293 }
13294
13295 if c.trace {
13296 dumpResponse(response)
13297 }
13298
13299 if err := handleHTTPErrorResp(response); err != nil {
13300 return nil, fmt.Errorf("ListPrivateNetworks: http response: %w", err)
13301 }
13302
13303 bodyresp := new(ListPrivateNetworksResponse)
13304 if err := prepareJSONResponse(response, bodyresp); err != nil {
13305 return nil, fmt.Errorf("ListPrivateNetworks: prepare Json response: %w", err)
13306 }
13307
13308 return bodyresp, nil
13309 }
13310
13311 type CreatePrivateNetworkRequest struct {
13312 // Private Network description
13313 Description string `json:"description,omitempty" validate:"omitempty,lte=255"`
13314 // Private Network end IP address
13315 EndIP net.IP `json:"end-ip,omitempty"`
13316 Labels Labels `json:"labels,omitempty"`
13317 // Private Network name
13318 Name string `json:"name" validate:"required,gte=1,lte=255"`
13319 // Private Network netmask
13320 Netmask net.IP `json:"netmask,omitempty"`
13321 // Private Network DHCP Options
13322 Options *PrivateNetworkOptions `json:"options,omitempty"`
13323 // Private Network start IP address
13324 StartIP net.IP `json:"start-ip,omitempty"`
13325 }
13326
13327 // Create a Private Network
13328 func (c Client) CreatePrivateNetwork(ctx context.Context, req CreatePrivateNetworkRequest) (*Operation, error) {
13329 path := "/private-network"
13330
13331 body, err := prepareJSONBody(req)
13332 if err != nil {
13333 return nil, fmt.Errorf("CreatePrivateNetwork: prepare Json body: %w", err)
13334 }
13335
13336 request, err := http.NewRequestWithContext(ctx, "POST", c.serverEndpoint+path, body)
13337 if err != nil {
13338 return nil, fmt.Errorf("CreatePrivateNetwork: new request: %w", err)
13339 }
13340
13341 request.Header.Add("User-Agent", c.getUserAgent())
13342
13343 request.Header.Add("Content-Type", "application/json")
13344
13345 if err := c.executeRequestInterceptors(ctx, request); err != nil {
13346 return nil, fmt.Errorf("CreatePrivateNetwork: execute request editors: %w", err)
13347 }
13348
13349 if err := c.signRequest(request); err != nil {
13350 return nil, fmt.Errorf("CreatePrivateNetwork: sign request: %w", err)
13351 }
13352
13353 if c.trace {
13354 dumpRequest(request, "create-private-network")
13355 }
13356
13357 response, err := c.httpClient.Do(request)
13358 if err != nil {
13359 return nil, fmt.Errorf("CreatePrivateNetwork: http client do: %w", err)
13360 }
13361
13362 if c.trace {
13363 dumpResponse(response)
13364 }
13365
13366 if err := handleHTTPErrorResp(response); err != nil {
13367 return nil, fmt.Errorf("CreatePrivateNetwork: http response: %w", err)
13368 }
13369
13370 bodyresp := new(Operation)
13371 if err := prepareJSONResponse(response, bodyresp); err != nil {
13372 return nil, fmt.Errorf("CreatePrivateNetwork: prepare Json response: %w", err)
13373 }
13374
13375 return bodyresp, nil
13376 }
13377
13378 // Delete a Private Network
13379 func (c Client) DeletePrivateNetwork(ctx context.Context, id UUID) (*Operation, error) {
13380 path := fmt.Sprintf("/private-network/%v", id)
13381
13382 request, err := http.NewRequestWithContext(ctx, "DELETE", c.serverEndpoint+path, nil)
13383 if err != nil {
13384 return nil, fmt.Errorf("DeletePrivateNetwork: new request: %w", err)
13385 }
13386
13387 request.Header.Add("User-Agent", c.getUserAgent())
13388
13389 if err := c.executeRequestInterceptors(ctx, request); err != nil {
13390 return nil, fmt.Errorf("DeletePrivateNetwork: execute request editors: %w", err)
13391 }
13392
13393 if err := c.signRequest(request); err != nil {
13394 return nil, fmt.Errorf("DeletePrivateNetwork: sign request: %w", err)
13395 }
13396
13397 if c.trace {
13398 dumpRequest(request, "delete-private-network")
13399 }
13400
13401 response, err := c.httpClient.Do(request)
13402 if err != nil {
13403 return nil, fmt.Errorf("DeletePrivateNetwork: http client do: %w", err)
13404 }
13405
13406 if c.trace {
13407 dumpResponse(response)
13408 }
13409
13410 if err := handleHTTPErrorResp(response); err != nil {
13411 return nil, fmt.Errorf("DeletePrivateNetwork: http response: %w", err)
13412 }
13413
13414 bodyresp := new(Operation)
13415 if err := prepareJSONResponse(response, bodyresp); err != nil {
13416 return nil, fmt.Errorf("DeletePrivateNetwork: prepare Json response: %w", err)
13417 }
13418
13419 return bodyresp, nil
13420 }
13421
13422 // Retrieve Private Network details
13423 func (c Client) GetPrivateNetwork(ctx context.Context, id UUID) (*PrivateNetwork, error) {
13424 path := fmt.Sprintf("/private-network/%v", id)
13425
13426 request, err := http.NewRequestWithContext(ctx, "GET", c.serverEndpoint+path, nil)
13427 if err != nil {
13428 return nil, fmt.Errorf("GetPrivateNetwork: new request: %w", err)
13429 }
13430
13431 request.Header.Add("User-Agent", c.getUserAgent())
13432
13433 if err := c.executeRequestInterceptors(ctx, request); err != nil {
13434 return nil, fmt.Errorf("GetPrivateNetwork: execute request editors: %w", err)
13435 }
13436
13437 if err := c.signRequest(request); err != nil {
13438 return nil, fmt.Errorf("GetPrivateNetwork: sign request: %w", err)
13439 }
13440
13441 if c.trace {
13442 dumpRequest(request, "get-private-network")
13443 }
13444
13445 response, err := c.httpClient.Do(request)
13446 if err != nil {
13447 return nil, fmt.Errorf("GetPrivateNetwork: http client do: %w", err)
13448 }
13449
13450 if c.trace {
13451 dumpResponse(response)
13452 }
13453
13454 if err := handleHTTPErrorResp(response); err != nil {
13455 return nil, fmt.Errorf("GetPrivateNetwork: http response: %w", err)
13456 }
13457
13458 bodyresp := new(PrivateNetwork)
13459 if err := prepareJSONResponse(response, bodyresp); err != nil {
13460 return nil, fmt.Errorf("GetPrivateNetwork: prepare Json response: %w", err)
13461 }
13462
13463 return bodyresp, nil
13464 }
13465
13466 type UpdatePrivateNetworkRequest struct {
13467 // Private Network description
13468 Description string `json:"description,omitempty" validate:"omitempty,lte=255"`
13469 // Private Network end IP address
13470 EndIP net.IP `json:"end-ip,omitempty"`
13471 Labels Labels `json:"labels,omitempty"`
13472 // Private Network name
13473 Name string `json:"name,omitempty" validate:"omitempty,gte=1,lte=255"`
13474 // Private Network netmask
13475 Netmask net.IP `json:"netmask,omitempty"`
13476 // Private Network DHCP Options
13477 Options *PrivateNetworkOptions `json:"options,omitempty"`
13478 // Private Network start IP address
13479 StartIP net.IP `json:"start-ip,omitempty"`
13480 }
13481
13482 // Update a Private Network
13483 func (c Client) UpdatePrivateNetwork(ctx context.Context, id UUID, req UpdatePrivateNetworkRequest) (*Operation, error) {
13484 path := fmt.Sprintf("/private-network/%v", id)
13485
13486 body, err := prepareJSONBody(req)
13487 if err != nil {
13488 return nil, fmt.Errorf("UpdatePrivateNetwork: prepare Json body: %w", err)
13489 }
13490
13491 request, err := http.NewRequestWithContext(ctx, "PUT", c.serverEndpoint+path, body)
13492 if err != nil {
13493 return nil, fmt.Errorf("UpdatePrivateNetwork: new request: %w", err)
13494 }
13495
13496 request.Header.Add("User-Agent", c.getUserAgent())
13497
13498 request.Header.Add("Content-Type", "application/json")
13499
13500 if err := c.executeRequestInterceptors(ctx, request); err != nil {
13501 return nil, fmt.Errorf("UpdatePrivateNetwork: execute request editors: %w", err)
13502 }
13503
13504 if err := c.signRequest(request); err != nil {
13505 return nil, fmt.Errorf("UpdatePrivateNetwork: sign request: %w", err)
13506 }
13507
13508 if c.trace {
13509 dumpRequest(request, "update-private-network")
13510 }
13511
13512 response, err := c.httpClient.Do(request)
13513 if err != nil {
13514 return nil, fmt.Errorf("UpdatePrivateNetwork: http client do: %w", err)
13515 }
13516
13517 if c.trace {
13518 dumpResponse(response)
13519 }
13520
13521 if err := handleHTTPErrorResp(response); err != nil {
13522 return nil, fmt.Errorf("UpdatePrivateNetwork: http response: %w", err)
13523 }
13524
13525 bodyresp := new(Operation)
13526 if err := prepareJSONResponse(response, bodyresp); err != nil {
13527 return nil, fmt.Errorf("UpdatePrivateNetwork: prepare Json response: %w", err)
13528 }
13529
13530 return bodyresp, nil
13531 }
13532
13533 type ResetPrivateNetworkFieldField string
13534
13535 const (
13536 ResetPrivateNetworkFieldFieldLabels ResetPrivateNetworkFieldField = "labels"
13537 )
13538
13539 // Reset Private Network field
13540 func (c Client) ResetPrivateNetworkField(ctx context.Context, id UUID, field ResetPrivateNetworkFieldField) (*Operation, error) {
13541 path := fmt.Sprintf("/private-network/%v/%v", id, field)
13542
13543 request, err := http.NewRequestWithContext(ctx, "DELETE", c.serverEndpoint+path, nil)
13544 if err != nil {
13545 return nil, fmt.Errorf("ResetPrivateNetworkField: new request: %w", err)
13546 }
13547
13548 request.Header.Add("User-Agent", c.getUserAgent())
13549
13550 if err := c.executeRequestInterceptors(ctx, request); err != nil {
13551 return nil, fmt.Errorf("ResetPrivateNetworkField: execute request editors: %w", err)
13552 }
13553
13554 if err := c.signRequest(request); err != nil {
13555 return nil, fmt.Errorf("ResetPrivateNetworkField: sign request: %w", err)
13556 }
13557
13558 if c.trace {
13559 dumpRequest(request, "reset-private-network-field")
13560 }
13561
13562 response, err := c.httpClient.Do(request)
13563 if err != nil {
13564 return nil, fmt.Errorf("ResetPrivateNetworkField: http client do: %w", err)
13565 }
13566
13567 if c.trace {
13568 dumpResponse(response)
13569 }
13570
13571 if err := handleHTTPErrorResp(response); err != nil {
13572 return nil, fmt.Errorf("ResetPrivateNetworkField: http response: %w", err)
13573 }
13574
13575 bodyresp := new(Operation)
13576 if err := prepareJSONResponse(response, bodyresp); err != nil {
13577 return nil, fmt.Errorf("ResetPrivateNetworkField: prepare Json response: %w", err)
13578 }
13579
13580 return bodyresp, nil
13581 }
13582
13583 // Compute instance
13584 type AttachInstanceToPrivateNetworkRequestInstance struct {
13585 // Instance ID
13586 ID UUID `json:"id,omitempty"`
13587 }
13588
13589 type AttachInstanceToPrivateNetworkRequest struct {
13590 // Compute instance
13591 Instance *AttachInstanceToPrivateNetworkRequestInstance `json:"instance" validate:"required"`
13592 // Static IP address lease for the corresponding network interface
13593 IP net.IP `json:"ip,omitempty"`
13594 }
13595
13596 // Attach a Compute instance to a Private Network
13597 func (c Client) AttachInstanceToPrivateNetwork(ctx context.Context, id UUID, req AttachInstanceToPrivateNetworkRequest) (*Operation, error) {
13598 path := fmt.Sprintf("/private-network/%v:attach", id)
13599
13600 body, err := prepareJSONBody(req)
13601 if err != nil {
13602 return nil, fmt.Errorf("AttachInstanceToPrivateNetwork: prepare Json body: %w", err)
13603 }
13604
13605 request, err := http.NewRequestWithContext(ctx, "PUT", c.serverEndpoint+path, body)
13606 if err != nil {
13607 return nil, fmt.Errorf("AttachInstanceToPrivateNetwork: new request: %w", err)
13608 }
13609
13610 request.Header.Add("User-Agent", c.getUserAgent())
13611
13612 request.Header.Add("Content-Type", "application/json")
13613
13614 if err := c.executeRequestInterceptors(ctx, request); err != nil {
13615 return nil, fmt.Errorf("AttachInstanceToPrivateNetwork: execute request editors: %w", err)
13616 }
13617
13618 if err := c.signRequest(request); err != nil {
13619 return nil, fmt.Errorf("AttachInstanceToPrivateNetwork: sign request: %w", err)
13620 }
13621
13622 if c.trace {
13623 dumpRequest(request, "attach-instance-to-private-network")
13624 }
13625
13626 response, err := c.httpClient.Do(request)
13627 if err != nil {
13628 return nil, fmt.Errorf("AttachInstanceToPrivateNetwork: http client do: %w", err)
13629 }
13630
13631 if c.trace {
13632 dumpResponse(response)
13633 }
13634
13635 if err := handleHTTPErrorResp(response); err != nil {
13636 return nil, fmt.Errorf("AttachInstanceToPrivateNetwork: http response: %w", err)
13637 }
13638
13639 bodyresp := new(Operation)
13640 if err := prepareJSONResponse(response, bodyresp); err != nil {
13641 return nil, fmt.Errorf("AttachInstanceToPrivateNetwork: prepare Json response: %w", err)
13642 }
13643
13644 return bodyresp, nil
13645 }
13646
13647 type DetachInstanceFromPrivateNetworkRequest struct {
13648 // Instance
13649 Instance *Instance `json:"instance" validate:"required"`
13650 }
13651
13652 // Detach a Compute instance from a Private Network
13653 func (c Client) DetachInstanceFromPrivateNetwork(ctx context.Context, id UUID, req DetachInstanceFromPrivateNetworkRequest) (*Operation, error) {
13654 path := fmt.Sprintf("/private-network/%v:detach", id)
13655
13656 body, err := prepareJSONBody(req)
13657 if err != nil {
13658 return nil, fmt.Errorf("DetachInstanceFromPrivateNetwork: prepare Json body: %w", err)
13659 }
13660
13661 request, err := http.NewRequestWithContext(ctx, "PUT", c.serverEndpoint+path, body)
13662 if err != nil {
13663 return nil, fmt.Errorf("DetachInstanceFromPrivateNetwork: new request: %w", err)
13664 }
13665
13666 request.Header.Add("User-Agent", c.getUserAgent())
13667
13668 request.Header.Add("Content-Type", "application/json")
13669
13670 if err := c.executeRequestInterceptors(ctx, request); err != nil {
13671 return nil, fmt.Errorf("DetachInstanceFromPrivateNetwork: execute request editors: %w", err)
13672 }
13673
13674 if err := c.signRequest(request); err != nil {
13675 return nil, fmt.Errorf("DetachInstanceFromPrivateNetwork: sign request: %w", err)
13676 }
13677
13678 if c.trace {
13679 dumpRequest(request, "detach-instance-from-private-network")
13680 }
13681
13682 response, err := c.httpClient.Do(request)
13683 if err != nil {
13684 return nil, fmt.Errorf("DetachInstanceFromPrivateNetwork: http client do: %w", err)
13685 }
13686
13687 if c.trace {
13688 dumpResponse(response)
13689 }
13690
13691 if err := handleHTTPErrorResp(response); err != nil {
13692 return nil, fmt.Errorf("DetachInstanceFromPrivateNetwork: http response: %w", err)
13693 }
13694
13695 bodyresp := new(Operation)
13696 if err := prepareJSONResponse(response, bodyresp); err != nil {
13697 return nil, fmt.Errorf("DetachInstanceFromPrivateNetwork: prepare Json response: %w", err)
13698 }
13699
13700 return bodyresp, nil
13701 }
13702
13703 type UpdatePrivateNetworkInstanceIPRequestInstance struct {
13704 // Instance ID
13705 ID UUID `json:"id" validate:"required"`
13706 }
13707
13708 type UpdatePrivateNetworkInstanceIPRequest struct {
13709 Instance *UpdatePrivateNetworkInstanceIPRequestInstance `json:"instance,omitempty"`
13710 // Static IP address lease for the corresponding network interface
13711 IP net.IP `json:"ip,omitempty"`
13712 }
13713
13714 // Update the IP address of an instance attached to a managed private network
13715 func (c Client) UpdatePrivateNetworkInstanceIP(ctx context.Context, id UUID, req UpdatePrivateNetworkInstanceIPRequest) (*Operation, error) {
13716 path := fmt.Sprintf("/private-network/%v:update-ip", id)
13717
13718 body, err := prepareJSONBody(req)
13719 if err != nil {
13720 return nil, fmt.Errorf("UpdatePrivateNetworkInstanceIP: prepare Json body: %w", err)
13721 }
13722
13723 request, err := http.NewRequestWithContext(ctx, "PUT", c.serverEndpoint+path, body)
13724 if err != nil {
13725 return nil, fmt.Errorf("UpdatePrivateNetworkInstanceIP: new request: %w", err)
13726 }
13727
13728 request.Header.Add("User-Agent", c.getUserAgent())
13729
13730 request.Header.Add("Content-Type", "application/json")
13731
13732 if err := c.executeRequestInterceptors(ctx, request); err != nil {
13733 return nil, fmt.Errorf("UpdatePrivateNetworkInstanceIP: execute request editors: %w", err)
13734 }
13735
13736 if err := c.signRequest(request); err != nil {
13737 return nil, fmt.Errorf("UpdatePrivateNetworkInstanceIP: sign request: %w", err)
13738 }
13739
13740 if c.trace {
13741 dumpRequest(request, "update-private-network-instance-ip")
13742 }
13743
13744 response, err := c.httpClient.Do(request)
13745 if err != nil {
13746 return nil, fmt.Errorf("UpdatePrivateNetworkInstanceIP: http client do: %w", err)
13747 }
13748
13749 if c.trace {
13750 dumpResponse(response)
13751 }
13752
13753 if err := handleHTTPErrorResp(response); err != nil {
13754 return nil, fmt.Errorf("UpdatePrivateNetworkInstanceIP: http response: %w", err)
13755 }
13756
13757 bodyresp := new(Operation)
13758 if err := prepareJSONResponse(response, bodyresp); err != nil {
13759 return nil, fmt.Errorf("UpdatePrivateNetworkInstanceIP: prepare Json response: %w", err)
13760 }
13761
13762 return bodyresp, nil
13763 }
13764
13765 type ListQuotasResponse struct {
13766 Quotas []Quota `json:"quotas,omitempty"`
13767 }
13768
13769 // List Organization Quotas
13770 func (c Client) ListQuotas(ctx context.Context) (*ListQuotasResponse, error) {
13771 path := "/quota"
13772
13773 request, err := http.NewRequestWithContext(ctx, "GET", c.serverEndpoint+path, nil)
13774 if err != nil {
13775 return nil, fmt.Errorf("ListQuotas: new request: %w", err)
13776 }
13777
13778 request.Header.Add("User-Agent", c.getUserAgent())
13779
13780 if err := c.executeRequestInterceptors(ctx, request); err != nil {
13781 return nil, fmt.Errorf("ListQuotas: execute request editors: %w", err)
13782 }
13783
13784 if err := c.signRequest(request); err != nil {
13785 return nil, fmt.Errorf("ListQuotas: sign request: %w", err)
13786 }
13787
13788 if c.trace {
13789 dumpRequest(request, "list-quotas")
13790 }
13791
13792 response, err := c.httpClient.Do(request)
13793 if err != nil {
13794 return nil, fmt.Errorf("ListQuotas: http client do: %w", err)
13795 }
13796
13797 if c.trace {
13798 dumpResponse(response)
13799 }
13800
13801 if err := handleHTTPErrorResp(response); err != nil {
13802 return nil, fmt.Errorf("ListQuotas: http response: %w", err)
13803 }
13804
13805 bodyresp := new(ListQuotasResponse)
13806 if err := prepareJSONResponse(response, bodyresp); err != nil {
13807 return nil, fmt.Errorf("ListQuotas: prepare Json response: %w", err)
13808 }
13809
13810 return bodyresp, nil
13811 }
13812
13813 // Retrieve Resource Quota
13814 func (c Client) GetQuota(ctx context.Context, entity string) (*Quota, error) {
13815 path := fmt.Sprintf("/quota/%v", entity)
13816
13817 request, err := http.NewRequestWithContext(ctx, "GET", c.serverEndpoint+path, nil)
13818 if err != nil {
13819 return nil, fmt.Errorf("GetQuota: new request: %w", err)
13820 }
13821
13822 request.Header.Add("User-Agent", c.getUserAgent())
13823
13824 if err := c.executeRequestInterceptors(ctx, request); err != nil {
13825 return nil, fmt.Errorf("GetQuota: execute request editors: %w", err)
13826 }
13827
13828 if err := c.signRequest(request); err != nil {
13829 return nil, fmt.Errorf("GetQuota: sign request: %w", err)
13830 }
13831
13832 if c.trace {
13833 dumpRequest(request, "get-quota")
13834 }
13835
13836 response, err := c.httpClient.Do(request)
13837 if err != nil {
13838 return nil, fmt.Errorf("GetQuota: http client do: %w", err)
13839 }
13840
13841 if c.trace {
13842 dumpResponse(response)
13843 }
13844
13845 if err := handleHTTPErrorResp(response); err != nil {
13846 return nil, fmt.Errorf("GetQuota: http response: %w", err)
13847 }
13848
13849 bodyresp := new(Quota)
13850 if err := prepareJSONResponse(response, bodyresp); err != nil {
13851 return nil, fmt.Errorf("GetQuota: prepare Json response: %w", err)
13852 }
13853
13854 return bodyresp, nil
13855 }
13856
13857 // Delete the PTR DNS record for an elastic IP
13858 func (c Client) DeleteReverseDNSElasticIP(ctx context.Context, id UUID) (*Operation, error) {
13859 path := fmt.Sprintf("/reverse-dns/elastic-ip/%v", id)
13860
13861 request, err := http.NewRequestWithContext(ctx, "DELETE", c.serverEndpoint+path, nil)
13862 if err != nil {
13863 return nil, fmt.Errorf("DeleteReverseDNSElasticIP: new request: %w", err)
13864 }
13865
13866 request.Header.Add("User-Agent", c.getUserAgent())
13867
13868 if err := c.executeRequestInterceptors(ctx, request); err != nil {
13869 return nil, fmt.Errorf("DeleteReverseDNSElasticIP: execute request editors: %w", err)
13870 }
13871
13872 if err := c.signRequest(request); err != nil {
13873 return nil, fmt.Errorf("DeleteReverseDNSElasticIP: sign request: %w", err)
13874 }
13875
13876 if c.trace {
13877 dumpRequest(request, "delete-reverse-dns-elastic-ip")
13878 }
13879
13880 response, err := c.httpClient.Do(request)
13881 if err != nil {
13882 return nil, fmt.Errorf("DeleteReverseDNSElasticIP: http client do: %w", err)
13883 }
13884
13885 if c.trace {
13886 dumpResponse(response)
13887 }
13888
13889 if err := handleHTTPErrorResp(response); err != nil {
13890 return nil, fmt.Errorf("DeleteReverseDNSElasticIP: http response: %w", err)
13891 }
13892
13893 bodyresp := new(Operation)
13894 if err := prepareJSONResponse(response, bodyresp); err != nil {
13895 return nil, fmt.Errorf("DeleteReverseDNSElasticIP: prepare Json response: %w", err)
13896 }
13897
13898 return bodyresp, nil
13899 }
13900
13901 // Query the PTR DNS records for an elastic IP
13902 func (c Client) GetReverseDNSElasticIP(ctx context.Context, id UUID) (*ReverseDNSRecord, error) {
13903 path := fmt.Sprintf("/reverse-dns/elastic-ip/%v", id)
13904
13905 request, err := http.NewRequestWithContext(ctx, "GET", c.serverEndpoint+path, nil)
13906 if err != nil {
13907 return nil, fmt.Errorf("GetReverseDNSElasticIP: new request: %w", err)
13908 }
13909
13910 request.Header.Add("User-Agent", c.getUserAgent())
13911
13912 if err := c.executeRequestInterceptors(ctx, request); err != nil {
13913 return nil, fmt.Errorf("GetReverseDNSElasticIP: execute request editors: %w", err)
13914 }
13915
13916 if err := c.signRequest(request); err != nil {
13917 return nil, fmt.Errorf("GetReverseDNSElasticIP: sign request: %w", err)
13918 }
13919
13920 if c.trace {
13921 dumpRequest(request, "get-reverse-dns-elastic-ip")
13922 }
13923
13924 response, err := c.httpClient.Do(request)
13925 if err != nil {
13926 return nil, fmt.Errorf("GetReverseDNSElasticIP: http client do: %w", err)
13927 }
13928
13929 if c.trace {
13930 dumpResponse(response)
13931 }
13932
13933 if err := handleHTTPErrorResp(response); err != nil {
13934 return nil, fmt.Errorf("GetReverseDNSElasticIP: http response: %w", err)
13935 }
13936
13937 bodyresp := new(ReverseDNSRecord)
13938 if err := prepareJSONResponse(response, bodyresp); err != nil {
13939 return nil, fmt.Errorf("GetReverseDNSElasticIP: prepare Json response: %w", err)
13940 }
13941
13942 return bodyresp, nil
13943 }
13944
13945 type UpdateReverseDNSElasticIPRequest struct {
13946 DomainName string `json:"domain-name,omitempty" validate:"omitempty,gte=1,lte=253"`
13947 }
13948
13949 // Update/Create the PTR DNS record for an elastic IP
13950 func (c Client) UpdateReverseDNSElasticIP(ctx context.Context, id UUID, req UpdateReverseDNSElasticIPRequest) (*Operation, error) {
13951 path := fmt.Sprintf("/reverse-dns/elastic-ip/%v", id)
13952
13953 body, err := prepareJSONBody(req)
13954 if err != nil {
13955 return nil, fmt.Errorf("UpdateReverseDNSElasticIP: prepare Json body: %w", err)
13956 }
13957
13958 request, err := http.NewRequestWithContext(ctx, "POST", c.serverEndpoint+path, body)
13959 if err != nil {
13960 return nil, fmt.Errorf("UpdateReverseDNSElasticIP: new request: %w", err)
13961 }
13962
13963 request.Header.Add("User-Agent", c.getUserAgent())
13964
13965 request.Header.Add("Content-Type", "application/json")
13966
13967 if err := c.executeRequestInterceptors(ctx, request); err != nil {
13968 return nil, fmt.Errorf("UpdateReverseDNSElasticIP: execute request editors: %w", err)
13969 }
13970
13971 if err := c.signRequest(request); err != nil {
13972 return nil, fmt.Errorf("UpdateReverseDNSElasticIP: sign request: %w", err)
13973 }
13974
13975 if c.trace {
13976 dumpRequest(request, "update-reverse-dns-elastic-ip")
13977 }
13978
13979 response, err := c.httpClient.Do(request)
13980 if err != nil {
13981 return nil, fmt.Errorf("UpdateReverseDNSElasticIP: http client do: %w", err)
13982 }
13983
13984 if c.trace {
13985 dumpResponse(response)
13986 }
13987
13988 if err := handleHTTPErrorResp(response); err != nil {
13989 return nil, fmt.Errorf("UpdateReverseDNSElasticIP: http response: %w", err)
13990 }
13991
13992 bodyresp := new(Operation)
13993 if err := prepareJSONResponse(response, bodyresp); err != nil {
13994 return nil, fmt.Errorf("UpdateReverseDNSElasticIP: prepare Json response: %w", err)
13995 }
13996
13997 return bodyresp, nil
13998 }
13999
14000 // Delete the PTR DNS record for an instance
14001 func (c Client) DeleteReverseDNSInstance(ctx context.Context, id UUID) (*Operation, error) {
14002 path := fmt.Sprintf("/reverse-dns/instance/%v", id)
14003
14004 request, err := http.NewRequestWithContext(ctx, "DELETE", c.serverEndpoint+path, nil)
14005 if err != nil {
14006 return nil, fmt.Errorf("DeleteReverseDNSInstance: new request: %w", err)
14007 }
14008
14009 request.Header.Add("User-Agent", c.getUserAgent())
14010
14011 if err := c.executeRequestInterceptors(ctx, request); err != nil {
14012 return nil, fmt.Errorf("DeleteReverseDNSInstance: execute request editors: %w", err)
14013 }
14014
14015 if err := c.signRequest(request); err != nil {
14016 return nil, fmt.Errorf("DeleteReverseDNSInstance: sign request: %w", err)
14017 }
14018
14019 if c.trace {
14020 dumpRequest(request, "delete-reverse-dns-instance")
14021 }
14022
14023 response, err := c.httpClient.Do(request)
14024 if err != nil {
14025 return nil, fmt.Errorf("DeleteReverseDNSInstance: http client do: %w", err)
14026 }
14027
14028 if c.trace {
14029 dumpResponse(response)
14030 }
14031
14032 if err := handleHTTPErrorResp(response); err != nil {
14033 return nil, fmt.Errorf("DeleteReverseDNSInstance: http response: %w", err)
14034 }
14035
14036 bodyresp := new(Operation)
14037 if err := prepareJSONResponse(response, bodyresp); err != nil {
14038 return nil, fmt.Errorf("DeleteReverseDNSInstance: prepare Json response: %w", err)
14039 }
14040
14041 return bodyresp, nil
14042 }
14043
14044 // Query the PTR DNS records for an instance
14045 func (c Client) GetReverseDNSInstance(ctx context.Context, id UUID) (*ReverseDNSRecord, error) {
14046 path := fmt.Sprintf("/reverse-dns/instance/%v", id)
14047
14048 request, err := http.NewRequestWithContext(ctx, "GET", c.serverEndpoint+path, nil)
14049 if err != nil {
14050 return nil, fmt.Errorf("GetReverseDNSInstance: new request: %w", err)
14051 }
14052
14053 request.Header.Add("User-Agent", c.getUserAgent())
14054
14055 if err := c.executeRequestInterceptors(ctx, request); err != nil {
14056 return nil, fmt.Errorf("GetReverseDNSInstance: execute request editors: %w", err)
14057 }
14058
14059 if err := c.signRequest(request); err != nil {
14060 return nil, fmt.Errorf("GetReverseDNSInstance: sign request: %w", err)
14061 }
14062
14063 if c.trace {
14064 dumpRequest(request, "get-reverse-dns-instance")
14065 }
14066
14067 response, err := c.httpClient.Do(request)
14068 if err != nil {
14069 return nil, fmt.Errorf("GetReverseDNSInstance: http client do: %w", err)
14070 }
14071
14072 if c.trace {
14073 dumpResponse(response)
14074 }
14075
14076 if err := handleHTTPErrorResp(response); err != nil {
14077 return nil, fmt.Errorf("GetReverseDNSInstance: http response: %w", err)
14078 }
14079
14080 bodyresp := new(ReverseDNSRecord)
14081 if err := prepareJSONResponse(response, bodyresp); err != nil {
14082 return nil, fmt.Errorf("GetReverseDNSInstance: prepare Json response: %w", err)
14083 }
14084
14085 return bodyresp, nil
14086 }
14087
14088 type UpdateReverseDNSInstanceRequest struct {
14089 DomainName string `json:"domain-name,omitempty" validate:"omitempty,gte=1,lte=253"`
14090 }
14091
14092 // Update/Create the PTR DNS record for an instance
14093 func (c Client) UpdateReverseDNSInstance(ctx context.Context, id UUID, req UpdateReverseDNSInstanceRequest) (*Operation, error) {
14094 path := fmt.Sprintf("/reverse-dns/instance/%v", id)
14095
14096 body, err := prepareJSONBody(req)
14097 if err != nil {
14098 return nil, fmt.Errorf("UpdateReverseDNSInstance: prepare Json body: %w", err)
14099 }
14100
14101 request, err := http.NewRequestWithContext(ctx, "POST", c.serverEndpoint+path, body)
14102 if err != nil {
14103 return nil, fmt.Errorf("UpdateReverseDNSInstance: new request: %w", err)
14104 }
14105
14106 request.Header.Add("User-Agent", c.getUserAgent())
14107
14108 request.Header.Add("Content-Type", "application/json")
14109
14110 if err := c.executeRequestInterceptors(ctx, request); err != nil {
14111 return nil, fmt.Errorf("UpdateReverseDNSInstance: execute request editors: %w", err)
14112 }
14113
14114 if err := c.signRequest(request); err != nil {
14115 return nil, fmt.Errorf("UpdateReverseDNSInstance: sign request: %w", err)
14116 }
14117
14118 if c.trace {
14119 dumpRequest(request, "update-reverse-dns-instance")
14120 }
14121
14122 response, err := c.httpClient.Do(request)
14123 if err != nil {
14124 return nil, fmt.Errorf("UpdateReverseDNSInstance: http client do: %w", err)
14125 }
14126
14127 if c.trace {
14128 dumpResponse(response)
14129 }
14130
14131 if err := handleHTTPErrorResp(response); err != nil {
14132 return nil, fmt.Errorf("UpdateReverseDNSInstance: http response: %w", err)
14133 }
14134
14135 bodyresp := new(Operation)
14136 if err := prepareJSONResponse(response, bodyresp); err != nil {
14137 return nil, fmt.Errorf("UpdateReverseDNSInstance: prepare Json response: %w", err)
14138 }
14139
14140 return bodyresp, nil
14141 }
14142
14143 type ListSecurityGroupsResponse struct {
14144 SecurityGroups []SecurityGroup `json:"security-groups,omitempty"`
14145 }
14146
14147 // FindSecurityGroup attempts to find an SecurityGroup by nameOrID.
14148 func (l ListSecurityGroupsResponse) FindSecurityGroup(nameOrID string) (SecurityGroup, error) {
14149 var result []SecurityGroup
14150 for i, elem := range l.SecurityGroups {
14151 if string(elem.Name) == nameOrID || string(elem.ID) == nameOrID {
14152 result = append(result, l.SecurityGroups[i])
14153 }
14154 }
14155 if len(result) == 1 {
14156 return result[0], nil
14157 }
14158
14159 if len(result) > 1 {
14160 return SecurityGroup{}, fmt.Errorf("%q too many found in ListSecurityGroupsResponse: %w", nameOrID, ErrConflict)
14161 }
14162
14163 return SecurityGroup{}, fmt.Errorf("%q not found in ListSecurityGroupsResponse: %w", nameOrID, ErrNotFound)
14164 }
14165
14166 type ListSecurityGroupsVisibility string
14167
14168 const (
14169 ListSecurityGroupsVisibilityPrivate ListSecurityGroupsVisibility = "private"
14170 ListSecurityGroupsVisibilityPublic ListSecurityGroupsVisibility = "public"
14171 )
14172
14173 type ListSecurityGroupsOpt func(url.Values)
14174
14175 func ListSecurityGroupsWithVisibility(visibility ListSecurityGroupsVisibility) ListSecurityGroupsOpt {
14176 return func(q url.Values) {
14177 q.Add("visibility", fmt.Sprint(visibility))
14178 }
14179 }
14180
14181 // Lists security groups. When visibility is set to public, lists public security groups.
14182 // Public security groups are objects maintained by Exoscale which contain source addresses for
14183 // relevant services hosted by Exoscale. They can be used a source in ingress rules and as a destination
14184 // in egress rules.
14185 func (c Client) ListSecurityGroups(ctx context.Context, opts ...ListSecurityGroupsOpt) (*ListSecurityGroupsResponse, error) {
14186 path := "/security-group"
14187
14188 request, err := http.NewRequestWithContext(ctx, "GET", c.serverEndpoint+path, nil)
14189 if err != nil {
14190 return nil, fmt.Errorf("ListSecurityGroups: new request: %w", err)
14191 }
14192
14193 request.Header.Add("User-Agent", c.getUserAgent())
14194
14195 if len(opts) > 0 {
14196 q := request.URL.Query()
14197 for _, opt := range opts {
14198 opt(q)
14199 }
14200 request.URL.RawQuery = q.Encode()
14201 }
14202
14203 if err := c.executeRequestInterceptors(ctx, request); err != nil {
14204 return nil, fmt.Errorf("ListSecurityGroups: execute request editors: %w", err)
14205 }
14206
14207 if err := c.signRequest(request); err != nil {
14208 return nil, fmt.Errorf("ListSecurityGroups: sign request: %w", err)
14209 }
14210
14211 if c.trace {
14212 dumpRequest(request, "list-security-groups")
14213 }
14214
14215 response, err := c.httpClient.Do(request)
14216 if err != nil {
14217 return nil, fmt.Errorf("ListSecurityGroups: http client do: %w", err)
14218 }
14219
14220 if c.trace {
14221 dumpResponse(response)
14222 }
14223
14224 if err := handleHTTPErrorResp(response); err != nil {
14225 return nil, fmt.Errorf("ListSecurityGroups: http response: %w", err)
14226 }
14227
14228 bodyresp := new(ListSecurityGroupsResponse)
14229 if err := prepareJSONResponse(response, bodyresp); err != nil {
14230 return nil, fmt.Errorf("ListSecurityGroups: prepare Json response: %w", err)
14231 }
14232
14233 return bodyresp, nil
14234 }
14235
14236 type CreateSecurityGroupRequest struct {
14237 // Security Group description
14238 Description string `json:"description,omitempty" validate:"omitempty,lte=255"`
14239 // Security Group name
14240 Name string `json:"name" validate:"required,gte=1,lte=255"`
14241 }
14242
14243 // Create a Security Group
14244 func (c Client) CreateSecurityGroup(ctx context.Context, req CreateSecurityGroupRequest) (*Operation, error) {
14245 path := "/security-group"
14246
14247 body, err := prepareJSONBody(req)
14248 if err != nil {
14249 return nil, fmt.Errorf("CreateSecurityGroup: prepare Json body: %w", err)
14250 }
14251
14252 request, err := http.NewRequestWithContext(ctx, "POST", c.serverEndpoint+path, body)
14253 if err != nil {
14254 return nil, fmt.Errorf("CreateSecurityGroup: new request: %w", err)
14255 }
14256
14257 request.Header.Add("User-Agent", c.getUserAgent())
14258
14259 request.Header.Add("Content-Type", "application/json")
14260
14261 if err := c.executeRequestInterceptors(ctx, request); err != nil {
14262 return nil, fmt.Errorf("CreateSecurityGroup: execute request editors: %w", err)
14263 }
14264
14265 if err := c.signRequest(request); err != nil {
14266 return nil, fmt.Errorf("CreateSecurityGroup: sign request: %w", err)
14267 }
14268
14269 if c.trace {
14270 dumpRequest(request, "create-security-group")
14271 }
14272
14273 response, err := c.httpClient.Do(request)
14274 if err != nil {
14275 return nil, fmt.Errorf("CreateSecurityGroup: http client do: %w", err)
14276 }
14277
14278 if c.trace {
14279 dumpResponse(response)
14280 }
14281
14282 if err := handleHTTPErrorResp(response); err != nil {
14283 return nil, fmt.Errorf("CreateSecurityGroup: http response: %w", err)
14284 }
14285
14286 bodyresp := new(Operation)
14287 if err := prepareJSONResponse(response, bodyresp); err != nil {
14288 return nil, fmt.Errorf("CreateSecurityGroup: prepare Json response: %w", err)
14289 }
14290
14291 return bodyresp, nil
14292 }
14293
14294 // Delete a Security Group
14295 func (c Client) DeleteSecurityGroup(ctx context.Context, id UUID) (*Operation, error) {
14296 path := fmt.Sprintf("/security-group/%v", id)
14297
14298 request, err := http.NewRequestWithContext(ctx, "DELETE", c.serverEndpoint+path, nil)
14299 if err != nil {
14300 return nil, fmt.Errorf("DeleteSecurityGroup: new request: %w", err)
14301 }
14302
14303 request.Header.Add("User-Agent", c.getUserAgent())
14304
14305 if err := c.executeRequestInterceptors(ctx, request); err != nil {
14306 return nil, fmt.Errorf("DeleteSecurityGroup: execute request editors: %w", err)
14307 }
14308
14309 if err := c.signRequest(request); err != nil {
14310 return nil, fmt.Errorf("DeleteSecurityGroup: sign request: %w", err)
14311 }
14312
14313 if c.trace {
14314 dumpRequest(request, "delete-security-group")
14315 }
14316
14317 response, err := c.httpClient.Do(request)
14318 if err != nil {
14319 return nil, fmt.Errorf("DeleteSecurityGroup: http client do: %w", err)
14320 }
14321
14322 if c.trace {
14323 dumpResponse(response)
14324 }
14325
14326 if err := handleHTTPErrorResp(response); err != nil {
14327 return nil, fmt.Errorf("DeleteSecurityGroup: http response: %w", err)
14328 }
14329
14330 bodyresp := new(Operation)
14331 if err := prepareJSONResponse(response, bodyresp); err != nil {
14332 return nil, fmt.Errorf("DeleteSecurityGroup: prepare Json response: %w", err)
14333 }
14334
14335 return bodyresp, nil
14336 }
14337
14338 // Retrieve Security Group details
14339 func (c Client) GetSecurityGroup(ctx context.Context, id UUID) (*SecurityGroup, error) {
14340 path := fmt.Sprintf("/security-group/%v", id)
14341
14342 request, err := http.NewRequestWithContext(ctx, "GET", c.serverEndpoint+path, nil)
14343 if err != nil {
14344 return nil, fmt.Errorf("GetSecurityGroup: new request: %w", err)
14345 }
14346
14347 request.Header.Add("User-Agent", c.getUserAgent())
14348
14349 if err := c.executeRequestInterceptors(ctx, request); err != nil {
14350 return nil, fmt.Errorf("GetSecurityGroup: execute request editors: %w", err)
14351 }
14352
14353 if err := c.signRequest(request); err != nil {
14354 return nil, fmt.Errorf("GetSecurityGroup: sign request: %w", err)
14355 }
14356
14357 if c.trace {
14358 dumpRequest(request, "get-security-group")
14359 }
14360
14361 response, err := c.httpClient.Do(request)
14362 if err != nil {
14363 return nil, fmt.Errorf("GetSecurityGroup: http client do: %w", err)
14364 }
14365
14366 if c.trace {
14367 dumpResponse(response)
14368 }
14369
14370 if err := handleHTTPErrorResp(response); err != nil {
14371 return nil, fmt.Errorf("GetSecurityGroup: http response: %w", err)
14372 }
14373
14374 bodyresp := new(SecurityGroup)
14375 if err := prepareJSONResponse(response, bodyresp); err != nil {
14376 return nil, fmt.Errorf("GetSecurityGroup: prepare Json response: %w", err)
14377 }
14378
14379 return bodyresp, nil
14380 }
14381
14382 type AddRuleToSecurityGroupRequestFlowDirection string
14383
14384 const (
14385 AddRuleToSecurityGroupRequestFlowDirectionIngress AddRuleToSecurityGroupRequestFlowDirection = "ingress"
14386 AddRuleToSecurityGroupRequestFlowDirectionEgress AddRuleToSecurityGroupRequestFlowDirection = "egress"
14387 )
14388
14389 // ICMP details (default: -1 (ANY))
14390 type AddRuleToSecurityGroupRequestICMP struct {
14391 Code *int64 `json:"code,omitempty" validate:"omitempty,gte=-1,lte=254"`
14392 Type *int64 `json:"type,omitempty" validate:"omitempty,gte=-1,lte=254"`
14393 }
14394
14395 type AddRuleToSecurityGroupRequestProtocol string
14396
14397 const (
14398 AddRuleToSecurityGroupRequestProtocolTCP AddRuleToSecurityGroupRequestProtocol = "tcp"
14399 AddRuleToSecurityGroupRequestProtocolEsp AddRuleToSecurityGroupRequestProtocol = "esp"
14400 AddRuleToSecurityGroupRequestProtocolICMP AddRuleToSecurityGroupRequestProtocol = "icmp"
14401 AddRuleToSecurityGroupRequestProtocolUDP AddRuleToSecurityGroupRequestProtocol = "udp"
14402 AddRuleToSecurityGroupRequestProtocolGre AddRuleToSecurityGroupRequestProtocol = "gre"
14403 AddRuleToSecurityGroupRequestProtocolAh AddRuleToSecurityGroupRequestProtocol = "ah"
14404 AddRuleToSecurityGroupRequestProtocolIpip AddRuleToSecurityGroupRequestProtocol = "ipip"
14405 AddRuleToSecurityGroupRequestProtocolIcmpv6 AddRuleToSecurityGroupRequestProtocol = "icmpv6"
14406 )
14407
14408 type AddRuleToSecurityGroupRequest struct {
14409 // Security Group rule description
14410 Description string `json:"description,omitempty" validate:"omitempty,lte=255"`
14411 // End port of the range
14412 EndPort int64 `json:"end-port,omitempty" validate:"omitempty,gte=1,lte=65535"`
14413 // Network flow direction to match
14414 FlowDirection AddRuleToSecurityGroupRequestFlowDirection `json:"flow-direction" validate:"required"`
14415 // ICMP details (default: -1 (ANY))
14416 ICMP *AddRuleToSecurityGroupRequestICMP `json:"icmp,omitempty"`
14417 // CIDR-formatted network allowed
14418 Network string `json:"network,omitempty"`
14419 // Network protocol
14420 Protocol AddRuleToSecurityGroupRequestProtocol `json:"protocol" validate:"required"`
14421 // Security Group
14422 SecurityGroup *SecurityGroupResource `json:"security-group,omitempty"`
14423 // Start port of the range
14424 StartPort int64 `json:"start-port,omitempty" validate:"omitempty,gte=1,lte=65535"`
14425 }
14426
14427 // Create a Security Group rule
14428 func (c Client) AddRuleToSecurityGroup(ctx context.Context, id UUID, req AddRuleToSecurityGroupRequest) (*Operation, error) {
14429 path := fmt.Sprintf("/security-group/%v/rules", id)
14430
14431 body, err := prepareJSONBody(req)
14432 if err != nil {
14433 return nil, fmt.Errorf("AddRuleToSecurityGroup: prepare Json body: %w", err)
14434 }
14435
14436 request, err := http.NewRequestWithContext(ctx, "POST", c.serverEndpoint+path, body)
14437 if err != nil {
14438 return nil, fmt.Errorf("AddRuleToSecurityGroup: new request: %w", err)
14439 }
14440
14441 request.Header.Add("User-Agent", c.getUserAgent())
14442
14443 request.Header.Add("Content-Type", "application/json")
14444
14445 if err := c.executeRequestInterceptors(ctx, request); err != nil {
14446 return nil, fmt.Errorf("AddRuleToSecurityGroup: execute request editors: %w", err)
14447 }
14448
14449 if err := c.signRequest(request); err != nil {
14450 return nil, fmt.Errorf("AddRuleToSecurityGroup: sign request: %w", err)
14451 }
14452
14453 if c.trace {
14454 dumpRequest(request, "add-rule-to-security-group")
14455 }
14456
14457 response, err := c.httpClient.Do(request)
14458 if err != nil {
14459 return nil, fmt.Errorf("AddRuleToSecurityGroup: http client do: %w", err)
14460 }
14461
14462 if c.trace {
14463 dumpResponse(response)
14464 }
14465
14466 if err := handleHTTPErrorResp(response); err != nil {
14467 return nil, fmt.Errorf("AddRuleToSecurityGroup: http response: %w", err)
14468 }
14469
14470 bodyresp := new(Operation)
14471 if err := prepareJSONResponse(response, bodyresp); err != nil {
14472 return nil, fmt.Errorf("AddRuleToSecurityGroup: prepare Json response: %w", err)
14473 }
14474
14475 return bodyresp, nil
14476 }
14477
14478 // Delete a Security Group rule
14479 func (c Client) DeleteRuleFromSecurityGroup(ctx context.Context, id UUID, ruleID UUID) (*Operation, error) {
14480 path := fmt.Sprintf("/security-group/%v/rules/%v", id, ruleID)
14481
14482 request, err := http.NewRequestWithContext(ctx, "DELETE", c.serverEndpoint+path, nil)
14483 if err != nil {
14484 return nil, fmt.Errorf("DeleteRuleFromSecurityGroup: new request: %w", err)
14485 }
14486
14487 request.Header.Add("User-Agent", c.getUserAgent())
14488
14489 if err := c.executeRequestInterceptors(ctx, request); err != nil {
14490 return nil, fmt.Errorf("DeleteRuleFromSecurityGroup: execute request editors: %w", err)
14491 }
14492
14493 if err := c.signRequest(request); err != nil {
14494 return nil, fmt.Errorf("DeleteRuleFromSecurityGroup: sign request: %w", err)
14495 }
14496
14497 if c.trace {
14498 dumpRequest(request, "delete-rule-from-security-group")
14499 }
14500
14501 response, err := c.httpClient.Do(request)
14502 if err != nil {
14503 return nil, fmt.Errorf("DeleteRuleFromSecurityGroup: http client do: %w", err)
14504 }
14505
14506 if c.trace {
14507 dumpResponse(response)
14508 }
14509
14510 if err := handleHTTPErrorResp(response); err != nil {
14511 return nil, fmt.Errorf("DeleteRuleFromSecurityGroup: http response: %w", err)
14512 }
14513
14514 bodyresp := new(Operation)
14515 if err := prepareJSONResponse(response, bodyresp); err != nil {
14516 return nil, fmt.Errorf("DeleteRuleFromSecurityGroup: prepare Json response: %w", err)
14517 }
14518
14519 return bodyresp, nil
14520 }
14521
14522 type AddExternalSourceToSecurityGroupRequest struct {
14523 // CIDR-formatted network to add
14524 Cidr string `json:"cidr" validate:"required"`
14525 }
14526
14527 // Add an external source as a member of a Security Group
14528 func (c Client) AddExternalSourceToSecurityGroup(ctx context.Context, id UUID, req AddExternalSourceToSecurityGroupRequest) (*Operation, error) {
14529 path := fmt.Sprintf("/security-group/%v:add-source", id)
14530
14531 body, err := prepareJSONBody(req)
14532 if err != nil {
14533 return nil, fmt.Errorf("AddExternalSourceToSecurityGroup: prepare Json body: %w", err)
14534 }
14535
14536 request, err := http.NewRequestWithContext(ctx, "PUT", c.serverEndpoint+path, body)
14537 if err != nil {
14538 return nil, fmt.Errorf("AddExternalSourceToSecurityGroup: new request: %w", err)
14539 }
14540
14541 request.Header.Add("User-Agent", c.getUserAgent())
14542
14543 request.Header.Add("Content-Type", "application/json")
14544
14545 if err := c.executeRequestInterceptors(ctx, request); err != nil {
14546 return nil, fmt.Errorf("AddExternalSourceToSecurityGroup: execute request editors: %w", err)
14547 }
14548
14549 if err := c.signRequest(request); err != nil {
14550 return nil, fmt.Errorf("AddExternalSourceToSecurityGroup: sign request: %w", err)
14551 }
14552
14553 if c.trace {
14554 dumpRequest(request, "add-external-source-to-security-group")
14555 }
14556
14557 response, err := c.httpClient.Do(request)
14558 if err != nil {
14559 return nil, fmt.Errorf("AddExternalSourceToSecurityGroup: http client do: %w", err)
14560 }
14561
14562 if c.trace {
14563 dumpResponse(response)
14564 }
14565
14566 if err := handleHTTPErrorResp(response); err != nil {
14567 return nil, fmt.Errorf("AddExternalSourceToSecurityGroup: http response: %w", err)
14568 }
14569
14570 bodyresp := new(Operation)
14571 if err := prepareJSONResponse(response, bodyresp); err != nil {
14572 return nil, fmt.Errorf("AddExternalSourceToSecurityGroup: prepare Json response: %w", err)
14573 }
14574
14575 return bodyresp, nil
14576 }
14577
14578 type AttachInstanceToSecurityGroupRequest struct {
14579 // Instance
14580 Instance *Instance `json:"instance" validate:"required"`
14581 }
14582
14583 // Attach a Compute instance to a Security Group
14584 func (c Client) AttachInstanceToSecurityGroup(ctx context.Context, id UUID, req AttachInstanceToSecurityGroupRequest) (*Operation, error) {
14585 path := fmt.Sprintf("/security-group/%v:attach", id)
14586
14587 body, err := prepareJSONBody(req)
14588 if err != nil {
14589 return nil, fmt.Errorf("AttachInstanceToSecurityGroup: prepare Json body: %w", err)
14590 }
14591
14592 request, err := http.NewRequestWithContext(ctx, "PUT", c.serverEndpoint+path, body)
14593 if err != nil {
14594 return nil, fmt.Errorf("AttachInstanceToSecurityGroup: new request: %w", err)
14595 }
14596
14597 request.Header.Add("User-Agent", c.getUserAgent())
14598
14599 request.Header.Add("Content-Type", "application/json")
14600
14601 if err := c.executeRequestInterceptors(ctx, request); err != nil {
14602 return nil, fmt.Errorf("AttachInstanceToSecurityGroup: execute request editors: %w", err)
14603 }
14604
14605 if err := c.signRequest(request); err != nil {
14606 return nil, fmt.Errorf("AttachInstanceToSecurityGroup: sign request: %w", err)
14607 }
14608
14609 if c.trace {
14610 dumpRequest(request, "attach-instance-to-security-group")
14611 }
14612
14613 response, err := c.httpClient.Do(request)
14614 if err != nil {
14615 return nil, fmt.Errorf("AttachInstanceToSecurityGroup: http client do: %w", err)
14616 }
14617
14618 if c.trace {
14619 dumpResponse(response)
14620 }
14621
14622 if err := handleHTTPErrorResp(response); err != nil {
14623 return nil, fmt.Errorf("AttachInstanceToSecurityGroup: http response: %w", err)
14624 }
14625
14626 bodyresp := new(Operation)
14627 if err := prepareJSONResponse(response, bodyresp); err != nil {
14628 return nil, fmt.Errorf("AttachInstanceToSecurityGroup: prepare Json response: %w", err)
14629 }
14630
14631 return bodyresp, nil
14632 }
14633
14634 type DetachInstanceFromSecurityGroupRequest struct {
14635 // Instance
14636 Instance *Instance `json:"instance" validate:"required"`
14637 }
14638
14639 // Detach a Compute instance from a Security Group
14640 func (c Client) DetachInstanceFromSecurityGroup(ctx context.Context, id UUID, req DetachInstanceFromSecurityGroupRequest) (*Operation, error) {
14641 path := fmt.Sprintf("/security-group/%v:detach", id)
14642
14643 body, err := prepareJSONBody(req)
14644 if err != nil {
14645 return nil, fmt.Errorf("DetachInstanceFromSecurityGroup: prepare Json body: %w", err)
14646 }
14647
14648 request, err := http.NewRequestWithContext(ctx, "PUT", c.serverEndpoint+path, body)
14649 if err != nil {
14650 return nil, fmt.Errorf("DetachInstanceFromSecurityGroup: new request: %w", err)
14651 }
14652
14653 request.Header.Add("User-Agent", c.getUserAgent())
14654
14655 request.Header.Add("Content-Type", "application/json")
14656
14657 if err := c.executeRequestInterceptors(ctx, request); err != nil {
14658 return nil, fmt.Errorf("DetachInstanceFromSecurityGroup: execute request editors: %w", err)
14659 }
14660
14661 if err := c.signRequest(request); err != nil {
14662 return nil, fmt.Errorf("DetachInstanceFromSecurityGroup: sign request: %w", err)
14663 }
14664
14665 if c.trace {
14666 dumpRequest(request, "detach-instance-from-security-group")
14667 }
14668
14669 response, err := c.httpClient.Do(request)
14670 if err != nil {
14671 return nil, fmt.Errorf("DetachInstanceFromSecurityGroup: http client do: %w", err)
14672 }
14673
14674 if c.trace {
14675 dumpResponse(response)
14676 }
14677
14678 if err := handleHTTPErrorResp(response); err != nil {
14679 return nil, fmt.Errorf("DetachInstanceFromSecurityGroup: http response: %w", err)
14680 }
14681
14682 bodyresp := new(Operation)
14683 if err := prepareJSONResponse(response, bodyresp); err != nil {
14684 return nil, fmt.Errorf("DetachInstanceFromSecurityGroup: prepare Json response: %w", err)
14685 }
14686
14687 return bodyresp, nil
14688 }
14689
14690 type RemoveExternalSourceFromSecurityGroupRequest struct {
14691 // CIDR-formatted network to remove
14692 Cidr string `json:"cidr" validate:"required"`
14693 }
14694
14695 // Remove an external source from a Security Group
14696 func (c Client) RemoveExternalSourceFromSecurityGroup(ctx context.Context, id UUID, req RemoveExternalSourceFromSecurityGroupRequest) (*Operation, error) {
14697 path := fmt.Sprintf("/security-group/%v:remove-source", id)
14698
14699 body, err := prepareJSONBody(req)
14700 if err != nil {
14701 return nil, fmt.Errorf("RemoveExternalSourceFromSecurityGroup: prepare Json body: %w", err)
14702 }
14703
14704 request, err := http.NewRequestWithContext(ctx, "PUT", c.serverEndpoint+path, body)
14705 if err != nil {
14706 return nil, fmt.Errorf("RemoveExternalSourceFromSecurityGroup: new request: %w", err)
14707 }
14708
14709 request.Header.Add("User-Agent", c.getUserAgent())
14710
14711 request.Header.Add("Content-Type", "application/json")
14712
14713 if err := c.executeRequestInterceptors(ctx, request); err != nil {
14714 return nil, fmt.Errorf("RemoveExternalSourceFromSecurityGroup: execute request editors: %w", err)
14715 }
14716
14717 if err := c.signRequest(request); err != nil {
14718 return nil, fmt.Errorf("RemoveExternalSourceFromSecurityGroup: sign request: %w", err)
14719 }
14720
14721 if c.trace {
14722 dumpRequest(request, "remove-external-source-from-security-group")
14723 }
14724
14725 response, err := c.httpClient.Do(request)
14726 if err != nil {
14727 return nil, fmt.Errorf("RemoveExternalSourceFromSecurityGroup: http client do: %w", err)
14728 }
14729
14730 if c.trace {
14731 dumpResponse(response)
14732 }
14733
14734 if err := handleHTTPErrorResp(response); err != nil {
14735 return nil, fmt.Errorf("RemoveExternalSourceFromSecurityGroup: http response: %w", err)
14736 }
14737
14738 bodyresp := new(Operation)
14739 if err := prepareJSONResponse(response, bodyresp); err != nil {
14740 return nil, fmt.Errorf("RemoveExternalSourceFromSecurityGroup: prepare Json response: %w", err)
14741 }
14742
14743 return bodyresp, nil
14744 }
14745
14746 type ListSKSClustersResponse struct {
14747 SKSClusters []SKSCluster `json:"sks-clusters,omitempty"`
14748 }
14749
14750 // FindSKSCluster attempts to find an SKSCluster by nameOrID.
14751 func (l ListSKSClustersResponse) FindSKSCluster(nameOrID string) (SKSCluster, error) {
14752 var result []SKSCluster
14753 for i, elem := range l.SKSClusters {
14754 if string(elem.Name) == nameOrID || string(elem.ID) == nameOrID {
14755 result = append(result, l.SKSClusters[i])
14756 }
14757 }
14758 if len(result) == 1 {
14759 return result[0], nil
14760 }
14761
14762 if len(result) > 1 {
14763 return SKSCluster{}, fmt.Errorf("%q too many found in ListSKSClustersResponse: %w", nameOrID, ErrConflict)
14764 }
14765
14766 return SKSCluster{}, fmt.Errorf("%q not found in ListSKSClustersResponse: %w", nameOrID, ErrNotFound)
14767 }
14768
14769 // List SKS clusters
14770 func (c Client) ListSKSClusters(ctx context.Context) (*ListSKSClustersResponse, error) {
14771 path := "/sks-cluster"
14772
14773 request, err := http.NewRequestWithContext(ctx, "GET", c.serverEndpoint+path, nil)
14774 if err != nil {
14775 return nil, fmt.Errorf("ListSKSClusters: new request: %w", err)
14776 }
14777
14778 request.Header.Add("User-Agent", c.getUserAgent())
14779
14780 if err := c.executeRequestInterceptors(ctx, request); err != nil {
14781 return nil, fmt.Errorf("ListSKSClusters: execute request editors: %w", err)
14782 }
14783
14784 if err := c.signRequest(request); err != nil {
14785 return nil, fmt.Errorf("ListSKSClusters: sign request: %w", err)
14786 }
14787
14788 if c.trace {
14789 dumpRequest(request, "list-sks-clusters")
14790 }
14791
14792 response, err := c.httpClient.Do(request)
14793 if err != nil {
14794 return nil, fmt.Errorf("ListSKSClusters: http client do: %w", err)
14795 }
14796
14797 if c.trace {
14798 dumpResponse(response)
14799 }
14800
14801 if err := handleHTTPErrorResp(response); err != nil {
14802 return nil, fmt.Errorf("ListSKSClusters: http response: %w", err)
14803 }
14804
14805 bodyresp := new(ListSKSClustersResponse)
14806 if err := prepareJSONResponse(response, bodyresp); err != nil {
14807 return nil, fmt.Errorf("ListSKSClusters: prepare Json response: %w", err)
14808 }
14809
14810 return bodyresp, nil
14811 }
14812
14813 type CreateSKSClusterRequestCni string
14814
14815 const (
14816 CreateSKSClusterRequestCniCalico CreateSKSClusterRequestCni = "calico"
14817 CreateSKSClusterRequestCniCilium CreateSKSClusterRequestCni = "cilium"
14818 )
14819
14820 type CreateSKSClusterRequestLevel string
14821
14822 const (
14823 CreateSKSClusterRequestLevelStarter CreateSKSClusterRequestLevel = "starter"
14824 CreateSKSClusterRequestLevelPro CreateSKSClusterRequestLevel = "pro"
14825 )
14826
14827 type CreateSKSClusterRequest struct {
14828 // Cluster addons
14829 Addons []string `json:"addons,omitempty"`
14830 // Kubernetes Audit parameters
14831 Audit *SKSAuditCreate `json:"audit,omitempty"`
14832 // Enable auto upgrade of the control plane to the latest patch version available
14833 AutoUpgrade *bool `json:"auto-upgrade,omitempty"`
14834 // Cluster CNI
14835 Cni CreateSKSClusterRequestCni `json:"cni,omitempty"`
14836 // Creates an ad-hoc security group based on the choice of the selected CNI
14837 CreateDefaultSecurityGroup *bool `json:"create-default-security-group,omitempty"`
14838 // Cluster description
14839 Description *string `json:"description,omitempty" validate:"omitempty,lte=255"`
14840 // Indicates whether to deploy the Kubernetes network proxy. When unspecified, defaults to `true` unless Cilium CNI is selected
14841 EnableKubeProxy *bool `json:"enable-kube-proxy,omitempty"`
14842 // A list of Kubernetes-only Alpha features to enable for API server component
14843 FeatureGates []string `json:"feature-gates,omitempty"`
14844 Labels SKSClusterLabels `json:"labels,omitempty"`
14845 // Cluster service level
14846 Level CreateSKSClusterRequestLevel `json:"level" validate:"required"`
14847 // Cluster name
14848 Name string `json:"name" validate:"required,gte=1,lte=255"`
14849 // Cluster networking configuration.
14850 Networking *Networking `json:"networking,omitempty"`
14851 // SKS Cluster OpenID config map
14852 Oidc *SKSOidc `json:"oidc,omitempty"`
14853 // Control plane Kubernetes version
14854 Version string `json:"version" validate:"required"`
14855 }
14856
14857 // Create an SKS cluster
14858 func (c Client) CreateSKSCluster(ctx context.Context, req CreateSKSClusterRequest) (*Operation, error) {
14859 path := "/sks-cluster"
14860
14861 body, err := prepareJSONBody(req)
14862 if err != nil {
14863 return nil, fmt.Errorf("CreateSKSCluster: prepare Json body: %w", err)
14864 }
14865
14866 request, err := http.NewRequestWithContext(ctx, "POST", c.serverEndpoint+path, body)
14867 if err != nil {
14868 return nil, fmt.Errorf("CreateSKSCluster: new request: %w", err)
14869 }
14870
14871 request.Header.Add("User-Agent", c.getUserAgent())
14872
14873 request.Header.Add("Content-Type", "application/json")
14874
14875 if err := c.executeRequestInterceptors(ctx, request); err != nil {
14876 return nil, fmt.Errorf("CreateSKSCluster: execute request editors: %w", err)
14877 }
14878
14879 if err := c.signRequest(request); err != nil {
14880 return nil, fmt.Errorf("CreateSKSCluster: sign request: %w", err)
14881 }
14882
14883 if c.trace {
14884 dumpRequest(request, "create-sks-cluster")
14885 }
14886
14887 response, err := c.httpClient.Do(request)
14888 if err != nil {
14889 return nil, fmt.Errorf("CreateSKSCluster: http client do: %w", err)
14890 }
14891
14892 if c.trace {
14893 dumpResponse(response)
14894 }
14895
14896 if err := handleHTTPErrorResp(response); err != nil {
14897 return nil, fmt.Errorf("CreateSKSCluster: http response: %w", err)
14898 }
14899
14900 bodyresp := new(Operation)
14901 if err := prepareJSONResponse(response, bodyresp); err != nil {
14902 return nil, fmt.Errorf("CreateSKSCluster: prepare Json response: %w", err)
14903 }
14904
14905 return bodyresp, nil
14906 }
14907
14908 // This operation returns the deprecated resources for a given cluster
14909 func (c Client) ListSKSClusterDeprecatedResources(ctx context.Context, id UUID) ([]SKSClusterDeprecatedResource, error) {
14910 path := fmt.Sprintf("/sks-cluster-deprecated-resources/%v", id)
14911
14912 request, err := http.NewRequestWithContext(ctx, "GET", c.serverEndpoint+path, nil)
14913 if err != nil {
14914 return nil, fmt.Errorf("ListSKSClusterDeprecatedResources: new request: %w", err)
14915 }
14916
14917 request.Header.Add("User-Agent", c.getUserAgent())
14918
14919 if err := c.executeRequestInterceptors(ctx, request); err != nil {
14920 return nil, fmt.Errorf("ListSKSClusterDeprecatedResources: execute request editors: %w", err)
14921 }
14922
14923 if err := c.signRequest(request); err != nil {
14924 return nil, fmt.Errorf("ListSKSClusterDeprecatedResources: sign request: %w", err)
14925 }
14926
14927 if c.trace {
14928 dumpRequest(request, "list-sks-cluster-deprecated-resources")
14929 }
14930
14931 response, err := c.httpClient.Do(request)
14932 if err != nil {
14933 return nil, fmt.Errorf("ListSKSClusterDeprecatedResources: http client do: %w", err)
14934 }
14935
14936 if c.trace {
14937 dumpResponse(response)
14938 }
14939
14940 if err := handleHTTPErrorResp(response); err != nil {
14941 return nil, fmt.Errorf("ListSKSClusterDeprecatedResources: http response: %w", err)
14942 }
14943
14944 bodyresp := []SKSClusterDeprecatedResource{}
14945 if err := prepareJSONResponse(response, &bodyresp); err != nil {
14946 return nil, fmt.Errorf("ListSKSClusterDeprecatedResources: prepare Json response: %w", err)
14947 }
14948
14949 return bodyresp, nil
14950 }
14951
14952 type GenerateSKSClusterKubeconfigResponse struct {
14953 Kubeconfig string `json:"kubeconfig,omitempty"`
14954 }
14955
14956 // This operation returns a Kubeconfig file encoded in base64.
14957 func (c Client) GenerateSKSClusterKubeconfig(ctx context.Context, id UUID, req SKSKubeconfigRequest) (*GenerateSKSClusterKubeconfigResponse, error) {
14958 path := fmt.Sprintf("/sks-cluster-kubeconfig/%v", id)
14959
14960 body, err := prepareJSONBody(req)
14961 if err != nil {
14962 return nil, fmt.Errorf("GenerateSKSClusterKubeconfig: prepare Json body: %w", err)
14963 }
14964
14965 request, err := http.NewRequestWithContext(ctx, "POST", c.serverEndpoint+path, body)
14966 if err != nil {
14967 return nil, fmt.Errorf("GenerateSKSClusterKubeconfig: new request: %w", err)
14968 }
14969
14970 request.Header.Add("User-Agent", c.getUserAgent())
14971
14972 request.Header.Add("Content-Type", "application/json")
14973
14974 if err := c.executeRequestInterceptors(ctx, request); err != nil {
14975 return nil, fmt.Errorf("GenerateSKSClusterKubeconfig: execute request editors: %w", err)
14976 }
14977
14978 if err := c.signRequest(request); err != nil {
14979 return nil, fmt.Errorf("GenerateSKSClusterKubeconfig: sign request: %w", err)
14980 }
14981
14982 if c.trace {
14983 dumpRequest(request, "generate-sks-cluster-kubeconfig")
14984 }
14985
14986 response, err := c.httpClient.Do(request)
14987 if err != nil {
14988 return nil, fmt.Errorf("GenerateSKSClusterKubeconfig: http client do: %w", err)
14989 }
14990
14991 if c.trace {
14992 dumpResponse(response)
14993 }
14994
14995 if err := handleHTTPErrorResp(response); err != nil {
14996 return nil, fmt.Errorf("GenerateSKSClusterKubeconfig: http response: %w", err)
14997 }
14998
14999 bodyresp := new(GenerateSKSClusterKubeconfigResponse)
15000 if err := prepareJSONResponse(response, bodyresp); err != nil {
15001 return nil, fmt.Errorf("GenerateSKSClusterKubeconfig: prepare Json response: %w", err)
15002 }
15003
15004 return bodyresp, nil
15005 }
15006
15007 type ListSKSClusterVersionsResponse struct {
15008 SKSClusterVersions []string `json:"sks-cluster-versions,omitempty"`
15009 }
15010
15011 type ListSKSClusterVersionsOpt func(url.Values)
15012
15013 func ListSKSClusterVersionsWithIncludeDeprecated(includeDeprecated string) ListSKSClusterVersionsOpt {
15014 return func(q url.Values) {
15015 q.Add("include-deprecated", fmt.Sprint(includeDeprecated))
15016 }
15017 }
15018
15019 // List available versions for SKS clusters
15020 func (c Client) ListSKSClusterVersions(ctx context.Context, opts ...ListSKSClusterVersionsOpt) (*ListSKSClusterVersionsResponse, error) {
15021 path := "/sks-cluster-version"
15022
15023 request, err := http.NewRequestWithContext(ctx, "GET", c.serverEndpoint+path, nil)
15024 if err != nil {
15025 return nil, fmt.Errorf("ListSKSClusterVersions: new request: %w", err)
15026 }
15027
15028 request.Header.Add("User-Agent", c.getUserAgent())
15029
15030 if len(opts) > 0 {
15031 q := request.URL.Query()
15032 for _, opt := range opts {
15033 opt(q)
15034 }
15035 request.URL.RawQuery = q.Encode()
15036 }
15037
15038 if err := c.executeRequestInterceptors(ctx, request); err != nil {
15039 return nil, fmt.Errorf("ListSKSClusterVersions: execute request editors: %w", err)
15040 }
15041
15042 if err := c.signRequest(request); err != nil {
15043 return nil, fmt.Errorf("ListSKSClusterVersions: sign request: %w", err)
15044 }
15045
15046 if c.trace {
15047 dumpRequest(request, "list-sks-cluster-versions")
15048 }
15049
15050 response, err := c.httpClient.Do(request)
15051 if err != nil {
15052 return nil, fmt.Errorf("ListSKSClusterVersions: http client do: %w", err)
15053 }
15054
15055 if c.trace {
15056 dumpResponse(response)
15057 }
15058
15059 if err := handleHTTPErrorResp(response); err != nil {
15060 return nil, fmt.Errorf("ListSKSClusterVersions: http response: %w", err)
15061 }
15062
15063 bodyresp := new(ListSKSClusterVersionsResponse)
15064 if err := prepareJSONResponse(response, bodyresp); err != nil {
15065 return nil, fmt.Errorf("ListSKSClusterVersions: prepare Json response: %w", err)
15066 }
15067
15068 return bodyresp, nil
15069 }
15070
15071 // Delete an SKS cluster
15072 func (c Client) DeleteSKSCluster(ctx context.Context, id UUID) (*Operation, error) {
15073 path := fmt.Sprintf("/sks-cluster/%v", id)
15074
15075 request, err := http.NewRequestWithContext(ctx, "DELETE", c.serverEndpoint+path, nil)
15076 if err != nil {
15077 return nil, fmt.Errorf("DeleteSKSCluster: new request: %w", err)
15078 }
15079
15080 request.Header.Add("User-Agent", c.getUserAgent())
15081
15082 if err := c.executeRequestInterceptors(ctx, request); err != nil {
15083 return nil, fmt.Errorf("DeleteSKSCluster: execute request editors: %w", err)
15084 }
15085
15086 if err := c.signRequest(request); err != nil {
15087 return nil, fmt.Errorf("DeleteSKSCluster: sign request: %w", err)
15088 }
15089
15090 if c.trace {
15091 dumpRequest(request, "delete-sks-cluster")
15092 }
15093
15094 response, err := c.httpClient.Do(request)
15095 if err != nil {
15096 return nil, fmt.Errorf("DeleteSKSCluster: http client do: %w", err)
15097 }
15098
15099 if c.trace {
15100 dumpResponse(response)
15101 }
15102
15103 if err := handleHTTPErrorResp(response); err != nil {
15104 return nil, fmt.Errorf("DeleteSKSCluster: http response: %w", err)
15105 }
15106
15107 bodyresp := new(Operation)
15108 if err := prepareJSONResponse(response, bodyresp); err != nil {
15109 return nil, fmt.Errorf("DeleteSKSCluster: prepare Json response: %w", err)
15110 }
15111
15112 return bodyresp, nil
15113 }
15114
15115 // Retrieve SKS cluster details
15116 func (c Client) GetSKSCluster(ctx context.Context, id UUID) (*SKSCluster, error) {
15117 path := fmt.Sprintf("/sks-cluster/%v", id)
15118
15119 request, err := http.NewRequestWithContext(ctx, "GET", c.serverEndpoint+path, nil)
15120 if err != nil {
15121 return nil, fmt.Errorf("GetSKSCluster: new request: %w", err)
15122 }
15123
15124 request.Header.Add("User-Agent", c.getUserAgent())
15125
15126 if err := c.executeRequestInterceptors(ctx, request); err != nil {
15127 return nil, fmt.Errorf("GetSKSCluster: execute request editors: %w", err)
15128 }
15129
15130 if err := c.signRequest(request); err != nil {
15131 return nil, fmt.Errorf("GetSKSCluster: sign request: %w", err)
15132 }
15133
15134 if c.trace {
15135 dumpRequest(request, "get-sks-cluster")
15136 }
15137
15138 response, err := c.httpClient.Do(request)
15139 if err != nil {
15140 return nil, fmt.Errorf("GetSKSCluster: http client do: %w", err)
15141 }
15142
15143 if c.trace {
15144 dumpResponse(response)
15145 }
15146
15147 if err := handleHTTPErrorResp(response); err != nil {
15148 return nil, fmt.Errorf("GetSKSCluster: http response: %w", err)
15149 }
15150
15151 bodyresp := new(SKSCluster)
15152 if err := prepareJSONResponse(response, bodyresp); err != nil {
15153 return nil, fmt.Errorf("GetSKSCluster: prepare Json response: %w", err)
15154 }
15155
15156 return bodyresp, nil
15157 }
15158
15159 type UpdateSKSClusterRequest struct {
15160 // Cluster addons
15161 Addons []string `json:"addons,omitempty"`
15162 // Kubernetes Audit parameters
15163 Audit *SKSAuditUpdate `json:"audit,omitempty"`
15164 // Enable auto upgrade of the control plane to the latest patch version available
15165 AutoUpgrade *bool `json:"auto-upgrade,omitempty"`
15166 // Cluster description
15167 Description *string `json:"description,omitempty" validate:"omitempty,lte=255"`
15168 // Add or remove the operators certificate authority (CA) from the list of trusted CAs of the api server. The default value is true
15169 EnableOperatorsCA *bool `json:"enable-operators-ca,omitempty"`
15170 // A list of Kubernetes-only Alpha features to enable for API server component
15171 FeatureGates []string `json:"feature-gates"`
15172 Labels SKSClusterLabels `json:"labels,omitempty"`
15173 // Cluster name
15174 Name string `json:"name,omitempty" validate:"omitempty,gte=1,lte=255"`
15175 // SKS Cluster OpenID config map
15176 Oidc *SKSOidc `json:"oidc"`
15177 }
15178
15179 // Update an SKS cluster
15180 func (c Client) UpdateSKSCluster(ctx context.Context, id UUID, req UpdateSKSClusterRequest) (*Operation, error) {
15181 path := fmt.Sprintf("/sks-cluster/%v", id)
15182
15183 body, err := prepareJSONBody(req)
15184 if err != nil {
15185 return nil, fmt.Errorf("UpdateSKSCluster: prepare Json body: %w", err)
15186 }
15187
15188 request, err := http.NewRequestWithContext(ctx, "PUT", c.serverEndpoint+path, body)
15189 if err != nil {
15190 return nil, fmt.Errorf("UpdateSKSCluster: new request: %w", err)
15191 }
15192
15193 request.Header.Add("User-Agent", c.getUserAgent())
15194
15195 request.Header.Add("Content-Type", "application/json")
15196
15197 if err := c.executeRequestInterceptors(ctx, request); err != nil {
15198 return nil, fmt.Errorf("UpdateSKSCluster: execute request editors: %w", err)
15199 }
15200
15201 if err := c.signRequest(request); err != nil {
15202 return nil, fmt.Errorf("UpdateSKSCluster: sign request: %w", err)
15203 }
15204
15205 if c.trace {
15206 dumpRequest(request, "update-sks-cluster")
15207 }
15208
15209 response, err := c.httpClient.Do(request)
15210 if err != nil {
15211 return nil, fmt.Errorf("UpdateSKSCluster: http client do: %w", err)
15212 }
15213
15214 if c.trace {
15215 dumpResponse(response)
15216 }
15217
15218 if err := handleHTTPErrorResp(response); err != nil {
15219 return nil, fmt.Errorf("UpdateSKSCluster: http response: %w", err)
15220 }
15221
15222 bodyresp := new(Operation)
15223 if err := prepareJSONResponse(response, bodyresp); err != nil {
15224 return nil, fmt.Errorf("UpdateSKSCluster: prepare Json response: %w", err)
15225 }
15226
15227 return bodyresp, nil
15228 }
15229
15230 type GetSKSClusterAuthorityCertResponse struct {
15231 Cacert string `json:"cacert,omitempty"`
15232 }
15233
15234 type GetSKSClusterAuthorityCertAuthority string
15235
15236 const (
15237 GetSKSClusterAuthorityCertAuthorityControlPlane GetSKSClusterAuthorityCertAuthority = "control-plane"
15238 GetSKSClusterAuthorityCertAuthorityAggregation GetSKSClusterAuthorityCertAuthority = "aggregation"
15239 GetSKSClusterAuthorityCertAuthorityKubelet GetSKSClusterAuthorityCertAuthority = "kubelet"
15240 )
15241
15242 // This operation returns the certificate for the given SKS cluster authority encoded in base64.
15243 func (c Client) GetSKSClusterAuthorityCert(ctx context.Context, id UUID, authority GetSKSClusterAuthorityCertAuthority) (*GetSKSClusterAuthorityCertResponse, error) {
15244 path := fmt.Sprintf("/sks-cluster/%v/authority/%v/cert", id, authority)
15245
15246 request, err := http.NewRequestWithContext(ctx, "GET", c.serverEndpoint+path, nil)
15247 if err != nil {
15248 return nil, fmt.Errorf("GetSKSClusterAuthorityCert: new request: %w", err)
15249 }
15250
15251 request.Header.Add("User-Agent", c.getUserAgent())
15252
15253 if err := c.executeRequestInterceptors(ctx, request); err != nil {
15254 return nil, fmt.Errorf("GetSKSClusterAuthorityCert: execute request editors: %w", err)
15255 }
15256
15257 if err := c.signRequest(request); err != nil {
15258 return nil, fmt.Errorf("GetSKSClusterAuthorityCert: sign request: %w", err)
15259 }
15260
15261 if c.trace {
15262 dumpRequest(request, "get-sks-cluster-authority-cert")
15263 }
15264
15265 response, err := c.httpClient.Do(request)
15266 if err != nil {
15267 return nil, fmt.Errorf("GetSKSClusterAuthorityCert: http client do: %w", err)
15268 }
15269
15270 if c.trace {
15271 dumpResponse(response)
15272 }
15273
15274 if err := handleHTTPErrorResp(response); err != nil {
15275 return nil, fmt.Errorf("GetSKSClusterAuthorityCert: http response: %w", err)
15276 }
15277
15278 bodyresp := new(GetSKSClusterAuthorityCertResponse)
15279 if err := prepareJSONResponse(response, bodyresp); err != nil {
15280 return nil, fmt.Errorf("GetSKSClusterAuthorityCert: prepare Json response: %w", err)
15281 }
15282
15283 return bodyresp, nil
15284 }
15285
15286 type GetSKSClusterInspectionResponse map[string]any
15287
15288 // Helps troubleshoot common problems when deploying a kubernetes cluster. Inspections run every couple of minutes.
15289 func (c Client) GetSKSClusterInspection(ctx context.Context, id UUID) (*GetSKSClusterInspectionResponse, error) {
15290 path := fmt.Sprintf("/sks-cluster/%v/inspection", id)
15291
15292 request, err := http.NewRequestWithContext(ctx, "GET", c.serverEndpoint+path, nil)
15293 if err != nil {
15294 return nil, fmt.Errorf("GetSKSClusterInspection: new request: %w", err)
15295 }
15296
15297 request.Header.Add("User-Agent", c.getUserAgent())
15298
15299 if err := c.executeRequestInterceptors(ctx, request); err != nil {
15300 return nil, fmt.Errorf("GetSKSClusterInspection: execute request editors: %w", err)
15301 }
15302
15303 if err := c.signRequest(request); err != nil {
15304 return nil, fmt.Errorf("GetSKSClusterInspection: sign request: %w", err)
15305 }
15306
15307 if c.trace {
15308 dumpRequest(request, "get-sks-cluster-inspection")
15309 }
15310
15311 response, err := c.httpClient.Do(request)
15312 if err != nil {
15313 return nil, fmt.Errorf("GetSKSClusterInspection: http client do: %w", err)
15314 }
15315
15316 if c.trace {
15317 dumpResponse(response)
15318 }
15319
15320 if err := handleHTTPErrorResp(response); err != nil {
15321 return nil, fmt.Errorf("GetSKSClusterInspection: http response: %w", err)
15322 }
15323
15324 bodyresp := new(GetSKSClusterInspectionResponse)
15325 if err := prepareJSONResponse(response, bodyresp); err != nil {
15326 return nil, fmt.Errorf("GetSKSClusterInspection: prepare Json response: %w", err)
15327 }
15328
15329 return bodyresp, nil
15330 }
15331
15332 type CreateSKSNodepoolRequestPublicIPAssignment string
15333
15334 const (
15335 CreateSKSNodepoolRequestPublicIPAssignmentInet4 CreateSKSNodepoolRequestPublicIPAssignment = "inet4"
15336 CreateSKSNodepoolRequestPublicIPAssignmentDual CreateSKSNodepoolRequestPublicIPAssignment = "dual"
15337 )
15338
15339 type CreateSKSNodepoolRequest struct {
15340 // Nodepool addons
15341 Addons []string `json:"addons,omitempty"`
15342 // Nodepool Anti-affinity Groups
15343 AntiAffinityGroups []AntiAffinityGroup `json:"anti-affinity-groups,omitempty"`
15344 // Deploy target
15345 DeployTarget *DeployTarget `json:"deploy-target,omitempty"`
15346 // Nodepool description
15347 Description string `json:"description,omitempty" validate:"omitempty,lte=255"`
15348 // Nodepool instances disk size in GiB
15349 DiskSize int64 `json:"disk-size" validate:"required,gte=20,lte=51200"`
15350 // Prefix to apply to instances names (default: pool), lowercase only
15351 InstancePrefix string `json:"instance-prefix,omitempty" validate:"omitempty,gte=1,lte=30"`
15352 // Compute instance type
15353 InstanceType *InstanceType `json:"instance-type" validate:"required"`
15354 // Kubelet image GC options
15355 KubeletImageGC *KubeletImageGC `json:"kubelet-image-gc,omitempty"`
15356 Labels SKSNodepoolLabels `json:"labels,omitempty"`
15357 // Nodepool name, lowercase only
15358 Name string `json:"name" validate:"required,gte=1,lte=255"`
15359 // Nodepool Private Networks
15360 PrivateNetworks []PrivateNetwork `json:"private-networks,omitempty"`
15361 // Configures public IP assignment of the Instances with:
15362 // * both IPv4 and IPv6 (`dual`) addressing.
15363 // * both IPv4 and IPv6 (`dual`) addressing.
15364 PublicIPAssignment CreateSKSNodepoolRequestPublicIPAssignment `json:"public-ip-assignment,omitempty"`
15365 // Nodepool Security Groups
15366 SecurityGroups []SecurityGroup `json:"security-groups,omitempty"`
15367 // Number of instances
15368 Size int64 `json:"size" validate:"required,gt=0"`
15369 Taints SKSNodepoolTaints `json:"taints,omitempty"`
15370 }
15371
15372 // Create a new SKS Nodepool
15373 func (c Client) CreateSKSNodepool(ctx context.Context, id UUID, req CreateSKSNodepoolRequest) (*Operation, error) {
15374 path := fmt.Sprintf("/sks-cluster/%v/nodepool", id)
15375
15376 body, err := prepareJSONBody(req)
15377 if err != nil {
15378 return nil, fmt.Errorf("CreateSKSNodepool: prepare Json body: %w", err)
15379 }
15380
15381 request, err := http.NewRequestWithContext(ctx, "POST", c.serverEndpoint+path, body)
15382 if err != nil {
15383 return nil, fmt.Errorf("CreateSKSNodepool: new request: %w", err)
15384 }
15385
15386 request.Header.Add("User-Agent", c.getUserAgent())
15387
15388 request.Header.Add("Content-Type", "application/json")
15389
15390 if err := c.executeRequestInterceptors(ctx, request); err != nil {
15391 return nil, fmt.Errorf("CreateSKSNodepool: execute request editors: %w", err)
15392 }
15393
15394 if err := c.signRequest(request); err != nil {
15395 return nil, fmt.Errorf("CreateSKSNodepool: sign request: %w", err)
15396 }
15397
15398 if c.trace {
15399 dumpRequest(request, "create-sks-nodepool")
15400 }
15401
15402 response, err := c.httpClient.Do(request)
15403 if err != nil {
15404 return nil, fmt.Errorf("CreateSKSNodepool: http client do: %w", err)
15405 }
15406
15407 if c.trace {
15408 dumpResponse(response)
15409 }
15410
15411 if err := handleHTTPErrorResp(response); err != nil {
15412 return nil, fmt.Errorf("CreateSKSNodepool: http response: %w", err)
15413 }
15414
15415 bodyresp := new(Operation)
15416 if err := prepareJSONResponse(response, bodyresp); err != nil {
15417 return nil, fmt.Errorf("CreateSKSNodepool: prepare Json response: %w", err)
15418 }
15419
15420 return bodyresp, nil
15421 }
15422
15423 // Delete an SKS Nodepool
15424 func (c Client) DeleteSKSNodepool(ctx context.Context, id UUID, sksNodepoolID UUID) (*Operation, error) {
15425 path := fmt.Sprintf("/sks-cluster/%v/nodepool/%v", id, sksNodepoolID)
15426
15427 request, err := http.NewRequestWithContext(ctx, "DELETE", c.serverEndpoint+path, nil)
15428 if err != nil {
15429 return nil, fmt.Errorf("DeleteSKSNodepool: new request: %w", err)
15430 }
15431
15432 request.Header.Add("User-Agent", c.getUserAgent())
15433
15434 if err := c.executeRequestInterceptors(ctx, request); err != nil {
15435 return nil, fmt.Errorf("DeleteSKSNodepool: execute request editors: %w", err)
15436 }
15437
15438 if err := c.signRequest(request); err != nil {
15439 return nil, fmt.Errorf("DeleteSKSNodepool: sign request: %w", err)
15440 }
15441
15442 if c.trace {
15443 dumpRequest(request, "delete-sks-nodepool")
15444 }
15445
15446 response, err := c.httpClient.Do(request)
15447 if err != nil {
15448 return nil, fmt.Errorf("DeleteSKSNodepool: http client do: %w", err)
15449 }
15450
15451 if c.trace {
15452 dumpResponse(response)
15453 }
15454
15455 if err := handleHTTPErrorResp(response); err != nil {
15456 return nil, fmt.Errorf("DeleteSKSNodepool: http response: %w", err)
15457 }
15458
15459 bodyresp := new(Operation)
15460 if err := prepareJSONResponse(response, bodyresp); err != nil {
15461 return nil, fmt.Errorf("DeleteSKSNodepool: prepare Json response: %w", err)
15462 }
15463
15464 return bodyresp, nil
15465 }
15466
15467 // Retrieve SKS Nodepool details
15468 func (c Client) GetSKSNodepool(ctx context.Context, id UUID, sksNodepoolID UUID) (*SKSNodepool, error) {
15469 path := fmt.Sprintf("/sks-cluster/%v/nodepool/%v", id, sksNodepoolID)
15470
15471 request, err := http.NewRequestWithContext(ctx, "GET", c.serverEndpoint+path, nil)
15472 if err != nil {
15473 return nil, fmt.Errorf("GetSKSNodepool: new request: %w", err)
15474 }
15475
15476 request.Header.Add("User-Agent", c.getUserAgent())
15477
15478 if err := c.executeRequestInterceptors(ctx, request); err != nil {
15479 return nil, fmt.Errorf("GetSKSNodepool: execute request editors: %w", err)
15480 }
15481
15482 if err := c.signRequest(request); err != nil {
15483 return nil, fmt.Errorf("GetSKSNodepool: sign request: %w", err)
15484 }
15485
15486 if c.trace {
15487 dumpRequest(request, "get-sks-nodepool")
15488 }
15489
15490 response, err := c.httpClient.Do(request)
15491 if err != nil {
15492 return nil, fmt.Errorf("GetSKSNodepool: http client do: %w", err)
15493 }
15494
15495 if c.trace {
15496 dumpResponse(response)
15497 }
15498
15499 if err := handleHTTPErrorResp(response); err != nil {
15500 return nil, fmt.Errorf("GetSKSNodepool: http response: %w", err)
15501 }
15502
15503 bodyresp := new(SKSNodepool)
15504 if err := prepareJSONResponse(response, bodyresp); err != nil {
15505 return nil, fmt.Errorf("GetSKSNodepool: prepare Json response: %w", err)
15506 }
15507
15508 return bodyresp, nil
15509 }
15510
15511 type UpdateSKSNodepoolRequestPublicIPAssignment string
15512
15513 const (
15514 UpdateSKSNodepoolRequestPublicIPAssignmentInet4 UpdateSKSNodepoolRequestPublicIPAssignment = "inet4"
15515 UpdateSKSNodepoolRequestPublicIPAssignmentDual UpdateSKSNodepoolRequestPublicIPAssignment = "dual"
15516 )
15517
15518 type UpdateSKSNodepoolRequest struct {
15519 // Nodepool Anti-affinity Groups
15520 AntiAffinityGroups []AntiAffinityGroup `json:"anti-affinity-groups,omitempty"`
15521 // Deploy target
15522 DeployTarget *DeployTarget `json:"deploy-target"`
15523 // Nodepool description
15524 Description string `json:"description,omitempty" validate:"omitempty,lte=255"`
15525 // Nodepool instances disk size in GiB
15526 DiskSize int64 `json:"disk-size,omitempty" validate:"omitempty,gte=20,lte=51200"`
15527 // Prefix to apply to managed instances names (default: pool), lowercase only
15528 InstancePrefix string `json:"instance-prefix,omitempty" validate:"omitempty,gte=1,lte=30"`
15529 // Compute instance type
15530 InstanceType *InstanceType `json:"instance-type,omitempty"`
15531 Labels SKSNodepoolLabels `json:"labels,omitempty"`
15532 // Nodepool name, lowercase only
15533 Name string `json:"name,omitempty" validate:"omitempty,gte=1,lte=255"`
15534 // Nodepool Private Networks
15535 PrivateNetworks []PrivateNetwork `json:"private-networks,omitempty"`
15536 // Configures public IP assignment of the Instances with:
15537 // * both IPv4 and IPv6 (`dual`) addressing.
15538 // * both IPv4 and IPv6 (`dual`) addressing.
15539 PublicIPAssignment UpdateSKSNodepoolRequestPublicIPAssignment `json:"public-ip-assignment,omitempty"`
15540 // Nodepool Security Groups
15541 SecurityGroups []SecurityGroup `json:"security-groups,omitempty"`
15542 Taints SKSNodepoolTaints `json:"taints,omitempty"`
15543 }
15544
15545 // Update an SKS Nodepool
15546 func (c Client) UpdateSKSNodepool(ctx context.Context, id UUID, sksNodepoolID UUID, req UpdateSKSNodepoolRequest) (*Operation, error) {
15547 path := fmt.Sprintf("/sks-cluster/%v/nodepool/%v", id, sksNodepoolID)
15548
15549 body, err := prepareJSONBody(req)
15550 if err != nil {
15551 return nil, fmt.Errorf("UpdateSKSNodepool: prepare Json body: %w", err)
15552 }
15553
15554 request, err := http.NewRequestWithContext(ctx, "PUT", c.serverEndpoint+path, body)
15555 if err != nil {
15556 return nil, fmt.Errorf("UpdateSKSNodepool: new request: %w", err)
15557 }
15558
15559 request.Header.Add("User-Agent", c.getUserAgent())
15560
15561 request.Header.Add("Content-Type", "application/json")
15562
15563 if err := c.executeRequestInterceptors(ctx, request); err != nil {
15564 return nil, fmt.Errorf("UpdateSKSNodepool: execute request editors: %w", err)
15565 }
15566
15567 if err := c.signRequest(request); err != nil {
15568 return nil, fmt.Errorf("UpdateSKSNodepool: sign request: %w", err)
15569 }
15570
15571 if c.trace {
15572 dumpRequest(request, "update-sks-nodepool")
15573 }
15574
15575 response, err := c.httpClient.Do(request)
15576 if err != nil {
15577 return nil, fmt.Errorf("UpdateSKSNodepool: http client do: %w", err)
15578 }
15579
15580 if c.trace {
15581 dumpResponse(response)
15582 }
15583
15584 if err := handleHTTPErrorResp(response); err != nil {
15585 return nil, fmt.Errorf("UpdateSKSNodepool: http response: %w", err)
15586 }
15587
15588 bodyresp := new(Operation)
15589 if err := prepareJSONResponse(response, bodyresp); err != nil {
15590 return nil, fmt.Errorf("UpdateSKSNodepool: prepare Json response: %w", err)
15591 }
15592
15593 return bodyresp, nil
15594 }
15595
15596 type EvictSKSNodepoolMembersRequest struct {
15597 Instances []UUID `json:"instances,omitempty"`
15598 }
15599
15600 // This operation evicts the specified Compute instances member from the Nodepool, shrinking it to `<current nodepool size> - <# evicted members>`.
15601 func (c Client) EvictSKSNodepoolMembers(ctx context.Context, id UUID, sksNodepoolID UUID, req EvictSKSNodepoolMembersRequest) (*Operation, error) {
15602 path := fmt.Sprintf("/sks-cluster/%v/nodepool/%v:evict", id, sksNodepoolID)
15603
15604 body, err := prepareJSONBody(req)
15605 if err != nil {
15606 return nil, fmt.Errorf("EvictSKSNodepoolMembers: prepare Json body: %w", err)
15607 }
15608
15609 request, err := http.NewRequestWithContext(ctx, "PUT", c.serverEndpoint+path, body)
15610 if err != nil {
15611 return nil, fmt.Errorf("EvictSKSNodepoolMembers: new request: %w", err)
15612 }
15613
15614 request.Header.Add("User-Agent", c.getUserAgent())
15615
15616 request.Header.Add("Content-Type", "application/json")
15617
15618 if err := c.executeRequestInterceptors(ctx, request); err != nil {
15619 return nil, fmt.Errorf("EvictSKSNodepoolMembers: execute request editors: %w", err)
15620 }
15621
15622 if err := c.signRequest(request); err != nil {
15623 return nil, fmt.Errorf("EvictSKSNodepoolMembers: sign request: %w", err)
15624 }
15625
15626 if c.trace {
15627 dumpRequest(request, "evict-sks-nodepool-members")
15628 }
15629
15630 response, err := c.httpClient.Do(request)
15631 if err != nil {
15632 return nil, fmt.Errorf("EvictSKSNodepoolMembers: http client do: %w", err)
15633 }
15634
15635 if c.trace {
15636 dumpResponse(response)
15637 }
15638
15639 if err := handleHTTPErrorResp(response); err != nil {
15640 return nil, fmt.Errorf("EvictSKSNodepoolMembers: http response: %w", err)
15641 }
15642
15643 bodyresp := new(Operation)
15644 if err := prepareJSONResponse(response, bodyresp); err != nil {
15645 return nil, fmt.Errorf("EvictSKSNodepoolMembers: prepare Json response: %w", err)
15646 }
15647
15648 return bodyresp, nil
15649 }
15650
15651 type ScaleSKSNodepoolRequest struct {
15652 // Number of instances
15653 Size int64 `json:"size" validate:"required,gte=0"`
15654 }
15655
15656 // Scale a SKS Nodepool
15657 func (c Client) ScaleSKSNodepool(ctx context.Context, id UUID, sksNodepoolID UUID, req ScaleSKSNodepoolRequest) (*Operation, error) {
15658 path := fmt.Sprintf("/sks-cluster/%v/nodepool/%v:scale", id, sksNodepoolID)
15659
15660 body, err := prepareJSONBody(req)
15661 if err != nil {
15662 return nil, fmt.Errorf("ScaleSKSNodepool: prepare Json body: %w", err)
15663 }
15664
15665 request, err := http.NewRequestWithContext(ctx, "PUT", c.serverEndpoint+path, body)
15666 if err != nil {
15667 return nil, fmt.Errorf("ScaleSKSNodepool: new request: %w", err)
15668 }
15669
15670 request.Header.Add("User-Agent", c.getUserAgent())
15671
15672 request.Header.Add("Content-Type", "application/json")
15673
15674 if err := c.executeRequestInterceptors(ctx, request); err != nil {
15675 return nil, fmt.Errorf("ScaleSKSNodepool: execute request editors: %w", err)
15676 }
15677
15678 if err := c.signRequest(request); err != nil {
15679 return nil, fmt.Errorf("ScaleSKSNodepool: sign request: %w", err)
15680 }
15681
15682 if c.trace {
15683 dumpRequest(request, "scale-sks-nodepool")
15684 }
15685
15686 response, err := c.httpClient.Do(request)
15687 if err != nil {
15688 return nil, fmt.Errorf("ScaleSKSNodepool: http client do: %w", err)
15689 }
15690
15691 if c.trace {
15692 dumpResponse(response)
15693 }
15694
15695 if err := handleHTTPErrorResp(response); err != nil {
15696 return nil, fmt.Errorf("ScaleSKSNodepool: http response: %w", err)
15697 }
15698
15699 bodyresp := new(Operation)
15700 if err := prepareJSONResponse(response, bodyresp); err != nil {
15701 return nil, fmt.Errorf("ScaleSKSNodepool: prepare Json response: %w", err)
15702 }
15703
15704 return bodyresp, nil
15705 }
15706
15707 // Rotate Exoscale CCM credentials
15708 func (c Client) RotateSKSCcmCredentials(ctx context.Context, id UUID) (*Operation, error) {
15709 path := fmt.Sprintf("/sks-cluster/%v/rotate-ccm-credentials", id)
15710
15711 request, err := http.NewRequestWithContext(ctx, "PUT", c.serverEndpoint+path, nil)
15712 if err != nil {
15713 return nil, fmt.Errorf("RotateSKSCcmCredentials: new request: %w", err)
15714 }
15715
15716 request.Header.Add("User-Agent", c.getUserAgent())
15717
15718 if err := c.executeRequestInterceptors(ctx, request); err != nil {
15719 return nil, fmt.Errorf("RotateSKSCcmCredentials: execute request editors: %w", err)
15720 }
15721
15722 if err := c.signRequest(request); err != nil {
15723 return nil, fmt.Errorf("RotateSKSCcmCredentials: sign request: %w", err)
15724 }
15725
15726 if c.trace {
15727 dumpRequest(request, "rotate-sks-ccm-credentials")
15728 }
15729
15730 response, err := c.httpClient.Do(request)
15731 if err != nil {
15732 return nil, fmt.Errorf("RotateSKSCcmCredentials: http client do: %w", err)
15733 }
15734
15735 if c.trace {
15736 dumpResponse(response)
15737 }
15738
15739 if err := handleHTTPErrorResp(response); err != nil {
15740 return nil, fmt.Errorf("RotateSKSCcmCredentials: http response: %w", err)
15741 }
15742
15743 bodyresp := new(Operation)
15744 if err := prepareJSONResponse(response, bodyresp); err != nil {
15745 return nil, fmt.Errorf("RotateSKSCcmCredentials: prepare Json response: %w", err)
15746 }
15747
15748 return bodyresp, nil
15749 }
15750
15751 // Rotate Exoscale CSI credentials
15752 func (c Client) RotateSKSCsiCredentials(ctx context.Context, id UUID) (*Operation, error) {
15753 path := fmt.Sprintf("/sks-cluster/%v/rotate-csi-credentials", id)
15754
15755 request, err := http.NewRequestWithContext(ctx, "PUT", c.serverEndpoint+path, nil)
15756 if err != nil {
15757 return nil, fmt.Errorf("RotateSKSCsiCredentials: new request: %w", err)
15758 }
15759
15760 request.Header.Add("User-Agent", c.getUserAgent())
15761
15762 if err := c.executeRequestInterceptors(ctx, request); err != nil {
15763 return nil, fmt.Errorf("RotateSKSCsiCredentials: execute request editors: %w", err)
15764 }
15765
15766 if err := c.signRequest(request); err != nil {
15767 return nil, fmt.Errorf("RotateSKSCsiCredentials: sign request: %w", err)
15768 }
15769
15770 if c.trace {
15771 dumpRequest(request, "rotate-sks-csi-credentials")
15772 }
15773
15774 response, err := c.httpClient.Do(request)
15775 if err != nil {
15776 return nil, fmt.Errorf("RotateSKSCsiCredentials: http client do: %w", err)
15777 }
15778
15779 if c.trace {
15780 dumpResponse(response)
15781 }
15782
15783 if err := handleHTTPErrorResp(response); err != nil {
15784 return nil, fmt.Errorf("RotateSKSCsiCredentials: http response: %w", err)
15785 }
15786
15787 bodyresp := new(Operation)
15788 if err := prepareJSONResponse(response, bodyresp); err != nil {
15789 return nil, fmt.Errorf("RotateSKSCsiCredentials: prepare Json response: %w", err)
15790 }
15791
15792 return bodyresp, nil
15793 }
15794
15795 // Rotate Exoscale Karpenter credentials
15796 func (c Client) RotateSKSKarpenterCredentials(ctx context.Context, id UUID) (*Operation, error) {
15797 path := fmt.Sprintf("/sks-cluster/%v/rotate-karpenter-credentials", id)
15798
15799 request, err := http.NewRequestWithContext(ctx, "PUT", c.serverEndpoint+path, nil)
15800 if err != nil {
15801 return nil, fmt.Errorf("RotateSKSKarpenterCredentials: new request: %w", err)
15802 }
15803
15804 request.Header.Add("User-Agent", c.getUserAgent())
15805
15806 if err := c.executeRequestInterceptors(ctx, request); err != nil {
15807 return nil, fmt.Errorf("RotateSKSKarpenterCredentials: execute request editors: %w", err)
15808 }
15809
15810 if err := c.signRequest(request); err != nil {
15811 return nil, fmt.Errorf("RotateSKSKarpenterCredentials: sign request: %w", err)
15812 }
15813
15814 if c.trace {
15815 dumpRequest(request, "rotate-sks-karpenter-credentials")
15816 }
15817
15818 response, err := c.httpClient.Do(request)
15819 if err != nil {
15820 return nil, fmt.Errorf("RotateSKSKarpenterCredentials: http client do: %w", err)
15821 }
15822
15823 if c.trace {
15824 dumpResponse(response)
15825 }
15826
15827 if err := handleHTTPErrorResp(response); err != nil {
15828 return nil, fmt.Errorf("RotateSKSKarpenterCredentials: http response: %w", err)
15829 }
15830
15831 bodyresp := new(Operation)
15832 if err := prepareJSONResponse(response, bodyresp); err != nil {
15833 return nil, fmt.Errorf("RotateSKSKarpenterCredentials: prepare Json response: %w", err)
15834 }
15835
15836 return bodyresp, nil
15837 }
15838
15839 // Rotate operators certificate authority
15840 func (c Client) RotateSKSOperatorsCA(ctx context.Context, id UUID) (*Operation, error) {
15841 path := fmt.Sprintf("/sks-cluster/%v/rotate-operators-ca", id)
15842
15843 request, err := http.NewRequestWithContext(ctx, "PUT", c.serverEndpoint+path, nil)
15844 if err != nil {
15845 return nil, fmt.Errorf("RotateSKSOperatorsCA: new request: %w", err)
15846 }
15847
15848 request.Header.Add("User-Agent", c.getUserAgent())
15849
15850 if err := c.executeRequestInterceptors(ctx, request); err != nil {
15851 return nil, fmt.Errorf("RotateSKSOperatorsCA: execute request editors: %w", err)
15852 }
15853
15854 if err := c.signRequest(request); err != nil {
15855 return nil, fmt.Errorf("RotateSKSOperatorsCA: sign request: %w", err)
15856 }
15857
15858 if c.trace {
15859 dumpRequest(request, "rotate-sks-operators-ca")
15860 }
15861
15862 response, err := c.httpClient.Do(request)
15863 if err != nil {
15864 return nil, fmt.Errorf("RotateSKSOperatorsCA: http client do: %w", err)
15865 }
15866
15867 if c.trace {
15868 dumpResponse(response)
15869 }
15870
15871 if err := handleHTTPErrorResp(response); err != nil {
15872 return nil, fmt.Errorf("RotateSKSOperatorsCA: http response: %w", err)
15873 }
15874
15875 bodyresp := new(Operation)
15876 if err := prepareJSONResponse(response, bodyresp); err != nil {
15877 return nil, fmt.Errorf("RotateSKSOperatorsCA: prepare Json response: %w", err)
15878 }
15879
15880 return bodyresp, nil
15881 }
15882
15883 type UpgradeSKSClusterRequest struct {
15884 // Control plane Kubernetes version
15885 Version string `json:"version" validate:"required"`
15886 }
15887
15888 // Upgrade an SKS cluster
15889 func (c Client) UpgradeSKSCluster(ctx context.Context, id UUID, req UpgradeSKSClusterRequest) (*Operation, error) {
15890 path := fmt.Sprintf("/sks-cluster/%v/upgrade", id)
15891
15892 body, err := prepareJSONBody(req)
15893 if err != nil {
15894 return nil, fmt.Errorf("UpgradeSKSCluster: prepare Json body: %w", err)
15895 }
15896
15897 request, err := http.NewRequestWithContext(ctx, "PUT", c.serverEndpoint+path, body)
15898 if err != nil {
15899 return nil, fmt.Errorf("UpgradeSKSCluster: new request: %w", err)
15900 }
15901
15902 request.Header.Add("User-Agent", c.getUserAgent())
15903
15904 request.Header.Add("Content-Type", "application/json")
15905
15906 if err := c.executeRequestInterceptors(ctx, request); err != nil {
15907 return nil, fmt.Errorf("UpgradeSKSCluster: execute request editors: %w", err)
15908 }
15909
15910 if err := c.signRequest(request); err != nil {
15911 return nil, fmt.Errorf("UpgradeSKSCluster: sign request: %w", err)
15912 }
15913
15914 if c.trace {
15915 dumpRequest(request, "upgrade-sks-cluster")
15916 }
15917
15918 response, err := c.httpClient.Do(request)
15919 if err != nil {
15920 return nil, fmt.Errorf("UpgradeSKSCluster: http client do: %w", err)
15921 }
15922
15923 if c.trace {
15924 dumpResponse(response)
15925 }
15926
15927 if err := handleHTTPErrorResp(response); err != nil {
15928 return nil, fmt.Errorf("UpgradeSKSCluster: http response: %w", err)
15929 }
15930
15931 bodyresp := new(Operation)
15932 if err := prepareJSONResponse(response, bodyresp); err != nil {
15933 return nil, fmt.Errorf("UpgradeSKSCluster: prepare Json response: %w", err)
15934 }
15935
15936 return bodyresp, nil
15937 }
15938
15939 // Upgrade a SKS cluster to pro
15940 func (c Client) UpgradeSKSClusterServiceLevel(ctx context.Context, id UUID) (*Operation, error) {
15941 path := fmt.Sprintf("/sks-cluster/%v/upgrade-service-level", id)
15942
15943 request, err := http.NewRequestWithContext(ctx, "PUT", c.serverEndpoint+path, nil)
15944 if err != nil {
15945 return nil, fmt.Errorf("UpgradeSKSClusterServiceLevel: new request: %w", err)
15946 }
15947
15948 request.Header.Add("User-Agent", c.getUserAgent())
15949
15950 if err := c.executeRequestInterceptors(ctx, request); err != nil {
15951 return nil, fmt.Errorf("UpgradeSKSClusterServiceLevel: execute request editors: %w", err)
15952 }
15953
15954 if err := c.signRequest(request); err != nil {
15955 return nil, fmt.Errorf("UpgradeSKSClusterServiceLevel: sign request: %w", err)
15956 }
15957
15958 if c.trace {
15959 dumpRequest(request, "upgrade-sks-cluster-service-level")
15960 }
15961
15962 response, err := c.httpClient.Do(request)
15963 if err != nil {
15964 return nil, fmt.Errorf("UpgradeSKSClusterServiceLevel: http client do: %w", err)
15965 }
15966
15967 if c.trace {
15968 dumpResponse(response)
15969 }
15970
15971 if err := handleHTTPErrorResp(response); err != nil {
15972 return nil, fmt.Errorf("UpgradeSKSClusterServiceLevel: http response: %w", err)
15973 }
15974
15975 bodyresp := new(Operation)
15976 if err := prepareJSONResponse(response, bodyresp); err != nil {
15977 return nil, fmt.Errorf("UpgradeSKSClusterServiceLevel: prepare Json response: %w", err)
15978 }
15979
15980 return bodyresp, nil
15981 }
15982
15983 type GetActiveNodepoolTemplateResponse struct {
15984 ActiveTemplate UUID `json:"active-template,omitempty"`
15985 }
15986
15987 type GetActiveNodepoolTemplateVariant string
15988
15989 const (
15990 GetActiveNodepoolTemplateVariantStandard GetActiveNodepoolTemplateVariant = "standard"
15991 GetActiveNodepoolTemplateVariantNvidia GetActiveNodepoolTemplateVariant = "nvidia"
15992 )
15993
15994 // Get the active template for a given kube version and variant (standard | nvidia)
15995 func (c Client) GetActiveNodepoolTemplate(ctx context.Context, kubeVersion string, variant GetActiveNodepoolTemplateVariant) (*GetActiveNodepoolTemplateResponse, error) {
15996 path := fmt.Sprintf("/sks-template/%v/%v", kubeVersion, variant)
15997
15998 request, err := http.NewRequestWithContext(ctx, "GET", c.serverEndpoint+path, nil)
15999 if err != nil {
16000 return nil, fmt.Errorf("GetActiveNodepoolTemplate: new request: %w", err)
16001 }
16002
16003 request.Header.Add("User-Agent", c.getUserAgent())
16004
16005 if err := c.executeRequestInterceptors(ctx, request); err != nil {
16006 return nil, fmt.Errorf("GetActiveNodepoolTemplate: execute request editors: %w", err)
16007 }
16008
16009 if err := c.signRequest(request); err != nil {
16010 return nil, fmt.Errorf("GetActiveNodepoolTemplate: sign request: %w", err)
16011 }
16012
16013 if c.trace {
16014 dumpRequest(request, "get-active-nodepool-template")
16015 }
16016
16017 response, err := c.httpClient.Do(request)
16018 if err != nil {
16019 return nil, fmt.Errorf("GetActiveNodepoolTemplate: http client do: %w", err)
16020 }
16021
16022 if c.trace {
16023 dumpResponse(response)
16024 }
16025
16026 if err := handleHTTPErrorResp(response); err != nil {
16027 return nil, fmt.Errorf("GetActiveNodepoolTemplate: http response: %w", err)
16028 }
16029
16030 bodyresp := new(GetActiveNodepoolTemplateResponse)
16031 if err := prepareJSONResponse(response, bodyresp); err != nil {
16032 return nil, fmt.Errorf("GetActiveNodepoolTemplate: prepare Json response: %w", err)
16033 }
16034
16035 return bodyresp, nil
16036 }
16037
16038 type ListSnapshotsResponse struct {
16039 Snapshots []Snapshot `json:"snapshots,omitempty"`
16040 }
16041
16042 // FindSnapshot attempts to find an Snapshot by nameOrID.
16043 func (l ListSnapshotsResponse) FindSnapshot(nameOrID string) (Snapshot, error) {
16044 var result []Snapshot
16045 for i, elem := range l.Snapshots {
16046 if string(elem.Name) == nameOrID || string(elem.ID) == nameOrID {
16047 result = append(result, l.Snapshots[i])
16048 }
16049 }
16050 if len(result) == 1 {
16051 return result[0], nil
16052 }
16053
16054 if len(result) > 1 {
16055 return Snapshot{}, fmt.Errorf("%q too many found in ListSnapshotsResponse: %w", nameOrID, ErrConflict)
16056 }
16057
16058 return Snapshot{}, fmt.Errorf("%q not found in ListSnapshotsResponse: %w", nameOrID, ErrNotFound)
16059 }
16060
16061 // List Snapshots
16062 func (c Client) ListSnapshots(ctx context.Context) (*ListSnapshotsResponse, error) {
16063 path := "/snapshot"
16064
16065 request, err := http.NewRequestWithContext(ctx, "GET", c.serverEndpoint+path, nil)
16066 if err != nil {
16067 return nil, fmt.Errorf("ListSnapshots: new request: %w", err)
16068 }
16069
16070 request.Header.Add("User-Agent", c.getUserAgent())
16071
16072 if err := c.executeRequestInterceptors(ctx, request); err != nil {
16073 return nil, fmt.Errorf("ListSnapshots: execute request editors: %w", err)
16074 }
16075
16076 if err := c.signRequest(request); err != nil {
16077 return nil, fmt.Errorf("ListSnapshots: sign request: %w", err)
16078 }
16079
16080 if c.trace {
16081 dumpRequest(request, "list-snapshots")
16082 }
16083
16084 response, err := c.httpClient.Do(request)
16085 if err != nil {
16086 return nil, fmt.Errorf("ListSnapshots: http client do: %w", err)
16087 }
16088
16089 if c.trace {
16090 dumpResponse(response)
16091 }
16092
16093 if err := handleHTTPErrorResp(response); err != nil {
16094 return nil, fmt.Errorf("ListSnapshots: http response: %w", err)
16095 }
16096
16097 bodyresp := new(ListSnapshotsResponse)
16098 if err := prepareJSONResponse(response, bodyresp); err != nil {
16099 return nil, fmt.Errorf("ListSnapshots: prepare Json response: %w", err)
16100 }
16101
16102 return bodyresp, nil
16103 }
16104
16105 // Delete a Snapshot
16106 func (c Client) DeleteSnapshot(ctx context.Context, id UUID) (*Operation, error) {
16107 path := fmt.Sprintf("/snapshot/%v", id)
16108
16109 request, err := http.NewRequestWithContext(ctx, "DELETE", c.serverEndpoint+path, nil)
16110 if err != nil {
16111 return nil, fmt.Errorf("DeleteSnapshot: new request: %w", err)
16112 }
16113
16114 request.Header.Add("User-Agent", c.getUserAgent())
16115
16116 if err := c.executeRequestInterceptors(ctx, request); err != nil {
16117 return nil, fmt.Errorf("DeleteSnapshot: execute request editors: %w", err)
16118 }
16119
16120 if err := c.signRequest(request); err != nil {
16121 return nil, fmt.Errorf("DeleteSnapshot: sign request: %w", err)
16122 }
16123
16124 if c.trace {
16125 dumpRequest(request, "delete-snapshot")
16126 }
16127
16128 response, err := c.httpClient.Do(request)
16129 if err != nil {
16130 return nil, fmt.Errorf("DeleteSnapshot: http client do: %w", err)
16131 }
16132
16133 if c.trace {
16134 dumpResponse(response)
16135 }
16136
16137 if err := handleHTTPErrorResp(response); err != nil {
16138 return nil, fmt.Errorf("DeleteSnapshot: http response: %w", err)
16139 }
16140
16141 bodyresp := new(Operation)
16142 if err := prepareJSONResponse(response, bodyresp); err != nil {
16143 return nil, fmt.Errorf("DeleteSnapshot: prepare Json response: %w", err)
16144 }
16145
16146 return bodyresp, nil
16147 }
16148
16149 // Retrieve Snapshot details
16150 func (c Client) GetSnapshot(ctx context.Context, id UUID) (*Snapshot, error) {
16151 path := fmt.Sprintf("/snapshot/%v", id)
16152
16153 request, err := http.NewRequestWithContext(ctx, "GET", c.serverEndpoint+path, nil)
16154 if err != nil {
16155 return nil, fmt.Errorf("GetSnapshot: new request: %w", err)
16156 }
16157
16158 request.Header.Add("User-Agent", c.getUserAgent())
16159
16160 if err := c.executeRequestInterceptors(ctx, request); err != nil {
16161 return nil, fmt.Errorf("GetSnapshot: execute request editors: %w", err)
16162 }
16163
16164 if err := c.signRequest(request); err != nil {
16165 return nil, fmt.Errorf("GetSnapshot: sign request: %w", err)
16166 }
16167
16168 if c.trace {
16169 dumpRequest(request, "get-snapshot")
16170 }
16171
16172 response, err := c.httpClient.Do(request)
16173 if err != nil {
16174 return nil, fmt.Errorf("GetSnapshot: http client do: %w", err)
16175 }
16176
16177 if c.trace {
16178 dumpResponse(response)
16179 }
16180
16181 if err := handleHTTPErrorResp(response); err != nil {
16182 return nil, fmt.Errorf("GetSnapshot: http response: %w", err)
16183 }
16184
16185 bodyresp := new(Snapshot)
16186 if err := prepareJSONResponse(response, bodyresp); err != nil {
16187 return nil, fmt.Errorf("GetSnapshot: prepare Json response: %w", err)
16188 }
16189
16190 return bodyresp, nil
16191 }
16192
16193 // Export a Snapshot
16194 func (c Client) ExportSnapshot(ctx context.Context, id UUID) (*Operation, error) {
16195 path := fmt.Sprintf("/snapshot/%v:export", id)
16196
16197 request, err := http.NewRequestWithContext(ctx, "POST", c.serverEndpoint+path, nil)
16198 if err != nil {
16199 return nil, fmt.Errorf("ExportSnapshot: new request: %w", err)
16200 }
16201
16202 request.Header.Add("User-Agent", c.getUserAgent())
16203
16204 if err := c.executeRequestInterceptors(ctx, request); err != nil {
16205 return nil, fmt.Errorf("ExportSnapshot: execute request editors: %w", err)
16206 }
16207
16208 if err := c.signRequest(request); err != nil {
16209 return nil, fmt.Errorf("ExportSnapshot: sign request: %w", err)
16210 }
16211
16212 if c.trace {
16213 dumpRequest(request, "export-snapshot")
16214 }
16215
16216 response, err := c.httpClient.Do(request)
16217 if err != nil {
16218 return nil, fmt.Errorf("ExportSnapshot: http client do: %w", err)
16219 }
16220
16221 if c.trace {
16222 dumpResponse(response)
16223 }
16224
16225 if err := handleHTTPErrorResp(response); err != nil {
16226 return nil, fmt.Errorf("ExportSnapshot: http response: %w", err)
16227 }
16228
16229 bodyresp := new(Operation)
16230 if err := prepareJSONResponse(response, bodyresp); err != nil {
16231 return nil, fmt.Errorf("ExportSnapshot: prepare Json response: %w", err)
16232 }
16233
16234 return bodyresp, nil
16235 }
16236
16237 type PromoteSnapshotToTemplateRequest struct {
16238 // Template default user
16239 DefaultUser string `json:"default-user,omitempty" validate:"omitempty,gte=1,lte=255"`
16240 // Template description
16241 Description string `json:"description,omitempty" validate:"omitempty,lte=4096"`
16242 // Template name
16243 Name string `json:"name" validate:"required,gte=1,lte=255"`
16244 // Enable password-based login in the template
16245 PasswordEnabled *bool `json:"password-enabled,omitempty"`
16246 // Enable SSH key-based login in the template
16247 SSHKeyEnabled *bool `json:"ssh-key-enabled,omitempty"`
16248 }
16249
16250 // Promote a Snapshot to a Template
16251 func (c Client) PromoteSnapshotToTemplate(ctx context.Context, id UUID, req PromoteSnapshotToTemplateRequest) (*Operation, error) {
16252 path := fmt.Sprintf("/snapshot/%v:promote", id)
16253
16254 body, err := prepareJSONBody(req)
16255 if err != nil {
16256 return nil, fmt.Errorf("PromoteSnapshotToTemplate: prepare Json body: %w", err)
16257 }
16258
16259 request, err := http.NewRequestWithContext(ctx, "POST", c.serverEndpoint+path, body)
16260 if err != nil {
16261 return nil, fmt.Errorf("PromoteSnapshotToTemplate: new request: %w", err)
16262 }
16263
16264 request.Header.Add("User-Agent", c.getUserAgent())
16265
16266 request.Header.Add("Content-Type", "application/json")
16267
16268 if err := c.executeRequestInterceptors(ctx, request); err != nil {
16269 return nil, fmt.Errorf("PromoteSnapshotToTemplate: execute request editors: %w", err)
16270 }
16271
16272 if err := c.signRequest(request); err != nil {
16273 return nil, fmt.Errorf("PromoteSnapshotToTemplate: sign request: %w", err)
16274 }
16275
16276 if c.trace {
16277 dumpRequest(request, "promote-snapshot-to-template")
16278 }
16279
16280 response, err := c.httpClient.Do(request)
16281 if err != nil {
16282 return nil, fmt.Errorf("PromoteSnapshotToTemplate: http client do: %w", err)
16283 }
16284
16285 if c.trace {
16286 dumpResponse(response)
16287 }
16288
16289 if err := handleHTTPErrorResp(response); err != nil {
16290 return nil, fmt.Errorf("PromoteSnapshotToTemplate: http response: %w", err)
16291 }
16292
16293 bodyresp := new(Operation)
16294 if err := prepareJSONResponse(response, bodyresp); err != nil {
16295 return nil, fmt.Errorf("PromoteSnapshotToTemplate: prepare Json response: %w", err)
16296 }
16297
16298 return bodyresp, nil
16299 }
16300
16301 type ListSOSBucketsUsageResponse struct {
16302 SOSBucketsUsage []SOSBucketUsage `json:"sos-buckets-usage,omitempty"`
16303 }
16304
16305 // FindSOSBucketUsage attempts to find an SOSBucketUsage by name.
16306 func (l ListSOSBucketsUsageResponse) FindSOSBucketUsage(name string) (SOSBucketUsage, error) {
16307 var result []SOSBucketUsage
16308 for i, elem := range l.SOSBucketsUsage {
16309 if string(elem.Name) == name {
16310 result = append(result, l.SOSBucketsUsage[i])
16311 }
16312 }
16313 if len(result) == 1 {
16314 return result[0], nil
16315 }
16316
16317 if len(result) > 1 {
16318 return SOSBucketUsage{}, fmt.Errorf("%q too many found in ListSOSBucketsUsageResponse: %w", name, ErrConflict)
16319 }
16320
16321 return SOSBucketUsage{}, fmt.Errorf("%q not found in ListSOSBucketsUsageResponse: %w", name, ErrNotFound)
16322 }
16323
16324 // List SOS Buckets Usage
16325 func (c Client) ListSOSBucketsUsage(ctx context.Context) (*ListSOSBucketsUsageResponse, error) {
16326 path := "/sos-buckets-usage"
16327
16328 request, err := http.NewRequestWithContext(ctx, "GET", c.serverEndpoint+path, nil)
16329 if err != nil {
16330 return nil, fmt.Errorf("ListSOSBucketsUsage: new request: %w", err)
16331 }
16332
16333 request.Header.Add("User-Agent", c.getUserAgent())
16334
16335 if err := c.executeRequestInterceptors(ctx, request); err != nil {
16336 return nil, fmt.Errorf("ListSOSBucketsUsage: execute request editors: %w", err)
16337 }
16338
16339 if err := c.signRequest(request); err != nil {
16340 return nil, fmt.Errorf("ListSOSBucketsUsage: sign request: %w", err)
16341 }
16342
16343 if c.trace {
16344 dumpRequest(request, "list-sos-buckets-usage")
16345 }
16346
16347 response, err := c.httpClient.Do(request)
16348 if err != nil {
16349 return nil, fmt.Errorf("ListSOSBucketsUsage: http client do: %w", err)
16350 }
16351
16352 if c.trace {
16353 dumpResponse(response)
16354 }
16355
16356 if err := handleHTTPErrorResp(response); err != nil {
16357 return nil, fmt.Errorf("ListSOSBucketsUsage: http response: %w", err)
16358 }
16359
16360 bodyresp := new(ListSOSBucketsUsageResponse)
16361 if err := prepareJSONResponse(response, bodyresp); err != nil {
16362 return nil, fmt.Errorf("ListSOSBucketsUsage: prepare Json response: %w", err)
16363 }
16364
16365 return bodyresp, nil
16366 }
16367
16368 type GetSOSPresignedURLResponse struct {
16369 URL string `json:"url,omitempty"`
16370 }
16371
16372 type GetSOSPresignedURLOpt func(url.Values)
16373
16374 func GetSOSPresignedURLWithKey(key string) GetSOSPresignedURLOpt {
16375 return func(q url.Values) {
16376 q.Add("key", fmt.Sprint(key))
16377 }
16378 }
16379
16380 // Generates Presigned Download URL for SOS object
16381 func (c Client) GetSOSPresignedURL(ctx context.Context, bucket string, opts ...GetSOSPresignedURLOpt) (*GetSOSPresignedURLResponse, error) {
16382 path := fmt.Sprintf("/sos/%v/presigned-url", bucket)
16383
16384 request, err := http.NewRequestWithContext(ctx, "GET", c.serverEndpoint+path, nil)
16385 if err != nil {
16386 return nil, fmt.Errorf("GetSOSPresignedURL: new request: %w", err)
16387 }
16388
16389 request.Header.Add("User-Agent", c.getUserAgent())
16390
16391 if len(opts) > 0 {
16392 q := request.URL.Query()
16393 for _, opt := range opts {
16394 opt(q)
16395 }
16396 request.URL.RawQuery = q.Encode()
16397 }
16398
16399 if err := c.executeRequestInterceptors(ctx, request); err != nil {
16400 return nil, fmt.Errorf("GetSOSPresignedURL: execute request editors: %w", err)
16401 }
16402
16403 if err := c.signRequest(request); err != nil {
16404 return nil, fmt.Errorf("GetSOSPresignedURL: sign request: %w", err)
16405 }
16406
16407 if c.trace {
16408 dumpRequest(request, "get-sos-presigned-url")
16409 }
16410
16411 response, err := c.httpClient.Do(request)
16412 if err != nil {
16413 return nil, fmt.Errorf("GetSOSPresignedURL: http client do: %w", err)
16414 }
16415
16416 if c.trace {
16417 dumpResponse(response)
16418 }
16419
16420 if err := handleHTTPErrorResp(response); err != nil {
16421 return nil, fmt.Errorf("GetSOSPresignedURL: http response: %w", err)
16422 }
16423
16424 bodyresp := new(GetSOSPresignedURLResponse)
16425 if err := prepareJSONResponse(response, bodyresp); err != nil {
16426 return nil, fmt.Errorf("GetSOSPresignedURL: prepare Json response: %w", err)
16427 }
16428
16429 return bodyresp, nil
16430 }
16431
16432 type ListSSHKeysResponse struct {
16433 SSHKeys []SSHKey `json:"ssh-keys,omitempty"`
16434 }
16435
16436 // FindSSHKey attempts to find an SSHKey by nameOrFingerprint.
16437 func (l ListSSHKeysResponse) FindSSHKey(nameOrFingerprint string) (SSHKey, error) {
16438 var result []SSHKey
16439 for i, elem := range l.SSHKeys {
16440 if string(elem.Name) == nameOrFingerprint || string(elem.Fingerprint) == nameOrFingerprint {
16441 result = append(result, l.SSHKeys[i])
16442 }
16443 }
16444 if len(result) == 1 {
16445 return result[0], nil
16446 }
16447
16448 if len(result) > 1 {
16449 return SSHKey{}, fmt.Errorf("%q too many found in ListSSHKeysResponse: %w", nameOrFingerprint, ErrConflict)
16450 }
16451
16452 return SSHKey{}, fmt.Errorf("%q not found in ListSSHKeysResponse: %w", nameOrFingerprint, ErrNotFound)
16453 }
16454
16455 // List SSH keys
16456 func (c Client) ListSSHKeys(ctx context.Context) (*ListSSHKeysResponse, error) {
16457 path := "/ssh-key"
16458
16459 request, err := http.NewRequestWithContext(ctx, "GET", c.serverEndpoint+path, nil)
16460 if err != nil {
16461 return nil, fmt.Errorf("ListSSHKeys: new request: %w", err)
16462 }
16463
16464 request.Header.Add("User-Agent", c.getUserAgent())
16465
16466 if err := c.executeRequestInterceptors(ctx, request); err != nil {
16467 return nil, fmt.Errorf("ListSSHKeys: execute request editors: %w", err)
16468 }
16469
16470 if err := c.signRequest(request); err != nil {
16471 return nil, fmt.Errorf("ListSSHKeys: sign request: %w", err)
16472 }
16473
16474 if c.trace {
16475 dumpRequest(request, "list-ssh-keys")
16476 }
16477
16478 response, err := c.httpClient.Do(request)
16479 if err != nil {
16480 return nil, fmt.Errorf("ListSSHKeys: http client do: %w", err)
16481 }
16482
16483 if c.trace {
16484 dumpResponse(response)
16485 }
16486
16487 if err := handleHTTPErrorResp(response); err != nil {
16488 return nil, fmt.Errorf("ListSSHKeys: http response: %w", err)
16489 }
16490
16491 bodyresp := new(ListSSHKeysResponse)
16492 if err := prepareJSONResponse(response, bodyresp); err != nil {
16493 return nil, fmt.Errorf("ListSSHKeys: prepare Json response: %w", err)
16494 }
16495
16496 return bodyresp, nil
16497 }
16498
16499 type RegisterSSHKeyRequest struct {
16500 // SSH key name
16501 Name string `json:"name" validate:"required"`
16502 // Public key value
16503 PublicKey string `json:"public-key" validate:"required"`
16504 }
16505
16506 // Import SSH key
16507 func (c Client) RegisterSSHKey(ctx context.Context, req RegisterSSHKeyRequest) (*Operation, error) {
16508 path := "/ssh-key"
16509
16510 body, err := prepareJSONBody(req)
16511 if err != nil {
16512 return nil, fmt.Errorf("RegisterSSHKey: prepare Json body: %w", err)
16513 }
16514
16515 request, err := http.NewRequestWithContext(ctx, "POST", c.serverEndpoint+path, body)
16516 if err != nil {
16517 return nil, fmt.Errorf("RegisterSSHKey: new request: %w", err)
16518 }
16519
16520 request.Header.Add("User-Agent", c.getUserAgent())
16521
16522 request.Header.Add("Content-Type", "application/json")
16523
16524 if err := c.executeRequestInterceptors(ctx, request); err != nil {
16525 return nil, fmt.Errorf("RegisterSSHKey: execute request editors: %w", err)
16526 }
16527
16528 if err := c.signRequest(request); err != nil {
16529 return nil, fmt.Errorf("RegisterSSHKey: sign request: %w", err)
16530 }
16531
16532 if c.trace {
16533 dumpRequest(request, "register-ssh-key")
16534 }
16535
16536 response, err := c.httpClient.Do(request)
16537 if err != nil {
16538 return nil, fmt.Errorf("RegisterSSHKey: http client do: %w", err)
16539 }
16540
16541 if c.trace {
16542 dumpResponse(response)
16543 }
16544
16545 if err := handleHTTPErrorResp(response); err != nil {
16546 return nil, fmt.Errorf("RegisterSSHKey: http response: %w", err)
16547 }
16548
16549 bodyresp := new(Operation)
16550 if err := prepareJSONResponse(response, bodyresp); err != nil {
16551 return nil, fmt.Errorf("RegisterSSHKey: prepare Json response: %w", err)
16552 }
16553
16554 return bodyresp, nil
16555 }
16556
16557 // Delete a SSH key
16558 func (c Client) DeleteSSHKey(ctx context.Context, name string) (*Operation, error) {
16559 path := fmt.Sprintf("/ssh-key/%v", name)
16560
16561 request, err := http.NewRequestWithContext(ctx, "DELETE", c.serverEndpoint+path, nil)
16562 if err != nil {
16563 return nil, fmt.Errorf("DeleteSSHKey: new request: %w", err)
16564 }
16565
16566 request.Header.Add("User-Agent", c.getUserAgent())
16567
16568 if err := c.executeRequestInterceptors(ctx, request); err != nil {
16569 return nil, fmt.Errorf("DeleteSSHKey: execute request editors: %w", err)
16570 }
16571
16572 if err := c.signRequest(request); err != nil {
16573 return nil, fmt.Errorf("DeleteSSHKey: sign request: %w", err)
16574 }
16575
16576 if c.trace {
16577 dumpRequest(request, "delete-ssh-key")
16578 }
16579
16580 response, err := c.httpClient.Do(request)
16581 if err != nil {
16582 return nil, fmt.Errorf("DeleteSSHKey: http client do: %w", err)
16583 }
16584
16585 if c.trace {
16586 dumpResponse(response)
16587 }
16588
16589 if err := handleHTTPErrorResp(response); err != nil {
16590 return nil, fmt.Errorf("DeleteSSHKey: http response: %w", err)
16591 }
16592
16593 bodyresp := new(Operation)
16594 if err := prepareJSONResponse(response, bodyresp); err != nil {
16595 return nil, fmt.Errorf("DeleteSSHKey: prepare Json response: %w", err)
16596 }
16597
16598 return bodyresp, nil
16599 }
16600
16601 // Retrieve SSH key details
16602 func (c Client) GetSSHKey(ctx context.Context, name string) (*SSHKey, error) {
16603 path := fmt.Sprintf("/ssh-key/%v", name)
16604
16605 request, err := http.NewRequestWithContext(ctx, "GET", c.serverEndpoint+path, nil)
16606 if err != nil {
16607 return nil, fmt.Errorf("GetSSHKey: new request: %w", err)
16608 }
16609
16610 request.Header.Add("User-Agent", c.getUserAgent())
16611
16612 if err := c.executeRequestInterceptors(ctx, request); err != nil {
16613 return nil, fmt.Errorf("GetSSHKey: execute request editors: %w", err)
16614 }
16615
16616 if err := c.signRequest(request); err != nil {
16617 return nil, fmt.Errorf("GetSSHKey: sign request: %w", err)
16618 }
16619
16620 if c.trace {
16621 dumpRequest(request, "get-ssh-key")
16622 }
16623
16624 response, err := c.httpClient.Do(request)
16625 if err != nil {
16626 return nil, fmt.Errorf("GetSSHKey: http client do: %w", err)
16627 }
16628
16629 if c.trace {
16630 dumpResponse(response)
16631 }
16632
16633 if err := handleHTTPErrorResp(response); err != nil {
16634 return nil, fmt.Errorf("GetSSHKey: http response: %w", err)
16635 }
16636
16637 bodyresp := new(SSHKey)
16638 if err := prepareJSONResponse(response, bodyresp); err != nil {
16639 return nil, fmt.Errorf("GetSSHKey: prepare Json response: %w", err)
16640 }
16641
16642 return bodyresp, nil
16643 }
16644
16645 type ListTemplatesResponse struct {
16646 Templates []Template `json:"templates,omitempty"`
16647 }
16648
16649 // FindTemplate attempts to find an Template by nameOrID.
16650 func (l ListTemplatesResponse) FindTemplate(nameOrID string) (Template, error) {
16651 var result []Template
16652 for i, elem := range l.Templates {
16653 if string(elem.Name) == nameOrID || string(elem.ID) == nameOrID {
16654 result = append(result, l.Templates[i])
16655 }
16656 }
16657 if len(result) == 1 {
16658 return result[0], nil
16659 }
16660
16661 if len(result) > 1 {
16662 return Template{}, fmt.Errorf("%q too many found in ListTemplatesResponse: %w", nameOrID, ErrConflict)
16663 }
16664
16665 return Template{}, fmt.Errorf("%q not found in ListTemplatesResponse: %w", nameOrID, ErrNotFound)
16666 }
16667
16668 type ListTemplatesVisibility string
16669
16670 const (
16671 ListTemplatesVisibilityPrivate ListTemplatesVisibility = "private"
16672 ListTemplatesVisibilityPublic ListTemplatesVisibility = "public"
16673 )
16674
16675 type ListTemplatesOpt func(url.Values)
16676
16677 func ListTemplatesWithVisibility(visibility ListTemplatesVisibility) ListTemplatesOpt {
16678 return func(q url.Values) {
16679 q.Add("visibility", fmt.Sprint(visibility))
16680 }
16681 }
16682
16683 func ListTemplatesWithFamily(family string) ListTemplatesOpt {
16684 return func(q url.Values) {
16685 q.Add("family", fmt.Sprint(family))
16686 }
16687 }
16688
16689 // List Templates
16690 func (c Client) ListTemplates(ctx context.Context, opts ...ListTemplatesOpt) (*ListTemplatesResponse, error) {
16691 path := "/template"
16692
16693 request, err := http.NewRequestWithContext(ctx, "GET", c.serverEndpoint+path, nil)
16694 if err != nil {
16695 return nil, fmt.Errorf("ListTemplates: new request: %w", err)
16696 }
16697
16698 request.Header.Add("User-Agent", c.getUserAgent())
16699
16700 if len(opts) > 0 {
16701 q := request.URL.Query()
16702 for _, opt := range opts {
16703 opt(q)
16704 }
16705 request.URL.RawQuery = q.Encode()
16706 }
16707
16708 if err := c.executeRequestInterceptors(ctx, request); err != nil {
16709 return nil, fmt.Errorf("ListTemplates: execute request editors: %w", err)
16710 }
16711
16712 if err := c.signRequest(request); err != nil {
16713 return nil, fmt.Errorf("ListTemplates: sign request: %w", err)
16714 }
16715
16716 if c.trace {
16717 dumpRequest(request, "list-templates")
16718 }
16719
16720 response, err := c.httpClient.Do(request)
16721 if err != nil {
16722 return nil, fmt.Errorf("ListTemplates: http client do: %w", err)
16723 }
16724
16725 if c.trace {
16726 dumpResponse(response)
16727 }
16728
16729 if err := handleHTTPErrorResp(response); err != nil {
16730 return nil, fmt.Errorf("ListTemplates: http response: %w", err)
16731 }
16732
16733 bodyresp := new(ListTemplatesResponse)
16734 if err := prepareJSONResponse(response, bodyresp); err != nil {
16735 return nil, fmt.Errorf("ListTemplates: prepare Json response: %w", err)
16736 }
16737
16738 return bodyresp, nil
16739 }
16740
16741 type RegisterTemplateRequestBootMode string
16742
16743 const (
16744 RegisterTemplateRequestBootModeLegacy RegisterTemplateRequestBootMode = "legacy"
16745 RegisterTemplateRequestBootModeUefi RegisterTemplateRequestBootMode = "uefi"
16746 )
16747
16748 type RegisterTemplateRequest struct {
16749 // Template with support for Application Consistent Snapshots
16750 ApplicationConsistentSnapshotEnabled *bool `json:"application-consistent-snapshot-enabled,omitempty"`
16751 // Boot mode (default: legacy)
16752 BootMode RegisterTemplateRequestBootMode `json:"boot-mode,omitempty"`
16753 // Template build
16754 Build string `json:"build,omitempty" validate:"omitempty,gte=1,lte=255"`
16755 // Template MD5 checksum
16756 Checksum string `json:"checksum" validate:"required,gte=1"`
16757 // Template default user
16758 DefaultUser string `json:"default-user,omitempty" validate:"omitempty,gte=1,lte=255"`
16759 // Template description
16760 Description string `json:"description,omitempty" validate:"omitempty,lte=255"`
16761 // Template maintainer
16762 Maintainer string `json:"maintainer,omitempty" validate:"omitempty,gte=1,lte=255"`
16763 // Template name
16764 Name string `json:"name" validate:"required,gte=1,lte=255"`
16765 // Enable password-based login
16766 PasswordEnabled *bool `json:"password-enabled" validate:"required"`
16767 // Template size
16768 Size int64 `json:"size,omitempty" validate:"omitempty,gt=0"`
16769 // Enable SSH key-based login
16770 SSHKeyEnabled *bool `json:"ssh-key-enabled" validate:"required"`
16771 // Template source URL
16772 URL string `json:"url" validate:"required,gte=1"`
16773 // Template version
16774 Version string `json:"version,omitempty" validate:"omitempty,gte=1,lte=255"`
16775 }
16776
16777 // Register a Template
16778 func (c Client) RegisterTemplate(ctx context.Context, req RegisterTemplateRequest) (*Operation, error) {
16779 path := "/template"
16780
16781 body, err := prepareJSONBody(req)
16782 if err != nil {
16783 return nil, fmt.Errorf("RegisterTemplate: prepare Json body: %w", err)
16784 }
16785
16786 request, err := http.NewRequestWithContext(ctx, "POST", c.serverEndpoint+path, body)
16787 if err != nil {
16788 return nil, fmt.Errorf("RegisterTemplate: new request: %w", err)
16789 }
16790
16791 request.Header.Add("User-Agent", c.getUserAgent())
16792
16793 request.Header.Add("Content-Type", "application/json")
16794
16795 if err := c.executeRequestInterceptors(ctx, request); err != nil {
16796 return nil, fmt.Errorf("RegisterTemplate: execute request editors: %w", err)
16797 }
16798
16799 if err := c.signRequest(request); err != nil {
16800 return nil, fmt.Errorf("RegisterTemplate: sign request: %w", err)
16801 }
16802
16803 if c.trace {
16804 dumpRequest(request, "register-template")
16805 }
16806
16807 response, err := c.httpClient.Do(request)
16808 if err != nil {
16809 return nil, fmt.Errorf("RegisterTemplate: http client do: %w", err)
16810 }
16811
16812 if c.trace {
16813 dumpResponse(response)
16814 }
16815
16816 if err := handleHTTPErrorResp(response); err != nil {
16817 return nil, fmt.Errorf("RegisterTemplate: http response: %w", err)
16818 }
16819
16820 bodyresp := new(Operation)
16821 if err := prepareJSONResponse(response, bodyresp); err != nil {
16822 return nil, fmt.Errorf("RegisterTemplate: prepare Json response: %w", err)
16823 }
16824
16825 return bodyresp, nil
16826 }
16827
16828 // Delete a Template
16829 func (c Client) DeleteTemplate(ctx context.Context, id UUID) (*Operation, error) {
16830 path := fmt.Sprintf("/template/%v", id)
16831
16832 request, err := http.NewRequestWithContext(ctx, "DELETE", c.serverEndpoint+path, nil)
16833 if err != nil {
16834 return nil, fmt.Errorf("DeleteTemplate: new request: %w", err)
16835 }
16836
16837 request.Header.Add("User-Agent", c.getUserAgent())
16838
16839 if err := c.executeRequestInterceptors(ctx, request); err != nil {
16840 return nil, fmt.Errorf("DeleteTemplate: execute request editors: %w", err)
16841 }
16842
16843 if err := c.signRequest(request); err != nil {
16844 return nil, fmt.Errorf("DeleteTemplate: sign request: %w", err)
16845 }
16846
16847 if c.trace {
16848 dumpRequest(request, "delete-template")
16849 }
16850
16851 response, err := c.httpClient.Do(request)
16852 if err != nil {
16853 return nil, fmt.Errorf("DeleteTemplate: http client do: %w", err)
16854 }
16855
16856 if c.trace {
16857 dumpResponse(response)
16858 }
16859
16860 if err := handleHTTPErrorResp(response); err != nil {
16861 return nil, fmt.Errorf("DeleteTemplate: http response: %w", err)
16862 }
16863
16864 bodyresp := new(Operation)
16865 if err := prepareJSONResponse(response, bodyresp); err != nil {
16866 return nil, fmt.Errorf("DeleteTemplate: prepare Json response: %w", err)
16867 }
16868
16869 return bodyresp, nil
16870 }
16871
16872 // Retrieve Template details
16873 func (c Client) GetTemplate(ctx context.Context, id UUID) (*Template, error) {
16874 path := fmt.Sprintf("/template/%v", id)
16875
16876 request, err := http.NewRequestWithContext(ctx, "GET", c.serverEndpoint+path, nil)
16877 if err != nil {
16878 return nil, fmt.Errorf("GetTemplate: new request: %w", err)
16879 }
16880
16881 request.Header.Add("User-Agent", c.getUserAgent())
16882
16883 if err := c.executeRequestInterceptors(ctx, request); err != nil {
16884 return nil, fmt.Errorf("GetTemplate: execute request editors: %w", err)
16885 }
16886
16887 if err := c.signRequest(request); err != nil {
16888 return nil, fmt.Errorf("GetTemplate: sign request: %w", err)
16889 }
16890
16891 if c.trace {
16892 dumpRequest(request, "get-template")
16893 }
16894
16895 response, err := c.httpClient.Do(request)
16896 if err != nil {
16897 return nil, fmt.Errorf("GetTemplate: http client do: %w", err)
16898 }
16899
16900 if c.trace {
16901 dumpResponse(response)
16902 }
16903
16904 if err := handleHTTPErrorResp(response); err != nil {
16905 return nil, fmt.Errorf("GetTemplate: http response: %w", err)
16906 }
16907
16908 bodyresp := new(Template)
16909 if err := prepareJSONResponse(response, bodyresp); err != nil {
16910 return nil, fmt.Errorf("GetTemplate: prepare Json response: %w", err)
16911 }
16912
16913 return bodyresp, nil
16914 }
16915
16916 type CopyTemplateRequest struct {
16917 // Zone
16918 TargetZone *Zone `json:"target-zone" validate:"required"`
16919 }
16920
16921 // Copy a Template from a zone to another
16922 func (c Client) CopyTemplate(ctx context.Context, id UUID, req CopyTemplateRequest) (*Operation, error) {
16923 path := fmt.Sprintf("/template/%v", id)
16924
16925 body, err := prepareJSONBody(req)
16926 if err != nil {
16927 return nil, fmt.Errorf("CopyTemplate: prepare Json body: %w", err)
16928 }
16929
16930 request, err := http.NewRequestWithContext(ctx, "POST", c.serverEndpoint+path, body)
16931 if err != nil {
16932 return nil, fmt.Errorf("CopyTemplate: new request: %w", err)
16933 }
16934
16935 request.Header.Add("User-Agent", c.getUserAgent())
16936
16937 request.Header.Add("Content-Type", "application/json")
16938
16939 if err := c.executeRequestInterceptors(ctx, request); err != nil {
16940 return nil, fmt.Errorf("CopyTemplate: execute request editors: %w", err)
16941 }
16942
16943 if err := c.signRequest(request); err != nil {
16944 return nil, fmt.Errorf("CopyTemplate: sign request: %w", err)
16945 }
16946
16947 if c.trace {
16948 dumpRequest(request, "copy-template")
16949 }
16950
16951 response, err := c.httpClient.Do(request)
16952 if err != nil {
16953 return nil, fmt.Errorf("CopyTemplate: http client do: %w", err)
16954 }
16955
16956 if c.trace {
16957 dumpResponse(response)
16958 }
16959
16960 if err := handleHTTPErrorResp(response); err != nil {
16961 return nil, fmt.Errorf("CopyTemplate: http response: %w", err)
16962 }
16963
16964 bodyresp := new(Operation)
16965 if err := prepareJSONResponse(response, bodyresp); err != nil {
16966 return nil, fmt.Errorf("CopyTemplate: prepare Json response: %w", err)
16967 }
16968
16969 return bodyresp, nil
16970 }
16971
16972 type UpdateTemplateRequest struct {
16973 // Template Description
16974 Description string `json:"description,omitempty" validate:"omitempty,lte=255"`
16975 // Template name
16976 Name string `json:"name,omitempty" validate:"omitempty,gte=1,lte=255"`
16977 }
16978
16979 // Update template attributes
16980 func (c Client) UpdateTemplate(ctx context.Context, id UUID, req UpdateTemplateRequest) (*Operation, error) {
16981 path := fmt.Sprintf("/template/%v", id)
16982
16983 body, err := prepareJSONBody(req)
16984 if err != nil {
16985 return nil, fmt.Errorf("UpdateTemplate: prepare Json body: %w", err)
16986 }
16987
16988 request, err := http.NewRequestWithContext(ctx, "PUT", c.serverEndpoint+path, body)
16989 if err != nil {
16990 return nil, fmt.Errorf("UpdateTemplate: new request: %w", err)
16991 }
16992
16993 request.Header.Add("User-Agent", c.getUserAgent())
16994
16995 request.Header.Add("Content-Type", "application/json")
16996
16997 if err := c.executeRequestInterceptors(ctx, request); err != nil {
16998 return nil, fmt.Errorf("UpdateTemplate: execute request editors: %w", err)
16999 }
17000
17001 if err := c.signRequest(request); err != nil {
17002 return nil, fmt.Errorf("UpdateTemplate: sign request: %w", err)
17003 }
17004
17005 if c.trace {
17006 dumpRequest(request, "update-template")
17007 }
17008
17009 response, err := c.httpClient.Do(request)
17010 if err != nil {
17011 return nil, fmt.Errorf("UpdateTemplate: http client do: %w", err)
17012 }
17013
17014 if c.trace {
17015 dumpResponse(response)
17016 }
17017
17018 if err := handleHTTPErrorResp(response); err != nil {
17019 return nil, fmt.Errorf("UpdateTemplate: http response: %w", err)
17020 }
17021
17022 bodyresp := new(Operation)
17023 if err := prepareJSONResponse(response, bodyresp); err != nil {
17024 return nil, fmt.Errorf("UpdateTemplate: prepare Json response: %w", err)
17025 }
17026
17027 return bodyresp, nil
17028 }
17029
17030 // Usage
17031 type GetUsageReportResponseUsage struct {
17032 // Description
17033 Description string `json:"description,omitempty"`
17034 // Period Start Date
17035 From string `json:"from,omitempty"`
17036 // Product
17037 Product string `json:"product,omitempty"`
17038 // Quantity
17039 Quantity string `json:"quantity,omitempty"`
17040 // Period End Date
17041 To string `json:"to,omitempty"`
17042 // Unit
17043 Unit string `json:"unit,omitempty"`
17044 // Variable
17045 Variable string `json:"variable,omitempty"`
17046 }
17047
17048 type GetUsageReportResponse struct {
17049 Usage []GetUsageReportResponseUsage `json:"usage,omitempty"`
17050 }
17051
17052 type GetUsageReportOpt func(url.Values)
17053
17054 func GetUsageReportWithPeriod(period string) GetUsageReportOpt {
17055 return func(q url.Values) {
17056 q.Add("period", fmt.Sprint(period))
17057 }
17058 }
17059
17060 // Returns aggregated usage reports for an organization
17061 func (c Client) GetUsageReport(ctx context.Context, opts ...GetUsageReportOpt) (*GetUsageReportResponse, error) {
17062 path := "/usage-report"
17063
17064 request, err := http.NewRequestWithContext(ctx, "GET", c.serverEndpoint+path, nil)
17065 if err != nil {
17066 return nil, fmt.Errorf("GetUsageReport: new request: %w", err)
17067 }
17068
17069 request.Header.Add("User-Agent", c.getUserAgent())
17070
17071 if len(opts) > 0 {
17072 q := request.URL.Query()
17073 for _, opt := range opts {
17074 opt(q)
17075 }
17076 request.URL.RawQuery = q.Encode()
17077 }
17078
17079 if err := c.executeRequestInterceptors(ctx, request); err != nil {
17080 return nil, fmt.Errorf("GetUsageReport: execute request editors: %w", err)
17081 }
17082
17083 if err := c.signRequest(request); err != nil {
17084 return nil, fmt.Errorf("GetUsageReport: sign request: %w", err)
17085 }
17086
17087 if c.trace {
17088 dumpRequest(request, "get-usage-report")
17089 }
17090
17091 response, err := c.httpClient.Do(request)
17092 if err != nil {
17093 return nil, fmt.Errorf("GetUsageReport: http client do: %w", err)
17094 }
17095
17096 if c.trace {
17097 dumpResponse(response)
17098 }
17099
17100 if err := handleHTTPErrorResp(response); err != nil {
17101 return nil, fmt.Errorf("GetUsageReport: http response: %w", err)
17102 }
17103
17104 bodyresp := new(GetUsageReportResponse)
17105 if err := prepareJSONResponse(response, bodyresp); err != nil {
17106 return nil, fmt.Errorf("GetUsageReport: prepare Json response: %w", err)
17107 }
17108
17109 return bodyresp, nil
17110 }
17111
17112 type ListUsersResponse struct {
17113 Users []User `json:"users,omitempty"`
17114 }
17115
17116 // FindUser attempts to find an User by id.
17117 func (l ListUsersResponse) FindUser(id string) (User, error) {
17118 var result []User
17119 for i, elem := range l.Users {
17120 if string(elem.ID) == id {
17121 result = append(result, l.Users[i])
17122 }
17123 }
17124 if len(result) == 1 {
17125 return result[0], nil
17126 }
17127
17128 if len(result) > 1 {
17129 return User{}, fmt.Errorf("%q too many found in ListUsersResponse: %w", id, ErrConflict)
17130 }
17131
17132 return User{}, fmt.Errorf("%q not found in ListUsersResponse: %w", id, ErrNotFound)
17133 }
17134
17135 func (c Client) ListUsers(ctx context.Context) (*ListUsersResponse, error) {
17136 path := "/user"
17137
17138 request, err := http.NewRequestWithContext(ctx, "GET", c.serverEndpoint+path, nil)
17139 if err != nil {
17140 return nil, fmt.Errorf("ListUsers: new request: %w", err)
17141 }
17142
17143 request.Header.Add("User-Agent", c.getUserAgent())
17144
17145 if err := c.executeRequestInterceptors(ctx, request); err != nil {
17146 return nil, fmt.Errorf("ListUsers: execute request editors: %w", err)
17147 }
17148
17149 if err := c.signRequest(request); err != nil {
17150 return nil, fmt.Errorf("ListUsers: sign request: %w", err)
17151 }
17152
17153 if c.trace {
17154 dumpRequest(request, "list-users")
17155 }
17156
17157 response, err := c.httpClient.Do(request)
17158 if err != nil {
17159 return nil, fmt.Errorf("ListUsers: http client do: %w", err)
17160 }
17161
17162 if c.trace {
17163 dumpResponse(response)
17164 }
17165
17166 if err := handleHTTPErrorResp(response); err != nil {
17167 return nil, fmt.Errorf("ListUsers: http response: %w", err)
17168 }
17169
17170 bodyresp := new(ListUsersResponse)
17171 if err := prepareJSONResponse(response, bodyresp); err != nil {
17172 return nil, fmt.Errorf("ListUsers: prepare Json response: %w", err)
17173 }
17174
17175 return bodyresp, nil
17176 }
17177
17178 type CreateUserRequest struct {
17179 // User Email
17180 Email string `json:"email" validate:"required"`
17181 // IAM Role
17182 Role *IAMRole `json:"role,omitempty"`
17183 }
17184
17185 func (c Client) CreateUser(ctx context.Context, req CreateUserRequest) (*Operation, error) {
17186 path := "/user"
17187
17188 body, err := prepareJSONBody(req)
17189 if err != nil {
17190 return nil, fmt.Errorf("CreateUser: prepare Json body: %w", err)
17191 }
17192
17193 request, err := http.NewRequestWithContext(ctx, "POST", c.serverEndpoint+path, body)
17194 if err != nil {
17195 return nil, fmt.Errorf("CreateUser: new request: %w", err)
17196 }
17197
17198 request.Header.Add("User-Agent", c.getUserAgent())
17199
17200 request.Header.Add("Content-Type", "application/json")
17201
17202 if err := c.executeRequestInterceptors(ctx, request); err != nil {
17203 return nil, fmt.Errorf("CreateUser: execute request editors: %w", err)
17204 }
17205
17206 if err := c.signRequest(request); err != nil {
17207 return nil, fmt.Errorf("CreateUser: sign request: %w", err)
17208 }
17209
17210 if c.trace {
17211 dumpRequest(request, "create-user")
17212 }
17213
17214 response, err := c.httpClient.Do(request)
17215 if err != nil {
17216 return nil, fmt.Errorf("CreateUser: http client do: %w", err)
17217 }
17218
17219 if c.trace {
17220 dumpResponse(response)
17221 }
17222
17223 if err := handleHTTPErrorResp(response); err != nil {
17224 return nil, fmt.Errorf("CreateUser: http response: %w", err)
17225 }
17226
17227 bodyresp := new(Operation)
17228 if err := prepareJSONResponse(response, bodyresp); err != nil {
17229 return nil, fmt.Errorf("CreateUser: prepare Json response: %w", err)
17230 }
17231
17232 return bodyresp, nil
17233 }
17234
17235 func (c Client) DeleteUser(ctx context.Context, id UUID) (*Operation, error) {
17236 path := fmt.Sprintf("/user/%v", id)
17237
17238 request, err := http.NewRequestWithContext(ctx, "DELETE", c.serverEndpoint+path, nil)
17239 if err != nil {
17240 return nil, fmt.Errorf("DeleteUser: new request: %w", err)
17241 }
17242
17243 request.Header.Add("User-Agent", c.getUserAgent())
17244
17245 if err := c.executeRequestInterceptors(ctx, request); err != nil {
17246 return nil, fmt.Errorf("DeleteUser: execute request editors: %w", err)
17247 }
17248
17249 if err := c.signRequest(request); err != nil {
17250 return nil, fmt.Errorf("DeleteUser: sign request: %w", err)
17251 }
17252
17253 if c.trace {
17254 dumpRequest(request, "delete-user")
17255 }
17256
17257 response, err := c.httpClient.Do(request)
17258 if err != nil {
17259 return nil, fmt.Errorf("DeleteUser: http client do: %w", err)
17260 }
17261
17262 if c.trace {
17263 dumpResponse(response)
17264 }
17265
17266 if err := handleHTTPErrorResp(response); err != nil {
17267 return nil, fmt.Errorf("DeleteUser: http response: %w", err)
17268 }
17269
17270 bodyresp := new(Operation)
17271 if err := prepareJSONResponse(response, bodyresp); err != nil {
17272 return nil, fmt.Errorf("DeleteUser: prepare Json response: %w", err)
17273 }
17274
17275 return bodyresp, nil
17276 }
17277
17278 type UpdateUserRoleRequest struct {
17279 // IAM Role
17280 Role *IAMRole `json:"role,omitempty"`
17281 }
17282
17283 func (c Client) UpdateUserRole(ctx context.Context, id UUID, req UpdateUserRoleRequest) (*Operation, error) {
17284 path := fmt.Sprintf("/user/%v", id)
17285
17286 body, err := prepareJSONBody(req)
17287 if err != nil {
17288 return nil, fmt.Errorf("UpdateUserRole: prepare Json body: %w", err)
17289 }
17290
17291 request, err := http.NewRequestWithContext(ctx, "PUT", c.serverEndpoint+path, body)
17292 if err != nil {
17293 return nil, fmt.Errorf("UpdateUserRole: new request: %w", err)
17294 }
17295
17296 request.Header.Add("User-Agent", c.getUserAgent())
17297
17298 request.Header.Add("Content-Type", "application/json")
17299
17300 if err := c.executeRequestInterceptors(ctx, request); err != nil {
17301 return nil, fmt.Errorf("UpdateUserRole: execute request editors: %w", err)
17302 }
17303
17304 if err := c.signRequest(request); err != nil {
17305 return nil, fmt.Errorf("UpdateUserRole: sign request: %w", err)
17306 }
17307
17308 if c.trace {
17309 dumpRequest(request, "update-user-role")
17310 }
17311
17312 response, err := c.httpClient.Do(request)
17313 if err != nil {
17314 return nil, fmt.Errorf("UpdateUserRole: http client do: %w", err)
17315 }
17316
17317 if c.trace {
17318 dumpResponse(response)
17319 }
17320
17321 if err := handleHTTPErrorResp(response); err != nil {
17322 return nil, fmt.Errorf("UpdateUserRole: http response: %w", err)
17323 }
17324
17325 bodyresp := new(Operation)
17326 if err := prepareJSONResponse(response, bodyresp); err != nil {
17327 return nil, fmt.Errorf("UpdateUserRole: prepare Json response: %w", err)
17328 }
17329
17330 return bodyresp, nil
17331 }
17332
17333 type ListZonesResponse struct {
17334 Zones []Zone `json:"zones,omitempty"`
17335 }
17336
17337 // FindZone attempts to find an Zone by nameOrAPIEndpoint.
17338 func (l ListZonesResponse) FindZone(nameOrAPIEndpoint string) (Zone, error) {
17339 var result []Zone
17340 for i, elem := range l.Zones {
17341 if string(elem.Name) == nameOrAPIEndpoint || string(elem.APIEndpoint) == nameOrAPIEndpoint {
17342 result = append(result, l.Zones[i])
17343 }
17344 }
17345 if len(result) == 1 {
17346 return result[0], nil
17347 }
17348
17349 if len(result) > 1 {
17350 return Zone{}, fmt.Errorf("%q too many found in ListZonesResponse: %w", nameOrAPIEndpoint, ErrConflict)
17351 }
17352
17353 return Zone{}, fmt.Errorf("%q not found in ListZonesResponse: %w", nameOrAPIEndpoint, ErrNotFound)
17354 }
17355
17356 // List Zones
17357 func (c Client) ListZones(ctx context.Context) (*ListZonesResponse, error) {
17358 path := "/zone"
17359
17360 request, err := http.NewRequestWithContext(ctx, "GET", c.serverEndpoint+path, nil)
17361 if err != nil {
17362 return nil, fmt.Errorf("ListZones: new request: %w", err)
17363 }
17364
17365 request.Header.Add("User-Agent", c.getUserAgent())
17366
17367 if err := c.executeRequestInterceptors(ctx, request); err != nil {
17368 return nil, fmt.Errorf("ListZones: execute request editors: %w", err)
17369 }
17370
17371 if err := c.signRequest(request); err != nil {
17372 return nil, fmt.Errorf("ListZones: sign request: %w", err)
17373 }
17374
17375 if c.trace {
17376 dumpRequest(request, "list-zones")
17377 }
17378
17379 response, err := c.httpClient.Do(request)
17380 if err != nil {
17381 return nil, fmt.Errorf("ListZones: http client do: %w", err)
17382 }
17383
17384 if c.trace {
17385 dumpResponse(response)
17386 }
17387
17388 if err := handleHTTPErrorResp(response); err != nil {
17389 return nil, fmt.Errorf("ListZones: http response: %w", err)
17390 }
17391
17392 bodyresp := new(ListZonesResponse)
17393 if err := prepareJSONResponse(response, bodyresp); err != nil {
17394 return nil, fmt.Errorf("ListZones: prepare Json response: %w", err)
17395 }
17396
17397 return bodyresp, nil
17398 }
17399