zz_api_ops.go raw
1 // Copyright 2022-2025 The sacloud/iaas-api-go Authors
2 //
3 // Licensed under the Apache License, Version 2.0 (the "License");
4 // you may not use this file except in compliance with the License.
5 // You may obtain a copy of the License at
6 //
7 // http://www.apache.org/licenses/LICENSE-2.0
8 //
9 // Unless required by applicable law or agreed to in writing, software
10 // distributed under the License is distributed on an "AS IS" BASIS,
11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 // See the License for the specific language governing permissions and
13 // limitations under the License.
14
15 // generated by 'github.com/sacloud/iaas-api-go/internal/tools/gen-api-op'; DO NOT EDIT
16
17 package iaas
18
19 import (
20 "context"
21
22 "github.com/sacloud/iaas-api-go/types"
23 "github.com/sacloud/packages-go/mutexkv"
24 )
25
26 var apiLocker = mutexkv.NewMutexKV()
27
28 func init() {
29 SetClientFactoryFunc("Archive", func(caller APICaller) interface{} {
30 return &ArchiveOp{
31 Client: caller,
32 PathSuffix: "api/cloud/1.1",
33 PathName: "archive",
34 }
35 })
36
37 SetClientFactoryFunc("AuthStatus", func(caller APICaller) interface{} {
38 return &AuthStatusOp{
39 Client: caller,
40 PathSuffix: "api/cloud/1.1",
41 PathName: "auth-status",
42 }
43 })
44
45 SetClientFactoryFunc("AutoBackup", func(caller APICaller) interface{} {
46 return &AutoBackupOp{
47 Client: caller,
48 PathSuffix: "api/cloud/1.1",
49 PathName: "commonserviceitem",
50 }
51 })
52
53 SetClientFactoryFunc("AutoScale", func(caller APICaller) interface{} {
54 return &AutoScaleOp{
55 Client: caller,
56 PathSuffix: "api/cloud/1.1",
57 PathName: "commonserviceitem",
58 }
59 })
60
61 SetClientFactoryFunc("Bill", func(caller APICaller) interface{} {
62 return &BillOp{
63 Client: caller,
64 PathSuffix: "api/system/1.0",
65 PathName: "bill",
66 }
67 })
68
69 SetClientFactoryFunc("Bridge", func(caller APICaller) interface{} {
70 return &BridgeOp{
71 Client: caller,
72 PathSuffix: "api/cloud/1.1",
73 PathName: "bridge",
74 }
75 })
76
77 SetClientFactoryFunc("CDROM", func(caller APICaller) interface{} {
78 return &CDROMOp{
79 Client: caller,
80 PathSuffix: "api/cloud/1.1",
81 PathName: "cdrom",
82 }
83 })
84
85 SetClientFactoryFunc("CertificateAuthority", func(caller APICaller) interface{} {
86 return &CertificateAuthorityOp{
87 Client: caller,
88 PathSuffix: "api/cloud/1.1",
89 PathName: "commonserviceitem",
90 }
91 })
92
93 SetClientFactoryFunc("ContainerRegistry", func(caller APICaller) interface{} {
94 return &ContainerRegistryOp{
95 Client: caller,
96 PathSuffix: "api/cloud/1.1",
97 PathName: "commonserviceitem",
98 }
99 })
100
101 SetClientFactoryFunc("Coupon", func(caller APICaller) interface{} {
102 return &CouponOp{
103 Client: caller,
104 PathSuffix: "api/system/1.0",
105 PathName: "coupon",
106 }
107 })
108
109 SetClientFactoryFunc("Database", func(caller APICaller) interface{} {
110 return &DatabaseOp{
111 Client: caller,
112 PathSuffix: "api/cloud/1.1",
113 PathName: "appliance",
114 }
115 })
116
117 SetClientFactoryFunc("Disk", func(caller APICaller) interface{} {
118 return &DiskOp{
119 Client: caller,
120 PathSuffix: "api/cloud/1.1",
121 PathName: "disk",
122 }
123 })
124
125 SetClientFactoryFunc("DiskPlan", func(caller APICaller) interface{} {
126 return &DiskPlanOp{
127 Client: caller,
128 PathSuffix: "api/cloud/1.1",
129 PathName: "product/disk",
130 }
131 })
132
133 SetClientFactoryFunc("DNS", func(caller APICaller) interface{} {
134 return &DNSOp{
135 Client: caller,
136 PathSuffix: "api/cloud/1.1",
137 PathName: "commonserviceitem",
138 }
139 })
140
141 SetClientFactoryFunc("EnhancedDB", func(caller APICaller) interface{} {
142 return &EnhancedDBOp{
143 Client: caller,
144 PathSuffix: "api/cloud/1.1",
145 PathName: "commonserviceitem",
146 }
147 })
148
149 SetClientFactoryFunc("ESME", func(caller APICaller) interface{} {
150 return &ESMEOp{
151 Client: caller,
152 PathSuffix: "api/cloud/1.1",
153 PathName: "commonserviceitem",
154 }
155 })
156
157 SetClientFactoryFunc("GSLB", func(caller APICaller) interface{} {
158 return &GSLBOp{
159 Client: caller,
160 PathSuffix: "api/cloud/1.1",
161 PathName: "commonserviceitem",
162 }
163 })
164
165 SetClientFactoryFunc("Icon", func(caller APICaller) interface{} {
166 return &IconOp{
167 Client: caller,
168 PathSuffix: "api/cloud/1.1",
169 PathName: "icon",
170 }
171 })
172
173 SetClientFactoryFunc("Interface", func(caller APICaller) interface{} {
174 return &InterfaceOp{
175 Client: caller,
176 PathSuffix: "api/cloud/1.1",
177 PathName: "interface",
178 }
179 })
180
181 SetClientFactoryFunc("Internet", func(caller APICaller) interface{} {
182 return &InternetOp{
183 Client: caller,
184 PathSuffix: "api/cloud/1.1",
185 PathName: "internet",
186 }
187 })
188
189 SetClientFactoryFunc("InternetPlan", func(caller APICaller) interface{} {
190 return &InternetPlanOp{
191 Client: caller,
192 PathSuffix: "api/cloud/1.1",
193 PathName: "product/internet",
194 }
195 })
196
197 SetClientFactoryFunc("IPAddress", func(caller APICaller) interface{} {
198 return &IPAddressOp{
199 Client: caller,
200 PathSuffix: "api/cloud/1.1",
201 PathName: "ipaddress",
202 }
203 })
204
205 SetClientFactoryFunc("IPv6Net", func(caller APICaller) interface{} {
206 return &IPv6NetOp{
207 Client: caller,
208 PathSuffix: "api/cloud/1.1",
209 PathName: "ipv6net",
210 }
211 })
212
213 SetClientFactoryFunc("IPv6Addr", func(caller APICaller) interface{} {
214 return &IPv6AddrOp{
215 Client: caller,
216 PathSuffix: "api/cloud/1.1",
217 PathName: "ipv6addr",
218 }
219 })
220
221 SetClientFactoryFunc("License", func(caller APICaller) interface{} {
222 return &LicenseOp{
223 Client: caller,
224 PathSuffix: "api/cloud/1.1",
225 PathName: "license",
226 }
227 })
228
229 SetClientFactoryFunc("LicenseInfo", func(caller APICaller) interface{} {
230 return &LicenseInfoOp{
231 Client: caller,
232 PathSuffix: "api/cloud/1.1",
233 PathName: "product/license",
234 }
235 })
236
237 SetClientFactoryFunc("LoadBalancer", func(caller APICaller) interface{} {
238 return &LoadBalancerOp{
239 Client: caller,
240 PathSuffix: "api/cloud/1.1",
241 PathName: "appliance",
242 }
243 })
244
245 SetClientFactoryFunc("LocalRouter", func(caller APICaller) interface{} {
246 return &LocalRouterOp{
247 Client: caller,
248 PathSuffix: "api/cloud/1.1",
249 PathName: "commonserviceitem",
250 }
251 })
252
253 SetClientFactoryFunc("MobileGateway", func(caller APICaller) interface{} {
254 return &MobileGatewayOp{
255 Client: caller,
256 PathSuffix: "api/cloud/1.1",
257 PathName: "appliance",
258 }
259 })
260
261 SetClientFactoryFunc("NFS", func(caller APICaller) interface{} {
262 return &NFSOp{
263 Client: caller,
264 PathSuffix: "api/cloud/1.1",
265 PathName: "appliance",
266 }
267 })
268
269 SetClientFactoryFunc("Note", func(caller APICaller) interface{} {
270 return &NoteOp{
271 Client: caller,
272 PathSuffix: "api/cloud/1.1",
273 PathName: "note",
274 }
275 })
276
277 SetClientFactoryFunc("PacketFilter", func(caller APICaller) interface{} {
278 return &PacketFilterOp{
279 Client: caller,
280 PathSuffix: "api/cloud/1.1",
281 PathName: "packetfilter",
282 }
283 })
284
285 SetClientFactoryFunc("PrivateHost", func(caller APICaller) interface{} {
286 return &PrivateHostOp{
287 Client: caller,
288 PathSuffix: "api/cloud/1.1",
289 PathName: "privatehost",
290 }
291 })
292
293 SetClientFactoryFunc("PrivateHostPlan", func(caller APICaller) interface{} {
294 return &PrivateHostPlanOp{
295 Client: caller,
296 PathSuffix: "api/cloud/1.1",
297 PathName: "product/privatehost",
298 }
299 })
300
301 SetClientFactoryFunc("ProxyLB", func(caller APICaller) interface{} {
302 return &ProxyLBOp{
303 Client: caller,
304 PathSuffix: "api/cloud/1.1",
305 PathName: "commonserviceitem",
306 }
307 })
308
309 SetClientFactoryFunc("Region", func(caller APICaller) interface{} {
310 return &RegionOp{
311 Client: caller,
312 PathSuffix: "api/cloud/1.1",
313 PathName: "region",
314 }
315 })
316
317 SetClientFactoryFunc("Server", func(caller APICaller) interface{} {
318 return &ServerOp{
319 Client: caller,
320 PathSuffix: "api/cloud/1.1",
321 PathName: "server",
322 }
323 })
324
325 SetClientFactoryFunc("ServerPlan", func(caller APICaller) interface{} {
326 return &ServerPlanOp{
327 Client: caller,
328 PathSuffix: "api/cloud/1.1",
329 PathName: "product/server",
330 }
331 })
332
333 SetClientFactoryFunc("ServiceClass", func(caller APICaller) interface{} {
334 return &ServiceClassOp{
335 Client: caller,
336 PathSuffix: "api/cloud/1.1",
337 PathName: "public/price",
338 }
339 })
340
341 SetClientFactoryFunc("SIM", func(caller APICaller) interface{} {
342 return &SIMOp{
343 Client: caller,
344 PathSuffix: "api/cloud/1.1",
345 PathName: "commonserviceitem",
346 }
347 })
348
349 SetClientFactoryFunc("SimpleMonitor", func(caller APICaller) interface{} {
350 return &SimpleMonitorOp{
351 Client: caller,
352 PathSuffix: "api/cloud/1.1",
353 PathName: "commonserviceitem",
354 }
355 })
356
357 SetClientFactoryFunc("SimpleNotificationDestination", func(caller APICaller) interface{} {
358 return &SimpleNotificationDestinationOp{
359 Client: caller,
360 PathSuffix: "api/cloud/1.1",
361 PathName: "commonserviceitem",
362 }
363 })
364
365 SetClientFactoryFunc("SimpleNotificationGroup", func(caller APICaller) interface{} {
366 return &SimpleNotificationGroupOp{
367 Client: caller,
368 PathSuffix: "api/cloud/1.1",
369 PathName: "commonserviceitem",
370 }
371 })
372
373 SetClientFactoryFunc("SSHKey", func(caller APICaller) interface{} {
374 return &SSHKeyOp{
375 Client: caller,
376 PathSuffix: "api/cloud/1.1",
377 PathName: "sshkey",
378 }
379 })
380
381 SetClientFactoryFunc("Subnet", func(caller APICaller) interface{} {
382 return &SubnetOp{
383 Client: caller,
384 PathSuffix: "api/cloud/1.1",
385 PathName: "subnet",
386 }
387 })
388
389 SetClientFactoryFunc("Switch", func(caller APICaller) interface{} {
390 return &SwitchOp{
391 Client: caller,
392 PathSuffix: "api/cloud/1.1",
393 PathName: "switch",
394 }
395 })
396
397 SetClientFactoryFunc("VPCRouter", func(caller APICaller) interface{} {
398 return &VPCRouterOp{
399 Client: caller,
400 PathSuffix: "api/cloud/1.1",
401 PathName: "appliance",
402 }
403 })
404
405 SetClientFactoryFunc("Zone", func(caller APICaller) interface{} {
406 return &ZoneOp{
407 Client: caller,
408 PathSuffix: "api/cloud/1.1",
409 PathName: "zone",
410 }
411 })
412 }
413
414 /*************************************************
415 * ArchiveOp
416 *************************************************/
417
418 // ArchiveOp implements ArchiveAPI interface
419 type ArchiveOp struct {
420 // Client APICaller
421 Client APICaller
422 // PathSuffix is used when building URL
423 PathSuffix string
424 // PathName is used when building URL
425 PathName string
426 }
427
428 // NewArchiveOp creates new ArchiveOp instance
429 func NewArchiveOp(caller APICaller) ArchiveAPI {
430 return GetClientFactoryFunc("Archive")(caller).(ArchiveAPI)
431 }
432
433 // Find is API call
434 func (o *ArchiveOp) Find(ctx context.Context, zone string, conditions *FindCondition) (*ArchiveFindResult, error) {
435 // build request URL
436 pathBuildParameter := map[string]interface{}{
437 "rootURL": SakuraCloudAPIRoot,
438 "pathSuffix": o.PathSuffix,
439 "pathName": o.PathName,
440 "zone": zone,
441 "conditions": conditions,
442 }
443
444 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}", pathBuildParameter)
445 if err != nil {
446 return nil, err
447 }
448 // build request body
449 var body interface{}
450 v, err := o.transformFindArgs(conditions)
451 if err != nil {
452 return nil, err
453 }
454 body = v
455
456 // do request
457 data, err := o.Client.Do(ctx, "GET", url, body)
458 if err != nil {
459 return nil, err
460 }
461
462 // build results
463 results, err := o.transformFindResults(data)
464 if err != nil {
465 return nil, err
466 }
467 return results, err
468 }
469
470 // Create is API call
471 func (o *ArchiveOp) Create(ctx context.Context, zone string, param *ArchiveCreateRequest) (*Archive, error) {
472 // build request URL
473 pathBuildParameter := map[string]interface{}{
474 "rootURL": SakuraCloudAPIRoot,
475 "pathSuffix": o.PathSuffix,
476 "pathName": o.PathName,
477 "zone": zone,
478 "param": param,
479 }
480
481 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}", pathBuildParameter)
482 if err != nil {
483 return nil, err
484 }
485 // build request body
486 var body interface{}
487 v, err := o.transformCreateArgs(param)
488 if err != nil {
489 return nil, err
490 }
491 body = v
492
493 // do request
494 data, err := o.Client.Do(ctx, "POST", url, body)
495 if err != nil {
496 return nil, err
497 }
498
499 // build results
500 results, err := o.transformCreateResults(data)
501 if err != nil {
502 return nil, err
503 }
504 return results.Archive, nil
505 }
506
507 // CreateBlank is API call
508 func (o *ArchiveOp) CreateBlank(ctx context.Context, zone string, param *ArchiveCreateBlankRequest) (*Archive, *FTPServer, error) {
509 // build request URL
510 pathBuildParameter := map[string]interface{}{
511 "rootURL": SakuraCloudAPIRoot,
512 "pathSuffix": o.PathSuffix,
513 "pathName": o.PathName,
514 "zone": zone,
515 "param": param,
516 }
517
518 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}", pathBuildParameter)
519 if err != nil {
520 return nil, nil, err
521 }
522 // build request body
523 var body interface{}
524 v, err := o.transformCreateBlankArgs(param)
525 if err != nil {
526 return nil, nil, err
527 }
528 body = v
529
530 // do request
531 data, err := o.Client.Do(ctx, "POST", url, body)
532 if err != nil {
533 return nil, nil, err
534 }
535
536 // build results
537 results, err := o.transformCreateBlankResults(data)
538 if err != nil {
539 return nil, nil, err
540 }
541 return results.Archive, results.FTPServer, nil
542 }
543
544 // Read is API call
545 func (o *ArchiveOp) Read(ctx context.Context, zone string, id types.ID) (*Archive, error) {
546 // build request URL
547 pathBuildParameter := map[string]interface{}{
548 "rootURL": SakuraCloudAPIRoot,
549 "pathSuffix": o.PathSuffix,
550 "pathName": o.PathName,
551 "zone": zone,
552 "id": id,
553 }
554
555 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}", pathBuildParameter)
556 if err != nil {
557 return nil, err
558 }
559 // build request body
560 var body interface{}
561
562 // do request
563 data, err := o.Client.Do(ctx, "GET", url, body)
564 if err != nil {
565 return nil, err
566 }
567
568 // build results
569 results, err := o.transformReadResults(data)
570 if err != nil {
571 return nil, err
572 }
573 return results.Archive, nil
574 }
575
576 // Update is API call
577 func (o *ArchiveOp) Update(ctx context.Context, zone string, id types.ID, param *ArchiveUpdateRequest) (*Archive, error) {
578 // build request URL
579 pathBuildParameter := map[string]interface{}{
580 "rootURL": SakuraCloudAPIRoot,
581 "pathSuffix": o.PathSuffix,
582 "pathName": o.PathName,
583 "zone": zone,
584 "id": id,
585 "param": param,
586 }
587
588 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}", pathBuildParameter)
589 if err != nil {
590 return nil, err
591 }
592 // build request body
593 var body interface{}
594 v, err := o.transformUpdateArgs(id, param)
595 if err != nil {
596 return nil, err
597 }
598 body = v
599
600 // do request
601 data, err := o.Client.Do(ctx, "PUT", url, body)
602 if err != nil {
603 return nil, err
604 }
605
606 // build results
607 results, err := o.transformUpdateResults(data)
608 if err != nil {
609 return nil, err
610 }
611 return results.Archive, nil
612 }
613
614 // Delete is API call
615 func (o *ArchiveOp) Delete(ctx context.Context, zone string, id types.ID) error {
616 // build request URL
617 pathBuildParameter := map[string]interface{}{
618 "rootURL": SakuraCloudAPIRoot,
619 "pathSuffix": o.PathSuffix,
620 "pathName": o.PathName,
621 "zone": zone,
622 "id": id,
623 }
624
625 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}", pathBuildParameter)
626 if err != nil {
627 return err
628 }
629 // build request body
630 var body interface{}
631
632 // do request
633 _, err = o.Client.Do(ctx, "DELETE", url, body)
634 if err != nil {
635 return err
636 }
637
638 // build results
639
640 return nil
641 }
642
643 // OpenFTP is API call
644 func (o *ArchiveOp) OpenFTP(ctx context.Context, zone string, id types.ID, openOption *OpenFTPRequest) (*FTPServer, error) {
645 // build request URL
646 pathBuildParameter := map[string]interface{}{
647 "rootURL": SakuraCloudAPIRoot,
648 "pathSuffix": o.PathSuffix,
649 "pathName": o.PathName,
650 "zone": zone,
651 "id": id,
652 "openOption": openOption,
653 }
654
655 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}/ftp", pathBuildParameter)
656 if err != nil {
657 return nil, err
658 }
659 // build request body
660 var body interface{}
661 v, err := o.transformOpenFTPArgs(id, openOption)
662 if err != nil {
663 return nil, err
664 }
665 body = v
666
667 // do request
668 data, err := o.Client.Do(ctx, "PUT", url, body)
669 if err != nil {
670 return nil, err
671 }
672
673 // build results
674 results, err := o.transformOpenFTPResults(data)
675 if err != nil {
676 return nil, err
677 }
678 return results.FTPServer, nil
679 }
680
681 // CloseFTP is API call
682 func (o *ArchiveOp) CloseFTP(ctx context.Context, zone string, id types.ID) error {
683 // build request URL
684 pathBuildParameter := map[string]interface{}{
685 "rootURL": SakuraCloudAPIRoot,
686 "pathSuffix": o.PathSuffix,
687 "pathName": o.PathName,
688 "zone": zone,
689 "id": id,
690 }
691
692 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}/ftp", pathBuildParameter)
693 if err != nil {
694 return err
695 }
696 // build request body
697 var body interface{}
698
699 // do request
700 _, err = o.Client.Do(ctx, "DELETE", url, body)
701 if err != nil {
702 return err
703 }
704
705 // build results
706
707 return nil
708 }
709
710 // Share is API call
711 func (o *ArchiveOp) Share(ctx context.Context, zone string, id types.ID) (*ArchiveShareInfo, error) {
712 // build request URL
713 pathBuildParameter := map[string]interface{}{
714 "rootURL": SakuraCloudAPIRoot,
715 "pathSuffix": o.PathSuffix,
716 "pathName": o.PathName,
717 "zone": zone,
718 "id": id,
719 }
720
721 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}/ftp", pathBuildParameter)
722 if err != nil {
723 return nil, err
724 }
725 // build request body
726 var body interface{}
727 v, err := o.transformShareArgs(id)
728 if err != nil {
729 return nil, err
730 }
731 body = v
732
733 // do request
734 data, err := o.Client.Do(ctx, "PUT", url, body)
735 if err != nil {
736 return nil, err
737 }
738
739 // build results
740 results, err := o.transformShareResults(data)
741 if err != nil {
742 return nil, err
743 }
744 return results.ArchiveShareInfo, nil
745 }
746
747 // CreateFromShared is API call
748 func (o *ArchiveOp) CreateFromShared(ctx context.Context, zone string, sourceArchiveID types.ID, destZoneID types.ID, param *ArchiveCreateRequestFromShared) (*Archive, error) {
749 // build request URL
750 pathBuildParameter := map[string]interface{}{
751 "rootURL": SakuraCloudAPIRoot,
752 "pathSuffix": o.PathSuffix,
753 "pathName": o.PathName,
754 "zone": zone,
755 "sourceArchiveID": sourceArchiveID,
756 "destZoneID": destZoneID,
757 "param": param,
758 }
759
760 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.sourceArchiveID}}/to/zone/{{.destZoneID}}", pathBuildParameter)
761 if err != nil {
762 return nil, err
763 }
764 // build request body
765 var body interface{}
766 v, err := o.transformCreateFromSharedArgs(sourceArchiveID, destZoneID, param)
767 if err != nil {
768 return nil, err
769 }
770 body = v
771
772 // do request
773 data, err := o.Client.Do(ctx, "POST", url, body)
774 if err != nil {
775 return nil, err
776 }
777
778 // build results
779 results, err := o.transformCreateFromSharedResults(data)
780 if err != nil {
781 return nil, err
782 }
783 return results.Archive, nil
784 }
785
786 // Transfer is API call
787 func (o *ArchiveOp) Transfer(ctx context.Context, zone string, sourceArchiveID types.ID, destZoneID types.ID, param *ArchiveTransferRequest) (*Archive, error) {
788 // build request URL
789 pathBuildParameter := map[string]interface{}{
790 "rootURL": SakuraCloudAPIRoot,
791 "pathSuffix": o.PathSuffix,
792 "pathName": o.PathName,
793 "zone": zone,
794 "sourceArchiveID": sourceArchiveID,
795 "destZoneID": destZoneID,
796 "param": param,
797 }
798
799 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.sourceArchiveID}}/to/zone/{{.destZoneID}}", pathBuildParameter)
800 if err != nil {
801 return nil, err
802 }
803 // build request body
804 var body interface{}
805 v, err := o.transformTransferArgs(sourceArchiveID, destZoneID, param)
806 if err != nil {
807 return nil, err
808 }
809 body = v
810
811 // do request
812 data, err := o.Client.Do(ctx, "POST", url, body)
813 if err != nil {
814 return nil, err
815 }
816
817 // build results
818 results, err := o.transformTransferResults(data)
819 if err != nil {
820 return nil, err
821 }
822 return results.Archive, nil
823 }
824
825 /*************************************************
826 * AuthStatusOp
827 *************************************************/
828
829 // AuthStatusOp implements AuthStatusAPI interface
830 type AuthStatusOp struct {
831 // Client APICaller
832 Client APICaller
833 // PathSuffix is used when building URL
834 PathSuffix string
835 // PathName is used when building URL
836 PathName string
837 }
838
839 // NewAuthStatusOp creates new AuthStatusOp instance
840 func NewAuthStatusOp(caller APICaller) AuthStatusAPI {
841 return GetClientFactoryFunc("AuthStatus")(caller).(AuthStatusAPI)
842 }
843
844 // Read is API call
845 func (o *AuthStatusOp) Read(ctx context.Context) (*AuthStatus, error) {
846 // build request URL
847 pathBuildParameter := map[string]interface{}{
848 "rootURL": SakuraCloudAPIRoot,
849 "pathSuffix": o.PathSuffix,
850 "pathName": o.PathName,
851 "zone": APIDefaultZone,
852 }
853
854 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}", pathBuildParameter)
855 if err != nil {
856 return nil, err
857 }
858 // build request body
859 var body interface{}
860
861 // do request
862 data, err := o.Client.Do(ctx, "GET", url, body)
863 if err != nil {
864 return nil, err
865 }
866
867 // build results
868 results, err := o.transformReadResults(data)
869 if err != nil {
870 return nil, err
871 }
872 return results.AuthStatus, nil
873 }
874
875 /*************************************************
876 * AutoBackupOp
877 *************************************************/
878
879 // AutoBackupOp implements AutoBackupAPI interface
880 type AutoBackupOp struct {
881 // Client APICaller
882 Client APICaller
883 // PathSuffix is used when building URL
884 PathSuffix string
885 // PathName is used when building URL
886 PathName string
887 }
888
889 // NewAutoBackupOp creates new AutoBackupOp instance
890 func NewAutoBackupOp(caller APICaller) AutoBackupAPI {
891 return GetClientFactoryFunc("AutoBackup")(caller).(AutoBackupAPI)
892 }
893
894 // Find is API call
895 func (o *AutoBackupOp) Find(ctx context.Context, zone string, conditions *FindCondition) (*AutoBackupFindResult, error) {
896 // build request URL
897 pathBuildParameter := map[string]interface{}{
898 "rootURL": SakuraCloudAPIRoot,
899 "pathSuffix": o.PathSuffix,
900 "pathName": o.PathName,
901 "zone": zone,
902 "conditions": conditions,
903 }
904
905 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}", pathBuildParameter)
906 if err != nil {
907 return nil, err
908 }
909 // build request body
910 var body interface{}
911 v, err := o.transformFindArgs(conditions)
912 if err != nil {
913 return nil, err
914 }
915 body = v
916
917 // do request
918 data, err := o.Client.Do(ctx, "GET", url, body)
919 if err != nil {
920 return nil, err
921 }
922
923 // build results
924 results, err := o.transformFindResults(data)
925 if err != nil {
926 return nil, err
927 }
928 return results, err
929 }
930
931 // Create is API call
932 func (o *AutoBackupOp) Create(ctx context.Context, zone string, param *AutoBackupCreateRequest) (*AutoBackup, error) {
933 // build request URL
934 pathBuildParameter := map[string]interface{}{
935 "rootURL": SakuraCloudAPIRoot,
936 "pathSuffix": o.PathSuffix,
937 "pathName": o.PathName,
938 "zone": zone,
939 "param": param,
940 }
941
942 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}", pathBuildParameter)
943 if err != nil {
944 return nil, err
945 }
946 // build request body
947 var body interface{}
948 v, err := o.transformCreateArgs(param)
949 if err != nil {
950 return nil, err
951 }
952 body = v
953
954 // do request
955 data, err := o.Client.Do(ctx, "POST", url, body)
956 if err != nil {
957 return nil, err
958 }
959
960 // build results
961 results, err := o.transformCreateResults(data)
962 if err != nil {
963 return nil, err
964 }
965 return results.AutoBackup, nil
966 }
967
968 // Read is API call
969 func (o *AutoBackupOp) Read(ctx context.Context, zone string, id types.ID) (*AutoBackup, error) {
970 // build request URL
971 pathBuildParameter := map[string]interface{}{
972 "rootURL": SakuraCloudAPIRoot,
973 "pathSuffix": o.PathSuffix,
974 "pathName": o.PathName,
975 "zone": zone,
976 "id": id,
977 }
978
979 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}", pathBuildParameter)
980 if err != nil {
981 return nil, err
982 }
983 // build request body
984 var body interface{}
985
986 // do request
987 data, err := o.Client.Do(ctx, "GET", url, body)
988 if err != nil {
989 return nil, err
990 }
991
992 // build results
993 results, err := o.transformReadResults(data)
994 if err != nil {
995 return nil, err
996 }
997 return results.AutoBackup, nil
998 }
999
1000 // Update is API call
1001 func (o *AutoBackupOp) Update(ctx context.Context, zone string, id types.ID, param *AutoBackupUpdateRequest) (*AutoBackup, error) {
1002 // build request URL
1003 pathBuildParameter := map[string]interface{}{
1004 "rootURL": SakuraCloudAPIRoot,
1005 "pathSuffix": o.PathSuffix,
1006 "pathName": o.PathName,
1007 "zone": zone,
1008 "id": id,
1009 "param": param,
1010 }
1011
1012 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}", pathBuildParameter)
1013 if err != nil {
1014 return nil, err
1015 }
1016 // build request body
1017 var body interface{}
1018 v, err := o.transformUpdateArgs(id, param)
1019 if err != nil {
1020 return nil, err
1021 }
1022 body = v
1023
1024 // do request
1025 data, err := o.Client.Do(ctx, "PUT", url, body)
1026 if err != nil {
1027 return nil, err
1028 }
1029
1030 // build results
1031 results, err := o.transformUpdateResults(data)
1032 if err != nil {
1033 return nil, err
1034 }
1035 return results.AutoBackup, nil
1036 }
1037
1038 // UpdateSettings is API call
1039 func (o *AutoBackupOp) UpdateSettings(ctx context.Context, zone string, id types.ID, param *AutoBackupUpdateSettingsRequest) (*AutoBackup, error) {
1040 // build request URL
1041 pathBuildParameter := map[string]interface{}{
1042 "rootURL": SakuraCloudAPIRoot,
1043 "pathSuffix": o.PathSuffix,
1044 "pathName": o.PathName,
1045 "zone": zone,
1046 "id": id,
1047 "param": param,
1048 }
1049
1050 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}", pathBuildParameter)
1051 if err != nil {
1052 return nil, err
1053 }
1054 // build request body
1055 var body interface{}
1056 v, err := o.transformUpdateSettingsArgs(id, param)
1057 if err != nil {
1058 return nil, err
1059 }
1060 body = v
1061
1062 // do request
1063 data, err := o.Client.Do(ctx, "PUT", url, body)
1064 if err != nil {
1065 return nil, err
1066 }
1067
1068 // build results
1069 results, err := o.transformUpdateSettingsResults(data)
1070 if err != nil {
1071 return nil, err
1072 }
1073 return results.AutoBackup, nil
1074 }
1075
1076 // Delete is API call
1077 func (o *AutoBackupOp) Delete(ctx context.Context, zone string, id types.ID) error {
1078 // build request URL
1079 pathBuildParameter := map[string]interface{}{
1080 "rootURL": SakuraCloudAPIRoot,
1081 "pathSuffix": o.PathSuffix,
1082 "pathName": o.PathName,
1083 "zone": zone,
1084 "id": id,
1085 }
1086
1087 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}", pathBuildParameter)
1088 if err != nil {
1089 return err
1090 }
1091 // build request body
1092 var body interface{}
1093
1094 // do request
1095 _, err = o.Client.Do(ctx, "DELETE", url, body)
1096 if err != nil {
1097 return err
1098 }
1099
1100 // build results
1101
1102 return nil
1103 }
1104
1105 /*************************************************
1106 * AutoScaleOp
1107 *************************************************/
1108
1109 // AutoScaleOp implements AutoScaleAPI interface
1110 type AutoScaleOp struct {
1111 // Client APICaller
1112 Client APICaller
1113 // PathSuffix is used when building URL
1114 PathSuffix string
1115 // PathName is used when building URL
1116 PathName string
1117 }
1118
1119 // NewAutoScaleOp creates new AutoScaleOp instance
1120 func NewAutoScaleOp(caller APICaller) AutoScaleAPI {
1121 return GetClientFactoryFunc("AutoScale")(caller).(AutoScaleAPI)
1122 }
1123
1124 // Find is API call
1125 func (o *AutoScaleOp) Find(ctx context.Context, conditions *FindCondition) (*AutoScaleFindResult, error) {
1126 // build request URL
1127 pathBuildParameter := map[string]interface{}{
1128 "rootURL": SakuraCloudAPIRoot,
1129 "pathSuffix": o.PathSuffix,
1130 "pathName": o.PathName,
1131 "zone": APIDefaultZone,
1132 "conditions": conditions,
1133 }
1134
1135 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}", pathBuildParameter)
1136 if err != nil {
1137 return nil, err
1138 }
1139 // build request body
1140 var body interface{}
1141 v, err := o.transformFindArgs(conditions)
1142 if err != nil {
1143 return nil, err
1144 }
1145 body = v
1146
1147 // do request
1148 data, err := o.Client.Do(ctx, "GET", url, body)
1149 if err != nil {
1150 return nil, err
1151 }
1152
1153 // build results
1154 results, err := o.transformFindResults(data)
1155 if err != nil {
1156 return nil, err
1157 }
1158 return results, err
1159 }
1160
1161 // Create is API call
1162 func (o *AutoScaleOp) Create(ctx context.Context, param *AutoScaleCreateRequest) (*AutoScale, error) {
1163 // build request URL
1164 pathBuildParameter := map[string]interface{}{
1165 "rootURL": SakuraCloudAPIRoot,
1166 "pathSuffix": o.PathSuffix,
1167 "pathName": o.PathName,
1168 "zone": APIDefaultZone,
1169 "param": param,
1170 }
1171
1172 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}", pathBuildParameter)
1173 if err != nil {
1174 return nil, err
1175 }
1176 // build request body
1177 var body interface{}
1178 v, err := o.transformCreateArgs(param)
1179 if err != nil {
1180 return nil, err
1181 }
1182 body = v
1183
1184 // do request
1185 data, err := o.Client.Do(ctx, "POST", url, body)
1186 if err != nil {
1187 return nil, err
1188 }
1189
1190 // build results
1191 results, err := o.transformCreateResults(data)
1192 if err != nil {
1193 return nil, err
1194 }
1195 return results.AutoScale, nil
1196 }
1197
1198 // Read is API call
1199 func (o *AutoScaleOp) Read(ctx context.Context, id types.ID) (*AutoScale, error) {
1200 // build request URL
1201 pathBuildParameter := map[string]interface{}{
1202 "rootURL": SakuraCloudAPIRoot,
1203 "pathSuffix": o.PathSuffix,
1204 "pathName": o.PathName,
1205 "zone": APIDefaultZone,
1206 "id": id,
1207 }
1208
1209 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}", pathBuildParameter)
1210 if err != nil {
1211 return nil, err
1212 }
1213 // build request body
1214 var body interface{}
1215
1216 // do request
1217 data, err := o.Client.Do(ctx, "GET", url, body)
1218 if err != nil {
1219 return nil, err
1220 }
1221
1222 // build results
1223 results, err := o.transformReadResults(data)
1224 if err != nil {
1225 return nil, err
1226 }
1227 return results.AutoScale, nil
1228 }
1229
1230 // Update is API call
1231 func (o *AutoScaleOp) Update(ctx context.Context, id types.ID, param *AutoScaleUpdateRequest) (*AutoScale, error) {
1232 // build request URL
1233 pathBuildParameter := map[string]interface{}{
1234 "rootURL": SakuraCloudAPIRoot,
1235 "pathSuffix": o.PathSuffix,
1236 "pathName": o.PathName,
1237 "zone": APIDefaultZone,
1238 "id": id,
1239 "param": param,
1240 }
1241
1242 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}", pathBuildParameter)
1243 if err != nil {
1244 return nil, err
1245 }
1246 // build request body
1247 var body interface{}
1248 v, err := o.transformUpdateArgs(id, param)
1249 if err != nil {
1250 return nil, err
1251 }
1252 body = v
1253
1254 // do request
1255 data, err := o.Client.Do(ctx, "PUT", url, body)
1256 if err != nil {
1257 return nil, err
1258 }
1259
1260 // build results
1261 results, err := o.transformUpdateResults(data)
1262 if err != nil {
1263 return nil, err
1264 }
1265 return results.AutoScale, nil
1266 }
1267
1268 // UpdateSettings is API call
1269 func (o *AutoScaleOp) UpdateSettings(ctx context.Context, id types.ID, param *AutoScaleUpdateSettingsRequest) (*AutoScale, error) {
1270 // build request URL
1271 pathBuildParameter := map[string]interface{}{
1272 "rootURL": SakuraCloudAPIRoot,
1273 "pathSuffix": o.PathSuffix,
1274 "pathName": o.PathName,
1275 "zone": APIDefaultZone,
1276 "id": id,
1277 "param": param,
1278 }
1279
1280 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}", pathBuildParameter)
1281 if err != nil {
1282 return nil, err
1283 }
1284 // build request body
1285 var body interface{}
1286 v, err := o.transformUpdateSettingsArgs(id, param)
1287 if err != nil {
1288 return nil, err
1289 }
1290 body = v
1291
1292 // do request
1293 data, err := o.Client.Do(ctx, "PUT", url, body)
1294 if err != nil {
1295 return nil, err
1296 }
1297
1298 // build results
1299 results, err := o.transformUpdateSettingsResults(data)
1300 if err != nil {
1301 return nil, err
1302 }
1303 return results.AutoScale, nil
1304 }
1305
1306 // Delete is API call
1307 func (o *AutoScaleOp) Delete(ctx context.Context, id types.ID) error {
1308 // build request URL
1309 pathBuildParameter := map[string]interface{}{
1310 "rootURL": SakuraCloudAPIRoot,
1311 "pathSuffix": o.PathSuffix,
1312 "pathName": o.PathName,
1313 "zone": APIDefaultZone,
1314 "id": id,
1315 }
1316
1317 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}", pathBuildParameter)
1318 if err != nil {
1319 return err
1320 }
1321 // build request body
1322 var body interface{}
1323
1324 // do request
1325 _, err = o.Client.Do(ctx, "DELETE", url, body)
1326 if err != nil {
1327 return err
1328 }
1329
1330 // build results
1331
1332 return nil
1333 }
1334
1335 // Status is API call
1336 func (o *AutoScaleOp) Status(ctx context.Context, id types.ID) (*AutoScaleStatus, error) {
1337 // build request URL
1338 pathBuildParameter := map[string]interface{}{
1339 "rootURL": SakuraCloudAPIRoot,
1340 "pathSuffix": o.PathSuffix,
1341 "pathName": o.PathName,
1342 "zone": APIDefaultZone,
1343 "id": id,
1344 }
1345
1346 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}/autoscale/status", pathBuildParameter)
1347 if err != nil {
1348 return nil, err
1349 }
1350 // build request body
1351 var body interface{}
1352
1353 // do request
1354 data, err := o.Client.Do(ctx, "GET", url, body)
1355 if err != nil {
1356 return nil, err
1357 }
1358
1359 // build results
1360 results, err := o.transformStatusResults(data)
1361 if err != nil {
1362 return nil, err
1363 }
1364 return results.AutoScaleStatus, nil
1365 }
1366
1367 // ScaleUp is API call
1368 func (o *AutoScaleOp) ScaleUp(ctx context.Context, id types.ID) error {
1369 // build request URL
1370 pathBuildParameter := map[string]interface{}{
1371 "rootURL": SakuraCloudAPIRoot,
1372 "pathSuffix": o.PathSuffix,
1373 "pathName": o.PathName,
1374 "zone": APIDefaultZone,
1375 "id": id,
1376 }
1377
1378 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}/autoscale/up", pathBuildParameter)
1379 if err != nil {
1380 return err
1381 }
1382 // build request body
1383 var body interface{}
1384
1385 // do request
1386 _, err = o.Client.Do(ctx, "PUT", url, body)
1387 if err != nil {
1388 return err
1389 }
1390
1391 // build results
1392
1393 return nil
1394 }
1395
1396 // ScaleDown is API call
1397 func (o *AutoScaleOp) ScaleDown(ctx context.Context, id types.ID) error {
1398 // build request URL
1399 pathBuildParameter := map[string]interface{}{
1400 "rootURL": SakuraCloudAPIRoot,
1401 "pathSuffix": o.PathSuffix,
1402 "pathName": o.PathName,
1403 "zone": APIDefaultZone,
1404 "id": id,
1405 }
1406
1407 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}/autoscale/down", pathBuildParameter)
1408 if err != nil {
1409 return err
1410 }
1411 // build request body
1412 var body interface{}
1413
1414 // do request
1415 _, err = o.Client.Do(ctx, "PUT", url, body)
1416 if err != nil {
1417 return err
1418 }
1419
1420 // build results
1421
1422 return nil
1423 }
1424
1425 /*************************************************
1426 * BillOp
1427 *************************************************/
1428
1429 // BillOp implements BillAPI interface
1430 type BillOp struct {
1431 // Client APICaller
1432 Client APICaller
1433 // PathSuffix is used when building URL
1434 PathSuffix string
1435 // PathName is used when building URL
1436 PathName string
1437 }
1438
1439 // NewBillOp creates new BillOp instance
1440 func NewBillOp(caller APICaller) BillAPI {
1441 return GetClientFactoryFunc("Bill")(caller).(BillAPI)
1442 }
1443
1444 // ByContract is API call
1445 func (o *BillOp) ByContract(ctx context.Context, accountID types.ID) (*BillByContractResult, error) {
1446 // build request URL
1447 pathBuildParameter := map[string]interface{}{
1448 "rootURL": SakuraCloudAPIRoot,
1449 "pathSuffix": o.PathSuffix,
1450 "pathName": o.PathName,
1451 "zone": APIDefaultZone,
1452 "accountID": accountID,
1453 }
1454
1455 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/by-contract/{{.accountID}}", pathBuildParameter)
1456 if err != nil {
1457 return nil, err
1458 }
1459 // build request body
1460 var body interface{}
1461
1462 // do request
1463 data, err := o.Client.Do(ctx, "GET", url, body)
1464 if err != nil {
1465 return nil, err
1466 }
1467
1468 // build results
1469 results, err := o.transformByContractResults(data)
1470 if err != nil {
1471 return nil, err
1472 }
1473 return results, err
1474 }
1475
1476 // ByContractYear is API call
1477 func (o *BillOp) ByContractYear(ctx context.Context, accountID types.ID, year int) (*BillByContractYearResult, error) {
1478 // build request URL
1479 pathBuildParameter := map[string]interface{}{
1480 "rootURL": SakuraCloudAPIRoot,
1481 "pathSuffix": o.PathSuffix,
1482 "pathName": o.PathName,
1483 "zone": APIDefaultZone,
1484 "accountID": accountID,
1485 "year": year,
1486 }
1487
1488 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/by-contract/{{.accountID}}/{{.year}}", pathBuildParameter)
1489 if err != nil {
1490 return nil, err
1491 }
1492 // build request body
1493 var body interface{}
1494
1495 // do request
1496 data, err := o.Client.Do(ctx, "GET", url, body)
1497 if err != nil {
1498 return nil, err
1499 }
1500
1501 // build results
1502 results, err := o.transformByContractYearResults(data)
1503 if err != nil {
1504 return nil, err
1505 }
1506 return results, err
1507 }
1508
1509 // ByContractYearMonth is API call
1510 func (o *BillOp) ByContractYearMonth(ctx context.Context, accountID types.ID, year int, month int) (*BillByContractYearMonthResult, error) {
1511 // build request URL
1512 pathBuildParameter := map[string]interface{}{
1513 "rootURL": SakuraCloudAPIRoot,
1514 "pathSuffix": o.PathSuffix,
1515 "pathName": o.PathName,
1516 "zone": APIDefaultZone,
1517 "accountID": accountID,
1518 "year": year,
1519 "month": month,
1520 }
1521
1522 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/by-contract/{{.accountID}}/{{.year}}/{{.month}}", pathBuildParameter)
1523 if err != nil {
1524 return nil, err
1525 }
1526 // build request body
1527 var body interface{}
1528
1529 // do request
1530 data, err := o.Client.Do(ctx, "GET", url, body)
1531 if err != nil {
1532 return nil, err
1533 }
1534
1535 // build results
1536 results, err := o.transformByContractYearMonthResults(data)
1537 if err != nil {
1538 return nil, err
1539 }
1540 return results, err
1541 }
1542
1543 // Read is API call
1544 func (o *BillOp) Read(ctx context.Context, id types.ID) (*BillReadResult, error) {
1545 // build request URL
1546 pathBuildParameter := map[string]interface{}{
1547 "rootURL": SakuraCloudAPIRoot,
1548 "pathSuffix": o.PathSuffix,
1549 "pathName": o.PathName,
1550 "zone": APIDefaultZone,
1551 "id": id,
1552 }
1553
1554 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/id/{{.id}}", pathBuildParameter)
1555 if err != nil {
1556 return nil, err
1557 }
1558 // build request body
1559 var body interface{}
1560
1561 // do request
1562 data, err := o.Client.Do(ctx, "GET", url, body)
1563 if err != nil {
1564 return nil, err
1565 }
1566
1567 // build results
1568 results, err := o.transformReadResults(data)
1569 if err != nil {
1570 return nil, err
1571 }
1572 return results, err
1573 }
1574
1575 // Details is API call
1576 func (o *BillOp) Details(ctx context.Context, MemberCode string, id types.ID) (*BillDetailsResult, error) {
1577 // build request URL
1578 pathBuildParameter := map[string]interface{}{
1579 "rootURL": SakuraCloudAPIRoot,
1580 "pathSuffix": o.PathSuffix,
1581 "pathName": o.PathName,
1582 "zone": APIDefaultZone,
1583 "MemberCode": MemberCode,
1584 "id": id,
1585 }
1586
1587 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}detail/{{.MemberCode}}/{{.id}}", pathBuildParameter)
1588 if err != nil {
1589 return nil, err
1590 }
1591 // build request body
1592 var body interface{}
1593
1594 // do request
1595 data, err := o.Client.Do(ctx, "GET", url, body)
1596 if err != nil {
1597 return nil, err
1598 }
1599
1600 // build results
1601 results, err := o.transformDetailsResults(data)
1602 if err != nil {
1603 return nil, err
1604 }
1605 return results, err
1606 }
1607
1608 // DetailsCSV is API call
1609 func (o *BillOp) DetailsCSV(ctx context.Context, MemberCode string, id types.ID) (*BillDetailCSV, error) {
1610 // build request URL
1611 pathBuildParameter := map[string]interface{}{
1612 "rootURL": SakuraCloudAPIRoot,
1613 "pathSuffix": o.PathSuffix,
1614 "pathName": o.PathName,
1615 "zone": APIDefaultZone,
1616 "MemberCode": MemberCode,
1617 "id": id,
1618 }
1619
1620 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}detail/{{.MemberCode}}/{{.id}}/csv", pathBuildParameter)
1621 if err != nil {
1622 return nil, err
1623 }
1624 // build request body
1625 var body interface{}
1626
1627 // do request
1628 data, err := o.Client.Do(ctx, "GET", url, body)
1629 if err != nil {
1630 return nil, err
1631 }
1632
1633 // build results
1634 results, err := o.transformDetailsCSVResults(data)
1635 if err != nil {
1636 return nil, err
1637 }
1638 return results.BillDetailCSV, nil
1639 }
1640
1641 /*************************************************
1642 * BridgeOp
1643 *************************************************/
1644
1645 // BridgeOp implements BridgeAPI interface
1646 type BridgeOp struct {
1647 // Client APICaller
1648 Client APICaller
1649 // PathSuffix is used when building URL
1650 PathSuffix string
1651 // PathName is used when building URL
1652 PathName string
1653 }
1654
1655 // NewBridgeOp creates new BridgeOp instance
1656 func NewBridgeOp(caller APICaller) BridgeAPI {
1657 return GetClientFactoryFunc("Bridge")(caller).(BridgeAPI)
1658 }
1659
1660 // Find is API call
1661 func (o *BridgeOp) Find(ctx context.Context, zone string, conditions *FindCondition) (*BridgeFindResult, error) {
1662 // build request URL
1663 pathBuildParameter := map[string]interface{}{
1664 "rootURL": SakuraCloudAPIRoot,
1665 "pathSuffix": o.PathSuffix,
1666 "pathName": o.PathName,
1667 "zone": zone,
1668 "conditions": conditions,
1669 }
1670
1671 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}", pathBuildParameter)
1672 if err != nil {
1673 return nil, err
1674 }
1675 // build request body
1676 var body interface{}
1677 v, err := o.transformFindArgs(conditions)
1678 if err != nil {
1679 return nil, err
1680 }
1681 body = v
1682
1683 // do request
1684 data, err := o.Client.Do(ctx, "GET", url, body)
1685 if err != nil {
1686 return nil, err
1687 }
1688
1689 // build results
1690 results, err := o.transformFindResults(data)
1691 if err != nil {
1692 return nil, err
1693 }
1694 return results, err
1695 }
1696
1697 // Create is API call
1698 func (o *BridgeOp) Create(ctx context.Context, zone string, param *BridgeCreateRequest) (*Bridge, error) {
1699 // build request URL
1700 pathBuildParameter := map[string]interface{}{
1701 "rootURL": SakuraCloudAPIRoot,
1702 "pathSuffix": o.PathSuffix,
1703 "pathName": o.PathName,
1704 "zone": zone,
1705 "param": param,
1706 }
1707
1708 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}", pathBuildParameter)
1709 if err != nil {
1710 return nil, err
1711 }
1712 // build request body
1713 var body interface{}
1714 v, err := o.transformCreateArgs(param)
1715 if err != nil {
1716 return nil, err
1717 }
1718 body = v
1719
1720 // do request
1721 data, err := o.Client.Do(ctx, "POST", url, body)
1722 if err != nil {
1723 return nil, err
1724 }
1725
1726 // build results
1727 results, err := o.transformCreateResults(data)
1728 if err != nil {
1729 return nil, err
1730 }
1731 return results.Bridge, nil
1732 }
1733
1734 // Read is API call
1735 func (o *BridgeOp) Read(ctx context.Context, zone string, id types.ID) (*Bridge, error) {
1736 // build request URL
1737 pathBuildParameter := map[string]interface{}{
1738 "rootURL": SakuraCloudAPIRoot,
1739 "pathSuffix": o.PathSuffix,
1740 "pathName": o.PathName,
1741 "zone": zone,
1742 "id": id,
1743 }
1744
1745 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}", pathBuildParameter)
1746 if err != nil {
1747 return nil, err
1748 }
1749 // build request body
1750 var body interface{}
1751
1752 // do request
1753 data, err := o.Client.Do(ctx, "GET", url, body)
1754 if err != nil {
1755 return nil, err
1756 }
1757
1758 // build results
1759 results, err := o.transformReadResults(data)
1760 if err != nil {
1761 return nil, err
1762 }
1763 return results.Bridge, nil
1764 }
1765
1766 // Update is API call
1767 func (o *BridgeOp) Update(ctx context.Context, zone string, id types.ID, param *BridgeUpdateRequest) (*Bridge, error) {
1768 // build request URL
1769 pathBuildParameter := map[string]interface{}{
1770 "rootURL": SakuraCloudAPIRoot,
1771 "pathSuffix": o.PathSuffix,
1772 "pathName": o.PathName,
1773 "zone": zone,
1774 "id": id,
1775 "param": param,
1776 }
1777
1778 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}", pathBuildParameter)
1779 if err != nil {
1780 return nil, err
1781 }
1782 // build request body
1783 var body interface{}
1784 v, err := o.transformUpdateArgs(id, param)
1785 if err != nil {
1786 return nil, err
1787 }
1788 body = v
1789
1790 // do request
1791 data, err := o.Client.Do(ctx, "PUT", url, body)
1792 if err != nil {
1793 return nil, err
1794 }
1795
1796 // build results
1797 results, err := o.transformUpdateResults(data)
1798 if err != nil {
1799 return nil, err
1800 }
1801 return results.Bridge, nil
1802 }
1803
1804 // Delete is API call
1805 func (o *BridgeOp) Delete(ctx context.Context, zone string, id types.ID) error {
1806 // build request URL
1807 pathBuildParameter := map[string]interface{}{
1808 "rootURL": SakuraCloudAPIRoot,
1809 "pathSuffix": o.PathSuffix,
1810 "pathName": o.PathName,
1811 "zone": zone,
1812 "id": id,
1813 }
1814
1815 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}", pathBuildParameter)
1816 if err != nil {
1817 return err
1818 }
1819 // build request body
1820 var body interface{}
1821
1822 // do request
1823 _, err = o.Client.Do(ctx, "DELETE", url, body)
1824 if err != nil {
1825 return err
1826 }
1827
1828 // build results
1829
1830 return nil
1831 }
1832
1833 /*************************************************
1834 * CDROMOp
1835 *************************************************/
1836
1837 // CDROMOp implements CDROMAPI interface
1838 type CDROMOp struct {
1839 // Client APICaller
1840 Client APICaller
1841 // PathSuffix is used when building URL
1842 PathSuffix string
1843 // PathName is used when building URL
1844 PathName string
1845 }
1846
1847 // NewCDROMOp creates new CDROMOp instance
1848 func NewCDROMOp(caller APICaller) CDROMAPI {
1849 return GetClientFactoryFunc("CDROM")(caller).(CDROMAPI)
1850 }
1851
1852 // Find is API call
1853 func (o *CDROMOp) Find(ctx context.Context, zone string, conditions *FindCondition) (*CDROMFindResult, error) {
1854 // build request URL
1855 pathBuildParameter := map[string]interface{}{
1856 "rootURL": SakuraCloudAPIRoot,
1857 "pathSuffix": o.PathSuffix,
1858 "pathName": o.PathName,
1859 "zone": zone,
1860 "conditions": conditions,
1861 }
1862
1863 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}", pathBuildParameter)
1864 if err != nil {
1865 return nil, err
1866 }
1867 // build request body
1868 var body interface{}
1869 v, err := o.transformFindArgs(conditions)
1870 if err != nil {
1871 return nil, err
1872 }
1873 body = v
1874
1875 // do request
1876 data, err := o.Client.Do(ctx, "GET", url, body)
1877 if err != nil {
1878 return nil, err
1879 }
1880
1881 // build results
1882 results, err := o.transformFindResults(data)
1883 if err != nil {
1884 return nil, err
1885 }
1886 return results, err
1887 }
1888
1889 // Create is API call
1890 func (o *CDROMOp) Create(ctx context.Context, zone string, param *CDROMCreateRequest) (*CDROM, *FTPServer, error) {
1891 // build request URL
1892 pathBuildParameter := map[string]interface{}{
1893 "rootURL": SakuraCloudAPIRoot,
1894 "pathSuffix": o.PathSuffix,
1895 "pathName": o.PathName,
1896 "zone": zone,
1897 "param": param,
1898 }
1899
1900 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}", pathBuildParameter)
1901 if err != nil {
1902 return nil, nil, err
1903 }
1904 // build request body
1905 var body interface{}
1906 v, err := o.transformCreateArgs(param)
1907 if err != nil {
1908 return nil, nil, err
1909 }
1910 body = v
1911
1912 // do request
1913 data, err := o.Client.Do(ctx, "POST", url, body)
1914 if err != nil {
1915 return nil, nil, err
1916 }
1917
1918 // build results
1919 results, err := o.transformCreateResults(data)
1920 if err != nil {
1921 return nil, nil, err
1922 }
1923 return results.CDROM, results.FTPServer, nil
1924 }
1925
1926 // Read is API call
1927 func (o *CDROMOp) Read(ctx context.Context, zone string, id types.ID) (*CDROM, error) {
1928 // build request URL
1929 pathBuildParameter := map[string]interface{}{
1930 "rootURL": SakuraCloudAPIRoot,
1931 "pathSuffix": o.PathSuffix,
1932 "pathName": o.PathName,
1933 "zone": zone,
1934 "id": id,
1935 }
1936
1937 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}", pathBuildParameter)
1938 if err != nil {
1939 return nil, err
1940 }
1941 // build request body
1942 var body interface{}
1943
1944 // do request
1945 data, err := o.Client.Do(ctx, "GET", url, body)
1946 if err != nil {
1947 return nil, err
1948 }
1949
1950 // build results
1951 results, err := o.transformReadResults(data)
1952 if err != nil {
1953 return nil, err
1954 }
1955 return results.CDROM, nil
1956 }
1957
1958 // Update is API call
1959 func (o *CDROMOp) Update(ctx context.Context, zone string, id types.ID, param *CDROMUpdateRequest) (*CDROM, error) {
1960 // build request URL
1961 pathBuildParameter := map[string]interface{}{
1962 "rootURL": SakuraCloudAPIRoot,
1963 "pathSuffix": o.PathSuffix,
1964 "pathName": o.PathName,
1965 "zone": zone,
1966 "id": id,
1967 "param": param,
1968 }
1969
1970 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}", pathBuildParameter)
1971 if err != nil {
1972 return nil, err
1973 }
1974 // build request body
1975 var body interface{}
1976 v, err := o.transformUpdateArgs(id, param)
1977 if err != nil {
1978 return nil, err
1979 }
1980 body = v
1981
1982 // do request
1983 data, err := o.Client.Do(ctx, "PUT", url, body)
1984 if err != nil {
1985 return nil, err
1986 }
1987
1988 // build results
1989 results, err := o.transformUpdateResults(data)
1990 if err != nil {
1991 return nil, err
1992 }
1993 return results.CDROM, nil
1994 }
1995
1996 // Delete is API call
1997 func (o *CDROMOp) Delete(ctx context.Context, zone string, id types.ID) error {
1998 // build request URL
1999 pathBuildParameter := map[string]interface{}{
2000 "rootURL": SakuraCloudAPIRoot,
2001 "pathSuffix": o.PathSuffix,
2002 "pathName": o.PathName,
2003 "zone": zone,
2004 "id": id,
2005 }
2006
2007 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}", pathBuildParameter)
2008 if err != nil {
2009 return err
2010 }
2011 // build request body
2012 var body interface{}
2013
2014 // do request
2015 _, err = o.Client.Do(ctx, "DELETE", url, body)
2016 if err != nil {
2017 return err
2018 }
2019
2020 // build results
2021
2022 return nil
2023 }
2024
2025 // OpenFTP is API call
2026 func (o *CDROMOp) OpenFTP(ctx context.Context, zone string, id types.ID, openOption *OpenFTPRequest) (*FTPServer, error) {
2027 // build request URL
2028 pathBuildParameter := map[string]interface{}{
2029 "rootURL": SakuraCloudAPIRoot,
2030 "pathSuffix": o.PathSuffix,
2031 "pathName": o.PathName,
2032 "zone": zone,
2033 "id": id,
2034 "openOption": openOption,
2035 }
2036
2037 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}/ftp", pathBuildParameter)
2038 if err != nil {
2039 return nil, err
2040 }
2041 // build request body
2042 var body interface{}
2043 v, err := o.transformOpenFTPArgs(id, openOption)
2044 if err != nil {
2045 return nil, err
2046 }
2047 body = v
2048
2049 // do request
2050 data, err := o.Client.Do(ctx, "PUT", url, body)
2051 if err != nil {
2052 return nil, err
2053 }
2054
2055 // build results
2056 results, err := o.transformOpenFTPResults(data)
2057 if err != nil {
2058 return nil, err
2059 }
2060 return results.FTPServer, nil
2061 }
2062
2063 // CloseFTP is API call
2064 func (o *CDROMOp) CloseFTP(ctx context.Context, zone string, id types.ID) error {
2065 // build request URL
2066 pathBuildParameter := map[string]interface{}{
2067 "rootURL": SakuraCloudAPIRoot,
2068 "pathSuffix": o.PathSuffix,
2069 "pathName": o.PathName,
2070 "zone": zone,
2071 "id": id,
2072 }
2073
2074 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}/ftp", pathBuildParameter)
2075 if err != nil {
2076 return err
2077 }
2078 // build request body
2079 var body interface{}
2080
2081 // do request
2082 _, err = o.Client.Do(ctx, "DELETE", url, body)
2083 if err != nil {
2084 return err
2085 }
2086
2087 // build results
2088
2089 return nil
2090 }
2091
2092 /*************************************************
2093 * CertificateAuthorityOp
2094 *************************************************/
2095
2096 // CertificateAuthorityOp implements CertificateAuthorityAPI interface
2097 type CertificateAuthorityOp struct {
2098 // Client APICaller
2099 Client APICaller
2100 // PathSuffix is used when building URL
2101 PathSuffix string
2102 // PathName is used when building URL
2103 PathName string
2104 }
2105
2106 // NewCertificateAuthorityOp creates new CertificateAuthorityOp instance
2107 func NewCertificateAuthorityOp(caller APICaller) CertificateAuthorityAPI {
2108 return GetClientFactoryFunc("CertificateAuthority")(caller).(CertificateAuthorityAPI)
2109 }
2110
2111 // Find is API call
2112 func (o *CertificateAuthorityOp) Find(ctx context.Context, conditions *FindCondition) (*CertificateAuthorityFindResult, error) {
2113 // build request URL
2114 pathBuildParameter := map[string]interface{}{
2115 "rootURL": SakuraCloudAPIRoot,
2116 "pathSuffix": o.PathSuffix,
2117 "pathName": o.PathName,
2118 "zone": APIDefaultZone,
2119 "conditions": conditions,
2120 }
2121
2122 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}", pathBuildParameter)
2123 if err != nil {
2124 return nil, err
2125 }
2126 // build request body
2127 var body interface{}
2128 v, err := o.transformFindArgs(conditions)
2129 if err != nil {
2130 return nil, err
2131 }
2132 body = v
2133
2134 // do request
2135 data, err := o.Client.Do(ctx, "GET", url, body)
2136 if err != nil {
2137 return nil, err
2138 }
2139
2140 // build results
2141 results, err := o.transformFindResults(data)
2142 if err != nil {
2143 return nil, err
2144 }
2145 return results, err
2146 }
2147
2148 // Create is API call
2149 func (o *CertificateAuthorityOp) Create(ctx context.Context, param *CertificateAuthorityCreateRequest) (*CertificateAuthority, error) {
2150 // build request URL
2151 pathBuildParameter := map[string]interface{}{
2152 "rootURL": SakuraCloudAPIRoot,
2153 "pathSuffix": o.PathSuffix,
2154 "pathName": o.PathName,
2155 "zone": APIDefaultZone,
2156 "param": param,
2157 }
2158
2159 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}", pathBuildParameter)
2160 if err != nil {
2161 return nil, err
2162 }
2163 // build request body
2164 var body interface{}
2165 v, err := o.transformCreateArgs(param)
2166 if err != nil {
2167 return nil, err
2168 }
2169 body = v
2170
2171 // do request
2172 data, err := o.Client.Do(ctx, "POST", url, body)
2173 if err != nil {
2174 return nil, err
2175 }
2176
2177 // build results
2178 results, err := o.transformCreateResults(data)
2179 if err != nil {
2180 return nil, err
2181 }
2182 return results.CertificateAuthority, nil
2183 }
2184
2185 // Read is API call
2186 func (o *CertificateAuthorityOp) Read(ctx context.Context, id types.ID) (*CertificateAuthority, error) {
2187 // build request URL
2188 pathBuildParameter := map[string]interface{}{
2189 "rootURL": SakuraCloudAPIRoot,
2190 "pathSuffix": o.PathSuffix,
2191 "pathName": o.PathName,
2192 "zone": APIDefaultZone,
2193 "id": id,
2194 }
2195
2196 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}", pathBuildParameter)
2197 if err != nil {
2198 return nil, err
2199 }
2200 // build request body
2201 var body interface{}
2202
2203 // do request
2204 data, err := o.Client.Do(ctx, "GET", url, body)
2205 if err != nil {
2206 return nil, err
2207 }
2208
2209 // build results
2210 results, err := o.transformReadResults(data)
2211 if err != nil {
2212 return nil, err
2213 }
2214 return results.CertificateAuthority, nil
2215 }
2216
2217 // Update is API call
2218 func (o *CertificateAuthorityOp) Update(ctx context.Context, id types.ID, param *CertificateAuthorityUpdateRequest) (*CertificateAuthority, error) {
2219 // build request URL
2220 pathBuildParameter := map[string]interface{}{
2221 "rootURL": SakuraCloudAPIRoot,
2222 "pathSuffix": o.PathSuffix,
2223 "pathName": o.PathName,
2224 "zone": APIDefaultZone,
2225 "id": id,
2226 "param": param,
2227 }
2228
2229 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}", pathBuildParameter)
2230 if err != nil {
2231 return nil, err
2232 }
2233 // build request body
2234 var body interface{}
2235 v, err := o.transformUpdateArgs(id, param)
2236 if err != nil {
2237 return nil, err
2238 }
2239 body = v
2240
2241 // do request
2242 data, err := o.Client.Do(ctx, "PUT", url, body)
2243 if err != nil {
2244 return nil, err
2245 }
2246
2247 // build results
2248 results, err := o.transformUpdateResults(data)
2249 if err != nil {
2250 return nil, err
2251 }
2252 return results.CertificateAuthority, nil
2253 }
2254
2255 // Delete is API call
2256 func (o *CertificateAuthorityOp) Delete(ctx context.Context, id types.ID) error {
2257 // build request URL
2258 pathBuildParameter := map[string]interface{}{
2259 "rootURL": SakuraCloudAPIRoot,
2260 "pathSuffix": o.PathSuffix,
2261 "pathName": o.PathName,
2262 "zone": APIDefaultZone,
2263 "id": id,
2264 }
2265
2266 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}", pathBuildParameter)
2267 if err != nil {
2268 return err
2269 }
2270 // build request body
2271 var body interface{}
2272
2273 // do request
2274 _, err = o.Client.Do(ctx, "DELETE", url, body)
2275 if err != nil {
2276 return err
2277 }
2278
2279 // build results
2280
2281 return nil
2282 }
2283
2284 // Detail is API call
2285 func (o *CertificateAuthorityOp) Detail(ctx context.Context, id types.ID) (*CertificateAuthorityDetail, error) {
2286 // build request URL
2287 pathBuildParameter := map[string]interface{}{
2288 "rootURL": SakuraCloudAPIRoot,
2289 "pathSuffix": o.PathSuffix,
2290 "pathName": o.PathName,
2291 "zone": APIDefaultZone,
2292 "id": id,
2293 }
2294
2295 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}/certificateauthority", pathBuildParameter)
2296 if err != nil {
2297 return nil, err
2298 }
2299 // build request body
2300 var body interface{}
2301
2302 // do request
2303 data, err := o.Client.Do(ctx, "GET", url, body)
2304 if err != nil {
2305 return nil, err
2306 }
2307
2308 // build results
2309 results, err := o.transformDetailResults(data)
2310 if err != nil {
2311 return nil, err
2312 }
2313 return results.CertificateAuthority, nil
2314 }
2315
2316 // AddClient is API call
2317 func (o *CertificateAuthorityOp) AddClient(ctx context.Context, id types.ID, param *CertificateAuthorityAddClientParam) (*CertificateAuthorityAddClientOrServerResult, error) {
2318 // build request URL
2319 pathBuildParameter := map[string]interface{}{
2320 "rootURL": SakuraCloudAPIRoot,
2321 "pathSuffix": o.PathSuffix,
2322 "pathName": o.PathName,
2323 "zone": APIDefaultZone,
2324 "id": id,
2325 "param": param,
2326 }
2327
2328 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}/certificateauthority/clients", pathBuildParameter)
2329 if err != nil {
2330 return nil, err
2331 }
2332 // build request body
2333 var body interface{}
2334 v, err := o.transformAddClientArgs(id, param)
2335 if err != nil {
2336 return nil, err
2337 }
2338 body = v
2339
2340 // do request
2341 data, err := o.Client.Do(ctx, "POST", url, body)
2342 if err != nil {
2343 return nil, err
2344 }
2345
2346 // build results
2347 results, err := o.transformAddClientResults(data)
2348 if err != nil {
2349 return nil, err
2350 }
2351 return results.CertificateAuthority, nil
2352 }
2353
2354 // ListClients is API call
2355 func (o *CertificateAuthorityOp) ListClients(ctx context.Context, id types.ID) (*CertificateAuthorityListClientsResult, error) {
2356 // build request URL
2357 pathBuildParameter := map[string]interface{}{
2358 "rootURL": SakuraCloudAPIRoot,
2359 "pathSuffix": o.PathSuffix,
2360 "pathName": o.PathName,
2361 "zone": APIDefaultZone,
2362 "id": id,
2363 }
2364
2365 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}/certificateauthority/clients", pathBuildParameter)
2366 if err != nil {
2367 return nil, err
2368 }
2369 // build request body
2370 var body interface{}
2371
2372 // do request
2373 data, err := o.Client.Do(ctx, "GET", url, body)
2374 if err != nil {
2375 return nil, err
2376 }
2377
2378 // build results
2379 results, err := o.transformListClientsResults(data)
2380 if err != nil {
2381 return nil, err
2382 }
2383 return results, err
2384 }
2385
2386 // ReadClient is API call
2387 func (o *CertificateAuthorityOp) ReadClient(ctx context.Context, id types.ID, clientID string) (*CertificateAuthorityClient, error) {
2388 // build request URL
2389 pathBuildParameter := map[string]interface{}{
2390 "rootURL": SakuraCloudAPIRoot,
2391 "pathSuffix": o.PathSuffix,
2392 "pathName": o.PathName,
2393 "zone": APIDefaultZone,
2394 "id": id,
2395 "clientID": clientID,
2396 }
2397
2398 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}/certificateauthority/clients/{{.clientID}}", pathBuildParameter)
2399 if err != nil {
2400 return nil, err
2401 }
2402 // build request body
2403 var body interface{}
2404
2405 // do request
2406 data, err := o.Client.Do(ctx, "GET", url, body)
2407 if err != nil {
2408 return nil, err
2409 }
2410
2411 // build results
2412 results, err := o.transformReadClientResults(data)
2413 if err != nil {
2414 return nil, err
2415 }
2416 return results.CertificateAuthority, nil
2417 }
2418
2419 // RevokeClient is API call
2420 func (o *CertificateAuthorityOp) RevokeClient(ctx context.Context, id types.ID, clientID string) error {
2421 // build request URL
2422 pathBuildParameter := map[string]interface{}{
2423 "rootURL": SakuraCloudAPIRoot,
2424 "pathSuffix": o.PathSuffix,
2425 "pathName": o.PathName,
2426 "zone": APIDefaultZone,
2427 "id": id,
2428 "clientID": clientID,
2429 }
2430
2431 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}/certificateauthority/clients/{{.clientID}}/revoke", pathBuildParameter)
2432 if err != nil {
2433 return err
2434 }
2435 // build request body
2436 var body interface{}
2437
2438 // do request
2439 _, err = o.Client.Do(ctx, "PUT", url, body)
2440 if err != nil {
2441 return err
2442 }
2443
2444 // build results
2445
2446 return nil
2447 }
2448
2449 // HoldClient is API call
2450 func (o *CertificateAuthorityOp) HoldClient(ctx context.Context, id types.ID, clientID string) error {
2451 // build request URL
2452 pathBuildParameter := map[string]interface{}{
2453 "rootURL": SakuraCloudAPIRoot,
2454 "pathSuffix": o.PathSuffix,
2455 "pathName": o.PathName,
2456 "zone": APIDefaultZone,
2457 "id": id,
2458 "clientID": clientID,
2459 }
2460
2461 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}/certificateauthority/clients/{{.clientID}}/hold", pathBuildParameter)
2462 if err != nil {
2463 return err
2464 }
2465 // build request body
2466 var body interface{}
2467
2468 // do request
2469 _, err = o.Client.Do(ctx, "PUT", url, body)
2470 if err != nil {
2471 return err
2472 }
2473
2474 // build results
2475
2476 return nil
2477 }
2478
2479 // ResumeClient is API call
2480 func (o *CertificateAuthorityOp) ResumeClient(ctx context.Context, id types.ID, clientID string) error {
2481 // build request URL
2482 pathBuildParameter := map[string]interface{}{
2483 "rootURL": SakuraCloudAPIRoot,
2484 "pathSuffix": o.PathSuffix,
2485 "pathName": o.PathName,
2486 "zone": APIDefaultZone,
2487 "id": id,
2488 "clientID": clientID,
2489 }
2490
2491 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}/certificateauthority/clients/{{.clientID}}/resume", pathBuildParameter)
2492 if err != nil {
2493 return err
2494 }
2495 // build request body
2496 var body interface{}
2497
2498 // do request
2499 _, err = o.Client.Do(ctx, "PUT", url, body)
2500 if err != nil {
2501 return err
2502 }
2503
2504 // build results
2505
2506 return nil
2507 }
2508
2509 // DenyClient is API call
2510 func (o *CertificateAuthorityOp) DenyClient(ctx context.Context, id types.ID, clientID string) error {
2511 // build request URL
2512 pathBuildParameter := map[string]interface{}{
2513 "rootURL": SakuraCloudAPIRoot,
2514 "pathSuffix": o.PathSuffix,
2515 "pathName": o.PathName,
2516 "zone": APIDefaultZone,
2517 "id": id,
2518 "clientID": clientID,
2519 }
2520
2521 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}/certificateauthority/clients/{{.clientID}}/deny", pathBuildParameter)
2522 if err != nil {
2523 return err
2524 }
2525 // build request body
2526 var body interface{}
2527
2528 // do request
2529 _, err = o.Client.Do(ctx, "PUT", url, body)
2530 if err != nil {
2531 return err
2532 }
2533
2534 // build results
2535
2536 return nil
2537 }
2538
2539 // AddServer is API call
2540 func (o *CertificateAuthorityOp) AddServer(ctx context.Context, id types.ID, param *CertificateAuthorityAddServerParam) (*CertificateAuthorityAddClientOrServerResult, error) {
2541 // build request URL
2542 pathBuildParameter := map[string]interface{}{
2543 "rootURL": SakuraCloudAPIRoot,
2544 "pathSuffix": o.PathSuffix,
2545 "pathName": o.PathName,
2546 "zone": APIDefaultZone,
2547 "id": id,
2548 "param": param,
2549 }
2550
2551 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}/certificateauthority/servers", pathBuildParameter)
2552 if err != nil {
2553 return nil, err
2554 }
2555 // build request body
2556 var body interface{}
2557 v, err := o.transformAddServerArgs(id, param)
2558 if err != nil {
2559 return nil, err
2560 }
2561 body = v
2562
2563 // do request
2564 data, err := o.Client.Do(ctx, "POST", url, body)
2565 if err != nil {
2566 return nil, err
2567 }
2568
2569 // build results
2570 results, err := o.transformAddServerResults(data)
2571 if err != nil {
2572 return nil, err
2573 }
2574 return results.CertificateAuthority, nil
2575 }
2576
2577 // ListServers is API call
2578 func (o *CertificateAuthorityOp) ListServers(ctx context.Context, id types.ID) (*CertificateAuthorityListServersResult, error) {
2579 // build request URL
2580 pathBuildParameter := map[string]interface{}{
2581 "rootURL": SakuraCloudAPIRoot,
2582 "pathSuffix": o.PathSuffix,
2583 "pathName": o.PathName,
2584 "zone": APIDefaultZone,
2585 "id": id,
2586 }
2587
2588 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}/certificateauthority/servers", pathBuildParameter)
2589 if err != nil {
2590 return nil, err
2591 }
2592 // build request body
2593 var body interface{}
2594
2595 // do request
2596 data, err := o.Client.Do(ctx, "GET", url, body)
2597 if err != nil {
2598 return nil, err
2599 }
2600
2601 // build results
2602 results, err := o.transformListServersResults(data)
2603 if err != nil {
2604 return nil, err
2605 }
2606 return results, err
2607 }
2608
2609 // ReadServer is API call
2610 func (o *CertificateAuthorityOp) ReadServer(ctx context.Context, id types.ID, serverID string) (*CertificateAuthorityServer, error) {
2611 // build request URL
2612 pathBuildParameter := map[string]interface{}{
2613 "rootURL": SakuraCloudAPIRoot,
2614 "pathSuffix": o.PathSuffix,
2615 "pathName": o.PathName,
2616 "zone": APIDefaultZone,
2617 "id": id,
2618 "serverID": serverID,
2619 }
2620
2621 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}/certificateauthority/servers/{{.serverID}}", pathBuildParameter)
2622 if err != nil {
2623 return nil, err
2624 }
2625 // build request body
2626 var body interface{}
2627
2628 // do request
2629 data, err := o.Client.Do(ctx, "GET", url, body)
2630 if err != nil {
2631 return nil, err
2632 }
2633
2634 // build results
2635 results, err := o.transformReadServerResults(data)
2636 if err != nil {
2637 return nil, err
2638 }
2639 return results.CertificateAuthority, nil
2640 }
2641
2642 // RevokeServer is API call
2643 func (o *CertificateAuthorityOp) RevokeServer(ctx context.Context, id types.ID, serverID string) error {
2644 // build request URL
2645 pathBuildParameter := map[string]interface{}{
2646 "rootURL": SakuraCloudAPIRoot,
2647 "pathSuffix": o.PathSuffix,
2648 "pathName": o.PathName,
2649 "zone": APIDefaultZone,
2650 "id": id,
2651 "serverID": serverID,
2652 }
2653
2654 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}/certificateauthority/servers/{{.serverID}}/revoke", pathBuildParameter)
2655 if err != nil {
2656 return err
2657 }
2658 // build request body
2659 var body interface{}
2660
2661 // do request
2662 _, err = o.Client.Do(ctx, "PUT", url, body)
2663 if err != nil {
2664 return err
2665 }
2666
2667 // build results
2668
2669 return nil
2670 }
2671
2672 // HoldServer is API call
2673 func (o *CertificateAuthorityOp) HoldServer(ctx context.Context, id types.ID, serverID string) error {
2674 // build request URL
2675 pathBuildParameter := map[string]interface{}{
2676 "rootURL": SakuraCloudAPIRoot,
2677 "pathSuffix": o.PathSuffix,
2678 "pathName": o.PathName,
2679 "zone": APIDefaultZone,
2680 "id": id,
2681 "serverID": serverID,
2682 }
2683
2684 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}/certificateauthority/servers/{{.serverID}}/hold", pathBuildParameter)
2685 if err != nil {
2686 return err
2687 }
2688 // build request body
2689 var body interface{}
2690
2691 // do request
2692 _, err = o.Client.Do(ctx, "PUT", url, body)
2693 if err != nil {
2694 return err
2695 }
2696
2697 // build results
2698
2699 return nil
2700 }
2701
2702 // ResumeServer is API call
2703 func (o *CertificateAuthorityOp) ResumeServer(ctx context.Context, id types.ID, serverID string) error {
2704 // build request URL
2705 pathBuildParameter := map[string]interface{}{
2706 "rootURL": SakuraCloudAPIRoot,
2707 "pathSuffix": o.PathSuffix,
2708 "pathName": o.PathName,
2709 "zone": APIDefaultZone,
2710 "id": id,
2711 "serverID": serverID,
2712 }
2713
2714 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}/certificateauthority/servers/{{.serverID}}/resume", pathBuildParameter)
2715 if err != nil {
2716 return err
2717 }
2718 // build request body
2719 var body interface{}
2720
2721 // do request
2722 _, err = o.Client.Do(ctx, "PUT", url, body)
2723 if err != nil {
2724 return err
2725 }
2726
2727 // build results
2728
2729 return nil
2730 }
2731
2732 /*************************************************
2733 * ContainerRegistryOp
2734 *************************************************/
2735
2736 // ContainerRegistryOp implements ContainerRegistryAPI interface
2737 type ContainerRegistryOp struct {
2738 // Client APICaller
2739 Client APICaller
2740 // PathSuffix is used when building URL
2741 PathSuffix string
2742 // PathName is used when building URL
2743 PathName string
2744 }
2745
2746 // NewContainerRegistryOp creates new ContainerRegistryOp instance
2747 func NewContainerRegistryOp(caller APICaller) ContainerRegistryAPI {
2748 return GetClientFactoryFunc("ContainerRegistry")(caller).(ContainerRegistryAPI)
2749 }
2750
2751 // Find is API call
2752 func (o *ContainerRegistryOp) Find(ctx context.Context, conditions *FindCondition) (*ContainerRegistryFindResult, error) {
2753 // build request URL
2754 pathBuildParameter := map[string]interface{}{
2755 "rootURL": SakuraCloudAPIRoot,
2756 "pathSuffix": o.PathSuffix,
2757 "pathName": o.PathName,
2758 "zone": APIDefaultZone,
2759 "conditions": conditions,
2760 }
2761
2762 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}", pathBuildParameter)
2763 if err != nil {
2764 return nil, err
2765 }
2766 // build request body
2767 var body interface{}
2768 v, err := o.transformFindArgs(conditions)
2769 if err != nil {
2770 return nil, err
2771 }
2772 body = v
2773
2774 // do request
2775 data, err := o.Client.Do(ctx, "GET", url, body)
2776 if err != nil {
2777 return nil, err
2778 }
2779
2780 // build results
2781 results, err := o.transformFindResults(data)
2782 if err != nil {
2783 return nil, err
2784 }
2785 return results, err
2786 }
2787
2788 // Create is API call
2789 func (o *ContainerRegistryOp) Create(ctx context.Context, param *ContainerRegistryCreateRequest) (*ContainerRegistry, error) {
2790 // build request URL
2791 pathBuildParameter := map[string]interface{}{
2792 "rootURL": SakuraCloudAPIRoot,
2793 "pathSuffix": o.PathSuffix,
2794 "pathName": o.PathName,
2795 "zone": APIDefaultZone,
2796 "param": param,
2797 }
2798
2799 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}", pathBuildParameter)
2800 if err != nil {
2801 return nil, err
2802 }
2803 // build request body
2804 var body interface{}
2805 v, err := o.transformCreateArgs(param)
2806 if err != nil {
2807 return nil, err
2808 }
2809 body = v
2810
2811 // do request
2812 data, err := o.Client.Do(ctx, "POST", url, body)
2813 if err != nil {
2814 return nil, err
2815 }
2816
2817 // build results
2818 results, err := o.transformCreateResults(data)
2819 if err != nil {
2820 return nil, err
2821 }
2822 return results.ContainerRegistry, nil
2823 }
2824
2825 // Read is API call
2826 func (o *ContainerRegistryOp) Read(ctx context.Context, id types.ID) (*ContainerRegistry, error) {
2827 // build request URL
2828 pathBuildParameter := map[string]interface{}{
2829 "rootURL": SakuraCloudAPIRoot,
2830 "pathSuffix": o.PathSuffix,
2831 "pathName": o.PathName,
2832 "zone": APIDefaultZone,
2833 "id": id,
2834 }
2835
2836 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}", pathBuildParameter)
2837 if err != nil {
2838 return nil, err
2839 }
2840 // build request body
2841 var body interface{}
2842
2843 // do request
2844 data, err := o.Client.Do(ctx, "GET", url, body)
2845 if err != nil {
2846 return nil, err
2847 }
2848
2849 // build results
2850 results, err := o.transformReadResults(data)
2851 if err != nil {
2852 return nil, err
2853 }
2854 return results.ContainerRegistry, nil
2855 }
2856
2857 // Update is API call
2858 func (o *ContainerRegistryOp) Update(ctx context.Context, id types.ID, param *ContainerRegistryUpdateRequest) (*ContainerRegistry, error) {
2859 // build request URL
2860 pathBuildParameter := map[string]interface{}{
2861 "rootURL": SakuraCloudAPIRoot,
2862 "pathSuffix": o.PathSuffix,
2863 "pathName": o.PathName,
2864 "zone": APIDefaultZone,
2865 "id": id,
2866 "param": param,
2867 }
2868
2869 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}", pathBuildParameter)
2870 if err != nil {
2871 return nil, err
2872 }
2873 // build request body
2874 var body interface{}
2875 v, err := o.transformUpdateArgs(id, param)
2876 if err != nil {
2877 return nil, err
2878 }
2879 body = v
2880
2881 // do request
2882 data, err := o.Client.Do(ctx, "PUT", url, body)
2883 if err != nil {
2884 return nil, err
2885 }
2886
2887 // build results
2888 results, err := o.transformUpdateResults(data)
2889 if err != nil {
2890 return nil, err
2891 }
2892 return results.ContainerRegistry, nil
2893 }
2894
2895 // UpdateSettings is API call
2896 func (o *ContainerRegistryOp) UpdateSettings(ctx context.Context, id types.ID, param *ContainerRegistryUpdateSettingsRequest) (*ContainerRegistry, error) {
2897 // build request URL
2898 pathBuildParameter := map[string]interface{}{
2899 "rootURL": SakuraCloudAPIRoot,
2900 "pathSuffix": o.PathSuffix,
2901 "pathName": o.PathName,
2902 "zone": APIDefaultZone,
2903 "id": id,
2904 "param": param,
2905 }
2906
2907 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}", pathBuildParameter)
2908 if err != nil {
2909 return nil, err
2910 }
2911 // build request body
2912 var body interface{}
2913 v, err := o.transformUpdateSettingsArgs(id, param)
2914 if err != nil {
2915 return nil, err
2916 }
2917 body = v
2918
2919 // do request
2920 data, err := o.Client.Do(ctx, "PUT", url, body)
2921 if err != nil {
2922 return nil, err
2923 }
2924
2925 // build results
2926 results, err := o.transformUpdateSettingsResults(data)
2927 if err != nil {
2928 return nil, err
2929 }
2930 return results.ContainerRegistry, nil
2931 }
2932
2933 // Delete is API call
2934 func (o *ContainerRegistryOp) Delete(ctx context.Context, id types.ID) error {
2935 // build request URL
2936 pathBuildParameter := map[string]interface{}{
2937 "rootURL": SakuraCloudAPIRoot,
2938 "pathSuffix": o.PathSuffix,
2939 "pathName": o.PathName,
2940 "zone": APIDefaultZone,
2941 "id": id,
2942 }
2943
2944 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}", pathBuildParameter)
2945 if err != nil {
2946 return err
2947 }
2948 // build request body
2949 var body interface{}
2950
2951 // do request
2952 _, err = o.Client.Do(ctx, "DELETE", url, body)
2953 if err != nil {
2954 return err
2955 }
2956
2957 // build results
2958
2959 return nil
2960 }
2961
2962 // ListUsers is API call
2963 func (o *ContainerRegistryOp) ListUsers(ctx context.Context, id types.ID) (*ContainerRegistryUsers, error) {
2964 // build request URL
2965 pathBuildParameter := map[string]interface{}{
2966 "rootURL": SakuraCloudAPIRoot,
2967 "pathSuffix": o.PathSuffix,
2968 "pathName": o.PathName,
2969 "zone": APIDefaultZone,
2970 "id": id,
2971 }
2972
2973 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}/containerregistry/users", pathBuildParameter)
2974 if err != nil {
2975 return nil, err
2976 }
2977 // build request body
2978 var body interface{}
2979
2980 // do request
2981 data, err := o.Client.Do(ctx, "GET", url, body)
2982 if err != nil {
2983 return nil, err
2984 }
2985
2986 // build results
2987 results, err := o.transformListUsersResults(data)
2988 if err != nil {
2989 return nil, err
2990 }
2991 return results.ContainerRegistryUsers, nil
2992 }
2993
2994 // AddUser is API call
2995 func (o *ContainerRegistryOp) AddUser(ctx context.Context, id types.ID, param *ContainerRegistryUserCreateRequest) error {
2996 // build request URL
2997 pathBuildParameter := map[string]interface{}{
2998 "rootURL": SakuraCloudAPIRoot,
2999 "pathSuffix": o.PathSuffix,
3000 "pathName": o.PathName,
3001 "zone": APIDefaultZone,
3002 "id": id,
3003 "param": param,
3004 }
3005
3006 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}/containerregistry/users", pathBuildParameter)
3007 if err != nil {
3008 return err
3009 }
3010 // build request body
3011 var body interface{}
3012 v, err := o.transformAddUserArgs(id, param)
3013 if err != nil {
3014 return err
3015 }
3016 body = v
3017
3018 // do request
3019 _, err = o.Client.Do(ctx, "POST", url, body)
3020 if err != nil {
3021 return err
3022 }
3023
3024 // build results
3025
3026 return nil
3027 }
3028
3029 // UpdateUser is API call
3030 func (o *ContainerRegistryOp) UpdateUser(ctx context.Context, id types.ID, username string, param *ContainerRegistryUserUpdateRequest) error {
3031 // build request URL
3032 pathBuildParameter := map[string]interface{}{
3033 "rootURL": SakuraCloudAPIRoot,
3034 "pathSuffix": o.PathSuffix,
3035 "pathName": o.PathName,
3036 "zone": APIDefaultZone,
3037 "id": id,
3038 "username": username,
3039 "param": param,
3040 }
3041
3042 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}/containerregistry/users/{{.username}}", pathBuildParameter)
3043 if err != nil {
3044 return err
3045 }
3046 // build request body
3047 var body interface{}
3048 v, err := o.transformUpdateUserArgs(id, username, param)
3049 if err != nil {
3050 return err
3051 }
3052 body = v
3053
3054 // do request
3055 _, err = o.Client.Do(ctx, "PUT", url, body)
3056 if err != nil {
3057 return err
3058 }
3059
3060 // build results
3061
3062 return nil
3063 }
3064
3065 // DeleteUser is API call
3066 func (o *ContainerRegistryOp) DeleteUser(ctx context.Context, id types.ID, username string) error {
3067 // build request URL
3068 pathBuildParameter := map[string]interface{}{
3069 "rootURL": SakuraCloudAPIRoot,
3070 "pathSuffix": o.PathSuffix,
3071 "pathName": o.PathName,
3072 "zone": APIDefaultZone,
3073 "id": id,
3074 "username": username,
3075 }
3076
3077 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}/containerregistry/users/{{.username}}", pathBuildParameter)
3078 if err != nil {
3079 return err
3080 }
3081 // build request body
3082 var body interface{}
3083
3084 // do request
3085 _, err = o.Client.Do(ctx, "DELETE", url, body)
3086 if err != nil {
3087 return err
3088 }
3089
3090 // build results
3091
3092 return nil
3093 }
3094
3095 /*************************************************
3096 * CouponOp
3097 *************************************************/
3098
3099 // CouponOp implements CouponAPI interface
3100 type CouponOp struct {
3101 // Client APICaller
3102 Client APICaller
3103 // PathSuffix is used when building URL
3104 PathSuffix string
3105 // PathName is used when building URL
3106 PathName string
3107 }
3108
3109 // NewCouponOp creates new CouponOp instance
3110 func NewCouponOp(caller APICaller) CouponAPI {
3111 return GetClientFactoryFunc("Coupon")(caller).(CouponAPI)
3112 }
3113
3114 // Find is API call
3115 func (o *CouponOp) Find(ctx context.Context, accountID types.ID) (*CouponFindResult, error) {
3116 // build request URL
3117 pathBuildParameter := map[string]interface{}{
3118 "rootURL": SakuraCloudAPIRoot,
3119 "pathSuffix": o.PathSuffix,
3120 "pathName": o.PathName,
3121 "zone": APIDefaultZone,
3122 "accountID": accountID,
3123 }
3124
3125 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.accountID}}", pathBuildParameter)
3126 if err != nil {
3127 return nil, err
3128 }
3129 // build request body
3130 var body interface{}
3131
3132 // do request
3133 data, err := o.Client.Do(ctx, "GET", url, body)
3134 if err != nil {
3135 return nil, err
3136 }
3137
3138 // build results
3139 results, err := o.transformFindResults(data)
3140 if err != nil {
3141 return nil, err
3142 }
3143 return results, err
3144 }
3145
3146 /*************************************************
3147 * DatabaseOp
3148 *************************************************/
3149
3150 // DatabaseOp implements DatabaseAPI interface
3151 type DatabaseOp struct {
3152 // Client APICaller
3153 Client APICaller
3154 // PathSuffix is used when building URL
3155 PathSuffix string
3156 // PathName is used when building URL
3157 PathName string
3158 }
3159
3160 // NewDatabaseOp creates new DatabaseOp instance
3161 func NewDatabaseOp(caller APICaller) DatabaseAPI {
3162 return GetClientFactoryFunc("Database")(caller).(DatabaseAPI)
3163 }
3164
3165 // Find is API call
3166 func (o *DatabaseOp) Find(ctx context.Context, zone string, conditions *FindCondition) (*DatabaseFindResult, error) {
3167 // build request URL
3168 pathBuildParameter := map[string]interface{}{
3169 "rootURL": SakuraCloudAPIRoot,
3170 "pathSuffix": o.PathSuffix,
3171 "pathName": o.PathName,
3172 "zone": zone,
3173 "conditions": conditions,
3174 }
3175
3176 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}", pathBuildParameter)
3177 if err != nil {
3178 return nil, err
3179 }
3180 // build request body
3181 var body interface{}
3182 v, err := o.transformFindArgs(conditions)
3183 if err != nil {
3184 return nil, err
3185 }
3186 body = v
3187
3188 // do request
3189 data, err := o.Client.Do(ctx, "GET", url, body)
3190 if err != nil {
3191 return nil, err
3192 }
3193
3194 // build results
3195 results, err := o.transformFindResults(data)
3196 if err != nil {
3197 return nil, err
3198 }
3199 return results, err
3200 }
3201
3202 // Create is API call
3203 func (o *DatabaseOp) Create(ctx context.Context, zone string, param *DatabaseCreateRequest) (*Database, error) {
3204 // build request URL
3205 pathBuildParameter := map[string]interface{}{
3206 "rootURL": SakuraCloudAPIRoot,
3207 "pathSuffix": o.PathSuffix,
3208 "pathName": o.PathName,
3209 "zone": zone,
3210 "param": param,
3211 }
3212
3213 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}", pathBuildParameter)
3214 if err != nil {
3215 return nil, err
3216 }
3217 // build request body
3218 var body interface{}
3219 v, err := o.transformCreateArgs(param)
3220 if err != nil {
3221 return nil, err
3222 }
3223 body = v
3224
3225 // do request
3226 data, err := o.Client.Do(ctx, "POST", url, body)
3227 if err != nil {
3228 return nil, err
3229 }
3230
3231 // build results
3232 results, err := o.transformCreateResults(data)
3233 if err != nil {
3234 return nil, err
3235 }
3236 return results.Database, nil
3237 }
3238
3239 // Read is API call
3240 func (o *DatabaseOp) Read(ctx context.Context, zone string, id types.ID) (*Database, error) {
3241 // build request URL
3242 pathBuildParameter := map[string]interface{}{
3243 "rootURL": SakuraCloudAPIRoot,
3244 "pathSuffix": o.PathSuffix,
3245 "pathName": o.PathName,
3246 "zone": zone,
3247 "id": id,
3248 }
3249
3250 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}", pathBuildParameter)
3251 if err != nil {
3252 return nil, err
3253 }
3254 // build request body
3255 var body interface{}
3256
3257 // do request
3258 data, err := o.Client.Do(ctx, "GET", url, body)
3259 if err != nil {
3260 return nil, err
3261 }
3262
3263 // build results
3264 results, err := o.transformReadResults(data)
3265 if err != nil {
3266 return nil, err
3267 }
3268 return results.Database, nil
3269 }
3270
3271 // Update is API call
3272 func (o *DatabaseOp) Update(ctx context.Context, zone string, id types.ID, param *DatabaseUpdateRequest) (*Database, error) {
3273 // build request URL
3274 pathBuildParameter := map[string]interface{}{
3275 "rootURL": SakuraCloudAPIRoot,
3276 "pathSuffix": o.PathSuffix,
3277 "pathName": o.PathName,
3278 "zone": zone,
3279 "id": id,
3280 "param": param,
3281 }
3282
3283 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}", pathBuildParameter)
3284 if err != nil {
3285 return nil, err
3286 }
3287 // build request body
3288 var body interface{}
3289 v, err := o.transformUpdateArgs(id, param)
3290 if err != nil {
3291 return nil, err
3292 }
3293 body = v
3294
3295 // do request
3296 data, err := o.Client.Do(ctx, "PUT", url, body)
3297 if err != nil {
3298 return nil, err
3299 }
3300
3301 // build results
3302 results, err := o.transformUpdateResults(data)
3303 if err != nil {
3304 return nil, err
3305 }
3306 return results.Database, nil
3307 }
3308
3309 // UpdateSettings is API call
3310 func (o *DatabaseOp) UpdateSettings(ctx context.Context, zone string, id types.ID, param *DatabaseUpdateSettingsRequest) (*Database, error) {
3311 // build request URL
3312 pathBuildParameter := map[string]interface{}{
3313 "rootURL": SakuraCloudAPIRoot,
3314 "pathSuffix": o.PathSuffix,
3315 "pathName": o.PathName,
3316 "zone": zone,
3317 "id": id,
3318 "param": param,
3319 }
3320
3321 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}", pathBuildParameter)
3322 if err != nil {
3323 return nil, err
3324 }
3325 // build request body
3326 var body interface{}
3327 v, err := o.transformUpdateSettingsArgs(id, param)
3328 if err != nil {
3329 return nil, err
3330 }
3331 body = v
3332
3333 // do request
3334 data, err := o.Client.Do(ctx, "PUT", url, body)
3335 if err != nil {
3336 return nil, err
3337 }
3338
3339 // build results
3340 results, err := o.transformUpdateSettingsResults(data)
3341 if err != nil {
3342 return nil, err
3343 }
3344 return results.Database, nil
3345 }
3346
3347 // Delete is API call
3348 func (o *DatabaseOp) Delete(ctx context.Context, zone string, id types.ID) error {
3349 // build request URL
3350 pathBuildParameter := map[string]interface{}{
3351 "rootURL": SakuraCloudAPIRoot,
3352 "pathSuffix": o.PathSuffix,
3353 "pathName": o.PathName,
3354 "zone": zone,
3355 "id": id,
3356 }
3357
3358 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}", pathBuildParameter)
3359 if err != nil {
3360 return err
3361 }
3362 // build request body
3363 var body interface{}
3364
3365 // do request
3366 _, err = o.Client.Do(ctx, "DELETE", url, body)
3367 if err != nil {
3368 return err
3369 }
3370
3371 // build results
3372
3373 return nil
3374 }
3375
3376 // Config is API call
3377 func (o *DatabaseOp) Config(ctx context.Context, zone string, id types.ID) error {
3378 // build request URL
3379 pathBuildParameter := map[string]interface{}{
3380 "rootURL": SakuraCloudAPIRoot,
3381 "pathSuffix": o.PathSuffix,
3382 "pathName": o.PathName,
3383 "zone": zone,
3384 "id": id,
3385 }
3386
3387 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}/config", pathBuildParameter)
3388 if err != nil {
3389 return err
3390 }
3391 // build request body
3392 var body interface{}
3393
3394 // do request
3395 _, err = o.Client.Do(ctx, "PUT", url, body)
3396 if err != nil {
3397 return err
3398 }
3399
3400 // build results
3401
3402 return nil
3403 }
3404
3405 // Boot is API call
3406 func (o *DatabaseOp) Boot(ctx context.Context, zone string, id types.ID) error {
3407 // build request URL
3408 pathBuildParameter := map[string]interface{}{
3409 "rootURL": SakuraCloudAPIRoot,
3410 "pathSuffix": o.PathSuffix,
3411 "pathName": o.PathName,
3412 "zone": zone,
3413 "id": id,
3414 }
3415
3416 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}/power", pathBuildParameter)
3417 if err != nil {
3418 return err
3419 }
3420 lockKey, err := buildURL("GlobalLock", pathBuildParameter)
3421 if err != nil {
3422 return err
3423 }
3424 apiLocker.Lock(lockKey)
3425 defer apiLocker.Unlock(lockKey)
3426 // build request body
3427 var body interface{}
3428
3429 // do request
3430 _, err = o.Client.Do(ctx, "PUT", url, body)
3431 if err != nil {
3432 return err
3433 }
3434
3435 // build results
3436
3437 return nil
3438 }
3439
3440 // Shutdown is API call
3441 func (o *DatabaseOp) Shutdown(ctx context.Context, zone string, id types.ID, shutdownOption *ShutdownOption) error {
3442 // build request URL
3443 pathBuildParameter := map[string]interface{}{
3444 "rootURL": SakuraCloudAPIRoot,
3445 "pathSuffix": o.PathSuffix,
3446 "pathName": o.PathName,
3447 "zone": zone,
3448 "id": id,
3449 "shutdownOption": shutdownOption,
3450 }
3451
3452 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}/power", pathBuildParameter)
3453 if err != nil {
3454 return err
3455 }
3456 lockKey, err := buildURL("GlobalLock", pathBuildParameter)
3457 if err != nil {
3458 return err
3459 }
3460 apiLocker.Lock(lockKey)
3461 defer apiLocker.Unlock(lockKey)
3462 // build request body
3463 var body interface{}
3464 v, err := o.transformShutdownArgs(id, shutdownOption)
3465 if err != nil {
3466 return err
3467 }
3468 body = v
3469
3470 // do request
3471 _, err = o.Client.Do(ctx, "DELETE", url, body)
3472 if err != nil {
3473 return err
3474 }
3475
3476 // build results
3477
3478 return nil
3479 }
3480
3481 // Reset is API call
3482 func (o *DatabaseOp) Reset(ctx context.Context, zone string, id types.ID) error {
3483 // build request URL
3484 pathBuildParameter := map[string]interface{}{
3485 "rootURL": SakuraCloudAPIRoot,
3486 "pathSuffix": o.PathSuffix,
3487 "pathName": o.PathName,
3488 "zone": zone,
3489 "id": id,
3490 }
3491
3492 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}/reset", pathBuildParameter)
3493 if err != nil {
3494 return err
3495 }
3496 lockKey, err := buildURL("GlobalLock", pathBuildParameter)
3497 if err != nil {
3498 return err
3499 }
3500 apiLocker.Lock(lockKey)
3501 defer apiLocker.Unlock(lockKey)
3502 // build request body
3503 var body interface{}
3504
3505 // do request
3506 _, err = o.Client.Do(ctx, "PUT", url, body)
3507 if err != nil {
3508 return err
3509 }
3510
3511 // build results
3512
3513 return nil
3514 }
3515
3516 // MonitorCPU is API call
3517 func (o *DatabaseOp) MonitorCPU(ctx context.Context, zone string, id types.ID, condition *MonitorCondition) (*CPUTimeActivity, error) {
3518 // build request URL
3519 pathBuildParameter := map[string]interface{}{
3520 "rootURL": SakuraCloudAPIRoot,
3521 "pathSuffix": o.PathSuffix,
3522 "pathName": o.PathName,
3523 "zone": zone,
3524 "id": id,
3525 "condition": condition,
3526 }
3527
3528 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}/cpu/monitor", pathBuildParameter)
3529 if err != nil {
3530 return nil, err
3531 }
3532 // build request body
3533 var body interface{}
3534 v, err := o.transformMonitorCPUArgs(id, condition)
3535 if err != nil {
3536 return nil, err
3537 }
3538 body = v
3539
3540 // do request
3541 data, err := o.Client.Do(ctx, "GET", url, body)
3542 if err != nil {
3543 return nil, err
3544 }
3545
3546 // build results
3547 results, err := o.transformMonitorCPUResults(data)
3548 if err != nil {
3549 return nil, err
3550 }
3551 return results.CPUTimeActivity, nil
3552 }
3553
3554 // MonitorDisk is API call
3555 func (o *DatabaseOp) MonitorDisk(ctx context.Context, zone string, id types.ID, condition *MonitorCondition) (*DiskActivity, error) {
3556 // build request URL
3557 pathBuildParameter := map[string]interface{}{
3558 "rootURL": SakuraCloudAPIRoot,
3559 "pathSuffix": o.PathSuffix,
3560 "pathName": o.PathName,
3561 "zone": zone,
3562 "id": id,
3563 "condition": condition,
3564 }
3565
3566 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}/disk/0/monitor", pathBuildParameter)
3567 if err != nil {
3568 return nil, err
3569 }
3570 // build request body
3571 var body interface{}
3572 v, err := o.transformMonitorDiskArgs(id, condition)
3573 if err != nil {
3574 return nil, err
3575 }
3576 body = v
3577
3578 // do request
3579 data, err := o.Client.Do(ctx, "GET", url, body)
3580 if err != nil {
3581 return nil, err
3582 }
3583
3584 // build results
3585 results, err := o.transformMonitorDiskResults(data)
3586 if err != nil {
3587 return nil, err
3588 }
3589 return results.DiskActivity, nil
3590 }
3591
3592 // MonitorInterface is API call
3593 func (o *DatabaseOp) MonitorInterface(ctx context.Context, zone string, id types.ID, condition *MonitorCondition) (*InterfaceActivity, error) {
3594 // build request URL
3595 pathBuildParameter := map[string]interface{}{
3596 "rootURL": SakuraCloudAPIRoot,
3597 "pathSuffix": o.PathSuffix,
3598 "pathName": o.PathName,
3599 "zone": zone,
3600 "id": id,
3601 "condition": condition,
3602 }
3603
3604 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}/interface/monitor", pathBuildParameter)
3605 if err != nil {
3606 return nil, err
3607 }
3608 // build request body
3609 var body interface{}
3610 v, err := o.transformMonitorInterfaceArgs(id, condition)
3611 if err != nil {
3612 return nil, err
3613 }
3614 body = v
3615
3616 // do request
3617 data, err := o.Client.Do(ctx, "GET", url, body)
3618 if err != nil {
3619 return nil, err
3620 }
3621
3622 // build results
3623 results, err := o.transformMonitorInterfaceResults(data)
3624 if err != nil {
3625 return nil, err
3626 }
3627 return results.InterfaceActivity, nil
3628 }
3629
3630 // MonitorDatabase is API call
3631 func (o *DatabaseOp) MonitorDatabase(ctx context.Context, zone string, id types.ID, condition *MonitorCondition) (*DatabaseActivity, error) {
3632 // build request URL
3633 pathBuildParameter := map[string]interface{}{
3634 "rootURL": SakuraCloudAPIRoot,
3635 "pathSuffix": o.PathSuffix,
3636 "pathName": o.PathName,
3637 "zone": zone,
3638 "id": id,
3639 "condition": condition,
3640 }
3641
3642 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}/database/monitor", pathBuildParameter)
3643 if err != nil {
3644 return nil, err
3645 }
3646 // build request body
3647 var body interface{}
3648 v, err := o.transformMonitorDatabaseArgs(id, condition)
3649 if err != nil {
3650 return nil, err
3651 }
3652 body = v
3653
3654 // do request
3655 data, err := o.Client.Do(ctx, "GET", url, body)
3656 if err != nil {
3657 return nil, err
3658 }
3659
3660 // build results
3661 results, err := o.transformMonitorDatabaseResults(data)
3662 if err != nil {
3663 return nil, err
3664 }
3665 return results.DatabaseActivity, nil
3666 }
3667
3668 // Status is API call
3669 func (o *DatabaseOp) Status(ctx context.Context, zone string, id types.ID) (*DatabaseStatus, error) {
3670 // build request URL
3671 pathBuildParameter := map[string]interface{}{
3672 "rootURL": SakuraCloudAPIRoot,
3673 "pathSuffix": o.PathSuffix,
3674 "pathName": o.PathName,
3675 "zone": zone,
3676 "id": id,
3677 }
3678
3679 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}/status", pathBuildParameter)
3680 if err != nil {
3681 return nil, err
3682 }
3683 // build request body
3684 var body interface{}
3685
3686 // do request
3687 data, err := o.Client.Do(ctx, "GET", url, body)
3688 if err != nil {
3689 return nil, err
3690 }
3691
3692 // build results
3693 results, err := o.transformStatusResults(data)
3694 if err != nil {
3695 return nil, err
3696 }
3697 return results.DatabaseStatus, nil
3698 }
3699
3700 // GetParameter is API call
3701 func (o *DatabaseOp) GetParameter(ctx context.Context, zone string, id types.ID) (*DatabaseParameter, error) {
3702 // build request URL
3703 pathBuildParameter := map[string]interface{}{
3704 "rootURL": SakuraCloudAPIRoot,
3705 "pathSuffix": o.PathSuffix,
3706 "pathName": o.PathName,
3707 "zone": zone,
3708 "id": id,
3709 }
3710
3711 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}/database/parameter", pathBuildParameter)
3712 if err != nil {
3713 return nil, err
3714 }
3715 // build request body
3716 var body interface{}
3717
3718 // do request
3719 data, err := o.Client.Do(ctx, "GET", url, body)
3720 if err != nil {
3721 return nil, err
3722 }
3723
3724 // build results
3725 results, err := o.transformGetParameterResults(data)
3726 if err != nil {
3727 return nil, err
3728 }
3729 return results.DatabaseParameter, nil
3730 }
3731
3732 // SetParameter is API call
3733 func (o *DatabaseOp) SetParameter(ctx context.Context, zone string, id types.ID, param map[string]interface{}) error {
3734 // build request URL
3735 pathBuildParameter := map[string]interface{}{
3736 "rootURL": SakuraCloudAPIRoot,
3737 "pathSuffix": o.PathSuffix,
3738 "pathName": o.PathName,
3739 "zone": zone,
3740 "id": id,
3741 "param": param,
3742 }
3743
3744 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}/database/parameter", pathBuildParameter)
3745 if err != nil {
3746 return err
3747 }
3748 // build request body
3749 var body interface{}
3750 v, err := o.transformSetParameterArgs(id, param)
3751 if err != nil {
3752 return err
3753 }
3754 body = v
3755
3756 // do request
3757 _, err = o.Client.Do(ctx, "PUT", url, body)
3758 if err != nil {
3759 return err
3760 }
3761
3762 // build results
3763
3764 return nil
3765 }
3766
3767 /*************************************************
3768 * DiskOp
3769 *************************************************/
3770
3771 // DiskOp implements DiskAPI interface
3772 type DiskOp struct {
3773 // Client APICaller
3774 Client APICaller
3775 // PathSuffix is used when building URL
3776 PathSuffix string
3777 // PathName is used when building URL
3778 PathName string
3779 }
3780
3781 // NewDiskOp creates new DiskOp instance
3782 func NewDiskOp(caller APICaller) DiskAPI {
3783 return GetClientFactoryFunc("Disk")(caller).(DiskAPI)
3784 }
3785
3786 // Find is API call
3787 func (o *DiskOp) Find(ctx context.Context, zone string, conditions *FindCondition) (*DiskFindResult, error) {
3788 // build request URL
3789 pathBuildParameter := map[string]interface{}{
3790 "rootURL": SakuraCloudAPIRoot,
3791 "pathSuffix": o.PathSuffix,
3792 "pathName": o.PathName,
3793 "zone": zone,
3794 "conditions": conditions,
3795 }
3796
3797 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}", pathBuildParameter)
3798 if err != nil {
3799 return nil, err
3800 }
3801 // build request body
3802 var body interface{}
3803 v, err := o.transformFindArgs(conditions)
3804 if err != nil {
3805 return nil, err
3806 }
3807 body = v
3808
3809 // do request
3810 data, err := o.Client.Do(ctx, "GET", url, body)
3811 if err != nil {
3812 return nil, err
3813 }
3814
3815 // build results
3816 results, err := o.transformFindResults(data)
3817 if err != nil {
3818 return nil, err
3819 }
3820 return results, err
3821 }
3822
3823 // Create is API call
3824 func (o *DiskOp) Create(ctx context.Context, zone string, createParam *DiskCreateRequest, distantFrom []types.ID, kmeKeyID types.ID) (*Disk, error) {
3825 // build request URL
3826 pathBuildParameter := map[string]interface{}{
3827 "rootURL": SakuraCloudAPIRoot,
3828 "pathSuffix": o.PathSuffix,
3829 "pathName": o.PathName,
3830 "zone": zone,
3831 "createParam": createParam,
3832 "distantFrom": distantFrom,
3833 "kmeKeyID": kmeKeyID,
3834 }
3835
3836 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}", pathBuildParameter)
3837 if err != nil {
3838 return nil, err
3839 }
3840 // build request body
3841 var body interface{}
3842 v, err := o.transformCreateArgs(createParam, distantFrom, kmeKeyID)
3843 if err != nil {
3844 return nil, err
3845 }
3846 body = v
3847
3848 // do request
3849 data, err := o.Client.Do(ctx, "POST", url, body)
3850 if err != nil {
3851 return nil, err
3852 }
3853
3854 // build results
3855 results, err := o.transformCreateResults(data)
3856 if err != nil {
3857 return nil, err
3858 }
3859 return results.Disk, nil
3860 }
3861
3862 // Config is API call
3863 func (o *DiskOp) Config(ctx context.Context, zone string, id types.ID, edit *DiskEditRequest) error {
3864 // build request URL
3865 pathBuildParameter := map[string]interface{}{
3866 "rootURL": SakuraCloudAPIRoot,
3867 "pathSuffix": o.PathSuffix,
3868 "pathName": o.PathName,
3869 "zone": zone,
3870 "id": id,
3871 "edit": edit,
3872 }
3873
3874 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}/config", pathBuildParameter)
3875 if err != nil {
3876 return err
3877 }
3878 // build request body
3879 var body interface{}
3880 v, err := o.transformConfigArgs(id, edit)
3881 if err != nil {
3882 return err
3883 }
3884 body = v
3885
3886 // do request
3887 _, err = o.Client.Do(ctx, "PUT", url, body)
3888 if err != nil {
3889 return err
3890 }
3891
3892 // build results
3893
3894 return nil
3895 }
3896
3897 // CreateWithConfig is API call
3898 func (o *DiskOp) CreateWithConfig(ctx context.Context, zone string, createParam *DiskCreateRequest, editParam *DiskEditRequest, bootAtAvailable bool, distantFrom []types.ID, kmeKeyID types.ID) (*Disk, error) {
3899 // build request URL
3900 pathBuildParameter := map[string]interface{}{
3901 "rootURL": SakuraCloudAPIRoot,
3902 "pathSuffix": o.PathSuffix,
3903 "pathName": o.PathName,
3904 "zone": zone,
3905 "createParam": createParam,
3906 "editParam": editParam,
3907 "bootAtAvailable": bootAtAvailable,
3908 "distantFrom": distantFrom,
3909 "kmeKeyID": kmeKeyID,
3910 }
3911
3912 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}", pathBuildParameter)
3913 if err != nil {
3914 return nil, err
3915 }
3916 // build request body
3917 var body interface{}
3918 v, err := o.transformCreateWithConfigArgs(createParam, editParam, bootAtAvailable, distantFrom, kmeKeyID)
3919 if err != nil {
3920 return nil, err
3921 }
3922 body = v
3923
3924 // do request
3925 data, err := o.Client.Do(ctx, "POST", url, body)
3926 if err != nil {
3927 return nil, err
3928 }
3929
3930 // build results
3931 results, err := o.transformCreateWithConfigResults(data)
3932 if err != nil {
3933 return nil, err
3934 }
3935 return results.Disk, nil
3936 }
3937
3938 // ResizePartition is API call
3939 func (o *DiskOp) ResizePartition(ctx context.Context, zone string, id types.ID, param *DiskResizePartitionRequest) error {
3940 // build request URL
3941 pathBuildParameter := map[string]interface{}{
3942 "rootURL": SakuraCloudAPIRoot,
3943 "pathSuffix": o.PathSuffix,
3944 "pathName": o.PathName,
3945 "zone": zone,
3946 "id": id,
3947 "param": param,
3948 }
3949
3950 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}/resize-partition", pathBuildParameter)
3951 if err != nil {
3952 return err
3953 }
3954 // build request body
3955 var body interface{}
3956 v, err := o.transformResizePartitionArgs(id, param)
3957 if err != nil {
3958 return err
3959 }
3960 body = v
3961
3962 // do request
3963 _, err = o.Client.Do(ctx, "PUT", url, body)
3964 if err != nil {
3965 return err
3966 }
3967
3968 // build results
3969
3970 return nil
3971 }
3972
3973 // ConnectToServer is API call
3974 func (o *DiskOp) ConnectToServer(ctx context.Context, zone string, id types.ID, serverID types.ID) error {
3975 // build request URL
3976 pathBuildParameter := map[string]interface{}{
3977 "rootURL": SakuraCloudAPIRoot,
3978 "pathSuffix": o.PathSuffix,
3979 "pathName": o.PathName,
3980 "zone": zone,
3981 "id": id,
3982 "serverID": serverID,
3983 }
3984
3985 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}/to/server/{{.serverID}}", pathBuildParameter)
3986 if err != nil {
3987 return err
3988 }
3989 // build request body
3990 var body interface{}
3991
3992 // do request
3993 _, err = o.Client.Do(ctx, "PUT", url, body)
3994 if err != nil {
3995 return err
3996 }
3997
3998 // build results
3999
4000 return nil
4001 }
4002
4003 // DisconnectFromServer is API call
4004 func (o *DiskOp) DisconnectFromServer(ctx context.Context, zone string, id types.ID) error {
4005 // build request URL
4006 pathBuildParameter := map[string]interface{}{
4007 "rootURL": SakuraCloudAPIRoot,
4008 "pathSuffix": o.PathSuffix,
4009 "pathName": o.PathName,
4010 "zone": zone,
4011 "id": id,
4012 }
4013
4014 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}/to/server", pathBuildParameter)
4015 if err != nil {
4016 return err
4017 }
4018 // build request body
4019 var body interface{}
4020
4021 // do request
4022 _, err = o.Client.Do(ctx, "DELETE", url, body)
4023 if err != nil {
4024 return err
4025 }
4026
4027 // build results
4028
4029 return nil
4030 }
4031
4032 // Read is API call
4033 func (o *DiskOp) Read(ctx context.Context, zone string, id types.ID) (*Disk, error) {
4034 // build request URL
4035 pathBuildParameter := map[string]interface{}{
4036 "rootURL": SakuraCloudAPIRoot,
4037 "pathSuffix": o.PathSuffix,
4038 "pathName": o.PathName,
4039 "zone": zone,
4040 "id": id,
4041 }
4042
4043 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}", pathBuildParameter)
4044 if err != nil {
4045 return nil, err
4046 }
4047 // build request body
4048 var body interface{}
4049
4050 // do request
4051 data, err := o.Client.Do(ctx, "GET", url, body)
4052 if err != nil {
4053 return nil, err
4054 }
4055
4056 // build results
4057 results, err := o.transformReadResults(data)
4058 if err != nil {
4059 return nil, err
4060 }
4061 return results.Disk, nil
4062 }
4063
4064 // Update is API call
4065 func (o *DiskOp) Update(ctx context.Context, zone string, id types.ID, param *DiskUpdateRequest) (*Disk, error) {
4066 // build request URL
4067 pathBuildParameter := map[string]interface{}{
4068 "rootURL": SakuraCloudAPIRoot,
4069 "pathSuffix": o.PathSuffix,
4070 "pathName": o.PathName,
4071 "zone": zone,
4072 "id": id,
4073 "param": param,
4074 }
4075
4076 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}", pathBuildParameter)
4077 if err != nil {
4078 return nil, err
4079 }
4080 // build request body
4081 var body interface{}
4082 v, err := o.transformUpdateArgs(id, param)
4083 if err != nil {
4084 return nil, err
4085 }
4086 body = v
4087
4088 // do request
4089 data, err := o.Client.Do(ctx, "PUT", url, body)
4090 if err != nil {
4091 return nil, err
4092 }
4093
4094 // build results
4095 results, err := o.transformUpdateResults(data)
4096 if err != nil {
4097 return nil, err
4098 }
4099 return results.Disk, nil
4100 }
4101
4102 // Delete is API call
4103 func (o *DiskOp) Delete(ctx context.Context, zone string, id types.ID) error {
4104 // build request URL
4105 pathBuildParameter := map[string]interface{}{
4106 "rootURL": SakuraCloudAPIRoot,
4107 "pathSuffix": o.PathSuffix,
4108 "pathName": o.PathName,
4109 "zone": zone,
4110 "id": id,
4111 }
4112
4113 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}", pathBuildParameter)
4114 if err != nil {
4115 return err
4116 }
4117 // build request body
4118 var body interface{}
4119
4120 // do request
4121 _, err = o.Client.Do(ctx, "DELETE", url, body)
4122 if err != nil {
4123 return err
4124 }
4125
4126 // build results
4127
4128 return nil
4129 }
4130
4131 // Monitor is API call
4132 func (o *DiskOp) Monitor(ctx context.Context, zone string, id types.ID, condition *MonitorCondition) (*DiskActivity, error) {
4133 // build request URL
4134 pathBuildParameter := map[string]interface{}{
4135 "rootURL": SakuraCloudAPIRoot,
4136 "pathSuffix": o.PathSuffix,
4137 "pathName": o.PathName,
4138 "zone": zone,
4139 "id": id,
4140 "condition": condition,
4141 }
4142
4143 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}/monitor", pathBuildParameter)
4144 if err != nil {
4145 return nil, err
4146 }
4147 // build request body
4148 var body interface{}
4149 v, err := o.transformMonitorArgs(id, condition)
4150 if err != nil {
4151 return nil, err
4152 }
4153 body = v
4154
4155 // do request
4156 data, err := o.Client.Do(ctx, "GET", url, body)
4157 if err != nil {
4158 return nil, err
4159 }
4160
4161 // build results
4162 results, err := o.transformMonitorResults(data)
4163 if err != nil {
4164 return nil, err
4165 }
4166 return results.DiskActivity, nil
4167 }
4168
4169 // MonitorDisk is API call
4170 func (o *DiskOp) MonitorDisk(ctx context.Context, zone string, id types.ID, condition *MonitorCondition) (*DiskActivity, error) {
4171 // build request URL
4172 pathBuildParameter := map[string]interface{}{
4173 "rootURL": SakuraCloudAPIRoot,
4174 "pathSuffix": o.PathSuffix,
4175 "pathName": o.PathName,
4176 "zone": zone,
4177 "id": id,
4178 "condition": condition,
4179 }
4180
4181 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}/monitor", pathBuildParameter)
4182 if err != nil {
4183 return nil, err
4184 }
4185 // build request body
4186 var body interface{}
4187 v, err := o.transformMonitorDiskArgs(id, condition)
4188 if err != nil {
4189 return nil, err
4190 }
4191 body = v
4192
4193 // do request
4194 data, err := o.Client.Do(ctx, "GET", url, body)
4195 if err != nil {
4196 return nil, err
4197 }
4198
4199 // build results
4200 results, err := o.transformMonitorDiskResults(data)
4201 if err != nil {
4202 return nil, err
4203 }
4204 return results.DiskActivity, nil
4205 }
4206
4207 /*************************************************
4208 * DiskPlanOp
4209 *************************************************/
4210
4211 // DiskPlanOp implements DiskPlanAPI interface
4212 type DiskPlanOp struct {
4213 // Client APICaller
4214 Client APICaller
4215 // PathSuffix is used when building URL
4216 PathSuffix string
4217 // PathName is used when building URL
4218 PathName string
4219 }
4220
4221 // NewDiskPlanOp creates new DiskPlanOp instance
4222 func NewDiskPlanOp(caller APICaller) DiskPlanAPI {
4223 return GetClientFactoryFunc("DiskPlan")(caller).(DiskPlanAPI)
4224 }
4225
4226 // Find is API call
4227 func (o *DiskPlanOp) Find(ctx context.Context, zone string, conditions *FindCondition) (*DiskPlanFindResult, error) {
4228 // build request URL
4229 pathBuildParameter := map[string]interface{}{
4230 "rootURL": SakuraCloudAPIRoot,
4231 "pathSuffix": o.PathSuffix,
4232 "pathName": o.PathName,
4233 "zone": zone,
4234 "conditions": conditions,
4235 }
4236
4237 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}", pathBuildParameter)
4238 if err != nil {
4239 return nil, err
4240 }
4241 // build request body
4242 var body interface{}
4243 v, err := o.transformFindArgs(conditions)
4244 if err != nil {
4245 return nil, err
4246 }
4247 body = v
4248
4249 // do request
4250 data, err := o.Client.Do(ctx, "GET", url, body)
4251 if err != nil {
4252 return nil, err
4253 }
4254
4255 // build results
4256 results, err := o.transformFindResults(data)
4257 if err != nil {
4258 return nil, err
4259 }
4260 return results, err
4261 }
4262
4263 // Read is API call
4264 func (o *DiskPlanOp) Read(ctx context.Context, zone string, id types.ID) (*DiskPlan, error) {
4265 // build request URL
4266 pathBuildParameter := map[string]interface{}{
4267 "rootURL": SakuraCloudAPIRoot,
4268 "pathSuffix": o.PathSuffix,
4269 "pathName": o.PathName,
4270 "zone": zone,
4271 "id": id,
4272 }
4273
4274 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}", pathBuildParameter)
4275 if err != nil {
4276 return nil, err
4277 }
4278 // build request body
4279 var body interface{}
4280
4281 // do request
4282 data, err := o.Client.Do(ctx, "GET", url, body)
4283 if err != nil {
4284 return nil, err
4285 }
4286
4287 // build results
4288 results, err := o.transformReadResults(data)
4289 if err != nil {
4290 return nil, err
4291 }
4292 return results.DiskPlan, nil
4293 }
4294
4295 /*************************************************
4296 * DNSOp
4297 *************************************************/
4298
4299 // DNSOp implements DNSAPI interface
4300 type DNSOp struct {
4301 // Client APICaller
4302 Client APICaller
4303 // PathSuffix is used when building URL
4304 PathSuffix string
4305 // PathName is used when building URL
4306 PathName string
4307 }
4308
4309 // NewDNSOp creates new DNSOp instance
4310 func NewDNSOp(caller APICaller) DNSAPI {
4311 return GetClientFactoryFunc("DNS")(caller).(DNSAPI)
4312 }
4313
4314 // Find is API call
4315 func (o *DNSOp) Find(ctx context.Context, conditions *FindCondition) (*DNSFindResult, error) {
4316 // build request URL
4317 pathBuildParameter := map[string]interface{}{
4318 "rootURL": SakuraCloudAPIRoot,
4319 "pathSuffix": o.PathSuffix,
4320 "pathName": o.PathName,
4321 "zone": APIDefaultZone,
4322 "conditions": conditions,
4323 }
4324
4325 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}", pathBuildParameter)
4326 if err != nil {
4327 return nil, err
4328 }
4329 // build request body
4330 var body interface{}
4331 v, err := o.transformFindArgs(conditions)
4332 if err != nil {
4333 return nil, err
4334 }
4335 body = v
4336
4337 // do request
4338 data, err := o.Client.Do(ctx, "GET", url, body)
4339 if err != nil {
4340 return nil, err
4341 }
4342
4343 // build results
4344 results, err := o.transformFindResults(data)
4345 if err != nil {
4346 return nil, err
4347 }
4348 return results, err
4349 }
4350
4351 // Create is API call
4352 func (o *DNSOp) Create(ctx context.Context, param *DNSCreateRequest) (*DNS, error) {
4353 // build request URL
4354 pathBuildParameter := map[string]interface{}{
4355 "rootURL": SakuraCloudAPIRoot,
4356 "pathSuffix": o.PathSuffix,
4357 "pathName": o.PathName,
4358 "zone": APIDefaultZone,
4359 "param": param,
4360 }
4361
4362 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}", pathBuildParameter)
4363 if err != nil {
4364 return nil, err
4365 }
4366 // build request body
4367 var body interface{}
4368 v, err := o.transformCreateArgs(param)
4369 if err != nil {
4370 return nil, err
4371 }
4372 body = v
4373
4374 // do request
4375 data, err := o.Client.Do(ctx, "POST", url, body)
4376 if err != nil {
4377 return nil, err
4378 }
4379
4380 // build results
4381 results, err := o.transformCreateResults(data)
4382 if err != nil {
4383 return nil, err
4384 }
4385 return results.DNS, nil
4386 }
4387
4388 // Read is API call
4389 func (o *DNSOp) Read(ctx context.Context, id types.ID) (*DNS, error) {
4390 // build request URL
4391 pathBuildParameter := map[string]interface{}{
4392 "rootURL": SakuraCloudAPIRoot,
4393 "pathSuffix": o.PathSuffix,
4394 "pathName": o.PathName,
4395 "zone": APIDefaultZone,
4396 "id": id,
4397 }
4398
4399 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}", pathBuildParameter)
4400 if err != nil {
4401 return nil, err
4402 }
4403 // build request body
4404 var body interface{}
4405
4406 // do request
4407 data, err := o.Client.Do(ctx, "GET", url, body)
4408 if err != nil {
4409 return nil, err
4410 }
4411
4412 // build results
4413 results, err := o.transformReadResults(data)
4414 if err != nil {
4415 return nil, err
4416 }
4417 return results.DNS, nil
4418 }
4419
4420 // Update is API call
4421 func (o *DNSOp) Update(ctx context.Context, id types.ID, param *DNSUpdateRequest) (*DNS, error) {
4422 // build request URL
4423 pathBuildParameter := map[string]interface{}{
4424 "rootURL": SakuraCloudAPIRoot,
4425 "pathSuffix": o.PathSuffix,
4426 "pathName": o.PathName,
4427 "zone": APIDefaultZone,
4428 "id": id,
4429 "param": param,
4430 }
4431
4432 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}", pathBuildParameter)
4433 if err != nil {
4434 return nil, err
4435 }
4436 // build request body
4437 var body interface{}
4438 v, err := o.transformUpdateArgs(id, param)
4439 if err != nil {
4440 return nil, err
4441 }
4442 body = v
4443
4444 // do request
4445 data, err := o.Client.Do(ctx, "PUT", url, body)
4446 if err != nil {
4447 return nil, err
4448 }
4449
4450 // build results
4451 results, err := o.transformUpdateResults(data)
4452 if err != nil {
4453 return nil, err
4454 }
4455 return results.DNS, nil
4456 }
4457
4458 // UpdateSettings is API call
4459 func (o *DNSOp) UpdateSettings(ctx context.Context, id types.ID, param *DNSUpdateSettingsRequest) (*DNS, error) {
4460 // build request URL
4461 pathBuildParameter := map[string]interface{}{
4462 "rootURL": SakuraCloudAPIRoot,
4463 "pathSuffix": o.PathSuffix,
4464 "pathName": o.PathName,
4465 "zone": APIDefaultZone,
4466 "id": id,
4467 "param": param,
4468 }
4469
4470 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}", pathBuildParameter)
4471 if err != nil {
4472 return nil, err
4473 }
4474 // build request body
4475 var body interface{}
4476 v, err := o.transformUpdateSettingsArgs(id, param)
4477 if err != nil {
4478 return nil, err
4479 }
4480 body = v
4481
4482 // do request
4483 data, err := o.Client.Do(ctx, "PUT", url, body)
4484 if err != nil {
4485 return nil, err
4486 }
4487
4488 // build results
4489 results, err := o.transformUpdateSettingsResults(data)
4490 if err != nil {
4491 return nil, err
4492 }
4493 return results.DNS, nil
4494 }
4495
4496 // Delete is API call
4497 func (o *DNSOp) Delete(ctx context.Context, id types.ID) error {
4498 // build request URL
4499 pathBuildParameter := map[string]interface{}{
4500 "rootURL": SakuraCloudAPIRoot,
4501 "pathSuffix": o.PathSuffix,
4502 "pathName": o.PathName,
4503 "zone": APIDefaultZone,
4504 "id": id,
4505 }
4506
4507 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}", pathBuildParameter)
4508 if err != nil {
4509 return err
4510 }
4511 // build request body
4512 var body interface{}
4513
4514 // do request
4515 _, err = o.Client.Do(ctx, "DELETE", url, body)
4516 if err != nil {
4517 return err
4518 }
4519
4520 // build results
4521
4522 return nil
4523 }
4524
4525 /*************************************************
4526 * EnhancedDBOp
4527 *************************************************/
4528
4529 // EnhancedDBOp implements EnhancedDBAPI interface
4530 type EnhancedDBOp struct {
4531 // Client APICaller
4532 Client APICaller
4533 // PathSuffix is used when building URL
4534 PathSuffix string
4535 // PathName is used when building URL
4536 PathName string
4537 }
4538
4539 // NewEnhancedDBOp creates new EnhancedDBOp instance
4540 func NewEnhancedDBOp(caller APICaller) EnhancedDBAPI {
4541 return GetClientFactoryFunc("EnhancedDB")(caller).(EnhancedDBAPI)
4542 }
4543
4544 // Find is API call
4545 func (o *EnhancedDBOp) Find(ctx context.Context, conditions *FindCondition) (*EnhancedDBFindResult, error) {
4546 // build request URL
4547 pathBuildParameter := map[string]interface{}{
4548 "rootURL": SakuraCloudAPIRoot,
4549 "pathSuffix": o.PathSuffix,
4550 "pathName": o.PathName,
4551 "zone": APIDefaultZone,
4552 "conditions": conditions,
4553 }
4554
4555 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}", pathBuildParameter)
4556 if err != nil {
4557 return nil, err
4558 }
4559 // build request body
4560 var body interface{}
4561 v, err := o.transformFindArgs(conditions)
4562 if err != nil {
4563 return nil, err
4564 }
4565 body = v
4566
4567 // do request
4568 data, err := o.Client.Do(ctx, "GET", url, body)
4569 if err != nil {
4570 return nil, err
4571 }
4572
4573 // build results
4574 results, err := o.transformFindResults(data)
4575 if err != nil {
4576 return nil, err
4577 }
4578 return results, err
4579 }
4580
4581 // Create is API call
4582 func (o *EnhancedDBOp) Create(ctx context.Context, param *EnhancedDBCreateRequest) (*EnhancedDB, error) {
4583 // build request URL
4584 pathBuildParameter := map[string]interface{}{
4585 "rootURL": SakuraCloudAPIRoot,
4586 "pathSuffix": o.PathSuffix,
4587 "pathName": o.PathName,
4588 "zone": APIDefaultZone,
4589 "param": param,
4590 }
4591
4592 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}", pathBuildParameter)
4593 if err != nil {
4594 return nil, err
4595 }
4596 // build request body
4597 var body interface{}
4598 v, err := o.transformCreateArgs(param)
4599 if err != nil {
4600 return nil, err
4601 }
4602 body = v
4603
4604 // do request
4605 data, err := o.Client.Do(ctx, "POST", url, body)
4606 if err != nil {
4607 return nil, err
4608 }
4609
4610 // build results
4611 results, err := o.transformCreateResults(data)
4612 if err != nil {
4613 return nil, err
4614 }
4615 return results.EnhancedDB, nil
4616 }
4617
4618 // Read is API call
4619 func (o *EnhancedDBOp) Read(ctx context.Context, id types.ID) (*EnhancedDB, error) {
4620 // build request URL
4621 pathBuildParameter := map[string]interface{}{
4622 "rootURL": SakuraCloudAPIRoot,
4623 "pathSuffix": o.PathSuffix,
4624 "pathName": o.PathName,
4625 "zone": APIDefaultZone,
4626 "id": id,
4627 }
4628
4629 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}", pathBuildParameter)
4630 if err != nil {
4631 return nil, err
4632 }
4633 // build request body
4634 var body interface{}
4635
4636 // do request
4637 data, err := o.Client.Do(ctx, "GET", url, body)
4638 if err != nil {
4639 return nil, err
4640 }
4641
4642 // build results
4643 results, err := o.transformReadResults(data)
4644 if err != nil {
4645 return nil, err
4646 }
4647 return results.EnhancedDB, nil
4648 }
4649
4650 // Update is API call
4651 func (o *EnhancedDBOp) Update(ctx context.Context, id types.ID, param *EnhancedDBUpdateRequest) (*EnhancedDB, error) {
4652 // build request URL
4653 pathBuildParameter := map[string]interface{}{
4654 "rootURL": SakuraCloudAPIRoot,
4655 "pathSuffix": o.PathSuffix,
4656 "pathName": o.PathName,
4657 "zone": APIDefaultZone,
4658 "id": id,
4659 "param": param,
4660 }
4661
4662 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}", pathBuildParameter)
4663 if err != nil {
4664 return nil, err
4665 }
4666 // build request body
4667 var body interface{}
4668 v, err := o.transformUpdateArgs(id, param)
4669 if err != nil {
4670 return nil, err
4671 }
4672 body = v
4673
4674 // do request
4675 data, err := o.Client.Do(ctx, "PUT", url, body)
4676 if err != nil {
4677 return nil, err
4678 }
4679
4680 // build results
4681 results, err := o.transformUpdateResults(data)
4682 if err != nil {
4683 return nil, err
4684 }
4685 return results.EnhancedDB, nil
4686 }
4687
4688 // Delete is API call
4689 func (o *EnhancedDBOp) Delete(ctx context.Context, id types.ID) error {
4690 // build request URL
4691 pathBuildParameter := map[string]interface{}{
4692 "rootURL": SakuraCloudAPIRoot,
4693 "pathSuffix": o.PathSuffix,
4694 "pathName": o.PathName,
4695 "zone": APIDefaultZone,
4696 "id": id,
4697 }
4698
4699 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}", pathBuildParameter)
4700 if err != nil {
4701 return err
4702 }
4703 // build request body
4704 var body interface{}
4705
4706 // do request
4707 _, err = o.Client.Do(ctx, "DELETE", url, body)
4708 if err != nil {
4709 return err
4710 }
4711
4712 // build results
4713
4714 return nil
4715 }
4716
4717 // SetPassword is API call
4718 func (o *EnhancedDBOp) SetPassword(ctx context.Context, id types.ID, param *EnhancedDBSetPasswordRequest) error {
4719 // build request URL
4720 pathBuildParameter := map[string]interface{}{
4721 "rootURL": SakuraCloudAPIRoot,
4722 "pathSuffix": o.PathSuffix,
4723 "pathName": o.PathName,
4724 "zone": APIDefaultZone,
4725 "id": id,
4726 "param": param,
4727 }
4728
4729 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}/enhanceddb/set-password", pathBuildParameter)
4730 if err != nil {
4731 return err
4732 }
4733 // build request body
4734 var body interface{}
4735 v, err := o.transformSetPasswordArgs(id, param)
4736 if err != nil {
4737 return err
4738 }
4739 body = v
4740
4741 // do request
4742 _, err = o.Client.Do(ctx, "PUT", url, body)
4743 if err != nil {
4744 return err
4745 }
4746
4747 // build results
4748
4749 return nil
4750 }
4751
4752 // GetConfig is API call
4753 func (o *EnhancedDBOp) GetConfig(ctx context.Context, id types.ID) (*EnhancedDBConfig, error) {
4754 // build request URL
4755 pathBuildParameter := map[string]interface{}{
4756 "rootURL": SakuraCloudAPIRoot,
4757 "pathSuffix": o.PathSuffix,
4758 "pathName": o.PathName,
4759 "zone": APIDefaultZone,
4760 "id": id,
4761 }
4762
4763 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}/enhanceddb/config", pathBuildParameter)
4764 if err != nil {
4765 return nil, err
4766 }
4767 // build request body
4768 var body interface{}
4769
4770 // do request
4771 data, err := o.Client.Do(ctx, "GET", url, body)
4772 if err != nil {
4773 return nil, err
4774 }
4775
4776 // build results
4777 results, err := o.transformGetConfigResults(data)
4778 if err != nil {
4779 return nil, err
4780 }
4781 return results.EnhancedDBConfig, nil
4782 }
4783
4784 // SetConfig is API call
4785 func (o *EnhancedDBOp) SetConfig(ctx context.Context, id types.ID, param *EnhancedDBSetConfigRequest) error {
4786 // build request URL
4787 pathBuildParameter := map[string]interface{}{
4788 "rootURL": SakuraCloudAPIRoot,
4789 "pathSuffix": o.PathSuffix,
4790 "pathName": o.PathName,
4791 "zone": APIDefaultZone,
4792 "id": id,
4793 "param": param,
4794 }
4795
4796 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}/enhanceddb/config", pathBuildParameter)
4797 if err != nil {
4798 return err
4799 }
4800 // build request body
4801 var body interface{}
4802 v, err := o.transformSetConfigArgs(id, param)
4803 if err != nil {
4804 return err
4805 }
4806 body = v
4807
4808 // do request
4809 _, err = o.Client.Do(ctx, "PUT", url, body)
4810 if err != nil {
4811 return err
4812 }
4813
4814 // build results
4815
4816 return nil
4817 }
4818
4819 /*************************************************
4820 * ESMEOp
4821 *************************************************/
4822
4823 // ESMEOp implements ESMEAPI interface
4824 type ESMEOp struct {
4825 // Client APICaller
4826 Client APICaller
4827 // PathSuffix is used when building URL
4828 PathSuffix string
4829 // PathName is used when building URL
4830 PathName string
4831 }
4832
4833 // NewESMEOp creates new ESMEOp instance
4834 func NewESMEOp(caller APICaller) ESMEAPI {
4835 return GetClientFactoryFunc("ESME")(caller).(ESMEAPI)
4836 }
4837
4838 // Find is API call
4839 func (o *ESMEOp) Find(ctx context.Context, conditions *FindCondition) (*ESMEFindResult, error) {
4840 // build request URL
4841 pathBuildParameter := map[string]interface{}{
4842 "rootURL": SakuraCloudAPIRoot,
4843 "pathSuffix": o.PathSuffix,
4844 "pathName": o.PathName,
4845 "zone": APIDefaultZone,
4846 "conditions": conditions,
4847 }
4848
4849 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}", pathBuildParameter)
4850 if err != nil {
4851 return nil, err
4852 }
4853 // build request body
4854 var body interface{}
4855 v, err := o.transformFindArgs(conditions)
4856 if err != nil {
4857 return nil, err
4858 }
4859 body = v
4860
4861 // do request
4862 data, err := o.Client.Do(ctx, "GET", url, body)
4863 if err != nil {
4864 return nil, err
4865 }
4866
4867 // build results
4868 results, err := o.transformFindResults(data)
4869 if err != nil {
4870 return nil, err
4871 }
4872 return results, err
4873 }
4874
4875 // Create is API call
4876 func (o *ESMEOp) Create(ctx context.Context, param *ESMECreateRequest) (*ESME, error) {
4877 // build request URL
4878 pathBuildParameter := map[string]interface{}{
4879 "rootURL": SakuraCloudAPIRoot,
4880 "pathSuffix": o.PathSuffix,
4881 "pathName": o.PathName,
4882 "zone": APIDefaultZone,
4883 "param": param,
4884 }
4885
4886 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}", pathBuildParameter)
4887 if err != nil {
4888 return nil, err
4889 }
4890 // build request body
4891 var body interface{}
4892 v, err := o.transformCreateArgs(param)
4893 if err != nil {
4894 return nil, err
4895 }
4896 body = v
4897
4898 // do request
4899 data, err := o.Client.Do(ctx, "POST", url, body)
4900 if err != nil {
4901 return nil, err
4902 }
4903
4904 // build results
4905 results, err := o.transformCreateResults(data)
4906 if err != nil {
4907 return nil, err
4908 }
4909 return results.ESME, nil
4910 }
4911
4912 // Read is API call
4913 func (o *ESMEOp) Read(ctx context.Context, id types.ID) (*ESME, error) {
4914 // build request URL
4915 pathBuildParameter := map[string]interface{}{
4916 "rootURL": SakuraCloudAPIRoot,
4917 "pathSuffix": o.PathSuffix,
4918 "pathName": o.PathName,
4919 "zone": APIDefaultZone,
4920 "id": id,
4921 }
4922
4923 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}", pathBuildParameter)
4924 if err != nil {
4925 return nil, err
4926 }
4927 // build request body
4928 var body interface{}
4929
4930 // do request
4931 data, err := o.Client.Do(ctx, "GET", url, body)
4932 if err != nil {
4933 return nil, err
4934 }
4935
4936 // build results
4937 results, err := o.transformReadResults(data)
4938 if err != nil {
4939 return nil, err
4940 }
4941 return results.ESME, nil
4942 }
4943
4944 // Update is API call
4945 func (o *ESMEOp) Update(ctx context.Context, id types.ID, param *ESMEUpdateRequest) (*ESME, error) {
4946 // build request URL
4947 pathBuildParameter := map[string]interface{}{
4948 "rootURL": SakuraCloudAPIRoot,
4949 "pathSuffix": o.PathSuffix,
4950 "pathName": o.PathName,
4951 "zone": APIDefaultZone,
4952 "id": id,
4953 "param": param,
4954 }
4955
4956 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}", pathBuildParameter)
4957 if err != nil {
4958 return nil, err
4959 }
4960 // build request body
4961 var body interface{}
4962 v, err := o.transformUpdateArgs(id, param)
4963 if err != nil {
4964 return nil, err
4965 }
4966 body = v
4967
4968 // do request
4969 data, err := o.Client.Do(ctx, "PUT", url, body)
4970 if err != nil {
4971 return nil, err
4972 }
4973
4974 // build results
4975 results, err := o.transformUpdateResults(data)
4976 if err != nil {
4977 return nil, err
4978 }
4979 return results.ESME, nil
4980 }
4981
4982 // Delete is API call
4983 func (o *ESMEOp) Delete(ctx context.Context, id types.ID) error {
4984 // build request URL
4985 pathBuildParameter := map[string]interface{}{
4986 "rootURL": SakuraCloudAPIRoot,
4987 "pathSuffix": o.PathSuffix,
4988 "pathName": o.PathName,
4989 "zone": APIDefaultZone,
4990 "id": id,
4991 }
4992
4993 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}", pathBuildParameter)
4994 if err != nil {
4995 return err
4996 }
4997 // build request body
4998 var body interface{}
4999
5000 // do request
5001 _, err = o.Client.Do(ctx, "DELETE", url, body)
5002 if err != nil {
5003 return err
5004 }
5005
5006 // build results
5007
5008 return nil
5009 }
5010
5011 // SendMessageWithGeneratedOTP is API call
5012 func (o *ESMEOp) SendMessageWithGeneratedOTP(ctx context.Context, id types.ID, param *ESMESendMessageWithGeneratedOTPRequest) (*ESMESendMessageResult, error) {
5013 // build request URL
5014 pathBuildParameter := map[string]interface{}{
5015 "rootURL": SakuraCloudAPIRoot,
5016 "pathSuffix": o.PathSuffix,
5017 "pathName": o.PathName,
5018 "zone": APIDefaultZone,
5019 "id": id,
5020 "param": param,
5021 }
5022
5023 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}/esme/2fa/otp", pathBuildParameter)
5024 if err != nil {
5025 return nil, err
5026 }
5027 // build request body
5028 var body interface{}
5029 v, err := o.transformSendMessageWithGeneratedOTPArgs(id, param)
5030 if err != nil {
5031 return nil, err
5032 }
5033 body = v
5034
5035 // do request
5036 data, err := o.Client.Do(ctx, "PUT", url, body)
5037 if err != nil {
5038 return nil, err
5039 }
5040
5041 // build results
5042 results, err := o.transformSendMessageWithGeneratedOTPResults(data)
5043 if err != nil {
5044 return nil, err
5045 }
5046 return results.ESMESendMessageResult, nil
5047 }
5048
5049 // SendMessageWithInputtedOTP is API call
5050 func (o *ESMEOp) SendMessageWithInputtedOTP(ctx context.Context, id types.ID, param *ESMESendMessageWithInputtedOTPRequest) (*ESMESendMessageResult, error) {
5051 // build request URL
5052 pathBuildParameter := map[string]interface{}{
5053 "rootURL": SakuraCloudAPIRoot,
5054 "pathSuffix": o.PathSuffix,
5055 "pathName": o.PathName,
5056 "zone": APIDefaultZone,
5057 "id": id,
5058 "param": param,
5059 }
5060
5061 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}/esme/2fa", pathBuildParameter)
5062 if err != nil {
5063 return nil, err
5064 }
5065 // build request body
5066 var body interface{}
5067 v, err := o.transformSendMessageWithInputtedOTPArgs(id, param)
5068 if err != nil {
5069 return nil, err
5070 }
5071 body = v
5072
5073 // do request
5074 data, err := o.Client.Do(ctx, "PUT", url, body)
5075 if err != nil {
5076 return nil, err
5077 }
5078
5079 // build results
5080 results, err := o.transformSendMessageWithInputtedOTPResults(data)
5081 if err != nil {
5082 return nil, err
5083 }
5084 return results.ESMESendMessageResult, nil
5085 }
5086
5087 // Logs is API call
5088 func (o *ESMEOp) Logs(ctx context.Context, id types.ID) ([]*ESMELogs, error) {
5089 // build request URL
5090 pathBuildParameter := map[string]interface{}{
5091 "rootURL": SakuraCloudAPIRoot,
5092 "pathSuffix": o.PathSuffix,
5093 "pathName": o.PathName,
5094 "zone": APIDefaultZone,
5095 "id": id,
5096 }
5097
5098 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}/esme/logs", pathBuildParameter)
5099 if err != nil {
5100 return nil, err
5101 }
5102 // build request body
5103 var body interface{}
5104
5105 // do request
5106 data, err := o.Client.Do(ctx, "GET", url, body)
5107 if err != nil {
5108 return nil, err
5109 }
5110
5111 // build results
5112 results, err := o.transformLogsResults(data)
5113 if err != nil {
5114 return nil, err
5115 }
5116 return results.Logs, nil
5117 }
5118
5119 /*************************************************
5120 * GSLBOp
5121 *************************************************/
5122
5123 // GSLBOp implements GSLBAPI interface
5124 type GSLBOp struct {
5125 // Client APICaller
5126 Client APICaller
5127 // PathSuffix is used when building URL
5128 PathSuffix string
5129 // PathName is used when building URL
5130 PathName string
5131 }
5132
5133 // NewGSLBOp creates new GSLBOp instance
5134 func NewGSLBOp(caller APICaller) GSLBAPI {
5135 return GetClientFactoryFunc("GSLB")(caller).(GSLBAPI)
5136 }
5137
5138 // Find is API call
5139 func (o *GSLBOp) Find(ctx context.Context, conditions *FindCondition) (*GSLBFindResult, error) {
5140 // build request URL
5141 pathBuildParameter := map[string]interface{}{
5142 "rootURL": SakuraCloudAPIRoot,
5143 "pathSuffix": o.PathSuffix,
5144 "pathName": o.PathName,
5145 "zone": APIDefaultZone,
5146 "conditions": conditions,
5147 }
5148
5149 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}", pathBuildParameter)
5150 if err != nil {
5151 return nil, err
5152 }
5153 // build request body
5154 var body interface{}
5155 v, err := o.transformFindArgs(conditions)
5156 if err != nil {
5157 return nil, err
5158 }
5159 body = v
5160
5161 // do request
5162 data, err := o.Client.Do(ctx, "GET", url, body)
5163 if err != nil {
5164 return nil, err
5165 }
5166
5167 // build results
5168 results, err := o.transformFindResults(data)
5169 if err != nil {
5170 return nil, err
5171 }
5172 return results, err
5173 }
5174
5175 // Create is API call
5176 func (o *GSLBOp) Create(ctx context.Context, param *GSLBCreateRequest) (*GSLB, error) {
5177 // build request URL
5178 pathBuildParameter := map[string]interface{}{
5179 "rootURL": SakuraCloudAPIRoot,
5180 "pathSuffix": o.PathSuffix,
5181 "pathName": o.PathName,
5182 "zone": APIDefaultZone,
5183 "param": param,
5184 }
5185
5186 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}", pathBuildParameter)
5187 if err != nil {
5188 return nil, err
5189 }
5190 // build request body
5191 var body interface{}
5192 v, err := o.transformCreateArgs(param)
5193 if err != nil {
5194 return nil, err
5195 }
5196 body = v
5197
5198 // do request
5199 data, err := o.Client.Do(ctx, "POST", url, body)
5200 if err != nil {
5201 return nil, err
5202 }
5203
5204 // build results
5205 results, err := o.transformCreateResults(data)
5206 if err != nil {
5207 return nil, err
5208 }
5209 return results.GSLB, nil
5210 }
5211
5212 // Read is API call
5213 func (o *GSLBOp) Read(ctx context.Context, id types.ID) (*GSLB, error) {
5214 // build request URL
5215 pathBuildParameter := map[string]interface{}{
5216 "rootURL": SakuraCloudAPIRoot,
5217 "pathSuffix": o.PathSuffix,
5218 "pathName": o.PathName,
5219 "zone": APIDefaultZone,
5220 "id": id,
5221 }
5222
5223 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}", pathBuildParameter)
5224 if err != nil {
5225 return nil, err
5226 }
5227 // build request body
5228 var body interface{}
5229
5230 // do request
5231 data, err := o.Client.Do(ctx, "GET", url, body)
5232 if err != nil {
5233 return nil, err
5234 }
5235
5236 // build results
5237 results, err := o.transformReadResults(data)
5238 if err != nil {
5239 return nil, err
5240 }
5241 return results.GSLB, nil
5242 }
5243
5244 // Update is API call
5245 func (o *GSLBOp) Update(ctx context.Context, id types.ID, param *GSLBUpdateRequest) (*GSLB, error) {
5246 // build request URL
5247 pathBuildParameter := map[string]interface{}{
5248 "rootURL": SakuraCloudAPIRoot,
5249 "pathSuffix": o.PathSuffix,
5250 "pathName": o.PathName,
5251 "zone": APIDefaultZone,
5252 "id": id,
5253 "param": param,
5254 }
5255
5256 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}", pathBuildParameter)
5257 if err != nil {
5258 return nil, err
5259 }
5260 // build request body
5261 var body interface{}
5262 v, err := o.transformUpdateArgs(id, param)
5263 if err != nil {
5264 return nil, err
5265 }
5266 body = v
5267
5268 // do request
5269 data, err := o.Client.Do(ctx, "PUT", url, body)
5270 if err != nil {
5271 return nil, err
5272 }
5273
5274 // build results
5275 results, err := o.transformUpdateResults(data)
5276 if err != nil {
5277 return nil, err
5278 }
5279 return results.GSLB, nil
5280 }
5281
5282 // UpdateSettings is API call
5283 func (o *GSLBOp) UpdateSettings(ctx context.Context, id types.ID, param *GSLBUpdateSettingsRequest) (*GSLB, error) {
5284 // build request URL
5285 pathBuildParameter := map[string]interface{}{
5286 "rootURL": SakuraCloudAPIRoot,
5287 "pathSuffix": o.PathSuffix,
5288 "pathName": o.PathName,
5289 "zone": APIDefaultZone,
5290 "id": id,
5291 "param": param,
5292 }
5293
5294 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}", pathBuildParameter)
5295 if err != nil {
5296 return nil, err
5297 }
5298 // build request body
5299 var body interface{}
5300 v, err := o.transformUpdateSettingsArgs(id, param)
5301 if err != nil {
5302 return nil, err
5303 }
5304 body = v
5305
5306 // do request
5307 data, err := o.Client.Do(ctx, "PUT", url, body)
5308 if err != nil {
5309 return nil, err
5310 }
5311
5312 // build results
5313 results, err := o.transformUpdateSettingsResults(data)
5314 if err != nil {
5315 return nil, err
5316 }
5317 return results.GSLB, nil
5318 }
5319
5320 // Delete is API call
5321 func (o *GSLBOp) Delete(ctx context.Context, id types.ID) error {
5322 // build request URL
5323 pathBuildParameter := map[string]interface{}{
5324 "rootURL": SakuraCloudAPIRoot,
5325 "pathSuffix": o.PathSuffix,
5326 "pathName": o.PathName,
5327 "zone": APIDefaultZone,
5328 "id": id,
5329 }
5330
5331 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}", pathBuildParameter)
5332 if err != nil {
5333 return err
5334 }
5335 // build request body
5336 var body interface{}
5337
5338 // do request
5339 _, err = o.Client.Do(ctx, "DELETE", url, body)
5340 if err != nil {
5341 return err
5342 }
5343
5344 // build results
5345
5346 return nil
5347 }
5348
5349 /*************************************************
5350 * IconOp
5351 *************************************************/
5352
5353 // IconOp implements IconAPI interface
5354 type IconOp struct {
5355 // Client APICaller
5356 Client APICaller
5357 // PathSuffix is used when building URL
5358 PathSuffix string
5359 // PathName is used when building URL
5360 PathName string
5361 }
5362
5363 // NewIconOp creates new IconOp instance
5364 func NewIconOp(caller APICaller) IconAPI {
5365 return GetClientFactoryFunc("Icon")(caller).(IconAPI)
5366 }
5367
5368 // Find is API call
5369 func (o *IconOp) Find(ctx context.Context, conditions *FindCondition) (*IconFindResult, error) {
5370 // build request URL
5371 pathBuildParameter := map[string]interface{}{
5372 "rootURL": SakuraCloudAPIRoot,
5373 "pathSuffix": o.PathSuffix,
5374 "pathName": o.PathName,
5375 "zone": APIDefaultZone,
5376 "conditions": conditions,
5377 }
5378
5379 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}", pathBuildParameter)
5380 if err != nil {
5381 return nil, err
5382 }
5383 // build request body
5384 var body interface{}
5385 v, err := o.transformFindArgs(conditions)
5386 if err != nil {
5387 return nil, err
5388 }
5389 body = v
5390
5391 // do request
5392 data, err := o.Client.Do(ctx, "GET", url, body)
5393 if err != nil {
5394 return nil, err
5395 }
5396
5397 // build results
5398 results, err := o.transformFindResults(data)
5399 if err != nil {
5400 return nil, err
5401 }
5402 return results, err
5403 }
5404
5405 // Create is API call
5406 func (o *IconOp) Create(ctx context.Context, param *IconCreateRequest) (*Icon, error) {
5407 // build request URL
5408 pathBuildParameter := map[string]interface{}{
5409 "rootURL": SakuraCloudAPIRoot,
5410 "pathSuffix": o.PathSuffix,
5411 "pathName": o.PathName,
5412 "zone": APIDefaultZone,
5413 "param": param,
5414 }
5415
5416 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}", pathBuildParameter)
5417 if err != nil {
5418 return nil, err
5419 }
5420 // build request body
5421 var body interface{}
5422 v, err := o.transformCreateArgs(param)
5423 if err != nil {
5424 return nil, err
5425 }
5426 body = v
5427
5428 // do request
5429 data, err := o.Client.Do(ctx, "POST", url, body)
5430 if err != nil {
5431 return nil, err
5432 }
5433
5434 // build results
5435 results, err := o.transformCreateResults(data)
5436 if err != nil {
5437 return nil, err
5438 }
5439 return results.Icon, nil
5440 }
5441
5442 // Read is API call
5443 func (o *IconOp) Read(ctx context.Context, id types.ID) (*Icon, error) {
5444 // build request URL
5445 pathBuildParameter := map[string]interface{}{
5446 "rootURL": SakuraCloudAPIRoot,
5447 "pathSuffix": o.PathSuffix,
5448 "pathName": o.PathName,
5449 "zone": APIDefaultZone,
5450 "id": id,
5451 }
5452
5453 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}", pathBuildParameter)
5454 if err != nil {
5455 return nil, err
5456 }
5457 // build request body
5458 var body interface{}
5459
5460 // do request
5461 data, err := o.Client.Do(ctx, "GET", url, body)
5462 if err != nil {
5463 return nil, err
5464 }
5465
5466 // build results
5467 results, err := o.transformReadResults(data)
5468 if err != nil {
5469 return nil, err
5470 }
5471 return results.Icon, nil
5472 }
5473
5474 // Update is API call
5475 func (o *IconOp) Update(ctx context.Context, id types.ID, param *IconUpdateRequest) (*Icon, error) {
5476 // build request URL
5477 pathBuildParameter := map[string]interface{}{
5478 "rootURL": SakuraCloudAPIRoot,
5479 "pathSuffix": o.PathSuffix,
5480 "pathName": o.PathName,
5481 "zone": APIDefaultZone,
5482 "id": id,
5483 "param": param,
5484 }
5485
5486 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}", pathBuildParameter)
5487 if err != nil {
5488 return nil, err
5489 }
5490 // build request body
5491 var body interface{}
5492 v, err := o.transformUpdateArgs(id, param)
5493 if err != nil {
5494 return nil, err
5495 }
5496 body = v
5497
5498 // do request
5499 data, err := o.Client.Do(ctx, "PUT", url, body)
5500 if err != nil {
5501 return nil, err
5502 }
5503
5504 // build results
5505 results, err := o.transformUpdateResults(data)
5506 if err != nil {
5507 return nil, err
5508 }
5509 return results.Icon, nil
5510 }
5511
5512 // Delete is API call
5513 func (o *IconOp) Delete(ctx context.Context, id types.ID) error {
5514 // build request URL
5515 pathBuildParameter := map[string]interface{}{
5516 "rootURL": SakuraCloudAPIRoot,
5517 "pathSuffix": o.PathSuffix,
5518 "pathName": o.PathName,
5519 "zone": APIDefaultZone,
5520 "id": id,
5521 }
5522
5523 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}", pathBuildParameter)
5524 if err != nil {
5525 return err
5526 }
5527 // build request body
5528 var body interface{}
5529
5530 // do request
5531 _, err = o.Client.Do(ctx, "DELETE", url, body)
5532 if err != nil {
5533 return err
5534 }
5535
5536 // build results
5537
5538 return nil
5539 }
5540
5541 /*************************************************
5542 * InterfaceOp
5543 *************************************************/
5544
5545 // InterfaceOp implements InterfaceAPI interface
5546 type InterfaceOp struct {
5547 // Client APICaller
5548 Client APICaller
5549 // PathSuffix is used when building URL
5550 PathSuffix string
5551 // PathName is used when building URL
5552 PathName string
5553 }
5554
5555 // NewInterfaceOp creates new InterfaceOp instance
5556 func NewInterfaceOp(caller APICaller) InterfaceAPI {
5557 return GetClientFactoryFunc("Interface")(caller).(InterfaceAPI)
5558 }
5559
5560 // Find is API call
5561 func (o *InterfaceOp) Find(ctx context.Context, zone string, conditions *FindCondition) (*InterfaceFindResult, error) {
5562 // build request URL
5563 pathBuildParameter := map[string]interface{}{
5564 "rootURL": SakuraCloudAPIRoot,
5565 "pathSuffix": o.PathSuffix,
5566 "pathName": o.PathName,
5567 "zone": zone,
5568 "conditions": conditions,
5569 }
5570
5571 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}", pathBuildParameter)
5572 if err != nil {
5573 return nil, err
5574 }
5575 // build request body
5576 var body interface{}
5577 v, err := o.transformFindArgs(conditions)
5578 if err != nil {
5579 return nil, err
5580 }
5581 body = v
5582
5583 // do request
5584 data, err := o.Client.Do(ctx, "GET", url, body)
5585 if err != nil {
5586 return nil, err
5587 }
5588
5589 // build results
5590 results, err := o.transformFindResults(data)
5591 if err != nil {
5592 return nil, err
5593 }
5594 return results, err
5595 }
5596
5597 // Create is API call
5598 func (o *InterfaceOp) Create(ctx context.Context, zone string, param *InterfaceCreateRequest) (*Interface, error) {
5599 // build request URL
5600 pathBuildParameter := map[string]interface{}{
5601 "rootURL": SakuraCloudAPIRoot,
5602 "pathSuffix": o.PathSuffix,
5603 "pathName": o.PathName,
5604 "zone": zone,
5605 "param": param,
5606 }
5607
5608 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}", pathBuildParameter)
5609 if err != nil {
5610 return nil, err
5611 }
5612 // build request body
5613 var body interface{}
5614 v, err := o.transformCreateArgs(param)
5615 if err != nil {
5616 return nil, err
5617 }
5618 body = v
5619
5620 // do request
5621 data, err := o.Client.Do(ctx, "POST", url, body)
5622 if err != nil {
5623 return nil, err
5624 }
5625
5626 // build results
5627 results, err := o.transformCreateResults(data)
5628 if err != nil {
5629 return nil, err
5630 }
5631 return results.Interface, nil
5632 }
5633
5634 // Read is API call
5635 func (o *InterfaceOp) Read(ctx context.Context, zone string, id types.ID) (*Interface, error) {
5636 // build request URL
5637 pathBuildParameter := map[string]interface{}{
5638 "rootURL": SakuraCloudAPIRoot,
5639 "pathSuffix": o.PathSuffix,
5640 "pathName": o.PathName,
5641 "zone": zone,
5642 "id": id,
5643 }
5644
5645 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}", pathBuildParameter)
5646 if err != nil {
5647 return nil, err
5648 }
5649 // build request body
5650 var body interface{}
5651
5652 // do request
5653 data, err := o.Client.Do(ctx, "GET", url, body)
5654 if err != nil {
5655 return nil, err
5656 }
5657
5658 // build results
5659 results, err := o.transformReadResults(data)
5660 if err != nil {
5661 return nil, err
5662 }
5663 return results.Interface, nil
5664 }
5665
5666 // Update is API call
5667 func (o *InterfaceOp) Update(ctx context.Context, zone string, id types.ID, param *InterfaceUpdateRequest) (*Interface, error) {
5668 // build request URL
5669 pathBuildParameter := map[string]interface{}{
5670 "rootURL": SakuraCloudAPIRoot,
5671 "pathSuffix": o.PathSuffix,
5672 "pathName": o.PathName,
5673 "zone": zone,
5674 "id": id,
5675 "param": param,
5676 }
5677
5678 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}", pathBuildParameter)
5679 if err != nil {
5680 return nil, err
5681 }
5682 // build request body
5683 var body interface{}
5684 v, err := o.transformUpdateArgs(id, param)
5685 if err != nil {
5686 return nil, err
5687 }
5688 body = v
5689
5690 // do request
5691 data, err := o.Client.Do(ctx, "PUT", url, body)
5692 if err != nil {
5693 return nil, err
5694 }
5695
5696 // build results
5697 results, err := o.transformUpdateResults(data)
5698 if err != nil {
5699 return nil, err
5700 }
5701 return results.Interface, nil
5702 }
5703
5704 // Delete is API call
5705 func (o *InterfaceOp) Delete(ctx context.Context, zone string, id types.ID) error {
5706 // build request URL
5707 pathBuildParameter := map[string]interface{}{
5708 "rootURL": SakuraCloudAPIRoot,
5709 "pathSuffix": o.PathSuffix,
5710 "pathName": o.PathName,
5711 "zone": zone,
5712 "id": id,
5713 }
5714
5715 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}", pathBuildParameter)
5716 if err != nil {
5717 return err
5718 }
5719 // build request body
5720 var body interface{}
5721
5722 // do request
5723 _, err = o.Client.Do(ctx, "DELETE", url, body)
5724 if err != nil {
5725 return err
5726 }
5727
5728 // build results
5729
5730 return nil
5731 }
5732
5733 // Monitor is API call
5734 func (o *InterfaceOp) Monitor(ctx context.Context, zone string, id types.ID, condition *MonitorCondition) (*InterfaceActivity, error) {
5735 // build request URL
5736 pathBuildParameter := map[string]interface{}{
5737 "rootURL": SakuraCloudAPIRoot,
5738 "pathSuffix": o.PathSuffix,
5739 "pathName": o.PathName,
5740 "zone": zone,
5741 "id": id,
5742 "condition": condition,
5743 }
5744
5745 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}/monitor", pathBuildParameter)
5746 if err != nil {
5747 return nil, err
5748 }
5749 // build request body
5750 var body interface{}
5751 v, err := o.transformMonitorArgs(id, condition)
5752 if err != nil {
5753 return nil, err
5754 }
5755 body = v
5756
5757 // do request
5758 data, err := o.Client.Do(ctx, "GET", url, body)
5759 if err != nil {
5760 return nil, err
5761 }
5762
5763 // build results
5764 results, err := o.transformMonitorResults(data)
5765 if err != nil {
5766 return nil, err
5767 }
5768 return results.InterfaceActivity, nil
5769 }
5770
5771 // ConnectToSharedSegment is API call
5772 func (o *InterfaceOp) ConnectToSharedSegment(ctx context.Context, zone string, id types.ID) error {
5773 // build request URL
5774 pathBuildParameter := map[string]interface{}{
5775 "rootURL": SakuraCloudAPIRoot,
5776 "pathSuffix": o.PathSuffix,
5777 "pathName": o.PathName,
5778 "zone": zone,
5779 "id": id,
5780 }
5781
5782 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}/to/switch/shared", pathBuildParameter)
5783 if err != nil {
5784 return err
5785 }
5786 // build request body
5787 var body interface{}
5788
5789 // do request
5790 _, err = o.Client.Do(ctx, "PUT", url, body)
5791 if err != nil {
5792 return err
5793 }
5794
5795 // build results
5796
5797 return nil
5798 }
5799
5800 // ConnectToSwitch is API call
5801 func (o *InterfaceOp) ConnectToSwitch(ctx context.Context, zone string, id types.ID, switchID types.ID) error {
5802 // build request URL
5803 pathBuildParameter := map[string]interface{}{
5804 "rootURL": SakuraCloudAPIRoot,
5805 "pathSuffix": o.PathSuffix,
5806 "pathName": o.PathName,
5807 "zone": zone,
5808 "id": id,
5809 "switchID": switchID,
5810 }
5811
5812 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}/to/switch/{{.switchID}}", pathBuildParameter)
5813 if err != nil {
5814 return err
5815 }
5816 // build request body
5817 var body interface{}
5818
5819 // do request
5820 _, err = o.Client.Do(ctx, "PUT", url, body)
5821 if err != nil {
5822 return err
5823 }
5824
5825 // build results
5826
5827 return nil
5828 }
5829
5830 // DisconnectFromSwitch is API call
5831 func (o *InterfaceOp) DisconnectFromSwitch(ctx context.Context, zone string, id types.ID) error {
5832 // build request URL
5833 pathBuildParameter := map[string]interface{}{
5834 "rootURL": SakuraCloudAPIRoot,
5835 "pathSuffix": o.PathSuffix,
5836 "pathName": o.PathName,
5837 "zone": zone,
5838 "id": id,
5839 }
5840
5841 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}/to/switch", pathBuildParameter)
5842 if err != nil {
5843 return err
5844 }
5845 // build request body
5846 var body interface{}
5847
5848 // do request
5849 _, err = o.Client.Do(ctx, "DELETE", url, body)
5850 if err != nil {
5851 return err
5852 }
5853
5854 // build results
5855
5856 return nil
5857 }
5858
5859 // ConnectToPacketFilter is API call
5860 func (o *InterfaceOp) ConnectToPacketFilter(ctx context.Context, zone string, id types.ID, packetFilterID types.ID) error {
5861 // build request URL
5862 pathBuildParameter := map[string]interface{}{
5863 "rootURL": SakuraCloudAPIRoot,
5864 "pathSuffix": o.PathSuffix,
5865 "pathName": o.PathName,
5866 "zone": zone,
5867 "id": id,
5868 "packetFilterID": packetFilterID,
5869 }
5870
5871 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}/to/packetfilter/{{.packetFilterID}}", pathBuildParameter)
5872 if err != nil {
5873 return err
5874 }
5875 // build request body
5876 var body interface{}
5877
5878 // do request
5879 _, err = o.Client.Do(ctx, "PUT", url, body)
5880 if err != nil {
5881 return err
5882 }
5883
5884 // build results
5885
5886 return nil
5887 }
5888
5889 // DisconnectFromPacketFilter is API call
5890 func (o *InterfaceOp) DisconnectFromPacketFilter(ctx context.Context, zone string, id types.ID) error {
5891 // build request URL
5892 pathBuildParameter := map[string]interface{}{
5893 "rootURL": SakuraCloudAPIRoot,
5894 "pathSuffix": o.PathSuffix,
5895 "pathName": o.PathName,
5896 "zone": zone,
5897 "id": id,
5898 }
5899
5900 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}/to/packetfilter", pathBuildParameter)
5901 if err != nil {
5902 return err
5903 }
5904 // build request body
5905 var body interface{}
5906
5907 // do request
5908 _, err = o.Client.Do(ctx, "DELETE", url, body)
5909 if err != nil {
5910 return err
5911 }
5912
5913 // build results
5914
5915 return nil
5916 }
5917
5918 /*************************************************
5919 * InternetOp
5920 *************************************************/
5921
5922 // InternetOp implements InternetAPI interface
5923 type InternetOp struct {
5924 // Client APICaller
5925 Client APICaller
5926 // PathSuffix is used when building URL
5927 PathSuffix string
5928 // PathName is used when building URL
5929 PathName string
5930 }
5931
5932 // NewInternetOp creates new InternetOp instance
5933 func NewInternetOp(caller APICaller) InternetAPI {
5934 return GetClientFactoryFunc("Internet")(caller).(InternetAPI)
5935 }
5936
5937 // Find is API call
5938 func (o *InternetOp) Find(ctx context.Context, zone string, conditions *FindCondition) (*InternetFindResult, error) {
5939 // build request URL
5940 pathBuildParameter := map[string]interface{}{
5941 "rootURL": SakuraCloudAPIRoot,
5942 "pathSuffix": o.PathSuffix,
5943 "pathName": o.PathName,
5944 "zone": zone,
5945 "conditions": conditions,
5946 }
5947
5948 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}", pathBuildParameter)
5949 if err != nil {
5950 return nil, err
5951 }
5952 // build request body
5953 var body interface{}
5954 v, err := o.transformFindArgs(conditions)
5955 if err != nil {
5956 return nil, err
5957 }
5958 body = v
5959
5960 // do request
5961 data, err := o.Client.Do(ctx, "GET", url, body)
5962 if err != nil {
5963 return nil, err
5964 }
5965
5966 // build results
5967 results, err := o.transformFindResults(data)
5968 if err != nil {
5969 return nil, err
5970 }
5971 return results, err
5972 }
5973
5974 // Create is API call
5975 func (o *InternetOp) Create(ctx context.Context, zone string, param *InternetCreateRequest) (*Internet, error) {
5976 // build request URL
5977 pathBuildParameter := map[string]interface{}{
5978 "rootURL": SakuraCloudAPIRoot,
5979 "pathSuffix": o.PathSuffix,
5980 "pathName": o.PathName,
5981 "zone": zone,
5982 "param": param,
5983 }
5984
5985 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}", pathBuildParameter)
5986 if err != nil {
5987 return nil, err
5988 }
5989 // build request body
5990 var body interface{}
5991 v, err := o.transformCreateArgs(param)
5992 if err != nil {
5993 return nil, err
5994 }
5995 body = v
5996
5997 // do request
5998 data, err := o.Client.Do(ctx, "POST", url, body)
5999 if err != nil {
6000 return nil, err
6001 }
6002
6003 // build results
6004 results, err := o.transformCreateResults(data)
6005 if err != nil {
6006 return nil, err
6007 }
6008 return results.Internet, nil
6009 }
6010
6011 // Read is API call
6012 func (o *InternetOp) Read(ctx context.Context, zone string, id types.ID) (*Internet, error) {
6013 // build request URL
6014 pathBuildParameter := map[string]interface{}{
6015 "rootURL": SakuraCloudAPIRoot,
6016 "pathSuffix": o.PathSuffix,
6017 "pathName": o.PathName,
6018 "zone": zone,
6019 "id": id,
6020 }
6021
6022 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}", pathBuildParameter)
6023 if err != nil {
6024 return nil, err
6025 }
6026 // build request body
6027 var body interface{}
6028
6029 // do request
6030 data, err := o.Client.Do(ctx, "GET", url, body)
6031 if err != nil {
6032 return nil, err
6033 }
6034
6035 // build results
6036 results, err := o.transformReadResults(data)
6037 if err != nil {
6038 return nil, err
6039 }
6040 return results.Internet, nil
6041 }
6042
6043 // Update is API call
6044 func (o *InternetOp) Update(ctx context.Context, zone string, id types.ID, param *InternetUpdateRequest) (*Internet, error) {
6045 // build request URL
6046 pathBuildParameter := map[string]interface{}{
6047 "rootURL": SakuraCloudAPIRoot,
6048 "pathSuffix": o.PathSuffix,
6049 "pathName": o.PathName,
6050 "zone": zone,
6051 "id": id,
6052 "param": param,
6053 }
6054
6055 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}", pathBuildParameter)
6056 if err != nil {
6057 return nil, err
6058 }
6059 // build request body
6060 var body interface{}
6061 v, err := o.transformUpdateArgs(id, param)
6062 if err != nil {
6063 return nil, err
6064 }
6065 body = v
6066
6067 // do request
6068 data, err := o.Client.Do(ctx, "PUT", url, body)
6069 if err != nil {
6070 return nil, err
6071 }
6072
6073 // build results
6074 results, err := o.transformUpdateResults(data)
6075 if err != nil {
6076 return nil, err
6077 }
6078 return results.Internet, nil
6079 }
6080
6081 // Delete is API call
6082 func (o *InternetOp) Delete(ctx context.Context, zone string, id types.ID) error {
6083 // build request URL
6084 pathBuildParameter := map[string]interface{}{
6085 "rootURL": SakuraCloudAPIRoot,
6086 "pathSuffix": o.PathSuffix,
6087 "pathName": o.PathName,
6088 "zone": zone,
6089 "id": id,
6090 }
6091
6092 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}", pathBuildParameter)
6093 if err != nil {
6094 return err
6095 }
6096 // build request body
6097 var body interface{}
6098
6099 // do request
6100 _, err = o.Client.Do(ctx, "DELETE", url, body)
6101 if err != nil {
6102 return err
6103 }
6104
6105 // build results
6106
6107 return nil
6108 }
6109
6110 // UpdateBandWidth is API call
6111 func (o *InternetOp) UpdateBandWidth(ctx context.Context, zone string, id types.ID, param *InternetUpdateBandWidthRequest) (*Internet, error) {
6112 // build request URL
6113 pathBuildParameter := map[string]interface{}{
6114 "rootURL": SakuraCloudAPIRoot,
6115 "pathSuffix": o.PathSuffix,
6116 "pathName": o.PathName,
6117 "zone": zone,
6118 "id": id,
6119 "param": param,
6120 }
6121
6122 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}/bandwidth", pathBuildParameter)
6123 if err != nil {
6124 return nil, err
6125 }
6126 // build request body
6127 var body interface{}
6128 v, err := o.transformUpdateBandWidthArgs(id, param)
6129 if err != nil {
6130 return nil, err
6131 }
6132 body = v
6133
6134 // do request
6135 data, err := o.Client.Do(ctx, "PUT", url, body)
6136 if err != nil {
6137 return nil, err
6138 }
6139
6140 // build results
6141 results, err := o.transformUpdateBandWidthResults(data)
6142 if err != nil {
6143 return nil, err
6144 }
6145 return results.Internet, nil
6146 }
6147
6148 // AddSubnet is API call
6149 func (o *InternetOp) AddSubnet(ctx context.Context, zone string, id types.ID, param *InternetAddSubnetRequest) (*InternetSubnetOperationResult, error) {
6150 // build request URL
6151 pathBuildParameter := map[string]interface{}{
6152 "rootURL": SakuraCloudAPIRoot,
6153 "pathSuffix": o.PathSuffix,
6154 "pathName": o.PathName,
6155 "zone": zone,
6156 "id": id,
6157 "param": param,
6158 }
6159
6160 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}/subnet", pathBuildParameter)
6161 if err != nil {
6162 return nil, err
6163 }
6164 // build request body
6165 var body interface{}
6166 v, err := o.transformAddSubnetArgs(id, param)
6167 if err != nil {
6168 return nil, err
6169 }
6170 body = v
6171
6172 // do request
6173 data, err := o.Client.Do(ctx, "POST", url, body)
6174 if err != nil {
6175 return nil, err
6176 }
6177
6178 // build results
6179 results, err := o.transformAddSubnetResults(data)
6180 if err != nil {
6181 return nil, err
6182 }
6183 return results.Subnet, nil
6184 }
6185
6186 // UpdateSubnet is API call
6187 func (o *InternetOp) UpdateSubnet(ctx context.Context, zone string, id types.ID, subnetID types.ID, param *InternetUpdateSubnetRequest) (*InternetSubnetOperationResult, error) {
6188 // build request URL
6189 pathBuildParameter := map[string]interface{}{
6190 "rootURL": SakuraCloudAPIRoot,
6191 "pathSuffix": o.PathSuffix,
6192 "pathName": o.PathName,
6193 "zone": zone,
6194 "id": id,
6195 "subnetID": subnetID,
6196 "param": param,
6197 }
6198
6199 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}/subnet/{{.subnetID}}", pathBuildParameter)
6200 if err != nil {
6201 return nil, err
6202 }
6203 // build request body
6204 var body interface{}
6205 v, err := o.transformUpdateSubnetArgs(id, subnetID, param)
6206 if err != nil {
6207 return nil, err
6208 }
6209 body = v
6210
6211 // do request
6212 data, err := o.Client.Do(ctx, "PUT", url, body)
6213 if err != nil {
6214 return nil, err
6215 }
6216
6217 // build results
6218 results, err := o.transformUpdateSubnetResults(data)
6219 if err != nil {
6220 return nil, err
6221 }
6222 return results.Subnet, nil
6223 }
6224
6225 // DeleteSubnet is API call
6226 func (o *InternetOp) DeleteSubnet(ctx context.Context, zone string, id types.ID, subnetID types.ID) error {
6227 // build request URL
6228 pathBuildParameter := map[string]interface{}{
6229 "rootURL": SakuraCloudAPIRoot,
6230 "pathSuffix": o.PathSuffix,
6231 "pathName": o.PathName,
6232 "zone": zone,
6233 "id": id,
6234 "subnetID": subnetID,
6235 }
6236
6237 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}/subnet/{{.subnetID}}", pathBuildParameter)
6238 if err != nil {
6239 return err
6240 }
6241 // build request body
6242 var body interface{}
6243
6244 // do request
6245 _, err = o.Client.Do(ctx, "DELETE", url, body)
6246 if err != nil {
6247 return err
6248 }
6249
6250 // build results
6251
6252 return nil
6253 }
6254
6255 // Monitor is API call
6256 func (o *InternetOp) Monitor(ctx context.Context, zone string, id types.ID, condition *MonitorCondition) (*RouterActivity, error) {
6257 // build request URL
6258 pathBuildParameter := map[string]interface{}{
6259 "rootURL": SakuraCloudAPIRoot,
6260 "pathSuffix": o.PathSuffix,
6261 "pathName": o.PathName,
6262 "zone": zone,
6263 "id": id,
6264 "condition": condition,
6265 }
6266
6267 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}/monitor", pathBuildParameter)
6268 if err != nil {
6269 return nil, err
6270 }
6271 // build request body
6272 var body interface{}
6273 v, err := o.transformMonitorArgs(id, condition)
6274 if err != nil {
6275 return nil, err
6276 }
6277 body = v
6278
6279 // do request
6280 data, err := o.Client.Do(ctx, "GET", url, body)
6281 if err != nil {
6282 return nil, err
6283 }
6284
6285 // build results
6286 results, err := o.transformMonitorResults(data)
6287 if err != nil {
6288 return nil, err
6289 }
6290 return results.RouterActivity, nil
6291 }
6292
6293 // MonitorRouter is API call
6294 func (o *InternetOp) MonitorRouter(ctx context.Context, zone string, id types.ID, condition *MonitorCondition) (*RouterActivity, error) {
6295 // build request URL
6296 pathBuildParameter := map[string]interface{}{
6297 "rootURL": SakuraCloudAPIRoot,
6298 "pathSuffix": o.PathSuffix,
6299 "pathName": o.PathName,
6300 "zone": zone,
6301 "id": id,
6302 "condition": condition,
6303 }
6304
6305 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}/monitor", pathBuildParameter)
6306 if err != nil {
6307 return nil, err
6308 }
6309 // build request body
6310 var body interface{}
6311 v, err := o.transformMonitorRouterArgs(id, condition)
6312 if err != nil {
6313 return nil, err
6314 }
6315 body = v
6316
6317 // do request
6318 data, err := o.Client.Do(ctx, "GET", url, body)
6319 if err != nil {
6320 return nil, err
6321 }
6322
6323 // build results
6324 results, err := o.transformMonitorRouterResults(data)
6325 if err != nil {
6326 return nil, err
6327 }
6328 return results.RouterActivity, nil
6329 }
6330
6331 // EnableIPv6 is API call
6332 func (o *InternetOp) EnableIPv6(ctx context.Context, zone string, id types.ID) (*IPv6NetInfo, error) {
6333 // build request URL
6334 pathBuildParameter := map[string]interface{}{
6335 "rootURL": SakuraCloudAPIRoot,
6336 "pathSuffix": o.PathSuffix,
6337 "pathName": o.PathName,
6338 "zone": zone,
6339 "id": id,
6340 }
6341
6342 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}/ipv6net", pathBuildParameter)
6343 if err != nil {
6344 return nil, err
6345 }
6346 // build request body
6347 var body interface{}
6348
6349 // do request
6350 data, err := o.Client.Do(ctx, "POST", url, body)
6351 if err != nil {
6352 return nil, err
6353 }
6354
6355 // build results
6356 results, err := o.transformEnableIPv6Results(data)
6357 if err != nil {
6358 return nil, err
6359 }
6360 return results.IPv6Net, nil
6361 }
6362
6363 // DisableIPv6 is API call
6364 func (o *InternetOp) DisableIPv6(ctx context.Context, zone string, id types.ID, ipv6netID types.ID) error {
6365 // build request URL
6366 pathBuildParameter := map[string]interface{}{
6367 "rootURL": SakuraCloudAPIRoot,
6368 "pathSuffix": o.PathSuffix,
6369 "pathName": o.PathName,
6370 "zone": zone,
6371 "id": id,
6372 "ipv6netID": ipv6netID,
6373 }
6374
6375 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}/ipv6net/{{.ipv6netID}}", pathBuildParameter)
6376 if err != nil {
6377 return err
6378 }
6379 // build request body
6380 var body interface{}
6381
6382 // do request
6383 _, err = o.Client.Do(ctx, "DELETE", url, body)
6384 if err != nil {
6385 return err
6386 }
6387
6388 // build results
6389
6390 return nil
6391 }
6392
6393 /*************************************************
6394 * InternetPlanOp
6395 *************************************************/
6396
6397 // InternetPlanOp implements InternetPlanAPI interface
6398 type InternetPlanOp struct {
6399 // Client APICaller
6400 Client APICaller
6401 // PathSuffix is used when building URL
6402 PathSuffix string
6403 // PathName is used when building URL
6404 PathName string
6405 }
6406
6407 // NewInternetPlanOp creates new InternetPlanOp instance
6408 func NewInternetPlanOp(caller APICaller) InternetPlanAPI {
6409 return GetClientFactoryFunc("InternetPlan")(caller).(InternetPlanAPI)
6410 }
6411
6412 // Find is API call
6413 func (o *InternetPlanOp) Find(ctx context.Context, zone string, conditions *FindCondition) (*InternetPlanFindResult, error) {
6414 // build request URL
6415 pathBuildParameter := map[string]interface{}{
6416 "rootURL": SakuraCloudAPIRoot,
6417 "pathSuffix": o.PathSuffix,
6418 "pathName": o.PathName,
6419 "zone": zone,
6420 "conditions": conditions,
6421 }
6422
6423 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}", pathBuildParameter)
6424 if err != nil {
6425 return nil, err
6426 }
6427 // build request body
6428 var body interface{}
6429 v, err := o.transformFindArgs(conditions)
6430 if err != nil {
6431 return nil, err
6432 }
6433 body = v
6434
6435 // do request
6436 data, err := o.Client.Do(ctx, "GET", url, body)
6437 if err != nil {
6438 return nil, err
6439 }
6440
6441 // build results
6442 results, err := o.transformFindResults(data)
6443 if err != nil {
6444 return nil, err
6445 }
6446 return results, err
6447 }
6448
6449 // Read is API call
6450 func (o *InternetPlanOp) Read(ctx context.Context, zone string, id types.ID) (*InternetPlan, error) {
6451 // build request URL
6452 pathBuildParameter := map[string]interface{}{
6453 "rootURL": SakuraCloudAPIRoot,
6454 "pathSuffix": o.PathSuffix,
6455 "pathName": o.PathName,
6456 "zone": zone,
6457 "id": id,
6458 }
6459
6460 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}", pathBuildParameter)
6461 if err != nil {
6462 return nil, err
6463 }
6464 // build request body
6465 var body interface{}
6466
6467 // do request
6468 data, err := o.Client.Do(ctx, "GET", url, body)
6469 if err != nil {
6470 return nil, err
6471 }
6472
6473 // build results
6474 results, err := o.transformReadResults(data)
6475 if err != nil {
6476 return nil, err
6477 }
6478 return results.InternetPlan, nil
6479 }
6480
6481 /*************************************************
6482 * IPAddressOp
6483 *************************************************/
6484
6485 // IPAddressOp implements IPAddressAPI interface
6486 type IPAddressOp struct {
6487 // Client APICaller
6488 Client APICaller
6489 // PathSuffix is used when building URL
6490 PathSuffix string
6491 // PathName is used when building URL
6492 PathName string
6493 }
6494
6495 // NewIPAddressOp creates new IPAddressOp instance
6496 func NewIPAddressOp(caller APICaller) IPAddressAPI {
6497 return GetClientFactoryFunc("IPAddress")(caller).(IPAddressAPI)
6498 }
6499
6500 // List is API call
6501 func (o *IPAddressOp) List(ctx context.Context, zone string) (*IPAddressListResult, error) {
6502 // build request URL
6503 pathBuildParameter := map[string]interface{}{
6504 "rootURL": SakuraCloudAPIRoot,
6505 "pathSuffix": o.PathSuffix,
6506 "pathName": o.PathName,
6507 "zone": zone,
6508 }
6509
6510 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}", pathBuildParameter)
6511 if err != nil {
6512 return nil, err
6513 }
6514 // build request body
6515 var body interface{}
6516
6517 // do request
6518 data, err := o.Client.Do(ctx, "GET", url, body)
6519 if err != nil {
6520 return nil, err
6521 }
6522
6523 // build results
6524 results, err := o.transformListResults(data)
6525 if err != nil {
6526 return nil, err
6527 }
6528 return results, err
6529 }
6530
6531 // Read is API call
6532 func (o *IPAddressOp) Read(ctx context.Context, zone string, ipAddress string) (*IPAddress, error) {
6533 // build request URL
6534 pathBuildParameter := map[string]interface{}{
6535 "rootURL": SakuraCloudAPIRoot,
6536 "pathSuffix": o.PathSuffix,
6537 "pathName": o.PathName,
6538 "zone": zone,
6539 "ipAddress": ipAddress,
6540 }
6541
6542 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.ipAddress}}", pathBuildParameter)
6543 if err != nil {
6544 return nil, err
6545 }
6546 // build request body
6547 var body interface{}
6548
6549 // do request
6550 data, err := o.Client.Do(ctx, "GET", url, body)
6551 if err != nil {
6552 return nil, err
6553 }
6554
6555 // build results
6556 results, err := o.transformReadResults(data)
6557 if err != nil {
6558 return nil, err
6559 }
6560 return results.IPAddress, nil
6561 }
6562
6563 // UpdateHostName is API call
6564 func (o *IPAddressOp) UpdateHostName(ctx context.Context, zone string, ipAddress string, hostName string) (*IPAddress, error) {
6565 // build request URL
6566 pathBuildParameter := map[string]interface{}{
6567 "rootURL": SakuraCloudAPIRoot,
6568 "pathSuffix": o.PathSuffix,
6569 "pathName": o.PathName,
6570 "zone": zone,
6571 "ipAddress": ipAddress,
6572 "hostName": hostName,
6573 }
6574
6575 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.ipAddress}}", pathBuildParameter)
6576 if err != nil {
6577 return nil, err
6578 }
6579 // build request body
6580 var body interface{}
6581 v, err := o.transformUpdateHostNameArgs(ipAddress, hostName)
6582 if err != nil {
6583 return nil, err
6584 }
6585 body = v
6586
6587 // do request
6588 data, err := o.Client.Do(ctx, "PUT", url, body)
6589 if err != nil {
6590 return nil, err
6591 }
6592
6593 // build results
6594 results, err := o.transformUpdateHostNameResults(data)
6595 if err != nil {
6596 return nil, err
6597 }
6598 return results.IPAddress, nil
6599 }
6600
6601 /*************************************************
6602 * IPv6NetOp
6603 *************************************************/
6604
6605 // IPv6NetOp implements IPv6NetAPI interface
6606 type IPv6NetOp struct {
6607 // Client APICaller
6608 Client APICaller
6609 // PathSuffix is used when building URL
6610 PathSuffix string
6611 // PathName is used when building URL
6612 PathName string
6613 }
6614
6615 // NewIPv6NetOp creates new IPv6NetOp instance
6616 func NewIPv6NetOp(caller APICaller) IPv6NetAPI {
6617 return GetClientFactoryFunc("IPv6Net")(caller).(IPv6NetAPI)
6618 }
6619
6620 // List is API call
6621 func (o *IPv6NetOp) List(ctx context.Context, zone string) (*IPv6NetListResult, error) {
6622 // build request URL
6623 pathBuildParameter := map[string]interface{}{
6624 "rootURL": SakuraCloudAPIRoot,
6625 "pathSuffix": o.PathSuffix,
6626 "pathName": o.PathName,
6627 "zone": zone,
6628 }
6629
6630 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}", pathBuildParameter)
6631 if err != nil {
6632 return nil, err
6633 }
6634 // build request body
6635 var body interface{}
6636
6637 // do request
6638 data, err := o.Client.Do(ctx, "GET", url, body)
6639 if err != nil {
6640 return nil, err
6641 }
6642
6643 // build results
6644 results, err := o.transformListResults(data)
6645 if err != nil {
6646 return nil, err
6647 }
6648 return results, err
6649 }
6650
6651 // Find is API call
6652 func (o *IPv6NetOp) Find(ctx context.Context, zone string, conditions *FindCondition) (*IPv6NetFindResult, error) {
6653 // build request URL
6654 pathBuildParameter := map[string]interface{}{
6655 "rootURL": SakuraCloudAPIRoot,
6656 "pathSuffix": o.PathSuffix,
6657 "pathName": o.PathName,
6658 "zone": zone,
6659 "conditions": conditions,
6660 }
6661
6662 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}", pathBuildParameter)
6663 if err != nil {
6664 return nil, err
6665 }
6666 // build request body
6667 var body interface{}
6668 v, err := o.transformFindArgs(conditions)
6669 if err != nil {
6670 return nil, err
6671 }
6672 body = v
6673
6674 // do request
6675 data, err := o.Client.Do(ctx, "GET", url, body)
6676 if err != nil {
6677 return nil, err
6678 }
6679
6680 // build results
6681 results, err := o.transformFindResults(data)
6682 if err != nil {
6683 return nil, err
6684 }
6685 return results, err
6686 }
6687
6688 // Read is API call
6689 func (o *IPv6NetOp) Read(ctx context.Context, zone string, id types.ID) (*IPv6Net, error) {
6690 // build request URL
6691 pathBuildParameter := map[string]interface{}{
6692 "rootURL": SakuraCloudAPIRoot,
6693 "pathSuffix": o.PathSuffix,
6694 "pathName": o.PathName,
6695 "zone": zone,
6696 "id": id,
6697 }
6698
6699 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}", pathBuildParameter)
6700 if err != nil {
6701 return nil, err
6702 }
6703 // build request body
6704 var body interface{}
6705
6706 // do request
6707 data, err := o.Client.Do(ctx, "GET", url, body)
6708 if err != nil {
6709 return nil, err
6710 }
6711
6712 // build results
6713 results, err := o.transformReadResults(data)
6714 if err != nil {
6715 return nil, err
6716 }
6717 return results.IPv6Net, nil
6718 }
6719
6720 /*************************************************
6721 * IPv6AddrOp
6722 *************************************************/
6723
6724 // IPv6AddrOp implements IPv6AddrAPI interface
6725 type IPv6AddrOp struct {
6726 // Client APICaller
6727 Client APICaller
6728 // PathSuffix is used when building URL
6729 PathSuffix string
6730 // PathName is used when building URL
6731 PathName string
6732 }
6733
6734 // NewIPv6AddrOp creates new IPv6AddrOp instance
6735 func NewIPv6AddrOp(caller APICaller) IPv6AddrAPI {
6736 return GetClientFactoryFunc("IPv6Addr")(caller).(IPv6AddrAPI)
6737 }
6738
6739 // Find is API call
6740 func (o *IPv6AddrOp) Find(ctx context.Context, zone string, conditions *FindCondition) (*IPv6AddrFindResult, error) {
6741 // build request URL
6742 pathBuildParameter := map[string]interface{}{
6743 "rootURL": SakuraCloudAPIRoot,
6744 "pathSuffix": o.PathSuffix,
6745 "pathName": o.PathName,
6746 "zone": zone,
6747 "conditions": conditions,
6748 }
6749
6750 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}", pathBuildParameter)
6751 if err != nil {
6752 return nil, err
6753 }
6754 // build request body
6755 var body interface{}
6756 v, err := o.transformFindArgs(conditions)
6757 if err != nil {
6758 return nil, err
6759 }
6760 body = v
6761
6762 // do request
6763 data, err := o.Client.Do(ctx, "GET", url, body)
6764 if err != nil {
6765 return nil, err
6766 }
6767
6768 // build results
6769 results, err := o.transformFindResults(data)
6770 if err != nil {
6771 return nil, err
6772 }
6773 return results, err
6774 }
6775
6776 // Create is API call
6777 func (o *IPv6AddrOp) Create(ctx context.Context, zone string, param *IPv6AddrCreateRequest) (*IPv6Addr, error) {
6778 // build request URL
6779 pathBuildParameter := map[string]interface{}{
6780 "rootURL": SakuraCloudAPIRoot,
6781 "pathSuffix": o.PathSuffix,
6782 "pathName": o.PathName,
6783 "zone": zone,
6784 "param": param,
6785 }
6786
6787 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}", pathBuildParameter)
6788 if err != nil {
6789 return nil, err
6790 }
6791 // build request body
6792 var body interface{}
6793 v, err := o.transformCreateArgs(param)
6794 if err != nil {
6795 return nil, err
6796 }
6797 body = v
6798
6799 // do request
6800 data, err := o.Client.Do(ctx, "POST", url, body)
6801 if err != nil {
6802 return nil, err
6803 }
6804
6805 // build results
6806 results, err := o.transformCreateResults(data)
6807 if err != nil {
6808 return nil, err
6809 }
6810 return results.IPv6Addr, nil
6811 }
6812
6813 // Read is API call
6814 func (o *IPv6AddrOp) Read(ctx context.Context, zone string, ipv6addr string) (*IPv6Addr, error) {
6815 // build request URL
6816 pathBuildParameter := map[string]interface{}{
6817 "rootURL": SakuraCloudAPIRoot,
6818 "pathSuffix": o.PathSuffix,
6819 "pathName": o.PathName,
6820 "zone": zone,
6821 "id": ipv6addr,
6822 }
6823
6824 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}", pathBuildParameter)
6825 if err != nil {
6826 return nil, err
6827 }
6828 // build request body
6829 var body interface{}
6830
6831 // do request
6832 data, err := o.Client.Do(ctx, "GET", url, body)
6833 if err != nil {
6834 return nil, err
6835 }
6836
6837 // build results
6838 results, err := o.transformReadResults(data)
6839 if err != nil {
6840 return nil, err
6841 }
6842 return results.IPv6Addr, nil
6843 }
6844
6845 // Update is API call
6846 func (o *IPv6AddrOp) Update(ctx context.Context, zone string, ipv6addr string, param *IPv6AddrUpdateRequest) (*IPv6Addr, error) {
6847 // build request URL
6848 pathBuildParameter := map[string]interface{}{
6849 "rootURL": SakuraCloudAPIRoot,
6850 "pathSuffix": o.PathSuffix,
6851 "pathName": o.PathName,
6852 "zone": zone,
6853 "id": ipv6addr,
6854 "param": param,
6855 }
6856
6857 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}", pathBuildParameter)
6858 if err != nil {
6859 return nil, err
6860 }
6861 // build request body
6862 var body interface{}
6863 v, err := o.transformUpdateArgs(ipv6addr, param)
6864 if err != nil {
6865 return nil, err
6866 }
6867 body = v
6868
6869 // do request
6870 data, err := o.Client.Do(ctx, "PUT", url, body)
6871 if err != nil {
6872 return nil, err
6873 }
6874
6875 // build results
6876 results, err := o.transformUpdateResults(data)
6877 if err != nil {
6878 return nil, err
6879 }
6880 return results.IPv6Addr, nil
6881 }
6882
6883 // Delete is API call
6884 func (o *IPv6AddrOp) Delete(ctx context.Context, zone string, ipv6addr string) error {
6885 // build request URL
6886 pathBuildParameter := map[string]interface{}{
6887 "rootURL": SakuraCloudAPIRoot,
6888 "pathSuffix": o.PathSuffix,
6889 "pathName": o.PathName,
6890 "zone": zone,
6891 "id": ipv6addr,
6892 }
6893
6894 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}", pathBuildParameter)
6895 if err != nil {
6896 return err
6897 }
6898 // build request body
6899 var body interface{}
6900
6901 // do request
6902 _, err = o.Client.Do(ctx, "DELETE", url, body)
6903 if err != nil {
6904 return err
6905 }
6906
6907 // build results
6908
6909 return nil
6910 }
6911
6912 /*************************************************
6913 * LicenseOp
6914 *************************************************/
6915
6916 // LicenseOp implements LicenseAPI interface
6917 type LicenseOp struct {
6918 // Client APICaller
6919 Client APICaller
6920 // PathSuffix is used when building URL
6921 PathSuffix string
6922 // PathName is used when building URL
6923 PathName string
6924 }
6925
6926 // NewLicenseOp creates new LicenseOp instance
6927 func NewLicenseOp(caller APICaller) LicenseAPI {
6928 return GetClientFactoryFunc("License")(caller).(LicenseAPI)
6929 }
6930
6931 // Find is API call
6932 func (o *LicenseOp) Find(ctx context.Context, conditions *FindCondition) (*LicenseFindResult, error) {
6933 // build request URL
6934 pathBuildParameter := map[string]interface{}{
6935 "rootURL": SakuraCloudAPIRoot,
6936 "pathSuffix": o.PathSuffix,
6937 "pathName": o.PathName,
6938 "zone": APIDefaultZone,
6939 "conditions": conditions,
6940 }
6941
6942 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}", pathBuildParameter)
6943 if err != nil {
6944 return nil, err
6945 }
6946 // build request body
6947 var body interface{}
6948 v, err := o.transformFindArgs(conditions)
6949 if err != nil {
6950 return nil, err
6951 }
6952 body = v
6953
6954 // do request
6955 data, err := o.Client.Do(ctx, "GET", url, body)
6956 if err != nil {
6957 return nil, err
6958 }
6959
6960 // build results
6961 results, err := o.transformFindResults(data)
6962 if err != nil {
6963 return nil, err
6964 }
6965 return results, err
6966 }
6967
6968 // Create is API call
6969 func (o *LicenseOp) Create(ctx context.Context, param *LicenseCreateRequest) (*License, error) {
6970 // build request URL
6971 pathBuildParameter := map[string]interface{}{
6972 "rootURL": SakuraCloudAPIRoot,
6973 "pathSuffix": o.PathSuffix,
6974 "pathName": o.PathName,
6975 "zone": APIDefaultZone,
6976 "param": param,
6977 }
6978
6979 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}", pathBuildParameter)
6980 if err != nil {
6981 return nil, err
6982 }
6983 // build request body
6984 var body interface{}
6985 v, err := o.transformCreateArgs(param)
6986 if err != nil {
6987 return nil, err
6988 }
6989 body = v
6990
6991 // do request
6992 data, err := o.Client.Do(ctx, "POST", url, body)
6993 if err != nil {
6994 return nil, err
6995 }
6996
6997 // build results
6998 results, err := o.transformCreateResults(data)
6999 if err != nil {
7000 return nil, err
7001 }
7002 return results.License, nil
7003 }
7004
7005 // Read is API call
7006 func (o *LicenseOp) Read(ctx context.Context, id types.ID) (*License, error) {
7007 // build request URL
7008 pathBuildParameter := map[string]interface{}{
7009 "rootURL": SakuraCloudAPIRoot,
7010 "pathSuffix": o.PathSuffix,
7011 "pathName": o.PathName,
7012 "zone": APIDefaultZone,
7013 "id": id,
7014 }
7015
7016 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}", pathBuildParameter)
7017 if err != nil {
7018 return nil, err
7019 }
7020 // build request body
7021 var body interface{}
7022
7023 // do request
7024 data, err := o.Client.Do(ctx, "GET", url, body)
7025 if err != nil {
7026 return nil, err
7027 }
7028
7029 // build results
7030 results, err := o.transformReadResults(data)
7031 if err != nil {
7032 return nil, err
7033 }
7034 return results.License, nil
7035 }
7036
7037 // Update is API call
7038 func (o *LicenseOp) Update(ctx context.Context, id types.ID, param *LicenseUpdateRequest) (*License, error) {
7039 // build request URL
7040 pathBuildParameter := map[string]interface{}{
7041 "rootURL": SakuraCloudAPIRoot,
7042 "pathSuffix": o.PathSuffix,
7043 "pathName": o.PathName,
7044 "zone": APIDefaultZone,
7045 "id": id,
7046 "param": param,
7047 }
7048
7049 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}", pathBuildParameter)
7050 if err != nil {
7051 return nil, err
7052 }
7053 // build request body
7054 var body interface{}
7055 v, err := o.transformUpdateArgs(id, param)
7056 if err != nil {
7057 return nil, err
7058 }
7059 body = v
7060
7061 // do request
7062 data, err := o.Client.Do(ctx, "PUT", url, body)
7063 if err != nil {
7064 return nil, err
7065 }
7066
7067 // build results
7068 results, err := o.transformUpdateResults(data)
7069 if err != nil {
7070 return nil, err
7071 }
7072 return results.License, nil
7073 }
7074
7075 // Delete is API call
7076 func (o *LicenseOp) Delete(ctx context.Context, id types.ID) error {
7077 // build request URL
7078 pathBuildParameter := map[string]interface{}{
7079 "rootURL": SakuraCloudAPIRoot,
7080 "pathSuffix": o.PathSuffix,
7081 "pathName": o.PathName,
7082 "zone": APIDefaultZone,
7083 "id": id,
7084 }
7085
7086 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}", pathBuildParameter)
7087 if err != nil {
7088 return err
7089 }
7090 // build request body
7091 var body interface{}
7092
7093 // do request
7094 _, err = o.Client.Do(ctx, "DELETE", url, body)
7095 if err != nil {
7096 return err
7097 }
7098
7099 // build results
7100
7101 return nil
7102 }
7103
7104 /*************************************************
7105 * LicenseInfoOp
7106 *************************************************/
7107
7108 // LicenseInfoOp implements LicenseInfoAPI interface
7109 type LicenseInfoOp struct {
7110 // Client APICaller
7111 Client APICaller
7112 // PathSuffix is used when building URL
7113 PathSuffix string
7114 // PathName is used when building URL
7115 PathName string
7116 }
7117
7118 // NewLicenseInfoOp creates new LicenseInfoOp instance
7119 func NewLicenseInfoOp(caller APICaller) LicenseInfoAPI {
7120 return GetClientFactoryFunc("LicenseInfo")(caller).(LicenseInfoAPI)
7121 }
7122
7123 // Find is API call
7124 func (o *LicenseInfoOp) Find(ctx context.Context, conditions *FindCondition) (*LicenseInfoFindResult, error) {
7125 // build request URL
7126 pathBuildParameter := map[string]interface{}{
7127 "rootURL": SakuraCloudAPIRoot,
7128 "pathSuffix": o.PathSuffix,
7129 "pathName": o.PathName,
7130 "zone": APIDefaultZone,
7131 "conditions": conditions,
7132 }
7133
7134 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}", pathBuildParameter)
7135 if err != nil {
7136 return nil, err
7137 }
7138 // build request body
7139 var body interface{}
7140 v, err := o.transformFindArgs(conditions)
7141 if err != nil {
7142 return nil, err
7143 }
7144 body = v
7145
7146 // do request
7147 data, err := o.Client.Do(ctx, "GET", url, body)
7148 if err != nil {
7149 return nil, err
7150 }
7151
7152 // build results
7153 results, err := o.transformFindResults(data)
7154 if err != nil {
7155 return nil, err
7156 }
7157 return results, err
7158 }
7159
7160 // Read is API call
7161 func (o *LicenseInfoOp) Read(ctx context.Context, id types.ID) (*LicenseInfo, error) {
7162 // build request URL
7163 pathBuildParameter := map[string]interface{}{
7164 "rootURL": SakuraCloudAPIRoot,
7165 "pathSuffix": o.PathSuffix,
7166 "pathName": o.PathName,
7167 "zone": APIDefaultZone,
7168 "id": id,
7169 }
7170
7171 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}", pathBuildParameter)
7172 if err != nil {
7173 return nil, err
7174 }
7175 // build request body
7176 var body interface{}
7177
7178 // do request
7179 data, err := o.Client.Do(ctx, "GET", url, body)
7180 if err != nil {
7181 return nil, err
7182 }
7183
7184 // build results
7185 results, err := o.transformReadResults(data)
7186 if err != nil {
7187 return nil, err
7188 }
7189 return results.LicenseInfo, nil
7190 }
7191
7192 /*************************************************
7193 * LoadBalancerOp
7194 *************************************************/
7195
7196 // LoadBalancerOp implements LoadBalancerAPI interface
7197 type LoadBalancerOp struct {
7198 // Client APICaller
7199 Client APICaller
7200 // PathSuffix is used when building URL
7201 PathSuffix string
7202 // PathName is used when building URL
7203 PathName string
7204 }
7205
7206 // NewLoadBalancerOp creates new LoadBalancerOp instance
7207 func NewLoadBalancerOp(caller APICaller) LoadBalancerAPI {
7208 return GetClientFactoryFunc("LoadBalancer")(caller).(LoadBalancerAPI)
7209 }
7210
7211 // Find is API call
7212 func (o *LoadBalancerOp) Find(ctx context.Context, zone string, conditions *FindCondition) (*LoadBalancerFindResult, error) {
7213 // build request URL
7214 pathBuildParameter := map[string]interface{}{
7215 "rootURL": SakuraCloudAPIRoot,
7216 "pathSuffix": o.PathSuffix,
7217 "pathName": o.PathName,
7218 "zone": zone,
7219 "conditions": conditions,
7220 }
7221
7222 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}", pathBuildParameter)
7223 if err != nil {
7224 return nil, err
7225 }
7226 // build request body
7227 var body interface{}
7228 v, err := o.transformFindArgs(conditions)
7229 if err != nil {
7230 return nil, err
7231 }
7232 body = v
7233
7234 // do request
7235 data, err := o.Client.Do(ctx, "GET", url, body)
7236 if err != nil {
7237 return nil, err
7238 }
7239
7240 // build results
7241 results, err := o.transformFindResults(data)
7242 if err != nil {
7243 return nil, err
7244 }
7245 return results, err
7246 }
7247
7248 // Create is API call
7249 func (o *LoadBalancerOp) Create(ctx context.Context, zone string, param *LoadBalancerCreateRequest) (*LoadBalancer, error) {
7250 // build request URL
7251 pathBuildParameter := map[string]interface{}{
7252 "rootURL": SakuraCloudAPIRoot,
7253 "pathSuffix": o.PathSuffix,
7254 "pathName": o.PathName,
7255 "zone": zone,
7256 "param": param,
7257 }
7258
7259 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}", pathBuildParameter)
7260 if err != nil {
7261 return nil, err
7262 }
7263 // build request body
7264 var body interface{}
7265 v, err := o.transformCreateArgs(param)
7266 if err != nil {
7267 return nil, err
7268 }
7269 body = v
7270
7271 // do request
7272 data, err := o.Client.Do(ctx, "POST", url, body)
7273 if err != nil {
7274 return nil, err
7275 }
7276
7277 // build results
7278 results, err := o.transformCreateResults(data)
7279 if err != nil {
7280 return nil, err
7281 }
7282 return results.LoadBalancer, nil
7283 }
7284
7285 // Read is API call
7286 func (o *LoadBalancerOp) Read(ctx context.Context, zone string, id types.ID) (*LoadBalancer, error) {
7287 // build request URL
7288 pathBuildParameter := map[string]interface{}{
7289 "rootURL": SakuraCloudAPIRoot,
7290 "pathSuffix": o.PathSuffix,
7291 "pathName": o.PathName,
7292 "zone": zone,
7293 "id": id,
7294 }
7295
7296 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}", pathBuildParameter)
7297 if err != nil {
7298 return nil, err
7299 }
7300 // build request body
7301 var body interface{}
7302
7303 // do request
7304 data, err := o.Client.Do(ctx, "GET", url, body)
7305 if err != nil {
7306 return nil, err
7307 }
7308
7309 // build results
7310 results, err := o.transformReadResults(data)
7311 if err != nil {
7312 return nil, err
7313 }
7314 return results.LoadBalancer, nil
7315 }
7316
7317 // Update is API call
7318 func (o *LoadBalancerOp) Update(ctx context.Context, zone string, id types.ID, param *LoadBalancerUpdateRequest) (*LoadBalancer, error) {
7319 // build request URL
7320 pathBuildParameter := map[string]interface{}{
7321 "rootURL": SakuraCloudAPIRoot,
7322 "pathSuffix": o.PathSuffix,
7323 "pathName": o.PathName,
7324 "zone": zone,
7325 "id": id,
7326 "param": param,
7327 }
7328
7329 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}", pathBuildParameter)
7330 if err != nil {
7331 return nil, err
7332 }
7333 // build request body
7334 var body interface{}
7335 v, err := o.transformUpdateArgs(id, param)
7336 if err != nil {
7337 return nil, err
7338 }
7339 body = v
7340
7341 // do request
7342 data, err := o.Client.Do(ctx, "PUT", url, body)
7343 if err != nil {
7344 return nil, err
7345 }
7346
7347 // build results
7348 results, err := o.transformUpdateResults(data)
7349 if err != nil {
7350 return nil, err
7351 }
7352 return results.LoadBalancer, nil
7353 }
7354
7355 // UpdateSettings is API call
7356 func (o *LoadBalancerOp) UpdateSettings(ctx context.Context, zone string, id types.ID, param *LoadBalancerUpdateSettingsRequest) (*LoadBalancer, error) {
7357 // build request URL
7358 pathBuildParameter := map[string]interface{}{
7359 "rootURL": SakuraCloudAPIRoot,
7360 "pathSuffix": o.PathSuffix,
7361 "pathName": o.PathName,
7362 "zone": zone,
7363 "id": id,
7364 "param": param,
7365 }
7366
7367 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}", pathBuildParameter)
7368 if err != nil {
7369 return nil, err
7370 }
7371 // build request body
7372 var body interface{}
7373 v, err := o.transformUpdateSettingsArgs(id, param)
7374 if err != nil {
7375 return nil, err
7376 }
7377 body = v
7378
7379 // do request
7380 data, err := o.Client.Do(ctx, "PUT", url, body)
7381 if err != nil {
7382 return nil, err
7383 }
7384
7385 // build results
7386 results, err := o.transformUpdateSettingsResults(data)
7387 if err != nil {
7388 return nil, err
7389 }
7390 return results.LoadBalancer, nil
7391 }
7392
7393 // Delete is API call
7394 func (o *LoadBalancerOp) Delete(ctx context.Context, zone string, id types.ID) error {
7395 // build request URL
7396 pathBuildParameter := map[string]interface{}{
7397 "rootURL": SakuraCloudAPIRoot,
7398 "pathSuffix": o.PathSuffix,
7399 "pathName": o.PathName,
7400 "zone": zone,
7401 "id": id,
7402 }
7403
7404 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}", pathBuildParameter)
7405 if err != nil {
7406 return err
7407 }
7408 // build request body
7409 var body interface{}
7410
7411 // do request
7412 _, err = o.Client.Do(ctx, "DELETE", url, body)
7413 if err != nil {
7414 return err
7415 }
7416
7417 // build results
7418
7419 return nil
7420 }
7421
7422 // Config is API call
7423 func (o *LoadBalancerOp) Config(ctx context.Context, zone string, id types.ID) error {
7424 // build request URL
7425 pathBuildParameter := map[string]interface{}{
7426 "rootURL": SakuraCloudAPIRoot,
7427 "pathSuffix": o.PathSuffix,
7428 "pathName": o.PathName,
7429 "zone": zone,
7430 "id": id,
7431 }
7432
7433 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}/config", pathBuildParameter)
7434 if err != nil {
7435 return err
7436 }
7437 // build request body
7438 var body interface{}
7439
7440 // do request
7441 _, err = o.Client.Do(ctx, "PUT", url, body)
7442 if err != nil {
7443 return err
7444 }
7445
7446 // build results
7447
7448 return nil
7449 }
7450
7451 // Boot is API call
7452 func (o *LoadBalancerOp) Boot(ctx context.Context, zone string, id types.ID) error {
7453 // build request URL
7454 pathBuildParameter := map[string]interface{}{
7455 "rootURL": SakuraCloudAPIRoot,
7456 "pathSuffix": o.PathSuffix,
7457 "pathName": o.PathName,
7458 "zone": zone,
7459 "id": id,
7460 }
7461
7462 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}/power", pathBuildParameter)
7463 if err != nil {
7464 return err
7465 }
7466 lockKey, err := buildURL("GlobalLock", pathBuildParameter)
7467 if err != nil {
7468 return err
7469 }
7470 apiLocker.Lock(lockKey)
7471 defer apiLocker.Unlock(lockKey)
7472 // build request body
7473 var body interface{}
7474
7475 // do request
7476 _, err = o.Client.Do(ctx, "PUT", url, body)
7477 if err != nil {
7478 return err
7479 }
7480
7481 // build results
7482
7483 return nil
7484 }
7485
7486 // Shutdown is API call
7487 func (o *LoadBalancerOp) Shutdown(ctx context.Context, zone string, id types.ID, shutdownOption *ShutdownOption) error {
7488 // build request URL
7489 pathBuildParameter := map[string]interface{}{
7490 "rootURL": SakuraCloudAPIRoot,
7491 "pathSuffix": o.PathSuffix,
7492 "pathName": o.PathName,
7493 "zone": zone,
7494 "id": id,
7495 "shutdownOption": shutdownOption,
7496 }
7497
7498 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}/power", pathBuildParameter)
7499 if err != nil {
7500 return err
7501 }
7502 lockKey, err := buildURL("GlobalLock", pathBuildParameter)
7503 if err != nil {
7504 return err
7505 }
7506 apiLocker.Lock(lockKey)
7507 defer apiLocker.Unlock(lockKey)
7508 // build request body
7509 var body interface{}
7510 v, err := o.transformShutdownArgs(id, shutdownOption)
7511 if err != nil {
7512 return err
7513 }
7514 body = v
7515
7516 // do request
7517 _, err = o.Client.Do(ctx, "DELETE", url, body)
7518 if err != nil {
7519 return err
7520 }
7521
7522 // build results
7523
7524 return nil
7525 }
7526
7527 // Reset is API call
7528 func (o *LoadBalancerOp) Reset(ctx context.Context, zone string, id types.ID) error {
7529 // build request URL
7530 pathBuildParameter := map[string]interface{}{
7531 "rootURL": SakuraCloudAPIRoot,
7532 "pathSuffix": o.PathSuffix,
7533 "pathName": o.PathName,
7534 "zone": zone,
7535 "id": id,
7536 }
7537
7538 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}/reset", pathBuildParameter)
7539 if err != nil {
7540 return err
7541 }
7542 lockKey, err := buildURL("GlobalLock", pathBuildParameter)
7543 if err != nil {
7544 return err
7545 }
7546 apiLocker.Lock(lockKey)
7547 defer apiLocker.Unlock(lockKey)
7548 // build request body
7549 var body interface{}
7550
7551 // do request
7552 _, err = o.Client.Do(ctx, "PUT", url, body)
7553 if err != nil {
7554 return err
7555 }
7556
7557 // build results
7558
7559 return nil
7560 }
7561
7562 // MonitorCPU is API call
7563 func (o *LoadBalancerOp) MonitorCPU(ctx context.Context, zone string, id types.ID, condition *MonitorCondition) (*CPUTimeActivity, error) {
7564 // build request URL
7565 pathBuildParameter := map[string]interface{}{
7566 "rootURL": SakuraCloudAPIRoot,
7567 "pathSuffix": o.PathSuffix,
7568 "pathName": o.PathName,
7569 "zone": zone,
7570 "id": id,
7571 "condition": condition,
7572 }
7573
7574 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}/cpu/monitor", pathBuildParameter)
7575 if err != nil {
7576 return nil, err
7577 }
7578 // build request body
7579 var body interface{}
7580 v, err := o.transformMonitorCPUArgs(id, condition)
7581 if err != nil {
7582 return nil, err
7583 }
7584 body = v
7585
7586 // do request
7587 data, err := o.Client.Do(ctx, "GET", url, body)
7588 if err != nil {
7589 return nil, err
7590 }
7591
7592 // build results
7593 results, err := o.transformMonitorCPUResults(data)
7594 if err != nil {
7595 return nil, err
7596 }
7597 return results.CPUTimeActivity, nil
7598 }
7599
7600 // MonitorInterface is API call
7601 func (o *LoadBalancerOp) MonitorInterface(ctx context.Context, zone string, id types.ID, condition *MonitorCondition) (*InterfaceActivity, error) {
7602 // build request URL
7603 pathBuildParameter := map[string]interface{}{
7604 "rootURL": SakuraCloudAPIRoot,
7605 "pathSuffix": o.PathSuffix,
7606 "pathName": o.PathName,
7607 "zone": zone,
7608 "id": id,
7609 "condition": condition,
7610 }
7611
7612 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}/interface/monitor", pathBuildParameter)
7613 if err != nil {
7614 return nil, err
7615 }
7616 // build request body
7617 var body interface{}
7618 v, err := o.transformMonitorInterfaceArgs(id, condition)
7619 if err != nil {
7620 return nil, err
7621 }
7622 body = v
7623
7624 // do request
7625 data, err := o.Client.Do(ctx, "GET", url, body)
7626 if err != nil {
7627 return nil, err
7628 }
7629
7630 // build results
7631 results, err := o.transformMonitorInterfaceResults(data)
7632 if err != nil {
7633 return nil, err
7634 }
7635 return results.InterfaceActivity, nil
7636 }
7637
7638 // Status is API call
7639 func (o *LoadBalancerOp) Status(ctx context.Context, zone string, id types.ID) (*LoadBalancerStatusResult, error) {
7640 // build request URL
7641 pathBuildParameter := map[string]interface{}{
7642 "rootURL": SakuraCloudAPIRoot,
7643 "pathSuffix": o.PathSuffix,
7644 "pathName": o.PathName,
7645 "zone": zone,
7646 "id": id,
7647 }
7648
7649 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}/status", pathBuildParameter)
7650 if err != nil {
7651 return nil, err
7652 }
7653 // build request body
7654 var body interface{}
7655
7656 // do request
7657 data, err := o.Client.Do(ctx, "GET", url, body)
7658 if err != nil {
7659 return nil, err
7660 }
7661
7662 // build results
7663 results, err := o.transformStatusResults(data)
7664 if err != nil {
7665 return nil, err
7666 }
7667 return results, err
7668 }
7669
7670 /*************************************************
7671 * LocalRouterOp
7672 *************************************************/
7673
7674 // LocalRouterOp implements LocalRouterAPI interface
7675 type LocalRouterOp struct {
7676 // Client APICaller
7677 Client APICaller
7678 // PathSuffix is used when building URL
7679 PathSuffix string
7680 // PathName is used when building URL
7681 PathName string
7682 }
7683
7684 // NewLocalRouterOp creates new LocalRouterOp instance
7685 func NewLocalRouterOp(caller APICaller) LocalRouterAPI {
7686 return GetClientFactoryFunc("LocalRouter")(caller).(LocalRouterAPI)
7687 }
7688
7689 // Find is API call
7690 func (o *LocalRouterOp) Find(ctx context.Context, conditions *FindCondition) (*LocalRouterFindResult, error) {
7691 // build request URL
7692 pathBuildParameter := map[string]interface{}{
7693 "rootURL": SakuraCloudAPIRoot,
7694 "pathSuffix": o.PathSuffix,
7695 "pathName": o.PathName,
7696 "zone": APIDefaultZone,
7697 "conditions": conditions,
7698 }
7699
7700 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}", pathBuildParameter)
7701 if err != nil {
7702 return nil, err
7703 }
7704 // build request body
7705 var body interface{}
7706 v, err := o.transformFindArgs(conditions)
7707 if err != nil {
7708 return nil, err
7709 }
7710 body = v
7711
7712 // do request
7713 data, err := o.Client.Do(ctx, "GET", url, body)
7714 if err != nil {
7715 return nil, err
7716 }
7717
7718 // build results
7719 results, err := o.transformFindResults(data)
7720 if err != nil {
7721 return nil, err
7722 }
7723 return results, err
7724 }
7725
7726 // Create is API call
7727 func (o *LocalRouterOp) Create(ctx context.Context, param *LocalRouterCreateRequest) (*LocalRouter, error) {
7728 // build request URL
7729 pathBuildParameter := map[string]interface{}{
7730 "rootURL": SakuraCloudAPIRoot,
7731 "pathSuffix": o.PathSuffix,
7732 "pathName": o.PathName,
7733 "zone": APIDefaultZone,
7734 "param": param,
7735 }
7736
7737 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}", pathBuildParameter)
7738 if err != nil {
7739 return nil, err
7740 }
7741 // build request body
7742 var body interface{}
7743 v, err := o.transformCreateArgs(param)
7744 if err != nil {
7745 return nil, err
7746 }
7747 body = v
7748
7749 // do request
7750 data, err := o.Client.Do(ctx, "POST", url, body)
7751 if err != nil {
7752 return nil, err
7753 }
7754
7755 // build results
7756 results, err := o.transformCreateResults(data)
7757 if err != nil {
7758 return nil, err
7759 }
7760 return results.LocalRouter, nil
7761 }
7762
7763 // Read is API call
7764 func (o *LocalRouterOp) Read(ctx context.Context, id types.ID) (*LocalRouter, error) {
7765 // build request URL
7766 pathBuildParameter := map[string]interface{}{
7767 "rootURL": SakuraCloudAPIRoot,
7768 "pathSuffix": o.PathSuffix,
7769 "pathName": o.PathName,
7770 "zone": APIDefaultZone,
7771 "id": id,
7772 }
7773
7774 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}", pathBuildParameter)
7775 if err != nil {
7776 return nil, err
7777 }
7778 // build request body
7779 var body interface{}
7780
7781 // do request
7782 data, err := o.Client.Do(ctx, "GET", url, body)
7783 if err != nil {
7784 return nil, err
7785 }
7786
7787 // build results
7788 results, err := o.transformReadResults(data)
7789 if err != nil {
7790 return nil, err
7791 }
7792 return results.LocalRouter, nil
7793 }
7794
7795 // Update is API call
7796 func (o *LocalRouterOp) Update(ctx context.Context, id types.ID, param *LocalRouterUpdateRequest) (*LocalRouter, error) {
7797 // build request URL
7798 pathBuildParameter := map[string]interface{}{
7799 "rootURL": SakuraCloudAPIRoot,
7800 "pathSuffix": o.PathSuffix,
7801 "pathName": o.PathName,
7802 "zone": APIDefaultZone,
7803 "id": id,
7804 "param": param,
7805 }
7806
7807 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}", pathBuildParameter)
7808 if err != nil {
7809 return nil, err
7810 }
7811 // build request body
7812 var body interface{}
7813 v, err := o.transformUpdateArgs(id, param)
7814 if err != nil {
7815 return nil, err
7816 }
7817 body = v
7818
7819 // do request
7820 data, err := o.Client.Do(ctx, "PUT", url, body)
7821 if err != nil {
7822 return nil, err
7823 }
7824
7825 // build results
7826 results, err := o.transformUpdateResults(data)
7827 if err != nil {
7828 return nil, err
7829 }
7830 return results.LocalRouter, nil
7831 }
7832
7833 // UpdateSettings is API call
7834 func (o *LocalRouterOp) UpdateSettings(ctx context.Context, id types.ID, param *LocalRouterUpdateSettingsRequest) (*LocalRouter, error) {
7835 // build request URL
7836 pathBuildParameter := map[string]interface{}{
7837 "rootURL": SakuraCloudAPIRoot,
7838 "pathSuffix": o.PathSuffix,
7839 "pathName": o.PathName,
7840 "zone": APIDefaultZone,
7841 "id": id,
7842 "param": param,
7843 }
7844
7845 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}", pathBuildParameter)
7846 if err != nil {
7847 return nil, err
7848 }
7849 // build request body
7850 var body interface{}
7851 v, err := o.transformUpdateSettingsArgs(id, param)
7852 if err != nil {
7853 return nil, err
7854 }
7855 body = v
7856
7857 // do request
7858 data, err := o.Client.Do(ctx, "PUT", url, body)
7859 if err != nil {
7860 return nil, err
7861 }
7862
7863 // build results
7864 results, err := o.transformUpdateSettingsResults(data)
7865 if err != nil {
7866 return nil, err
7867 }
7868 return results.LocalRouter, nil
7869 }
7870
7871 // Delete is API call
7872 func (o *LocalRouterOp) Delete(ctx context.Context, id types.ID) error {
7873 // build request URL
7874 pathBuildParameter := map[string]interface{}{
7875 "rootURL": SakuraCloudAPIRoot,
7876 "pathSuffix": o.PathSuffix,
7877 "pathName": o.PathName,
7878 "zone": APIDefaultZone,
7879 "id": id,
7880 }
7881
7882 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}", pathBuildParameter)
7883 if err != nil {
7884 return err
7885 }
7886 // build request body
7887 var body interface{}
7888
7889 // do request
7890 _, err = o.Client.Do(ctx, "DELETE", url, body)
7891 if err != nil {
7892 return err
7893 }
7894
7895 // build results
7896
7897 return nil
7898 }
7899
7900 // HealthStatus is API call
7901 func (o *LocalRouterOp) HealthStatus(ctx context.Context, id types.ID) (*LocalRouterHealth, error) {
7902 // build request URL
7903 pathBuildParameter := map[string]interface{}{
7904 "rootURL": SakuraCloudAPIRoot,
7905 "pathSuffix": o.PathSuffix,
7906 "pathName": o.PathName,
7907 "zone": APIDefaultZone,
7908 "id": id,
7909 }
7910
7911 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}/health", pathBuildParameter)
7912 if err != nil {
7913 return nil, err
7914 }
7915 // build request body
7916 var body interface{}
7917
7918 // do request
7919 data, err := o.Client.Do(ctx, "GET", url, body)
7920 if err != nil {
7921 return nil, err
7922 }
7923
7924 // build results
7925 results, err := o.transformHealthStatusResults(data)
7926 if err != nil {
7927 return nil, err
7928 }
7929 return results.LocalRouterHealth, nil
7930 }
7931
7932 // MonitorLocalRouter is API call
7933 func (o *LocalRouterOp) MonitorLocalRouter(ctx context.Context, id types.ID, condition *MonitorCondition) (*LocalRouterActivity, error) {
7934 // build request URL
7935 pathBuildParameter := map[string]interface{}{
7936 "rootURL": SakuraCloudAPIRoot,
7937 "pathSuffix": o.PathSuffix,
7938 "pathName": o.PathName,
7939 "zone": APIDefaultZone,
7940 "id": id,
7941 "condition": condition,
7942 }
7943
7944 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}/activity/localrouter/monitor", pathBuildParameter)
7945 if err != nil {
7946 return nil, err
7947 }
7948 // build request body
7949 var body interface{}
7950 v, err := o.transformMonitorLocalRouterArgs(id, condition)
7951 if err != nil {
7952 return nil, err
7953 }
7954 body = v
7955
7956 // do request
7957 data, err := o.Client.Do(ctx, "GET", url, body)
7958 if err != nil {
7959 return nil, err
7960 }
7961
7962 // build results
7963 results, err := o.transformMonitorLocalRouterResults(data)
7964 if err != nil {
7965 return nil, err
7966 }
7967 return results.LocalRouterActivity, nil
7968 }
7969
7970 /*************************************************
7971 * MobileGatewayOp
7972 *************************************************/
7973
7974 // MobileGatewayOp implements MobileGatewayAPI interface
7975 type MobileGatewayOp struct {
7976 // Client APICaller
7977 Client APICaller
7978 // PathSuffix is used when building URL
7979 PathSuffix string
7980 // PathName is used when building URL
7981 PathName string
7982 }
7983
7984 // NewMobileGatewayOp creates new MobileGatewayOp instance
7985 func NewMobileGatewayOp(caller APICaller) MobileGatewayAPI {
7986 return GetClientFactoryFunc("MobileGateway")(caller).(MobileGatewayAPI)
7987 }
7988
7989 // Find is API call
7990 func (o *MobileGatewayOp) Find(ctx context.Context, zone string, conditions *FindCondition) (*MobileGatewayFindResult, error) {
7991 // build request URL
7992 pathBuildParameter := map[string]interface{}{
7993 "rootURL": SakuraCloudAPIRoot,
7994 "pathSuffix": o.PathSuffix,
7995 "pathName": o.PathName,
7996 "zone": zone,
7997 "conditions": conditions,
7998 }
7999
8000 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}", pathBuildParameter)
8001 if err != nil {
8002 return nil, err
8003 }
8004 // build request body
8005 var body interface{}
8006 v, err := o.transformFindArgs(conditions)
8007 if err != nil {
8008 return nil, err
8009 }
8010 body = v
8011
8012 // do request
8013 data, err := o.Client.Do(ctx, "GET", url, body)
8014 if err != nil {
8015 return nil, err
8016 }
8017
8018 // build results
8019 results, err := o.transformFindResults(data)
8020 if err != nil {
8021 return nil, err
8022 }
8023 return results, err
8024 }
8025
8026 // Create is API call
8027 func (o *MobileGatewayOp) Create(ctx context.Context, zone string, param *MobileGatewayCreateRequest) (*MobileGateway, error) {
8028 // build request URL
8029 pathBuildParameter := map[string]interface{}{
8030 "rootURL": SakuraCloudAPIRoot,
8031 "pathSuffix": o.PathSuffix,
8032 "pathName": o.PathName,
8033 "zone": zone,
8034 "param": param,
8035 }
8036
8037 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}", pathBuildParameter)
8038 if err != nil {
8039 return nil, err
8040 }
8041 // build request body
8042 var body interface{}
8043 v, err := o.transformCreateArgs(param)
8044 if err != nil {
8045 return nil, err
8046 }
8047 body = v
8048
8049 // do request
8050 data, err := o.Client.Do(ctx, "POST", url, body)
8051 if err != nil {
8052 return nil, err
8053 }
8054
8055 // build results
8056 results, err := o.transformCreateResults(data)
8057 if err != nil {
8058 return nil, err
8059 }
8060 return results.MobileGateway, nil
8061 }
8062
8063 // Read is API call
8064 func (o *MobileGatewayOp) Read(ctx context.Context, zone string, id types.ID) (*MobileGateway, error) {
8065 // build request URL
8066 pathBuildParameter := map[string]interface{}{
8067 "rootURL": SakuraCloudAPIRoot,
8068 "pathSuffix": o.PathSuffix,
8069 "pathName": o.PathName,
8070 "zone": zone,
8071 "id": id,
8072 }
8073
8074 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}", pathBuildParameter)
8075 if err != nil {
8076 return nil, err
8077 }
8078 // build request body
8079 var body interface{}
8080
8081 // do request
8082 data, err := o.Client.Do(ctx, "GET", url, body)
8083 if err != nil {
8084 return nil, err
8085 }
8086
8087 // build results
8088 results, err := o.transformReadResults(data)
8089 if err != nil {
8090 return nil, err
8091 }
8092 return results.MobileGateway, nil
8093 }
8094
8095 // Update is API call
8096 func (o *MobileGatewayOp) Update(ctx context.Context, zone string, id types.ID, param *MobileGatewayUpdateRequest) (*MobileGateway, error) {
8097 // build request URL
8098 pathBuildParameter := map[string]interface{}{
8099 "rootURL": SakuraCloudAPIRoot,
8100 "pathSuffix": o.PathSuffix,
8101 "pathName": o.PathName,
8102 "zone": zone,
8103 "id": id,
8104 "param": param,
8105 }
8106
8107 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}", pathBuildParameter)
8108 if err != nil {
8109 return nil, err
8110 }
8111 // build request body
8112 var body interface{}
8113 v, err := o.transformUpdateArgs(id, param)
8114 if err != nil {
8115 return nil, err
8116 }
8117 body = v
8118
8119 // do request
8120 data, err := o.Client.Do(ctx, "PUT", url, body)
8121 if err != nil {
8122 return nil, err
8123 }
8124
8125 // build results
8126 results, err := o.transformUpdateResults(data)
8127 if err != nil {
8128 return nil, err
8129 }
8130 return results.MobileGateway, nil
8131 }
8132
8133 // UpdateSettings is API call
8134 func (o *MobileGatewayOp) UpdateSettings(ctx context.Context, zone string, id types.ID, param *MobileGatewayUpdateSettingsRequest) (*MobileGateway, error) {
8135 // build request URL
8136 pathBuildParameter := map[string]interface{}{
8137 "rootURL": SakuraCloudAPIRoot,
8138 "pathSuffix": o.PathSuffix,
8139 "pathName": o.PathName,
8140 "zone": zone,
8141 "id": id,
8142 "param": param,
8143 }
8144
8145 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}", pathBuildParameter)
8146 if err != nil {
8147 return nil, err
8148 }
8149 // build request body
8150 var body interface{}
8151 v, err := o.transformUpdateSettingsArgs(id, param)
8152 if err != nil {
8153 return nil, err
8154 }
8155 body = v
8156
8157 // do request
8158 data, err := o.Client.Do(ctx, "PUT", url, body)
8159 if err != nil {
8160 return nil, err
8161 }
8162
8163 // build results
8164 results, err := o.transformUpdateSettingsResults(data)
8165 if err != nil {
8166 return nil, err
8167 }
8168 return results.MobileGateway, nil
8169 }
8170
8171 // Delete is API call
8172 func (o *MobileGatewayOp) Delete(ctx context.Context, zone string, id types.ID) error {
8173 // build request URL
8174 pathBuildParameter := map[string]interface{}{
8175 "rootURL": SakuraCloudAPIRoot,
8176 "pathSuffix": o.PathSuffix,
8177 "pathName": o.PathName,
8178 "zone": zone,
8179 "id": id,
8180 }
8181
8182 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}", pathBuildParameter)
8183 if err != nil {
8184 return err
8185 }
8186 // build request body
8187 var body interface{}
8188
8189 // do request
8190 _, err = o.Client.Do(ctx, "DELETE", url, body)
8191 if err != nil {
8192 return err
8193 }
8194
8195 // build results
8196
8197 return nil
8198 }
8199
8200 // Config is API call
8201 func (o *MobileGatewayOp) Config(ctx context.Context, zone string, id types.ID) error {
8202 // build request URL
8203 pathBuildParameter := map[string]interface{}{
8204 "rootURL": SakuraCloudAPIRoot,
8205 "pathSuffix": o.PathSuffix,
8206 "pathName": o.PathName,
8207 "zone": zone,
8208 "id": id,
8209 }
8210
8211 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}/config", pathBuildParameter)
8212 if err != nil {
8213 return err
8214 }
8215 // build request body
8216 var body interface{}
8217
8218 // do request
8219 _, err = o.Client.Do(ctx, "PUT", url, body)
8220 if err != nil {
8221 return err
8222 }
8223
8224 // build results
8225
8226 return nil
8227 }
8228
8229 // Boot is API call
8230 func (o *MobileGatewayOp) Boot(ctx context.Context, zone string, id types.ID) error {
8231 // build request URL
8232 pathBuildParameter := map[string]interface{}{
8233 "rootURL": SakuraCloudAPIRoot,
8234 "pathSuffix": o.PathSuffix,
8235 "pathName": o.PathName,
8236 "zone": zone,
8237 "id": id,
8238 }
8239
8240 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}/power", pathBuildParameter)
8241 if err != nil {
8242 return err
8243 }
8244 lockKey, err := buildURL("GlobalLock", pathBuildParameter)
8245 if err != nil {
8246 return err
8247 }
8248 apiLocker.Lock(lockKey)
8249 defer apiLocker.Unlock(lockKey)
8250 // build request body
8251 var body interface{}
8252
8253 // do request
8254 _, err = o.Client.Do(ctx, "PUT", url, body)
8255 if err != nil {
8256 return err
8257 }
8258
8259 // build results
8260
8261 return nil
8262 }
8263
8264 // Shutdown is API call
8265 func (o *MobileGatewayOp) Shutdown(ctx context.Context, zone string, id types.ID, shutdownOption *ShutdownOption) error {
8266 // build request URL
8267 pathBuildParameter := map[string]interface{}{
8268 "rootURL": SakuraCloudAPIRoot,
8269 "pathSuffix": o.PathSuffix,
8270 "pathName": o.PathName,
8271 "zone": zone,
8272 "id": id,
8273 "shutdownOption": shutdownOption,
8274 }
8275
8276 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}/power", pathBuildParameter)
8277 if err != nil {
8278 return err
8279 }
8280 lockKey, err := buildURL("GlobalLock", pathBuildParameter)
8281 if err != nil {
8282 return err
8283 }
8284 apiLocker.Lock(lockKey)
8285 defer apiLocker.Unlock(lockKey)
8286 // build request body
8287 var body interface{}
8288 v, err := o.transformShutdownArgs(id, shutdownOption)
8289 if err != nil {
8290 return err
8291 }
8292 body = v
8293
8294 // do request
8295 _, err = o.Client.Do(ctx, "DELETE", url, body)
8296 if err != nil {
8297 return err
8298 }
8299
8300 // build results
8301
8302 return nil
8303 }
8304
8305 // Reset is API call
8306 func (o *MobileGatewayOp) Reset(ctx context.Context, zone string, id types.ID) error {
8307 // build request URL
8308 pathBuildParameter := map[string]interface{}{
8309 "rootURL": SakuraCloudAPIRoot,
8310 "pathSuffix": o.PathSuffix,
8311 "pathName": o.PathName,
8312 "zone": zone,
8313 "id": id,
8314 }
8315
8316 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}/reset", pathBuildParameter)
8317 if err != nil {
8318 return err
8319 }
8320 lockKey, err := buildURL("GlobalLock", pathBuildParameter)
8321 if err != nil {
8322 return err
8323 }
8324 apiLocker.Lock(lockKey)
8325 defer apiLocker.Unlock(lockKey)
8326 // build request body
8327 var body interface{}
8328
8329 // do request
8330 _, err = o.Client.Do(ctx, "PUT", url, body)
8331 if err != nil {
8332 return err
8333 }
8334
8335 // build results
8336
8337 return nil
8338 }
8339
8340 // ConnectToSwitch is API call
8341 func (o *MobileGatewayOp) ConnectToSwitch(ctx context.Context, zone string, id types.ID, switchID types.ID) error {
8342 // build request URL
8343 pathBuildParameter := map[string]interface{}{
8344 "rootURL": SakuraCloudAPIRoot,
8345 "pathSuffix": o.PathSuffix,
8346 "pathName": o.PathName,
8347 "zone": zone,
8348 "id": id,
8349 "switchID": switchID,
8350 }
8351
8352 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}/interface/1/to/switch/{{.switchID}}", pathBuildParameter)
8353 if err != nil {
8354 return err
8355 }
8356 // build request body
8357 var body interface{}
8358
8359 // do request
8360 _, err = o.Client.Do(ctx, "PUT", url, body)
8361 if err != nil {
8362 return err
8363 }
8364
8365 // build results
8366
8367 return nil
8368 }
8369
8370 // DisconnectFromSwitch is API call
8371 func (o *MobileGatewayOp) DisconnectFromSwitch(ctx context.Context, zone string, id types.ID) error {
8372 // build request URL
8373 pathBuildParameter := map[string]interface{}{
8374 "rootURL": SakuraCloudAPIRoot,
8375 "pathSuffix": o.PathSuffix,
8376 "pathName": o.PathName,
8377 "zone": zone,
8378 "id": id,
8379 }
8380
8381 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}/interface/1/to/switch", pathBuildParameter)
8382 if err != nil {
8383 return err
8384 }
8385 // build request body
8386 var body interface{}
8387
8388 // do request
8389 _, err = o.Client.Do(ctx, "DELETE", url, body)
8390 if err != nil {
8391 return err
8392 }
8393
8394 // build results
8395
8396 return nil
8397 }
8398
8399 // GetDNS is API call
8400 func (o *MobileGatewayOp) GetDNS(ctx context.Context, zone string, id types.ID) (*MobileGatewayDNSSetting, error) {
8401 // build request URL
8402 pathBuildParameter := map[string]interface{}{
8403 "rootURL": SakuraCloudAPIRoot,
8404 "pathSuffix": o.PathSuffix,
8405 "pathName": o.PathName,
8406 "zone": zone,
8407 "id": id,
8408 }
8409
8410 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}/mobilegateway/dnsresolver", pathBuildParameter)
8411 if err != nil {
8412 return nil, err
8413 }
8414 // build request body
8415 var body interface{}
8416
8417 // do request
8418 data, err := o.Client.Do(ctx, "GET", url, body)
8419 if err != nil {
8420 return nil, err
8421 }
8422
8423 // build results
8424 results, err := o.transformGetDNSResults(data)
8425 if err != nil {
8426 return nil, err
8427 }
8428 return results.SIMGroup, nil
8429 }
8430
8431 // SetDNS is API call
8432 func (o *MobileGatewayOp) SetDNS(ctx context.Context, zone string, id types.ID, param *MobileGatewayDNSSetting) error {
8433 // build request URL
8434 pathBuildParameter := map[string]interface{}{
8435 "rootURL": SakuraCloudAPIRoot,
8436 "pathSuffix": o.PathSuffix,
8437 "pathName": o.PathName,
8438 "zone": zone,
8439 "id": id,
8440 "param": param,
8441 }
8442
8443 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}/mobilegateway/dnsresolver", pathBuildParameter)
8444 if err != nil {
8445 return err
8446 }
8447 // build request body
8448 var body interface{}
8449 v, err := o.transformSetDNSArgs(id, param)
8450 if err != nil {
8451 return err
8452 }
8453 body = v
8454
8455 // do request
8456 _, err = o.Client.Do(ctx, "PUT", url, body)
8457 if err != nil {
8458 return err
8459 }
8460
8461 // build results
8462
8463 return nil
8464 }
8465
8466 // GetSIMRoutes is API call
8467 func (o *MobileGatewayOp) GetSIMRoutes(ctx context.Context, zone string, id types.ID) (MobileGatewaySIMRoutes, error) {
8468 // build request URL
8469 pathBuildParameter := map[string]interface{}{
8470 "rootURL": SakuraCloudAPIRoot,
8471 "pathSuffix": o.PathSuffix,
8472 "pathName": o.PathName,
8473 "zone": zone,
8474 "id": id,
8475 }
8476
8477 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}/mobilegateway/simroutes", pathBuildParameter)
8478 if err != nil {
8479 return nil, err
8480 }
8481 // build request body
8482 var body interface{}
8483
8484 // do request
8485 data, err := o.Client.Do(ctx, "GET", url, body)
8486 if err != nil {
8487 return nil, err
8488 }
8489
8490 // build results
8491 results, err := o.transformGetSIMRoutesResults(data)
8492 if err != nil {
8493 return nil, err
8494 }
8495 return results.SIMRoutes, nil
8496 }
8497
8498 // SetSIMRoutes is API call
8499 func (o *MobileGatewayOp) SetSIMRoutes(ctx context.Context, zone string, id types.ID, param []*MobileGatewaySIMRouteParam) error {
8500 // build request URL
8501 pathBuildParameter := map[string]interface{}{
8502 "rootURL": SakuraCloudAPIRoot,
8503 "pathSuffix": o.PathSuffix,
8504 "pathName": o.PathName,
8505 "zone": zone,
8506 "id": id,
8507 "param": param,
8508 }
8509
8510 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}/mobilegateway/simroutes", pathBuildParameter)
8511 if err != nil {
8512 return err
8513 }
8514 // build request body
8515 var body interface{}
8516 v, err := o.transformSetSIMRoutesArgs(id, param)
8517 if err != nil {
8518 return err
8519 }
8520 body = v
8521
8522 // do request
8523 _, err = o.Client.Do(ctx, "PUT", url, body)
8524 if err != nil {
8525 return err
8526 }
8527
8528 // build results
8529
8530 return nil
8531 }
8532
8533 // ListSIM is API call
8534 func (o *MobileGatewayOp) ListSIM(ctx context.Context, zone string, id types.ID) (MobileGatewaySIMs, error) {
8535 // build request URL
8536 pathBuildParameter := map[string]interface{}{
8537 "rootURL": SakuraCloudAPIRoot,
8538 "pathSuffix": o.PathSuffix,
8539 "pathName": o.PathName,
8540 "zone": zone,
8541 "id": id,
8542 }
8543
8544 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}/mobilegateway/sims", pathBuildParameter)
8545 if err != nil {
8546 return nil, err
8547 }
8548 // build request body
8549 var body interface{}
8550
8551 // do request
8552 data, err := o.Client.Do(ctx, "GET", url, body)
8553 if err != nil {
8554 return nil, err
8555 }
8556
8557 // build results
8558 results, err := o.transformListSIMResults(data)
8559 if err != nil {
8560 return nil, err
8561 }
8562 return results.SIM, nil
8563 }
8564
8565 // AddSIM is API call
8566 func (o *MobileGatewayOp) AddSIM(ctx context.Context, zone string, id types.ID, param *MobileGatewayAddSIMRequest) error {
8567 // build request URL
8568 pathBuildParameter := map[string]interface{}{
8569 "rootURL": SakuraCloudAPIRoot,
8570 "pathSuffix": o.PathSuffix,
8571 "pathName": o.PathName,
8572 "zone": zone,
8573 "id": id,
8574 "param": param,
8575 }
8576
8577 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}/mobilegateway/sims", pathBuildParameter)
8578 if err != nil {
8579 return err
8580 }
8581 // build request body
8582 var body interface{}
8583 v, err := o.transformAddSIMArgs(id, param)
8584 if err != nil {
8585 return err
8586 }
8587 body = v
8588
8589 // do request
8590 _, err = o.Client.Do(ctx, "POST", url, body)
8591 if err != nil {
8592 return err
8593 }
8594
8595 // build results
8596
8597 return nil
8598 }
8599
8600 // DeleteSIM is API call
8601 func (o *MobileGatewayOp) DeleteSIM(ctx context.Context, zone string, id types.ID, simID types.ID) error {
8602 // build request URL
8603 pathBuildParameter := map[string]interface{}{
8604 "rootURL": SakuraCloudAPIRoot,
8605 "pathSuffix": o.PathSuffix,
8606 "pathName": o.PathName,
8607 "zone": zone,
8608 "id": id,
8609 "simID": simID,
8610 }
8611
8612 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}/mobilegateway/sims/{{.simID}}", pathBuildParameter)
8613 if err != nil {
8614 return err
8615 }
8616 // build request body
8617 var body interface{}
8618
8619 // do request
8620 _, err = o.Client.Do(ctx, "DELETE", url, body)
8621 if err != nil {
8622 return err
8623 }
8624
8625 // build results
8626
8627 return nil
8628 }
8629
8630 // Logs is API call
8631 func (o *MobileGatewayOp) Logs(ctx context.Context, zone string, id types.ID) ([]*MobileGatewaySIMLogs, error) {
8632 // build request URL
8633 pathBuildParameter := map[string]interface{}{
8634 "rootURL": SakuraCloudAPIRoot,
8635 "pathSuffix": o.PathSuffix,
8636 "pathName": o.PathName,
8637 "zone": zone,
8638 "id": id,
8639 }
8640
8641 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}/mobilegateway/sessionlog", pathBuildParameter)
8642 if err != nil {
8643 return nil, err
8644 }
8645 // build request body
8646 var body interface{}
8647
8648 // do request
8649 data, err := o.Client.Do(ctx, "GET", url, body)
8650 if err != nil {
8651 return nil, err
8652 }
8653
8654 // build results
8655 results, err := o.transformLogsResults(data)
8656 if err != nil {
8657 return nil, err
8658 }
8659 return results.Logs, nil
8660 }
8661
8662 // GetTrafficConfig is API call
8663 func (o *MobileGatewayOp) GetTrafficConfig(ctx context.Context, zone string, id types.ID) (*MobileGatewayTrafficControl, error) {
8664 // build request URL
8665 pathBuildParameter := map[string]interface{}{
8666 "rootURL": SakuraCloudAPIRoot,
8667 "pathSuffix": o.PathSuffix,
8668 "pathName": o.PathName,
8669 "zone": zone,
8670 "id": id,
8671 }
8672
8673 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}/mobilegateway/traffic_monitoring", pathBuildParameter)
8674 if err != nil {
8675 return nil, err
8676 }
8677 // build request body
8678 var body interface{}
8679
8680 // do request
8681 data, err := o.Client.Do(ctx, "GET", url, body)
8682 if err != nil {
8683 return nil, err
8684 }
8685
8686 // build results
8687 results, err := o.transformGetTrafficConfigResults(data)
8688 if err != nil {
8689 return nil, err
8690 }
8691 return results.TrafficMonitoring, nil
8692 }
8693
8694 // SetTrafficConfig is API call
8695 func (o *MobileGatewayOp) SetTrafficConfig(ctx context.Context, zone string, id types.ID, param *MobileGatewayTrafficControl) error {
8696 // build request URL
8697 pathBuildParameter := map[string]interface{}{
8698 "rootURL": SakuraCloudAPIRoot,
8699 "pathSuffix": o.PathSuffix,
8700 "pathName": o.PathName,
8701 "zone": zone,
8702 "id": id,
8703 "param": param,
8704 }
8705
8706 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}/mobilegateway/traffic_monitoring", pathBuildParameter)
8707 if err != nil {
8708 return err
8709 }
8710 // build request body
8711 var body interface{}
8712 v, err := o.transformSetTrafficConfigArgs(id, param)
8713 if err != nil {
8714 return err
8715 }
8716 body = v
8717
8718 // do request
8719 _, err = o.Client.Do(ctx, "PUT", url, body)
8720 if err != nil {
8721 return err
8722 }
8723
8724 // build results
8725
8726 return nil
8727 }
8728
8729 // DeleteTrafficConfig is API call
8730 func (o *MobileGatewayOp) DeleteTrafficConfig(ctx context.Context, zone string, id types.ID) error {
8731 // build request URL
8732 pathBuildParameter := map[string]interface{}{
8733 "rootURL": SakuraCloudAPIRoot,
8734 "pathSuffix": o.PathSuffix,
8735 "pathName": o.PathName,
8736 "zone": zone,
8737 "id": id,
8738 }
8739
8740 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}/mobilegateway/traffic_monitoring", pathBuildParameter)
8741 if err != nil {
8742 return err
8743 }
8744 // build request body
8745 var body interface{}
8746
8747 // do request
8748 _, err = o.Client.Do(ctx, "DELETE", url, body)
8749 if err != nil {
8750 return err
8751 }
8752
8753 // build results
8754
8755 return nil
8756 }
8757
8758 // TrafficStatus is API call
8759 func (o *MobileGatewayOp) TrafficStatus(ctx context.Context, zone string, id types.ID) (*MobileGatewayTrafficStatus, error) {
8760 // build request URL
8761 pathBuildParameter := map[string]interface{}{
8762 "rootURL": SakuraCloudAPIRoot,
8763 "pathSuffix": o.PathSuffix,
8764 "pathName": o.PathName,
8765 "zone": zone,
8766 "id": id,
8767 }
8768
8769 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}/mobilegateway/traffic_status", pathBuildParameter)
8770 if err != nil {
8771 return nil, err
8772 }
8773 // build request body
8774 var body interface{}
8775
8776 // do request
8777 data, err := o.Client.Do(ctx, "GET", url, body)
8778 if err != nil {
8779 return nil, err
8780 }
8781
8782 // build results
8783 results, err := o.transformTrafficStatusResults(data)
8784 if err != nil {
8785 return nil, err
8786 }
8787 return results.TrafficStatus, nil
8788 }
8789
8790 // MonitorInterface is API call
8791 func (o *MobileGatewayOp) MonitorInterface(ctx context.Context, zone string, id types.ID, index int, condition *MonitorCondition) (*InterfaceActivity, error) {
8792 // build request URL
8793 pathBuildParameter := map[string]interface{}{
8794 "rootURL": SakuraCloudAPIRoot,
8795 "pathSuffix": o.PathSuffix,
8796 "pathName": o.PathName,
8797 "zone": zone,
8798 "id": id,
8799 "index": index,
8800 "condition": condition,
8801 }
8802
8803 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}/interface{{if ne .index 0}}/{{.index}}{{end}}/monitor", pathBuildParameter)
8804 if err != nil {
8805 return nil, err
8806 }
8807 // build request body
8808 var body interface{}
8809 v, err := o.transformMonitorInterfaceArgs(id, index, condition)
8810 if err != nil {
8811 return nil, err
8812 }
8813 body = v
8814
8815 // do request
8816 data, err := o.Client.Do(ctx, "GET", url, body)
8817 if err != nil {
8818 return nil, err
8819 }
8820
8821 // build results
8822 results, err := o.transformMonitorInterfaceResults(data)
8823 if err != nil {
8824 return nil, err
8825 }
8826 return results.InterfaceActivity, nil
8827 }
8828
8829 /*************************************************
8830 * NFSOp
8831 *************************************************/
8832
8833 // NFSOp implements NFSAPI interface
8834 type NFSOp struct {
8835 // Client APICaller
8836 Client APICaller
8837 // PathSuffix is used when building URL
8838 PathSuffix string
8839 // PathName is used when building URL
8840 PathName string
8841 }
8842
8843 // NewNFSOp creates new NFSOp instance
8844 func NewNFSOp(caller APICaller) NFSAPI {
8845 return GetClientFactoryFunc("NFS")(caller).(NFSAPI)
8846 }
8847
8848 // Find is API call
8849 func (o *NFSOp) Find(ctx context.Context, zone string, conditions *FindCondition) (*NFSFindResult, error) {
8850 // build request URL
8851 pathBuildParameter := map[string]interface{}{
8852 "rootURL": SakuraCloudAPIRoot,
8853 "pathSuffix": o.PathSuffix,
8854 "pathName": o.PathName,
8855 "zone": zone,
8856 "conditions": conditions,
8857 }
8858
8859 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}", pathBuildParameter)
8860 if err != nil {
8861 return nil, err
8862 }
8863 // build request body
8864 var body interface{}
8865 v, err := o.transformFindArgs(conditions)
8866 if err != nil {
8867 return nil, err
8868 }
8869 body = v
8870
8871 // do request
8872 data, err := o.Client.Do(ctx, "GET", url, body)
8873 if err != nil {
8874 return nil, err
8875 }
8876
8877 // build results
8878 results, err := o.transformFindResults(data)
8879 if err != nil {
8880 return nil, err
8881 }
8882 return results, err
8883 }
8884
8885 // Create is API call
8886 func (o *NFSOp) Create(ctx context.Context, zone string, param *NFSCreateRequest) (*NFS, error) {
8887 // build request URL
8888 pathBuildParameter := map[string]interface{}{
8889 "rootURL": SakuraCloudAPIRoot,
8890 "pathSuffix": o.PathSuffix,
8891 "pathName": o.PathName,
8892 "zone": zone,
8893 "param": param,
8894 }
8895
8896 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}", pathBuildParameter)
8897 if err != nil {
8898 return nil, err
8899 }
8900 // build request body
8901 var body interface{}
8902 v, err := o.transformCreateArgs(param)
8903 if err != nil {
8904 return nil, err
8905 }
8906 body = v
8907
8908 // do request
8909 data, err := o.Client.Do(ctx, "POST", url, body)
8910 if err != nil {
8911 return nil, err
8912 }
8913
8914 // build results
8915 results, err := o.transformCreateResults(data)
8916 if err != nil {
8917 return nil, err
8918 }
8919 return results.NFS, nil
8920 }
8921
8922 // Read is API call
8923 func (o *NFSOp) Read(ctx context.Context, zone string, id types.ID) (*NFS, error) {
8924 // build request URL
8925 pathBuildParameter := map[string]interface{}{
8926 "rootURL": SakuraCloudAPIRoot,
8927 "pathSuffix": o.PathSuffix,
8928 "pathName": o.PathName,
8929 "zone": zone,
8930 "id": id,
8931 }
8932
8933 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}", pathBuildParameter)
8934 if err != nil {
8935 return nil, err
8936 }
8937 // build request body
8938 var body interface{}
8939
8940 // do request
8941 data, err := o.Client.Do(ctx, "GET", url, body)
8942 if err != nil {
8943 return nil, err
8944 }
8945
8946 // build results
8947 results, err := o.transformReadResults(data)
8948 if err != nil {
8949 return nil, err
8950 }
8951 return results.NFS, nil
8952 }
8953
8954 // Update is API call
8955 func (o *NFSOp) Update(ctx context.Context, zone string, id types.ID, param *NFSUpdateRequest) (*NFS, error) {
8956 // build request URL
8957 pathBuildParameter := map[string]interface{}{
8958 "rootURL": SakuraCloudAPIRoot,
8959 "pathSuffix": o.PathSuffix,
8960 "pathName": o.PathName,
8961 "zone": zone,
8962 "id": id,
8963 "param": param,
8964 }
8965
8966 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}", pathBuildParameter)
8967 if err != nil {
8968 return nil, err
8969 }
8970 // build request body
8971 var body interface{}
8972 v, err := o.transformUpdateArgs(id, param)
8973 if err != nil {
8974 return nil, err
8975 }
8976 body = v
8977
8978 // do request
8979 data, err := o.Client.Do(ctx, "PUT", url, body)
8980 if err != nil {
8981 return nil, err
8982 }
8983
8984 // build results
8985 results, err := o.transformUpdateResults(data)
8986 if err != nil {
8987 return nil, err
8988 }
8989 return results.NFS, nil
8990 }
8991
8992 // Delete is API call
8993 func (o *NFSOp) Delete(ctx context.Context, zone string, id types.ID) error {
8994 // build request URL
8995 pathBuildParameter := map[string]interface{}{
8996 "rootURL": SakuraCloudAPIRoot,
8997 "pathSuffix": o.PathSuffix,
8998 "pathName": o.PathName,
8999 "zone": zone,
9000 "id": id,
9001 }
9002
9003 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}", pathBuildParameter)
9004 if err != nil {
9005 return err
9006 }
9007 // build request body
9008 var body interface{}
9009
9010 // do request
9011 _, err = o.Client.Do(ctx, "DELETE", url, body)
9012 if err != nil {
9013 return err
9014 }
9015
9016 // build results
9017
9018 return nil
9019 }
9020
9021 // Boot is API call
9022 func (o *NFSOp) Boot(ctx context.Context, zone string, id types.ID) error {
9023 // build request URL
9024 pathBuildParameter := map[string]interface{}{
9025 "rootURL": SakuraCloudAPIRoot,
9026 "pathSuffix": o.PathSuffix,
9027 "pathName": o.PathName,
9028 "zone": zone,
9029 "id": id,
9030 }
9031
9032 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}/power", pathBuildParameter)
9033 if err != nil {
9034 return err
9035 }
9036 lockKey, err := buildURL("GlobalLock", pathBuildParameter)
9037 if err != nil {
9038 return err
9039 }
9040 apiLocker.Lock(lockKey)
9041 defer apiLocker.Unlock(lockKey)
9042 // build request body
9043 var body interface{}
9044
9045 // do request
9046 _, err = o.Client.Do(ctx, "PUT", url, body)
9047 if err != nil {
9048 return err
9049 }
9050
9051 // build results
9052
9053 return nil
9054 }
9055
9056 // Shutdown is API call
9057 func (o *NFSOp) Shutdown(ctx context.Context, zone string, id types.ID, shutdownOption *ShutdownOption) error {
9058 // build request URL
9059 pathBuildParameter := map[string]interface{}{
9060 "rootURL": SakuraCloudAPIRoot,
9061 "pathSuffix": o.PathSuffix,
9062 "pathName": o.PathName,
9063 "zone": zone,
9064 "id": id,
9065 "shutdownOption": shutdownOption,
9066 }
9067
9068 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}/power", pathBuildParameter)
9069 if err != nil {
9070 return err
9071 }
9072 lockKey, err := buildURL("GlobalLock", pathBuildParameter)
9073 if err != nil {
9074 return err
9075 }
9076 apiLocker.Lock(lockKey)
9077 defer apiLocker.Unlock(lockKey)
9078 // build request body
9079 var body interface{}
9080 v, err := o.transformShutdownArgs(id, shutdownOption)
9081 if err != nil {
9082 return err
9083 }
9084 body = v
9085
9086 // do request
9087 _, err = o.Client.Do(ctx, "DELETE", url, body)
9088 if err != nil {
9089 return err
9090 }
9091
9092 // build results
9093
9094 return nil
9095 }
9096
9097 // Reset is API call
9098 func (o *NFSOp) Reset(ctx context.Context, zone string, id types.ID) error {
9099 // build request URL
9100 pathBuildParameter := map[string]interface{}{
9101 "rootURL": SakuraCloudAPIRoot,
9102 "pathSuffix": o.PathSuffix,
9103 "pathName": o.PathName,
9104 "zone": zone,
9105 "id": id,
9106 }
9107
9108 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}/reset", pathBuildParameter)
9109 if err != nil {
9110 return err
9111 }
9112 lockKey, err := buildURL("GlobalLock", pathBuildParameter)
9113 if err != nil {
9114 return err
9115 }
9116 apiLocker.Lock(lockKey)
9117 defer apiLocker.Unlock(lockKey)
9118 // build request body
9119 var body interface{}
9120
9121 // do request
9122 _, err = o.Client.Do(ctx, "PUT", url, body)
9123 if err != nil {
9124 return err
9125 }
9126
9127 // build results
9128
9129 return nil
9130 }
9131
9132 // MonitorCPU is API call
9133 func (o *NFSOp) MonitorCPU(ctx context.Context, zone string, id types.ID, condition *MonitorCondition) (*CPUTimeActivity, error) {
9134 // build request URL
9135 pathBuildParameter := map[string]interface{}{
9136 "rootURL": SakuraCloudAPIRoot,
9137 "pathSuffix": o.PathSuffix,
9138 "pathName": o.PathName,
9139 "zone": zone,
9140 "id": id,
9141 "condition": condition,
9142 }
9143
9144 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}/cpu/monitor", pathBuildParameter)
9145 if err != nil {
9146 return nil, err
9147 }
9148 // build request body
9149 var body interface{}
9150 v, err := o.transformMonitorCPUArgs(id, condition)
9151 if err != nil {
9152 return nil, err
9153 }
9154 body = v
9155
9156 // do request
9157 data, err := o.Client.Do(ctx, "GET", url, body)
9158 if err != nil {
9159 return nil, err
9160 }
9161
9162 // build results
9163 results, err := o.transformMonitorCPUResults(data)
9164 if err != nil {
9165 return nil, err
9166 }
9167 return results.CPUTimeActivity, nil
9168 }
9169
9170 // MonitorFreeDiskSize is API call
9171 func (o *NFSOp) MonitorFreeDiskSize(ctx context.Context, zone string, id types.ID, condition *MonitorCondition) (*FreeDiskSizeActivity, error) {
9172 // build request URL
9173 pathBuildParameter := map[string]interface{}{
9174 "rootURL": SakuraCloudAPIRoot,
9175 "pathSuffix": o.PathSuffix,
9176 "pathName": o.PathName,
9177 "zone": zone,
9178 "id": id,
9179 "condition": condition,
9180 }
9181
9182 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}/database/monitor", pathBuildParameter)
9183 if err != nil {
9184 return nil, err
9185 }
9186 // build request body
9187 var body interface{}
9188 v, err := o.transformMonitorFreeDiskSizeArgs(id, condition)
9189 if err != nil {
9190 return nil, err
9191 }
9192 body = v
9193
9194 // do request
9195 data, err := o.Client.Do(ctx, "GET", url, body)
9196 if err != nil {
9197 return nil, err
9198 }
9199
9200 // build results
9201 results, err := o.transformMonitorFreeDiskSizeResults(data)
9202 if err != nil {
9203 return nil, err
9204 }
9205 return results.FreeDiskSizeActivity, nil
9206 }
9207
9208 // MonitorInterface is API call
9209 func (o *NFSOp) MonitorInterface(ctx context.Context, zone string, id types.ID, condition *MonitorCondition) (*InterfaceActivity, error) {
9210 // build request URL
9211 pathBuildParameter := map[string]interface{}{
9212 "rootURL": SakuraCloudAPIRoot,
9213 "pathSuffix": o.PathSuffix,
9214 "pathName": o.PathName,
9215 "zone": zone,
9216 "id": id,
9217 "condition": condition,
9218 }
9219
9220 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}/interface/monitor", pathBuildParameter)
9221 if err != nil {
9222 return nil, err
9223 }
9224 // build request body
9225 var body interface{}
9226 v, err := o.transformMonitorInterfaceArgs(id, condition)
9227 if err != nil {
9228 return nil, err
9229 }
9230 body = v
9231
9232 // do request
9233 data, err := o.Client.Do(ctx, "GET", url, body)
9234 if err != nil {
9235 return nil, err
9236 }
9237
9238 // build results
9239 results, err := o.transformMonitorInterfaceResults(data)
9240 if err != nil {
9241 return nil, err
9242 }
9243 return results.InterfaceActivity, nil
9244 }
9245
9246 /*************************************************
9247 * NoteOp
9248 *************************************************/
9249
9250 // NoteOp implements NoteAPI interface
9251 type NoteOp struct {
9252 // Client APICaller
9253 Client APICaller
9254 // PathSuffix is used when building URL
9255 PathSuffix string
9256 // PathName is used when building URL
9257 PathName string
9258 }
9259
9260 // NewNoteOp creates new NoteOp instance
9261 func NewNoteOp(caller APICaller) NoteAPI {
9262 return GetClientFactoryFunc("Note")(caller).(NoteAPI)
9263 }
9264
9265 // Find is API call
9266 func (o *NoteOp) Find(ctx context.Context, conditions *FindCondition) (*NoteFindResult, error) {
9267 // build request URL
9268 pathBuildParameter := map[string]interface{}{
9269 "rootURL": SakuraCloudAPIRoot,
9270 "pathSuffix": o.PathSuffix,
9271 "pathName": o.PathName,
9272 "zone": APIDefaultZone,
9273 "conditions": conditions,
9274 }
9275
9276 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}", pathBuildParameter)
9277 if err != nil {
9278 return nil, err
9279 }
9280 // build request body
9281 var body interface{}
9282 v, err := o.transformFindArgs(conditions)
9283 if err != nil {
9284 return nil, err
9285 }
9286 body = v
9287
9288 // do request
9289 data, err := o.Client.Do(ctx, "GET", url, body)
9290 if err != nil {
9291 return nil, err
9292 }
9293
9294 // build results
9295 results, err := o.transformFindResults(data)
9296 if err != nil {
9297 return nil, err
9298 }
9299 return results, err
9300 }
9301
9302 // Create is API call
9303 func (o *NoteOp) Create(ctx context.Context, param *NoteCreateRequest) (*Note, error) {
9304 // build request URL
9305 pathBuildParameter := map[string]interface{}{
9306 "rootURL": SakuraCloudAPIRoot,
9307 "pathSuffix": o.PathSuffix,
9308 "pathName": o.PathName,
9309 "zone": APIDefaultZone,
9310 "param": param,
9311 }
9312
9313 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}", pathBuildParameter)
9314 if err != nil {
9315 return nil, err
9316 }
9317 // build request body
9318 var body interface{}
9319 v, err := o.transformCreateArgs(param)
9320 if err != nil {
9321 return nil, err
9322 }
9323 body = v
9324
9325 // do request
9326 data, err := o.Client.Do(ctx, "POST", url, body)
9327 if err != nil {
9328 return nil, err
9329 }
9330
9331 // build results
9332 results, err := o.transformCreateResults(data)
9333 if err != nil {
9334 return nil, err
9335 }
9336 return results.Note, nil
9337 }
9338
9339 // Read is API call
9340 func (o *NoteOp) Read(ctx context.Context, id types.ID) (*Note, error) {
9341 // build request URL
9342 pathBuildParameter := map[string]interface{}{
9343 "rootURL": SakuraCloudAPIRoot,
9344 "pathSuffix": o.PathSuffix,
9345 "pathName": o.PathName,
9346 "zone": APIDefaultZone,
9347 "id": id,
9348 }
9349
9350 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}", pathBuildParameter)
9351 if err != nil {
9352 return nil, err
9353 }
9354 // build request body
9355 var body interface{}
9356
9357 // do request
9358 data, err := o.Client.Do(ctx, "GET", url, body)
9359 if err != nil {
9360 return nil, err
9361 }
9362
9363 // build results
9364 results, err := o.transformReadResults(data)
9365 if err != nil {
9366 return nil, err
9367 }
9368 return results.Note, nil
9369 }
9370
9371 // Update is API call
9372 func (o *NoteOp) Update(ctx context.Context, id types.ID, param *NoteUpdateRequest) (*Note, error) {
9373 // build request URL
9374 pathBuildParameter := map[string]interface{}{
9375 "rootURL": SakuraCloudAPIRoot,
9376 "pathSuffix": o.PathSuffix,
9377 "pathName": o.PathName,
9378 "zone": APIDefaultZone,
9379 "id": id,
9380 "param": param,
9381 }
9382
9383 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}", pathBuildParameter)
9384 if err != nil {
9385 return nil, err
9386 }
9387 // build request body
9388 var body interface{}
9389 v, err := o.transformUpdateArgs(id, param)
9390 if err != nil {
9391 return nil, err
9392 }
9393 body = v
9394
9395 // do request
9396 data, err := o.Client.Do(ctx, "PUT", url, body)
9397 if err != nil {
9398 return nil, err
9399 }
9400
9401 // build results
9402 results, err := o.transformUpdateResults(data)
9403 if err != nil {
9404 return nil, err
9405 }
9406 return results.Note, nil
9407 }
9408
9409 // Delete is API call
9410 func (o *NoteOp) Delete(ctx context.Context, id types.ID) error {
9411 // build request URL
9412 pathBuildParameter := map[string]interface{}{
9413 "rootURL": SakuraCloudAPIRoot,
9414 "pathSuffix": o.PathSuffix,
9415 "pathName": o.PathName,
9416 "zone": APIDefaultZone,
9417 "id": id,
9418 }
9419
9420 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}", pathBuildParameter)
9421 if err != nil {
9422 return err
9423 }
9424 // build request body
9425 var body interface{}
9426
9427 // do request
9428 _, err = o.Client.Do(ctx, "DELETE", url, body)
9429 if err != nil {
9430 return err
9431 }
9432
9433 // build results
9434
9435 return nil
9436 }
9437
9438 /*************************************************
9439 * PacketFilterOp
9440 *************************************************/
9441
9442 // PacketFilterOp implements PacketFilterAPI interface
9443 type PacketFilterOp struct {
9444 // Client APICaller
9445 Client APICaller
9446 // PathSuffix is used when building URL
9447 PathSuffix string
9448 // PathName is used when building URL
9449 PathName string
9450 }
9451
9452 // NewPacketFilterOp creates new PacketFilterOp instance
9453 func NewPacketFilterOp(caller APICaller) PacketFilterAPI {
9454 return GetClientFactoryFunc("PacketFilter")(caller).(PacketFilterAPI)
9455 }
9456
9457 // Find is API call
9458 func (o *PacketFilterOp) Find(ctx context.Context, zone string, conditions *FindCondition) (*PacketFilterFindResult, error) {
9459 // build request URL
9460 pathBuildParameter := map[string]interface{}{
9461 "rootURL": SakuraCloudAPIRoot,
9462 "pathSuffix": o.PathSuffix,
9463 "pathName": o.PathName,
9464 "zone": zone,
9465 "conditions": conditions,
9466 }
9467
9468 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}", pathBuildParameter)
9469 if err != nil {
9470 return nil, err
9471 }
9472 // build request body
9473 var body interface{}
9474 v, err := o.transformFindArgs(conditions)
9475 if err != nil {
9476 return nil, err
9477 }
9478 body = v
9479
9480 // do request
9481 data, err := o.Client.Do(ctx, "GET", url, body)
9482 if err != nil {
9483 return nil, err
9484 }
9485
9486 // build results
9487 results, err := o.transformFindResults(data)
9488 if err != nil {
9489 return nil, err
9490 }
9491 return results, err
9492 }
9493
9494 // Create is API call
9495 func (o *PacketFilterOp) Create(ctx context.Context, zone string, param *PacketFilterCreateRequest) (*PacketFilter, error) {
9496 // build request URL
9497 pathBuildParameter := map[string]interface{}{
9498 "rootURL": SakuraCloudAPIRoot,
9499 "pathSuffix": o.PathSuffix,
9500 "pathName": o.PathName,
9501 "zone": zone,
9502 "param": param,
9503 }
9504
9505 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}", pathBuildParameter)
9506 if err != nil {
9507 return nil, err
9508 }
9509 // build request body
9510 var body interface{}
9511 v, err := o.transformCreateArgs(param)
9512 if err != nil {
9513 return nil, err
9514 }
9515 body = v
9516
9517 // do request
9518 data, err := o.Client.Do(ctx, "POST", url, body)
9519 if err != nil {
9520 return nil, err
9521 }
9522
9523 // build results
9524 results, err := o.transformCreateResults(data)
9525 if err != nil {
9526 return nil, err
9527 }
9528 return results.PacketFilter, nil
9529 }
9530
9531 // Read is API call
9532 func (o *PacketFilterOp) Read(ctx context.Context, zone string, id types.ID) (*PacketFilter, error) {
9533 // build request URL
9534 pathBuildParameter := map[string]interface{}{
9535 "rootURL": SakuraCloudAPIRoot,
9536 "pathSuffix": o.PathSuffix,
9537 "pathName": o.PathName,
9538 "zone": zone,
9539 "id": id,
9540 }
9541
9542 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}", pathBuildParameter)
9543 if err != nil {
9544 return nil, err
9545 }
9546 // build request body
9547 var body interface{}
9548
9549 // do request
9550 data, err := o.Client.Do(ctx, "GET", url, body)
9551 if err != nil {
9552 return nil, err
9553 }
9554
9555 // build results
9556 results, err := o.transformReadResults(data)
9557 if err != nil {
9558 return nil, err
9559 }
9560 return results.PacketFilter, nil
9561 }
9562
9563 // Update is API call
9564 func (o *PacketFilterOp) Update(ctx context.Context, zone string, id types.ID, updateParam *PacketFilterUpdateRequest, originalExpressionHash string) (*PacketFilter, error) {
9565 // build request URL
9566 pathBuildParameter := map[string]interface{}{
9567 "rootURL": SakuraCloudAPIRoot,
9568 "pathSuffix": o.PathSuffix,
9569 "pathName": o.PathName,
9570 "zone": zone,
9571 "id": id,
9572 "updateParam": updateParam,
9573 "originalExpressionHash": originalExpressionHash,
9574 }
9575
9576 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}", pathBuildParameter)
9577 if err != nil {
9578 return nil, err
9579 }
9580 // build request body
9581 var body interface{}
9582 v, err := o.transformUpdateArgs(id, updateParam, originalExpressionHash)
9583 if err != nil {
9584 return nil, err
9585 }
9586 body = v
9587
9588 // do request
9589 data, err := o.Client.Do(ctx, "PUT", url, body)
9590 if err != nil {
9591 return nil, err
9592 }
9593
9594 // build results
9595 results, err := o.transformUpdateResults(data)
9596 if err != nil {
9597 return nil, err
9598 }
9599 return results.PacketFilter, nil
9600 }
9601
9602 // Delete is API call
9603 func (o *PacketFilterOp) Delete(ctx context.Context, zone string, id types.ID) error {
9604 // build request URL
9605 pathBuildParameter := map[string]interface{}{
9606 "rootURL": SakuraCloudAPIRoot,
9607 "pathSuffix": o.PathSuffix,
9608 "pathName": o.PathName,
9609 "zone": zone,
9610 "id": id,
9611 }
9612
9613 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}", pathBuildParameter)
9614 if err != nil {
9615 return err
9616 }
9617 // build request body
9618 var body interface{}
9619
9620 // do request
9621 _, err = o.Client.Do(ctx, "DELETE", url, body)
9622 if err != nil {
9623 return err
9624 }
9625
9626 // build results
9627
9628 return nil
9629 }
9630
9631 /*************************************************
9632 * PrivateHostOp
9633 *************************************************/
9634
9635 // PrivateHostOp implements PrivateHostAPI interface
9636 type PrivateHostOp struct {
9637 // Client APICaller
9638 Client APICaller
9639 // PathSuffix is used when building URL
9640 PathSuffix string
9641 // PathName is used when building URL
9642 PathName string
9643 }
9644
9645 // NewPrivateHostOp creates new PrivateHostOp instance
9646 func NewPrivateHostOp(caller APICaller) PrivateHostAPI {
9647 return GetClientFactoryFunc("PrivateHost")(caller).(PrivateHostAPI)
9648 }
9649
9650 // Find is API call
9651 func (o *PrivateHostOp) Find(ctx context.Context, zone string, conditions *FindCondition) (*PrivateHostFindResult, error) {
9652 // build request URL
9653 pathBuildParameter := map[string]interface{}{
9654 "rootURL": SakuraCloudAPIRoot,
9655 "pathSuffix": o.PathSuffix,
9656 "pathName": o.PathName,
9657 "zone": zone,
9658 "conditions": conditions,
9659 }
9660
9661 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}", pathBuildParameter)
9662 if err != nil {
9663 return nil, err
9664 }
9665 // build request body
9666 var body interface{}
9667 v, err := o.transformFindArgs(conditions)
9668 if err != nil {
9669 return nil, err
9670 }
9671 body = v
9672
9673 // do request
9674 data, err := o.Client.Do(ctx, "GET", url, body)
9675 if err != nil {
9676 return nil, err
9677 }
9678
9679 // build results
9680 results, err := o.transformFindResults(data)
9681 if err != nil {
9682 return nil, err
9683 }
9684 return results, err
9685 }
9686
9687 // Create is API call
9688 func (o *PrivateHostOp) Create(ctx context.Context, zone string, param *PrivateHostCreateRequest) (*PrivateHost, error) {
9689 // build request URL
9690 pathBuildParameter := map[string]interface{}{
9691 "rootURL": SakuraCloudAPIRoot,
9692 "pathSuffix": o.PathSuffix,
9693 "pathName": o.PathName,
9694 "zone": zone,
9695 "param": param,
9696 }
9697
9698 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}", pathBuildParameter)
9699 if err != nil {
9700 return nil, err
9701 }
9702 // build request body
9703 var body interface{}
9704 v, err := o.transformCreateArgs(param)
9705 if err != nil {
9706 return nil, err
9707 }
9708 body = v
9709
9710 // do request
9711 data, err := o.Client.Do(ctx, "POST", url, body)
9712 if err != nil {
9713 return nil, err
9714 }
9715
9716 // build results
9717 results, err := o.transformCreateResults(data)
9718 if err != nil {
9719 return nil, err
9720 }
9721 return results.PrivateHost, nil
9722 }
9723
9724 // Read is API call
9725 func (o *PrivateHostOp) Read(ctx context.Context, zone string, id types.ID) (*PrivateHost, error) {
9726 // build request URL
9727 pathBuildParameter := map[string]interface{}{
9728 "rootURL": SakuraCloudAPIRoot,
9729 "pathSuffix": o.PathSuffix,
9730 "pathName": o.PathName,
9731 "zone": zone,
9732 "id": id,
9733 }
9734
9735 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}", pathBuildParameter)
9736 if err != nil {
9737 return nil, err
9738 }
9739 // build request body
9740 var body interface{}
9741
9742 // do request
9743 data, err := o.Client.Do(ctx, "GET", url, body)
9744 if err != nil {
9745 return nil, err
9746 }
9747
9748 // build results
9749 results, err := o.transformReadResults(data)
9750 if err != nil {
9751 return nil, err
9752 }
9753 return results.PrivateHost, nil
9754 }
9755
9756 // Update is API call
9757 func (o *PrivateHostOp) Update(ctx context.Context, zone string, id types.ID, param *PrivateHostUpdateRequest) (*PrivateHost, error) {
9758 // build request URL
9759 pathBuildParameter := map[string]interface{}{
9760 "rootURL": SakuraCloudAPIRoot,
9761 "pathSuffix": o.PathSuffix,
9762 "pathName": o.PathName,
9763 "zone": zone,
9764 "id": id,
9765 "param": param,
9766 }
9767
9768 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}", pathBuildParameter)
9769 if err != nil {
9770 return nil, err
9771 }
9772 // build request body
9773 var body interface{}
9774 v, err := o.transformUpdateArgs(id, param)
9775 if err != nil {
9776 return nil, err
9777 }
9778 body = v
9779
9780 // do request
9781 data, err := o.Client.Do(ctx, "PUT", url, body)
9782 if err != nil {
9783 return nil, err
9784 }
9785
9786 // build results
9787 results, err := o.transformUpdateResults(data)
9788 if err != nil {
9789 return nil, err
9790 }
9791 return results.PrivateHost, nil
9792 }
9793
9794 // Delete is API call
9795 func (o *PrivateHostOp) Delete(ctx context.Context, zone string, id types.ID) error {
9796 // build request URL
9797 pathBuildParameter := map[string]interface{}{
9798 "rootURL": SakuraCloudAPIRoot,
9799 "pathSuffix": o.PathSuffix,
9800 "pathName": o.PathName,
9801 "zone": zone,
9802 "id": id,
9803 }
9804
9805 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}", pathBuildParameter)
9806 if err != nil {
9807 return err
9808 }
9809 // build request body
9810 var body interface{}
9811
9812 // do request
9813 _, err = o.Client.Do(ctx, "DELETE", url, body)
9814 if err != nil {
9815 return err
9816 }
9817
9818 // build results
9819
9820 return nil
9821 }
9822
9823 /*************************************************
9824 * PrivateHostPlanOp
9825 *************************************************/
9826
9827 // PrivateHostPlanOp implements PrivateHostPlanAPI interface
9828 type PrivateHostPlanOp struct {
9829 // Client APICaller
9830 Client APICaller
9831 // PathSuffix is used when building URL
9832 PathSuffix string
9833 // PathName is used when building URL
9834 PathName string
9835 }
9836
9837 // NewPrivateHostPlanOp creates new PrivateHostPlanOp instance
9838 func NewPrivateHostPlanOp(caller APICaller) PrivateHostPlanAPI {
9839 return GetClientFactoryFunc("PrivateHostPlan")(caller).(PrivateHostPlanAPI)
9840 }
9841
9842 // Find is API call
9843 func (o *PrivateHostPlanOp) Find(ctx context.Context, zone string, conditions *FindCondition) (*PrivateHostPlanFindResult, error) {
9844 // build request URL
9845 pathBuildParameter := map[string]interface{}{
9846 "rootURL": SakuraCloudAPIRoot,
9847 "pathSuffix": o.PathSuffix,
9848 "pathName": o.PathName,
9849 "zone": zone,
9850 "conditions": conditions,
9851 }
9852
9853 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}", pathBuildParameter)
9854 if err != nil {
9855 return nil, err
9856 }
9857 // build request body
9858 var body interface{}
9859 v, err := o.transformFindArgs(conditions)
9860 if err != nil {
9861 return nil, err
9862 }
9863 body = v
9864
9865 // do request
9866 data, err := o.Client.Do(ctx, "GET", url, body)
9867 if err != nil {
9868 return nil, err
9869 }
9870
9871 // build results
9872 results, err := o.transformFindResults(data)
9873 if err != nil {
9874 return nil, err
9875 }
9876 return results, err
9877 }
9878
9879 // Read is API call
9880 func (o *PrivateHostPlanOp) Read(ctx context.Context, zone string, id types.ID) (*PrivateHostPlan, error) {
9881 // build request URL
9882 pathBuildParameter := map[string]interface{}{
9883 "rootURL": SakuraCloudAPIRoot,
9884 "pathSuffix": o.PathSuffix,
9885 "pathName": o.PathName,
9886 "zone": zone,
9887 "id": id,
9888 }
9889
9890 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}", pathBuildParameter)
9891 if err != nil {
9892 return nil, err
9893 }
9894 // build request body
9895 var body interface{}
9896
9897 // do request
9898 data, err := o.Client.Do(ctx, "GET", url, body)
9899 if err != nil {
9900 return nil, err
9901 }
9902
9903 // build results
9904 results, err := o.transformReadResults(data)
9905 if err != nil {
9906 return nil, err
9907 }
9908 return results.PrivateHostPlan, nil
9909 }
9910
9911 /*************************************************
9912 * ProxyLBOp
9913 *************************************************/
9914
9915 // ProxyLBOp implements ProxyLBAPI interface
9916 type ProxyLBOp struct {
9917 // Client APICaller
9918 Client APICaller
9919 // PathSuffix is used when building URL
9920 PathSuffix string
9921 // PathName is used when building URL
9922 PathName string
9923 }
9924
9925 // NewProxyLBOp creates new ProxyLBOp instance
9926 func NewProxyLBOp(caller APICaller) ProxyLBAPI {
9927 return GetClientFactoryFunc("ProxyLB")(caller).(ProxyLBAPI)
9928 }
9929
9930 // Find is API call
9931 func (o *ProxyLBOp) Find(ctx context.Context, conditions *FindCondition) (*ProxyLBFindResult, error) {
9932 // build request URL
9933 pathBuildParameter := map[string]interface{}{
9934 "rootURL": SakuraCloudAPIRoot,
9935 "pathSuffix": o.PathSuffix,
9936 "pathName": o.PathName,
9937 "zone": APIDefaultZone,
9938 "conditions": conditions,
9939 }
9940
9941 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}", pathBuildParameter)
9942 if err != nil {
9943 return nil, err
9944 }
9945 // build request body
9946 var body interface{}
9947 v, err := o.transformFindArgs(conditions)
9948 if err != nil {
9949 return nil, err
9950 }
9951 body = v
9952
9953 // do request
9954 data, err := o.Client.Do(ctx, "GET", url, body)
9955 if err != nil {
9956 return nil, err
9957 }
9958
9959 // build results
9960 results, err := o.transformFindResults(data)
9961 if err != nil {
9962 return nil, err
9963 }
9964 return results, err
9965 }
9966
9967 // Create is API call
9968 func (o *ProxyLBOp) Create(ctx context.Context, param *ProxyLBCreateRequest) (*ProxyLB, error) {
9969 // build request URL
9970 pathBuildParameter := map[string]interface{}{
9971 "rootURL": SakuraCloudAPIRoot,
9972 "pathSuffix": o.PathSuffix,
9973 "pathName": o.PathName,
9974 "zone": APIDefaultZone,
9975 "param": param,
9976 }
9977
9978 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}", pathBuildParameter)
9979 if err != nil {
9980 return nil, err
9981 }
9982 // build request body
9983 var body interface{}
9984 v, err := o.transformCreateArgs(param)
9985 if err != nil {
9986 return nil, err
9987 }
9988 body = v
9989
9990 // do request
9991 data, err := o.Client.Do(ctx, "POST", url, body)
9992 if err != nil {
9993 return nil, err
9994 }
9995
9996 // build results
9997 results, err := o.transformCreateResults(data)
9998 if err != nil {
9999 return nil, err
10000 }
10001 return results.ProxyLB, nil
10002 }
10003
10004 // Read is API call
10005 func (o *ProxyLBOp) Read(ctx context.Context, id types.ID) (*ProxyLB, error) {
10006 // build request URL
10007 pathBuildParameter := map[string]interface{}{
10008 "rootURL": SakuraCloudAPIRoot,
10009 "pathSuffix": o.PathSuffix,
10010 "pathName": o.PathName,
10011 "zone": APIDefaultZone,
10012 "id": id,
10013 }
10014
10015 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}", pathBuildParameter)
10016 if err != nil {
10017 return nil, err
10018 }
10019 // build request body
10020 var body interface{}
10021
10022 // do request
10023 data, err := o.Client.Do(ctx, "GET", url, body)
10024 if err != nil {
10025 return nil, err
10026 }
10027
10028 // build results
10029 results, err := o.transformReadResults(data)
10030 if err != nil {
10031 return nil, err
10032 }
10033 return results.ProxyLB, nil
10034 }
10035
10036 // Update is API call
10037 func (o *ProxyLBOp) Update(ctx context.Context, id types.ID, param *ProxyLBUpdateRequest) (*ProxyLB, error) {
10038 // build request URL
10039 pathBuildParameter := map[string]interface{}{
10040 "rootURL": SakuraCloudAPIRoot,
10041 "pathSuffix": o.PathSuffix,
10042 "pathName": o.PathName,
10043 "zone": APIDefaultZone,
10044 "id": id,
10045 "param": param,
10046 }
10047
10048 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}", pathBuildParameter)
10049 if err != nil {
10050 return nil, err
10051 }
10052 // build request body
10053 var body interface{}
10054 v, err := o.transformUpdateArgs(id, param)
10055 if err != nil {
10056 return nil, err
10057 }
10058 body = v
10059
10060 // do request
10061 data, err := o.Client.Do(ctx, "PUT", url, body)
10062 if err != nil {
10063 return nil, err
10064 }
10065
10066 // build results
10067 results, err := o.transformUpdateResults(data)
10068 if err != nil {
10069 return nil, err
10070 }
10071 return results.ProxyLB, nil
10072 }
10073
10074 // UpdateSettings is API call
10075 func (o *ProxyLBOp) UpdateSettings(ctx context.Context, id types.ID, param *ProxyLBUpdateSettingsRequest) (*ProxyLB, error) {
10076 // build request URL
10077 pathBuildParameter := map[string]interface{}{
10078 "rootURL": SakuraCloudAPIRoot,
10079 "pathSuffix": o.PathSuffix,
10080 "pathName": o.PathName,
10081 "zone": APIDefaultZone,
10082 "id": id,
10083 "param": param,
10084 }
10085
10086 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}", pathBuildParameter)
10087 if err != nil {
10088 return nil, err
10089 }
10090 // build request body
10091 var body interface{}
10092 v, err := o.transformUpdateSettingsArgs(id, param)
10093 if err != nil {
10094 return nil, err
10095 }
10096 body = v
10097
10098 // do request
10099 data, err := o.Client.Do(ctx, "PUT", url, body)
10100 if err != nil {
10101 return nil, err
10102 }
10103
10104 // build results
10105 results, err := o.transformUpdateSettingsResults(data)
10106 if err != nil {
10107 return nil, err
10108 }
10109 return results.ProxyLB, nil
10110 }
10111
10112 // Delete is API call
10113 func (o *ProxyLBOp) Delete(ctx context.Context, id types.ID) error {
10114 // build request URL
10115 pathBuildParameter := map[string]interface{}{
10116 "rootURL": SakuraCloudAPIRoot,
10117 "pathSuffix": o.PathSuffix,
10118 "pathName": o.PathName,
10119 "zone": APIDefaultZone,
10120 "id": id,
10121 }
10122
10123 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}", pathBuildParameter)
10124 if err != nil {
10125 return err
10126 }
10127 // build request body
10128 var body interface{}
10129
10130 // do request
10131 _, err = o.Client.Do(ctx, "DELETE", url, body)
10132 if err != nil {
10133 return err
10134 }
10135
10136 // build results
10137
10138 return nil
10139 }
10140
10141 // ChangePlan is API call
10142 func (o *ProxyLBOp) ChangePlan(ctx context.Context, id types.ID, param *ProxyLBChangePlanRequest) (*ProxyLB, error) {
10143 // build request URL
10144 pathBuildParameter := map[string]interface{}{
10145 "rootURL": SakuraCloudAPIRoot,
10146 "pathSuffix": o.PathSuffix,
10147 "pathName": o.PathName,
10148 "zone": APIDefaultZone,
10149 "id": id,
10150 "param": param,
10151 }
10152
10153 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}/plan", pathBuildParameter)
10154 if err != nil {
10155 return nil, err
10156 }
10157 // build request body
10158 var body interface{}
10159 v, err := o.transformChangePlanArgs(id, param)
10160 if err != nil {
10161 return nil, err
10162 }
10163 body = v
10164
10165 // do request
10166 data, err := o.Client.Do(ctx, "PUT", url, body)
10167 if err != nil {
10168 return nil, err
10169 }
10170
10171 // build results
10172 results, err := o.transformChangePlanResults(data)
10173 if err != nil {
10174 return nil, err
10175 }
10176 return results.ProxyLB, nil
10177 }
10178
10179 // GetCertificates is API call
10180 func (o *ProxyLBOp) GetCertificates(ctx context.Context, id types.ID) (*ProxyLBCertificates, error) {
10181 // build request URL
10182 pathBuildParameter := map[string]interface{}{
10183 "rootURL": SakuraCloudAPIRoot,
10184 "pathSuffix": o.PathSuffix,
10185 "pathName": o.PathName,
10186 "zone": APIDefaultZone,
10187 "id": id,
10188 }
10189
10190 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}/proxylb/sslcertificate", pathBuildParameter)
10191 if err != nil {
10192 return nil, err
10193 }
10194 // build request body
10195 var body interface{}
10196
10197 // do request
10198 data, err := o.Client.Do(ctx, "GET", url, body)
10199 if err != nil {
10200 return nil, err
10201 }
10202
10203 // build results
10204 results, err := o.transformGetCertificatesResults(data)
10205 if err != nil {
10206 return nil, err
10207 }
10208 return results.ProxyLBCertificates, nil
10209 }
10210
10211 // SetCertificates is API call
10212 func (o *ProxyLBOp) SetCertificates(ctx context.Context, id types.ID, param *ProxyLBSetCertificatesRequest) (*ProxyLBCertificates, error) {
10213 // build request URL
10214 pathBuildParameter := map[string]interface{}{
10215 "rootURL": SakuraCloudAPIRoot,
10216 "pathSuffix": o.PathSuffix,
10217 "pathName": o.PathName,
10218 "zone": APIDefaultZone,
10219 "id": id,
10220 "param": param,
10221 }
10222
10223 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}/proxylb/sslcertificate", pathBuildParameter)
10224 if err != nil {
10225 return nil, err
10226 }
10227 // build request body
10228 var body interface{}
10229 v, err := o.transformSetCertificatesArgs(id, param)
10230 if err != nil {
10231 return nil, err
10232 }
10233 body = v
10234
10235 // do request
10236 data, err := o.Client.Do(ctx, "PUT", url, body)
10237 if err != nil {
10238 return nil, err
10239 }
10240
10241 // build results
10242 results, err := o.transformSetCertificatesResults(data)
10243 if err != nil {
10244 return nil, err
10245 }
10246 return results.ProxyLBCertificates, nil
10247 }
10248
10249 // DeleteCertificates is API call
10250 func (o *ProxyLBOp) DeleteCertificates(ctx context.Context, id types.ID) error {
10251 // build request URL
10252 pathBuildParameter := map[string]interface{}{
10253 "rootURL": SakuraCloudAPIRoot,
10254 "pathSuffix": o.PathSuffix,
10255 "pathName": o.PathName,
10256 "zone": APIDefaultZone,
10257 "id": id,
10258 }
10259
10260 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}/proxylb/sslcertificate", pathBuildParameter)
10261 if err != nil {
10262 return err
10263 }
10264 // build request body
10265 var body interface{}
10266
10267 // do request
10268 _, err = o.Client.Do(ctx, "DELETE", url, body)
10269 if err != nil {
10270 return err
10271 }
10272
10273 // build results
10274
10275 return nil
10276 }
10277
10278 // RenewLetsEncryptCert is API call
10279 func (o *ProxyLBOp) RenewLetsEncryptCert(ctx context.Context, id types.ID) error {
10280 // build request URL
10281 pathBuildParameter := map[string]interface{}{
10282 "rootURL": SakuraCloudAPIRoot,
10283 "pathSuffix": o.PathSuffix,
10284 "pathName": o.PathName,
10285 "zone": APIDefaultZone,
10286 "id": id,
10287 }
10288
10289 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}/proxylb/letsencryptrenew", pathBuildParameter)
10290 if err != nil {
10291 return err
10292 }
10293 // build request body
10294 var body interface{}
10295
10296 // do request
10297 _, err = o.Client.Do(ctx, "PUT", url, body)
10298 if err != nil {
10299 return err
10300 }
10301
10302 // build results
10303
10304 return nil
10305 }
10306
10307 // HealthStatus is API call
10308 func (o *ProxyLBOp) HealthStatus(ctx context.Context, id types.ID) (*ProxyLBHealth, error) {
10309 // build request URL
10310 pathBuildParameter := map[string]interface{}{
10311 "rootURL": SakuraCloudAPIRoot,
10312 "pathSuffix": o.PathSuffix,
10313 "pathName": o.PathName,
10314 "zone": APIDefaultZone,
10315 "id": id,
10316 }
10317
10318 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}/health", pathBuildParameter)
10319 if err != nil {
10320 return nil, err
10321 }
10322 // build request body
10323 var body interface{}
10324
10325 // do request
10326 data, err := o.Client.Do(ctx, "GET", url, body)
10327 if err != nil {
10328 return nil, err
10329 }
10330
10331 // build results
10332 results, err := o.transformHealthStatusResults(data)
10333 if err != nil {
10334 return nil, err
10335 }
10336 return results.ProxyLBHealth, nil
10337 }
10338
10339 // MonitorConnection is API call
10340 func (o *ProxyLBOp) MonitorConnection(ctx context.Context, id types.ID, condition *MonitorCondition) (*ConnectionActivity, error) {
10341 // build request URL
10342 pathBuildParameter := map[string]interface{}{
10343 "rootURL": SakuraCloudAPIRoot,
10344 "pathSuffix": o.PathSuffix,
10345 "pathName": o.PathName,
10346 "zone": APIDefaultZone,
10347 "id": id,
10348 "condition": condition,
10349 }
10350
10351 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}/activity/proxylb/monitor", pathBuildParameter)
10352 if err != nil {
10353 return nil, err
10354 }
10355 // build request body
10356 var body interface{}
10357 v, err := o.transformMonitorConnectionArgs(id, condition)
10358 if err != nil {
10359 return nil, err
10360 }
10361 body = v
10362
10363 // do request
10364 data, err := o.Client.Do(ctx, "GET", url, body)
10365 if err != nil {
10366 return nil, err
10367 }
10368
10369 // build results
10370 results, err := o.transformMonitorConnectionResults(data)
10371 if err != nil {
10372 return nil, err
10373 }
10374 return results.ConnectionActivity, nil
10375 }
10376
10377 /*************************************************
10378 * RegionOp
10379 *************************************************/
10380
10381 // RegionOp implements RegionAPI interface
10382 type RegionOp struct {
10383 // Client APICaller
10384 Client APICaller
10385 // PathSuffix is used when building URL
10386 PathSuffix string
10387 // PathName is used when building URL
10388 PathName string
10389 }
10390
10391 // NewRegionOp creates new RegionOp instance
10392 func NewRegionOp(caller APICaller) RegionAPI {
10393 return GetClientFactoryFunc("Region")(caller).(RegionAPI)
10394 }
10395
10396 // Find is API call
10397 func (o *RegionOp) Find(ctx context.Context, conditions *FindCondition) (*RegionFindResult, error) {
10398 // build request URL
10399 pathBuildParameter := map[string]interface{}{
10400 "rootURL": SakuraCloudAPIRoot,
10401 "pathSuffix": o.PathSuffix,
10402 "pathName": o.PathName,
10403 "zone": APIDefaultZone,
10404 "conditions": conditions,
10405 }
10406
10407 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}", pathBuildParameter)
10408 if err != nil {
10409 return nil, err
10410 }
10411 // build request body
10412 var body interface{}
10413 v, err := o.transformFindArgs(conditions)
10414 if err != nil {
10415 return nil, err
10416 }
10417 body = v
10418
10419 // do request
10420 data, err := o.Client.Do(ctx, "GET", url, body)
10421 if err != nil {
10422 return nil, err
10423 }
10424
10425 // build results
10426 results, err := o.transformFindResults(data)
10427 if err != nil {
10428 return nil, err
10429 }
10430 return results, err
10431 }
10432
10433 // Read is API call
10434 func (o *RegionOp) Read(ctx context.Context, id types.ID) (*Region, error) {
10435 // build request URL
10436 pathBuildParameter := map[string]interface{}{
10437 "rootURL": SakuraCloudAPIRoot,
10438 "pathSuffix": o.PathSuffix,
10439 "pathName": o.PathName,
10440 "zone": APIDefaultZone,
10441 "id": id,
10442 }
10443
10444 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}", pathBuildParameter)
10445 if err != nil {
10446 return nil, err
10447 }
10448 // build request body
10449 var body interface{}
10450
10451 // do request
10452 data, err := o.Client.Do(ctx, "GET", url, body)
10453 if err != nil {
10454 return nil, err
10455 }
10456
10457 // build results
10458 results, err := o.transformReadResults(data)
10459 if err != nil {
10460 return nil, err
10461 }
10462 return results.Region, nil
10463 }
10464
10465 /*************************************************
10466 * ServerOp
10467 *************************************************/
10468
10469 // ServerOp implements ServerAPI interface
10470 type ServerOp struct {
10471 // Client APICaller
10472 Client APICaller
10473 // PathSuffix is used when building URL
10474 PathSuffix string
10475 // PathName is used when building URL
10476 PathName string
10477 }
10478
10479 // NewServerOp creates new ServerOp instance
10480 func NewServerOp(caller APICaller) ServerAPI {
10481 return GetClientFactoryFunc("Server")(caller).(ServerAPI)
10482 }
10483
10484 // Find is API call
10485 func (o *ServerOp) Find(ctx context.Context, zone string, conditions *FindCondition) (*ServerFindResult, error) {
10486 // build request URL
10487 pathBuildParameter := map[string]interface{}{
10488 "rootURL": SakuraCloudAPIRoot,
10489 "pathSuffix": o.PathSuffix,
10490 "pathName": o.PathName,
10491 "zone": zone,
10492 "conditions": conditions,
10493 }
10494
10495 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}", pathBuildParameter)
10496 if err != nil {
10497 return nil, err
10498 }
10499 // build request body
10500 var body interface{}
10501 v, err := o.transformFindArgs(conditions)
10502 if err != nil {
10503 return nil, err
10504 }
10505 body = v
10506
10507 // do request
10508 data, err := o.Client.Do(ctx, "GET", url, body)
10509 if err != nil {
10510 return nil, err
10511 }
10512
10513 // build results
10514 results, err := o.transformFindResults(data)
10515 if err != nil {
10516 return nil, err
10517 }
10518 return results, err
10519 }
10520
10521 // Create is API call
10522 func (o *ServerOp) Create(ctx context.Context, zone string, param *ServerCreateRequest) (*Server, error) {
10523 // build request URL
10524 pathBuildParameter := map[string]interface{}{
10525 "rootURL": SakuraCloudAPIRoot,
10526 "pathSuffix": o.PathSuffix,
10527 "pathName": o.PathName,
10528 "zone": zone,
10529 "param": param,
10530 }
10531
10532 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}", pathBuildParameter)
10533 if err != nil {
10534 return nil, err
10535 }
10536 // build request body
10537 var body interface{}
10538 v, err := o.transformCreateArgs(param)
10539 if err != nil {
10540 return nil, err
10541 }
10542 body = v
10543
10544 // do request
10545 data, err := o.Client.Do(ctx, "POST", url, body)
10546 if err != nil {
10547 return nil, err
10548 }
10549
10550 // build results
10551 results, err := o.transformCreateResults(data)
10552 if err != nil {
10553 return nil, err
10554 }
10555 return results.Server, nil
10556 }
10557
10558 // Read is API call
10559 func (o *ServerOp) Read(ctx context.Context, zone string, id types.ID) (*Server, error) {
10560 // build request URL
10561 pathBuildParameter := map[string]interface{}{
10562 "rootURL": SakuraCloudAPIRoot,
10563 "pathSuffix": o.PathSuffix,
10564 "pathName": o.PathName,
10565 "zone": zone,
10566 "id": id,
10567 }
10568
10569 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}", pathBuildParameter)
10570 if err != nil {
10571 return nil, err
10572 }
10573 // build request body
10574 var body interface{}
10575
10576 // do request
10577 data, err := o.Client.Do(ctx, "GET", url, body)
10578 if err != nil {
10579 return nil, err
10580 }
10581
10582 // build results
10583 results, err := o.transformReadResults(data)
10584 if err != nil {
10585 return nil, err
10586 }
10587 return results.Server, nil
10588 }
10589
10590 // Update is API call
10591 func (o *ServerOp) Update(ctx context.Context, zone string, id types.ID, param *ServerUpdateRequest) (*Server, error) {
10592 // build request URL
10593 pathBuildParameter := map[string]interface{}{
10594 "rootURL": SakuraCloudAPIRoot,
10595 "pathSuffix": o.PathSuffix,
10596 "pathName": o.PathName,
10597 "zone": zone,
10598 "id": id,
10599 "param": param,
10600 }
10601
10602 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}", pathBuildParameter)
10603 if err != nil {
10604 return nil, err
10605 }
10606 // build request body
10607 var body interface{}
10608 v, err := o.transformUpdateArgs(id, param)
10609 if err != nil {
10610 return nil, err
10611 }
10612 body = v
10613
10614 // do request
10615 data, err := o.Client.Do(ctx, "PUT", url, body)
10616 if err != nil {
10617 return nil, err
10618 }
10619
10620 // build results
10621 results, err := o.transformUpdateResults(data)
10622 if err != nil {
10623 return nil, err
10624 }
10625 return results.Server, nil
10626 }
10627
10628 // Delete is API call
10629 func (o *ServerOp) Delete(ctx context.Context, zone string, id types.ID) error {
10630 // build request URL
10631 pathBuildParameter := map[string]interface{}{
10632 "rootURL": SakuraCloudAPIRoot,
10633 "pathSuffix": o.PathSuffix,
10634 "pathName": o.PathName,
10635 "zone": zone,
10636 "id": id,
10637 }
10638
10639 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}", pathBuildParameter)
10640 if err != nil {
10641 return err
10642 }
10643 // build request body
10644 var body interface{}
10645
10646 // do request
10647 _, err = o.Client.Do(ctx, "DELETE", url, body)
10648 if err != nil {
10649 return err
10650 }
10651
10652 // build results
10653
10654 return nil
10655 }
10656
10657 // DeleteWithDisks is API call
10658 func (o *ServerOp) DeleteWithDisks(ctx context.Context, zone string, id types.ID, disks *ServerDeleteWithDisksRequest) error {
10659 // build request URL
10660 pathBuildParameter := map[string]interface{}{
10661 "rootURL": SakuraCloudAPIRoot,
10662 "pathSuffix": o.PathSuffix,
10663 "pathName": o.PathName,
10664 "zone": zone,
10665 "id": id,
10666 "disks": disks,
10667 }
10668
10669 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}", pathBuildParameter)
10670 if err != nil {
10671 return err
10672 }
10673 // build request body
10674 var body interface{}
10675 v, err := o.transformDeleteWithDisksArgs(id, disks)
10676 if err != nil {
10677 return err
10678 }
10679 body = v
10680
10681 // do request
10682 _, err = o.Client.Do(ctx, "DELETE", url, body)
10683 if err != nil {
10684 return err
10685 }
10686
10687 // build results
10688
10689 return nil
10690 }
10691
10692 // ChangePlan is API call
10693 func (o *ServerOp) ChangePlan(ctx context.Context, zone string, id types.ID, plan *ServerChangePlanRequest) (*Server, error) {
10694 // build request URL
10695 pathBuildParameter := map[string]interface{}{
10696 "rootURL": SakuraCloudAPIRoot,
10697 "pathSuffix": o.PathSuffix,
10698 "pathName": o.PathName,
10699 "zone": zone,
10700 "id": id,
10701 "plan": plan,
10702 }
10703
10704 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}/plan", pathBuildParameter)
10705 if err != nil {
10706 return nil, err
10707 }
10708 // build request body
10709 var body interface{}
10710 v, err := o.transformChangePlanArgs(id, plan)
10711 if err != nil {
10712 return nil, err
10713 }
10714 body = v
10715
10716 // do request
10717 data, err := o.Client.Do(ctx, "PUT", url, body)
10718 if err != nil {
10719 return nil, err
10720 }
10721
10722 // build results
10723 results, err := o.transformChangePlanResults(data)
10724 if err != nil {
10725 return nil, err
10726 }
10727 return results.Server, nil
10728 }
10729
10730 // InsertCDROM is API call
10731 func (o *ServerOp) InsertCDROM(ctx context.Context, zone string, id types.ID, insertParam *InsertCDROMRequest) error {
10732 // build request URL
10733 pathBuildParameter := map[string]interface{}{
10734 "rootURL": SakuraCloudAPIRoot,
10735 "pathSuffix": o.PathSuffix,
10736 "pathName": o.PathName,
10737 "zone": zone,
10738 "id": id,
10739 "insertParam": insertParam,
10740 }
10741
10742 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}/cdrom", pathBuildParameter)
10743 if err != nil {
10744 return err
10745 }
10746 // build request body
10747 var body interface{}
10748 v, err := o.transformInsertCDROMArgs(id, insertParam)
10749 if err != nil {
10750 return err
10751 }
10752 body = v
10753
10754 // do request
10755 _, err = o.Client.Do(ctx, "PUT", url, body)
10756 if err != nil {
10757 return err
10758 }
10759
10760 // build results
10761
10762 return nil
10763 }
10764
10765 // EjectCDROM is API call
10766 func (o *ServerOp) EjectCDROM(ctx context.Context, zone string, id types.ID, ejectParam *EjectCDROMRequest) error {
10767 // build request URL
10768 pathBuildParameter := map[string]interface{}{
10769 "rootURL": SakuraCloudAPIRoot,
10770 "pathSuffix": o.PathSuffix,
10771 "pathName": o.PathName,
10772 "zone": zone,
10773 "id": id,
10774 "ejectParam": ejectParam,
10775 }
10776
10777 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}/cdrom", pathBuildParameter)
10778 if err != nil {
10779 return err
10780 }
10781 // build request body
10782 var body interface{}
10783 v, err := o.transformEjectCDROMArgs(id, ejectParam)
10784 if err != nil {
10785 return err
10786 }
10787 body = v
10788
10789 // do request
10790 _, err = o.Client.Do(ctx, "DELETE", url, body)
10791 if err != nil {
10792 return err
10793 }
10794
10795 // build results
10796
10797 return nil
10798 }
10799
10800 // Boot is API call
10801 func (o *ServerOp) Boot(ctx context.Context, zone string, id types.ID) error {
10802 // build request URL
10803 pathBuildParameter := map[string]interface{}{
10804 "rootURL": SakuraCloudAPIRoot,
10805 "pathSuffix": o.PathSuffix,
10806 "pathName": o.PathName,
10807 "zone": zone,
10808 "id": id,
10809 }
10810
10811 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}/power", pathBuildParameter)
10812 if err != nil {
10813 return err
10814 }
10815 lockKey, err := buildURL("GlobalLock", pathBuildParameter)
10816 if err != nil {
10817 return err
10818 }
10819 apiLocker.Lock(lockKey)
10820 defer apiLocker.Unlock(lockKey)
10821 // build request body
10822 var body interface{}
10823
10824 // do request
10825 _, err = o.Client.Do(ctx, "PUT", url, body)
10826 if err != nil {
10827 return err
10828 }
10829
10830 // build results
10831
10832 return nil
10833 }
10834
10835 // Shutdown is API call
10836 func (o *ServerOp) Shutdown(ctx context.Context, zone string, id types.ID, shutdownOption *ShutdownOption) error {
10837 // build request URL
10838 pathBuildParameter := map[string]interface{}{
10839 "rootURL": SakuraCloudAPIRoot,
10840 "pathSuffix": o.PathSuffix,
10841 "pathName": o.PathName,
10842 "zone": zone,
10843 "id": id,
10844 "shutdownOption": shutdownOption,
10845 }
10846
10847 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}/power", pathBuildParameter)
10848 if err != nil {
10849 return err
10850 }
10851 lockKey, err := buildURL("GlobalLock", pathBuildParameter)
10852 if err != nil {
10853 return err
10854 }
10855 apiLocker.Lock(lockKey)
10856 defer apiLocker.Unlock(lockKey)
10857 // build request body
10858 var body interface{}
10859 v, err := o.transformShutdownArgs(id, shutdownOption)
10860 if err != nil {
10861 return err
10862 }
10863 body = v
10864
10865 // do request
10866 _, err = o.Client.Do(ctx, "DELETE", url, body)
10867 if err != nil {
10868 return err
10869 }
10870
10871 // build results
10872
10873 return nil
10874 }
10875
10876 // Reset is API call
10877 func (o *ServerOp) Reset(ctx context.Context, zone string, id types.ID) error {
10878 // build request URL
10879 pathBuildParameter := map[string]interface{}{
10880 "rootURL": SakuraCloudAPIRoot,
10881 "pathSuffix": o.PathSuffix,
10882 "pathName": o.PathName,
10883 "zone": zone,
10884 "id": id,
10885 }
10886
10887 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}/reset", pathBuildParameter)
10888 if err != nil {
10889 return err
10890 }
10891 lockKey, err := buildURL("GlobalLock", pathBuildParameter)
10892 if err != nil {
10893 return err
10894 }
10895 apiLocker.Lock(lockKey)
10896 defer apiLocker.Unlock(lockKey)
10897 // build request body
10898 var body interface{}
10899
10900 // do request
10901 _, err = o.Client.Do(ctx, "PUT", url, body)
10902 if err != nil {
10903 return err
10904 }
10905
10906 // build results
10907
10908 return nil
10909 }
10910
10911 // BootWithVariables is API call
10912 func (o *ServerOp) BootWithVariables(ctx context.Context, zone string, id types.ID, param *ServerBootVariables) error {
10913 // build request URL
10914 pathBuildParameter := map[string]interface{}{
10915 "rootURL": SakuraCloudAPIRoot,
10916 "pathSuffix": o.PathSuffix,
10917 "pathName": o.PathName,
10918 "zone": zone,
10919 "id": id,
10920 "param": param,
10921 }
10922
10923 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}/power", pathBuildParameter)
10924 if err != nil {
10925 return err
10926 }
10927 lockKey, err := buildURL("GlobalLock", pathBuildParameter)
10928 if err != nil {
10929 return err
10930 }
10931 apiLocker.Lock(lockKey)
10932 defer apiLocker.Unlock(lockKey)
10933 // build request body
10934 var body interface{}
10935 v, err := o.transformBootWithVariablesArgs(id, param)
10936 if err != nil {
10937 return err
10938 }
10939 body = v
10940
10941 // do request
10942 _, err = o.Client.Do(ctx, "PUT", url, body)
10943 if err != nil {
10944 return err
10945 }
10946
10947 // build results
10948
10949 return nil
10950 }
10951
10952 // SendKey is API call
10953 func (o *ServerOp) SendKey(ctx context.Context, zone string, id types.ID, keyboardParam *SendKeyRequest) error {
10954 // build request URL
10955 pathBuildParameter := map[string]interface{}{
10956 "rootURL": SakuraCloudAPIRoot,
10957 "pathSuffix": o.PathSuffix,
10958 "pathName": o.PathName,
10959 "zone": zone,
10960 "id": id,
10961 "keyboardParam": keyboardParam,
10962 }
10963
10964 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}/keyboard", pathBuildParameter)
10965 if err != nil {
10966 return err
10967 }
10968 // build request body
10969 var body interface{}
10970 v, err := o.transformSendKeyArgs(id, keyboardParam)
10971 if err != nil {
10972 return err
10973 }
10974 body = v
10975
10976 // do request
10977 _, err = o.Client.Do(ctx, "PUT", url, body)
10978 if err != nil {
10979 return err
10980 }
10981
10982 // build results
10983
10984 return nil
10985 }
10986
10987 // SendNMI is API call
10988 func (o *ServerOp) SendNMI(ctx context.Context, zone string, id types.ID) error {
10989 // build request URL
10990 pathBuildParameter := map[string]interface{}{
10991 "rootURL": SakuraCloudAPIRoot,
10992 "pathSuffix": o.PathSuffix,
10993 "pathName": o.PathName,
10994 "zone": zone,
10995 "id": id,
10996 }
10997
10998 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}/qemu/nmi", pathBuildParameter)
10999 if err != nil {
11000 return err
11001 }
11002 // build request body
11003 var body interface{}
11004
11005 // do request
11006 _, err = o.Client.Do(ctx, "PUT", url, body)
11007 if err != nil {
11008 return err
11009 }
11010
11011 // build results
11012
11013 return nil
11014 }
11015
11016 // GetVNCProxy is API call
11017 func (o *ServerOp) GetVNCProxy(ctx context.Context, zone string, id types.ID) (*VNCProxyInfo, error) {
11018 // build request URL
11019 pathBuildParameter := map[string]interface{}{
11020 "rootURL": SakuraCloudAPIRoot,
11021 "pathSuffix": o.PathSuffix,
11022 "pathName": o.PathName,
11023 "zone": zone,
11024 "id": id,
11025 }
11026
11027 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}/vnc/proxy", pathBuildParameter)
11028 if err != nil {
11029 return nil, err
11030 }
11031 // build request body
11032 var body interface{}
11033
11034 // do request
11035 data, err := o.Client.Do(ctx, "GET", url, body)
11036 if err != nil {
11037 return nil, err
11038 }
11039
11040 // build results
11041 results, err := o.transformGetVNCProxyResults(data)
11042 if err != nil {
11043 return nil, err
11044 }
11045 return results.VNCProxyInfo, nil
11046 }
11047
11048 // Monitor is API call
11049 func (o *ServerOp) Monitor(ctx context.Context, zone string, id types.ID, condition *MonitorCondition) (*CPUTimeActivity, error) {
11050 // build request URL
11051 pathBuildParameter := map[string]interface{}{
11052 "rootURL": SakuraCloudAPIRoot,
11053 "pathSuffix": o.PathSuffix,
11054 "pathName": o.PathName,
11055 "zone": zone,
11056 "id": id,
11057 "condition": condition,
11058 }
11059
11060 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}/monitor", pathBuildParameter)
11061 if err != nil {
11062 return nil, err
11063 }
11064 // build request body
11065 var body interface{}
11066 v, err := o.transformMonitorArgs(id, condition)
11067 if err != nil {
11068 return nil, err
11069 }
11070 body = v
11071
11072 // do request
11073 data, err := o.Client.Do(ctx, "GET", url, body)
11074 if err != nil {
11075 return nil, err
11076 }
11077
11078 // build results
11079 results, err := o.transformMonitorResults(data)
11080 if err != nil {
11081 return nil, err
11082 }
11083 return results.CPUTimeActivity, nil
11084 }
11085
11086 // MonitorCPU is API call
11087 func (o *ServerOp) MonitorCPU(ctx context.Context, zone string, id types.ID, condition *MonitorCondition) (*CPUTimeActivity, error) {
11088 // build request URL
11089 pathBuildParameter := map[string]interface{}{
11090 "rootURL": SakuraCloudAPIRoot,
11091 "pathSuffix": o.PathSuffix,
11092 "pathName": o.PathName,
11093 "zone": zone,
11094 "id": id,
11095 "condition": condition,
11096 }
11097
11098 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}/monitor", pathBuildParameter)
11099 if err != nil {
11100 return nil, err
11101 }
11102 // build request body
11103 var body interface{}
11104 v, err := o.transformMonitorCPUArgs(id, condition)
11105 if err != nil {
11106 return nil, err
11107 }
11108 body = v
11109
11110 // do request
11111 data, err := o.Client.Do(ctx, "GET", url, body)
11112 if err != nil {
11113 return nil, err
11114 }
11115
11116 // build results
11117 results, err := o.transformMonitorCPUResults(data)
11118 if err != nil {
11119 return nil, err
11120 }
11121 return results.CPUTimeActivity, nil
11122 }
11123
11124 /*************************************************
11125 * ServerPlanOp
11126 *************************************************/
11127
11128 // ServerPlanOp implements ServerPlanAPI interface
11129 type ServerPlanOp struct {
11130 // Client APICaller
11131 Client APICaller
11132 // PathSuffix is used when building URL
11133 PathSuffix string
11134 // PathName is used when building URL
11135 PathName string
11136 }
11137
11138 // NewServerPlanOp creates new ServerPlanOp instance
11139 func NewServerPlanOp(caller APICaller) ServerPlanAPI {
11140 return GetClientFactoryFunc("ServerPlan")(caller).(ServerPlanAPI)
11141 }
11142
11143 // Find is API call
11144 func (o *ServerPlanOp) Find(ctx context.Context, zone string, conditions *FindCondition) (*ServerPlanFindResult, error) {
11145 // build request URL
11146 pathBuildParameter := map[string]interface{}{
11147 "rootURL": SakuraCloudAPIRoot,
11148 "pathSuffix": o.PathSuffix,
11149 "pathName": o.PathName,
11150 "zone": zone,
11151 "conditions": conditions,
11152 }
11153
11154 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}", pathBuildParameter)
11155 if err != nil {
11156 return nil, err
11157 }
11158 // build request body
11159 var body interface{}
11160 v, err := o.transformFindArgs(conditions)
11161 if err != nil {
11162 return nil, err
11163 }
11164 body = v
11165
11166 // do request
11167 data, err := o.Client.Do(ctx, "GET", url, body)
11168 if err != nil {
11169 return nil, err
11170 }
11171
11172 // build results
11173 results, err := o.transformFindResults(data)
11174 if err != nil {
11175 return nil, err
11176 }
11177 return results, err
11178 }
11179
11180 // Read is API call
11181 func (o *ServerPlanOp) Read(ctx context.Context, zone string, id types.ID) (*ServerPlan, error) {
11182 // build request URL
11183 pathBuildParameter := map[string]interface{}{
11184 "rootURL": SakuraCloudAPIRoot,
11185 "pathSuffix": o.PathSuffix,
11186 "pathName": o.PathName,
11187 "zone": zone,
11188 "id": id,
11189 }
11190
11191 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}", pathBuildParameter)
11192 if err != nil {
11193 return nil, err
11194 }
11195 // build request body
11196 var body interface{}
11197
11198 // do request
11199 data, err := o.Client.Do(ctx, "GET", url, body)
11200 if err != nil {
11201 return nil, err
11202 }
11203
11204 // build results
11205 results, err := o.transformReadResults(data)
11206 if err != nil {
11207 return nil, err
11208 }
11209 return results.ServerPlan, nil
11210 }
11211
11212 /*************************************************
11213 * ServiceClassOp
11214 *************************************************/
11215
11216 // ServiceClassOp implements ServiceClassAPI interface
11217 type ServiceClassOp struct {
11218 // Client APICaller
11219 Client APICaller
11220 // PathSuffix is used when building URL
11221 PathSuffix string
11222 // PathName is used when building URL
11223 PathName string
11224 }
11225
11226 // NewServiceClassOp creates new ServiceClassOp instance
11227 func NewServiceClassOp(caller APICaller) ServiceClassAPI {
11228 return GetClientFactoryFunc("ServiceClass")(caller).(ServiceClassAPI)
11229 }
11230
11231 // Find is API call
11232 func (o *ServiceClassOp) Find(ctx context.Context, zone string, conditions *FindCondition) (*ServiceClassFindResult, error) {
11233 // build request URL
11234 pathBuildParameter := map[string]interface{}{
11235 "rootURL": SakuraCloudAPIRoot,
11236 "pathSuffix": o.PathSuffix,
11237 "pathName": o.PathName,
11238 "zone": zone,
11239 "conditions": conditions,
11240 }
11241
11242 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}", pathBuildParameter)
11243 if err != nil {
11244 return nil, err
11245 }
11246 // build request body
11247 var body interface{}
11248 v, err := o.transformFindArgs(conditions)
11249 if err != nil {
11250 return nil, err
11251 }
11252 body = v
11253
11254 // do request
11255 data, err := o.Client.Do(ctx, "GET", url, body)
11256 if err != nil {
11257 return nil, err
11258 }
11259
11260 // build results
11261 results, err := o.transformFindResults(data)
11262 if err != nil {
11263 return nil, err
11264 }
11265 return results, err
11266 }
11267
11268 /*************************************************
11269 * SIMOp
11270 *************************************************/
11271
11272 // SIMOp implements SIMAPI interface
11273 type SIMOp struct {
11274 // Client APICaller
11275 Client APICaller
11276 // PathSuffix is used when building URL
11277 PathSuffix string
11278 // PathName is used when building URL
11279 PathName string
11280 }
11281
11282 // NewSIMOp creates new SIMOp instance
11283 func NewSIMOp(caller APICaller) SIMAPI {
11284 return GetClientFactoryFunc("SIM")(caller).(SIMAPI)
11285 }
11286
11287 // Find is API call
11288 func (o *SIMOp) Find(ctx context.Context, conditions *FindCondition) (*SIMFindResult, error) {
11289 // build request URL
11290 pathBuildParameter := map[string]interface{}{
11291 "rootURL": SakuraCloudAPIRoot,
11292 "pathSuffix": o.PathSuffix,
11293 "pathName": o.PathName,
11294 "zone": APIDefaultZone,
11295 "conditions": conditions,
11296 }
11297
11298 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}", pathBuildParameter)
11299 if err != nil {
11300 return nil, err
11301 }
11302 // build request body
11303 var body interface{}
11304 v, err := o.transformFindArgs(conditions)
11305 if err != nil {
11306 return nil, err
11307 }
11308 body = v
11309
11310 // do request
11311 data, err := o.Client.Do(ctx, "GET", url, body)
11312 if err != nil {
11313 return nil, err
11314 }
11315
11316 // build results
11317 results, err := o.transformFindResults(data)
11318 if err != nil {
11319 return nil, err
11320 }
11321 return results, err
11322 }
11323
11324 // Create is API call
11325 func (o *SIMOp) Create(ctx context.Context, param *SIMCreateRequest) (*SIM, error) {
11326 // build request URL
11327 pathBuildParameter := map[string]interface{}{
11328 "rootURL": SakuraCloudAPIRoot,
11329 "pathSuffix": o.PathSuffix,
11330 "pathName": o.PathName,
11331 "zone": APIDefaultZone,
11332 "param": param,
11333 }
11334
11335 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}", pathBuildParameter)
11336 if err != nil {
11337 return nil, err
11338 }
11339 // build request body
11340 var body interface{}
11341 v, err := o.transformCreateArgs(param)
11342 if err != nil {
11343 return nil, err
11344 }
11345 body = v
11346
11347 // do request
11348 data, err := o.Client.Do(ctx, "POST", url, body)
11349 if err != nil {
11350 return nil, err
11351 }
11352
11353 // build results
11354 results, err := o.transformCreateResults(data)
11355 if err != nil {
11356 return nil, err
11357 }
11358 return results.SIM, nil
11359 }
11360
11361 // Read is API call
11362 func (o *SIMOp) Read(ctx context.Context, id types.ID) (*SIM, error) {
11363 // build request URL
11364 pathBuildParameter := map[string]interface{}{
11365 "rootURL": SakuraCloudAPIRoot,
11366 "pathSuffix": o.PathSuffix,
11367 "pathName": o.PathName,
11368 "zone": APIDefaultZone,
11369 "id": id,
11370 }
11371
11372 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}", pathBuildParameter)
11373 if err != nil {
11374 return nil, err
11375 }
11376 // build request body
11377 var body interface{}
11378
11379 // do request
11380 data, err := o.Client.Do(ctx, "GET", url, body)
11381 if err != nil {
11382 return nil, err
11383 }
11384
11385 // build results
11386 results, err := o.transformReadResults(data)
11387 if err != nil {
11388 return nil, err
11389 }
11390 return results.SIM, nil
11391 }
11392
11393 // Update is API call
11394 func (o *SIMOp) Update(ctx context.Context, id types.ID, param *SIMUpdateRequest) (*SIM, error) {
11395 // build request URL
11396 pathBuildParameter := map[string]interface{}{
11397 "rootURL": SakuraCloudAPIRoot,
11398 "pathSuffix": o.PathSuffix,
11399 "pathName": o.PathName,
11400 "zone": APIDefaultZone,
11401 "id": id,
11402 "param": param,
11403 }
11404
11405 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}", pathBuildParameter)
11406 if err != nil {
11407 return nil, err
11408 }
11409 // build request body
11410 var body interface{}
11411 v, err := o.transformUpdateArgs(id, param)
11412 if err != nil {
11413 return nil, err
11414 }
11415 body = v
11416
11417 // do request
11418 data, err := o.Client.Do(ctx, "PUT", url, body)
11419 if err != nil {
11420 return nil, err
11421 }
11422
11423 // build results
11424 results, err := o.transformUpdateResults(data)
11425 if err != nil {
11426 return nil, err
11427 }
11428 return results.SIM, nil
11429 }
11430
11431 // Delete is API call
11432 func (o *SIMOp) Delete(ctx context.Context, id types.ID) error {
11433 // build request URL
11434 pathBuildParameter := map[string]interface{}{
11435 "rootURL": SakuraCloudAPIRoot,
11436 "pathSuffix": o.PathSuffix,
11437 "pathName": o.PathName,
11438 "zone": APIDefaultZone,
11439 "id": id,
11440 }
11441
11442 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}", pathBuildParameter)
11443 if err != nil {
11444 return err
11445 }
11446 // build request body
11447 var body interface{}
11448
11449 // do request
11450 _, err = o.Client.Do(ctx, "DELETE", url, body)
11451 if err != nil {
11452 return err
11453 }
11454
11455 // build results
11456
11457 return nil
11458 }
11459
11460 // Activate is API call
11461 func (o *SIMOp) Activate(ctx context.Context, id types.ID) error {
11462 // build request URL
11463 pathBuildParameter := map[string]interface{}{
11464 "rootURL": SakuraCloudAPIRoot,
11465 "pathSuffix": o.PathSuffix,
11466 "pathName": o.PathName,
11467 "zone": APIDefaultZone,
11468 "id": id,
11469 }
11470
11471 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}/sim/activate", pathBuildParameter)
11472 if err != nil {
11473 return err
11474 }
11475 // build request body
11476 var body interface{}
11477
11478 // do request
11479 _, err = o.Client.Do(ctx, "PUT", url, body)
11480 if err != nil {
11481 return err
11482 }
11483
11484 // build results
11485
11486 return nil
11487 }
11488
11489 // Deactivate is API call
11490 func (o *SIMOp) Deactivate(ctx context.Context, id types.ID) error {
11491 // build request URL
11492 pathBuildParameter := map[string]interface{}{
11493 "rootURL": SakuraCloudAPIRoot,
11494 "pathSuffix": o.PathSuffix,
11495 "pathName": o.PathName,
11496 "zone": APIDefaultZone,
11497 "id": id,
11498 }
11499
11500 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}/sim/deactivate", pathBuildParameter)
11501 if err != nil {
11502 return err
11503 }
11504 // build request body
11505 var body interface{}
11506
11507 // do request
11508 _, err = o.Client.Do(ctx, "PUT", url, body)
11509 if err != nil {
11510 return err
11511 }
11512
11513 // build results
11514
11515 return nil
11516 }
11517
11518 // AssignIP is API call
11519 func (o *SIMOp) AssignIP(ctx context.Context, id types.ID, param *SIMAssignIPRequest) error {
11520 // build request URL
11521 pathBuildParameter := map[string]interface{}{
11522 "rootURL": SakuraCloudAPIRoot,
11523 "pathSuffix": o.PathSuffix,
11524 "pathName": o.PathName,
11525 "zone": APIDefaultZone,
11526 "id": id,
11527 "param": param,
11528 }
11529
11530 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}/sim/ip", pathBuildParameter)
11531 if err != nil {
11532 return err
11533 }
11534 // build request body
11535 var body interface{}
11536 v, err := o.transformAssignIPArgs(id, param)
11537 if err != nil {
11538 return err
11539 }
11540 body = v
11541
11542 // do request
11543 _, err = o.Client.Do(ctx, "PUT", url, body)
11544 if err != nil {
11545 return err
11546 }
11547
11548 // build results
11549
11550 return nil
11551 }
11552
11553 // ClearIP is API call
11554 func (o *SIMOp) ClearIP(ctx context.Context, id types.ID) error {
11555 // build request URL
11556 pathBuildParameter := map[string]interface{}{
11557 "rootURL": SakuraCloudAPIRoot,
11558 "pathSuffix": o.PathSuffix,
11559 "pathName": o.PathName,
11560 "zone": APIDefaultZone,
11561 "id": id,
11562 }
11563
11564 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}/sim/ip", pathBuildParameter)
11565 if err != nil {
11566 return err
11567 }
11568 // build request body
11569 var body interface{}
11570
11571 // do request
11572 _, err = o.Client.Do(ctx, "DELETE", url, body)
11573 if err != nil {
11574 return err
11575 }
11576
11577 // build results
11578
11579 return nil
11580 }
11581
11582 // IMEILock is API call
11583 func (o *SIMOp) IMEILock(ctx context.Context, id types.ID, param *SIMIMEILockRequest) error {
11584 // build request URL
11585 pathBuildParameter := map[string]interface{}{
11586 "rootURL": SakuraCloudAPIRoot,
11587 "pathSuffix": o.PathSuffix,
11588 "pathName": o.PathName,
11589 "zone": APIDefaultZone,
11590 "id": id,
11591 "param": param,
11592 }
11593
11594 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}/sim/imeilock", pathBuildParameter)
11595 if err != nil {
11596 return err
11597 }
11598 // build request body
11599 var body interface{}
11600 v, err := o.transformIMEILockArgs(id, param)
11601 if err != nil {
11602 return err
11603 }
11604 body = v
11605
11606 // do request
11607 _, err = o.Client.Do(ctx, "PUT", url, body)
11608 if err != nil {
11609 return err
11610 }
11611
11612 // build results
11613
11614 return nil
11615 }
11616
11617 // IMEIUnlock is API call
11618 func (o *SIMOp) IMEIUnlock(ctx context.Context, id types.ID) error {
11619 // build request URL
11620 pathBuildParameter := map[string]interface{}{
11621 "rootURL": SakuraCloudAPIRoot,
11622 "pathSuffix": o.PathSuffix,
11623 "pathName": o.PathName,
11624 "zone": APIDefaultZone,
11625 "id": id,
11626 }
11627
11628 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}/sim/imeilock", pathBuildParameter)
11629 if err != nil {
11630 return err
11631 }
11632 // build request body
11633 var body interface{}
11634
11635 // do request
11636 _, err = o.Client.Do(ctx, "DELETE", url, body)
11637 if err != nil {
11638 return err
11639 }
11640
11641 // build results
11642
11643 return nil
11644 }
11645
11646 // Logs is API call
11647 func (o *SIMOp) Logs(ctx context.Context, id types.ID) (*SIMLogsResult, error) {
11648 // build request URL
11649 pathBuildParameter := map[string]interface{}{
11650 "rootURL": SakuraCloudAPIRoot,
11651 "pathSuffix": o.PathSuffix,
11652 "pathName": o.PathName,
11653 "zone": APIDefaultZone,
11654 "id": id,
11655 }
11656
11657 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}/sim/sessionlog", pathBuildParameter)
11658 if err != nil {
11659 return nil, err
11660 }
11661 // build request body
11662 var body interface{}
11663
11664 // do request
11665 data, err := o.Client.Do(ctx, "GET", url, body)
11666 if err != nil {
11667 return nil, err
11668 }
11669
11670 // build results
11671 results, err := o.transformLogsResults(data)
11672 if err != nil {
11673 return nil, err
11674 }
11675 return results, err
11676 }
11677
11678 // GetNetworkOperator is API call
11679 func (o *SIMOp) GetNetworkOperator(ctx context.Context, id types.ID) ([]*SIMNetworkOperatorConfig, error) {
11680 // build request URL
11681 pathBuildParameter := map[string]interface{}{
11682 "rootURL": SakuraCloudAPIRoot,
11683 "pathSuffix": o.PathSuffix,
11684 "pathName": o.PathName,
11685 "zone": APIDefaultZone,
11686 "id": id,
11687 }
11688
11689 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}/sim/network_operator_config", pathBuildParameter)
11690 if err != nil {
11691 return nil, err
11692 }
11693 // build request body
11694 var body interface{}
11695
11696 // do request
11697 data, err := o.Client.Do(ctx, "GET", url, body)
11698 if err != nil {
11699 return nil, err
11700 }
11701
11702 // build results
11703 results, err := o.transformGetNetworkOperatorResults(data)
11704 if err != nil {
11705 return nil, err
11706 }
11707 return results.Configs, nil
11708 }
11709
11710 // SetNetworkOperator is API call
11711 func (o *SIMOp) SetNetworkOperator(ctx context.Context, id types.ID, configs []*SIMNetworkOperatorConfig) error {
11712 // build request URL
11713 pathBuildParameter := map[string]interface{}{
11714 "rootURL": SakuraCloudAPIRoot,
11715 "pathSuffix": o.PathSuffix,
11716 "pathName": o.PathName,
11717 "zone": APIDefaultZone,
11718 "id": id,
11719 "configs": configs,
11720 }
11721
11722 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}/sim/network_operator_config", pathBuildParameter)
11723 if err != nil {
11724 return err
11725 }
11726 // build request body
11727 var body interface{}
11728 v, err := o.transformSetNetworkOperatorArgs(id, configs)
11729 if err != nil {
11730 return err
11731 }
11732 body = v
11733
11734 // do request
11735 _, err = o.Client.Do(ctx, "PUT", url, body)
11736 if err != nil {
11737 return err
11738 }
11739
11740 // build results
11741
11742 return nil
11743 }
11744
11745 // MonitorSIM is API call
11746 func (o *SIMOp) MonitorSIM(ctx context.Context, id types.ID, condition *MonitorCondition) (*LinkActivity, error) {
11747 // build request URL
11748 pathBuildParameter := map[string]interface{}{
11749 "rootURL": SakuraCloudAPIRoot,
11750 "pathSuffix": o.PathSuffix,
11751 "pathName": o.PathName,
11752 "zone": APIDefaultZone,
11753 "id": id,
11754 "condition": condition,
11755 }
11756
11757 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}/sim/metrics/monitor", pathBuildParameter)
11758 if err != nil {
11759 return nil, err
11760 }
11761 // build request body
11762 var body interface{}
11763 v, err := o.transformMonitorSIMArgs(id, condition)
11764 if err != nil {
11765 return nil, err
11766 }
11767 body = v
11768
11769 // do request
11770 data, err := o.Client.Do(ctx, "GET", url, body)
11771 if err != nil {
11772 return nil, err
11773 }
11774
11775 // build results
11776 results, err := o.transformMonitorSIMResults(data)
11777 if err != nil {
11778 return nil, err
11779 }
11780 return results.LinkActivity, nil
11781 }
11782
11783 // Status is API call
11784 func (o *SIMOp) Status(ctx context.Context, id types.ID) (*SIMInfo, error) {
11785 // build request URL
11786 pathBuildParameter := map[string]interface{}{
11787 "rootURL": SakuraCloudAPIRoot,
11788 "pathSuffix": o.PathSuffix,
11789 "pathName": o.PathName,
11790 "zone": APIDefaultZone,
11791 "id": id,
11792 }
11793
11794 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}/sim/status", pathBuildParameter)
11795 if err != nil {
11796 return nil, err
11797 }
11798 // build request body
11799 var body interface{}
11800
11801 // do request
11802 data, err := o.Client.Do(ctx, "GET", url, body)
11803 if err != nil {
11804 return nil, err
11805 }
11806
11807 // build results
11808 results, err := o.transformStatusResults(data)
11809 if err != nil {
11810 return nil, err
11811 }
11812 return results.SIM, nil
11813 }
11814
11815 /*************************************************
11816 * SimpleMonitorOp
11817 *************************************************/
11818
11819 // SimpleMonitorOp implements SimpleMonitorAPI interface
11820 type SimpleMonitorOp struct {
11821 // Client APICaller
11822 Client APICaller
11823 // PathSuffix is used when building URL
11824 PathSuffix string
11825 // PathName is used when building URL
11826 PathName string
11827 }
11828
11829 // NewSimpleMonitorOp creates new SimpleMonitorOp instance
11830 func NewSimpleMonitorOp(caller APICaller) SimpleMonitorAPI {
11831 return GetClientFactoryFunc("SimpleMonitor")(caller).(SimpleMonitorAPI)
11832 }
11833
11834 // Find is API call
11835 func (o *SimpleMonitorOp) Find(ctx context.Context, conditions *FindCondition) (*SimpleMonitorFindResult, error) {
11836 // build request URL
11837 pathBuildParameter := map[string]interface{}{
11838 "rootURL": SakuraCloudAPIRoot,
11839 "pathSuffix": o.PathSuffix,
11840 "pathName": o.PathName,
11841 "zone": APIDefaultZone,
11842 "conditions": conditions,
11843 }
11844
11845 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}", pathBuildParameter)
11846 if err != nil {
11847 return nil, err
11848 }
11849 // build request body
11850 var body interface{}
11851 v, err := o.transformFindArgs(conditions)
11852 if err != nil {
11853 return nil, err
11854 }
11855 body = v
11856
11857 // do request
11858 data, err := o.Client.Do(ctx, "GET", url, body)
11859 if err != nil {
11860 return nil, err
11861 }
11862
11863 // build results
11864 results, err := o.transformFindResults(data)
11865 if err != nil {
11866 return nil, err
11867 }
11868 return results, err
11869 }
11870
11871 // Create is API call
11872 func (o *SimpleMonitorOp) Create(ctx context.Context, param *SimpleMonitorCreateRequest) (*SimpleMonitor, error) {
11873 // build request URL
11874 pathBuildParameter := map[string]interface{}{
11875 "rootURL": SakuraCloudAPIRoot,
11876 "pathSuffix": o.PathSuffix,
11877 "pathName": o.PathName,
11878 "zone": APIDefaultZone,
11879 "param": param,
11880 }
11881
11882 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}", pathBuildParameter)
11883 if err != nil {
11884 return nil, err
11885 }
11886 // build request body
11887 var body interface{}
11888 v, err := o.transformCreateArgs(param)
11889 if err != nil {
11890 return nil, err
11891 }
11892 body = v
11893
11894 // do request
11895 data, err := o.Client.Do(ctx, "POST", url, body)
11896 if err != nil {
11897 return nil, err
11898 }
11899
11900 // build results
11901 results, err := o.transformCreateResults(data)
11902 if err != nil {
11903 return nil, err
11904 }
11905 return results.SimpleMonitor, nil
11906 }
11907
11908 // Read is API call
11909 func (o *SimpleMonitorOp) Read(ctx context.Context, id types.ID) (*SimpleMonitor, error) {
11910 // build request URL
11911 pathBuildParameter := map[string]interface{}{
11912 "rootURL": SakuraCloudAPIRoot,
11913 "pathSuffix": o.PathSuffix,
11914 "pathName": o.PathName,
11915 "zone": APIDefaultZone,
11916 "id": id,
11917 }
11918
11919 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}", pathBuildParameter)
11920 if err != nil {
11921 return nil, err
11922 }
11923 // build request body
11924 var body interface{}
11925
11926 // do request
11927 data, err := o.Client.Do(ctx, "GET", url, body)
11928 if err != nil {
11929 return nil, err
11930 }
11931
11932 // build results
11933 results, err := o.transformReadResults(data)
11934 if err != nil {
11935 return nil, err
11936 }
11937 return results.SimpleMonitor, nil
11938 }
11939
11940 // Update is API call
11941 func (o *SimpleMonitorOp) Update(ctx context.Context, id types.ID, param *SimpleMonitorUpdateRequest) (*SimpleMonitor, error) {
11942 // build request URL
11943 pathBuildParameter := map[string]interface{}{
11944 "rootURL": SakuraCloudAPIRoot,
11945 "pathSuffix": o.PathSuffix,
11946 "pathName": o.PathName,
11947 "zone": APIDefaultZone,
11948 "id": id,
11949 "param": param,
11950 }
11951
11952 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}", pathBuildParameter)
11953 if err != nil {
11954 return nil, err
11955 }
11956 // build request body
11957 var body interface{}
11958 v, err := o.transformUpdateArgs(id, param)
11959 if err != nil {
11960 return nil, err
11961 }
11962 body = v
11963
11964 // do request
11965 data, err := o.Client.Do(ctx, "PUT", url, body)
11966 if err != nil {
11967 return nil, err
11968 }
11969
11970 // build results
11971 results, err := o.transformUpdateResults(data)
11972 if err != nil {
11973 return nil, err
11974 }
11975 return results.SimpleMonitor, nil
11976 }
11977
11978 // UpdateSettings is API call
11979 func (o *SimpleMonitorOp) UpdateSettings(ctx context.Context, id types.ID, param *SimpleMonitorUpdateSettingsRequest) (*SimpleMonitor, error) {
11980 // build request URL
11981 pathBuildParameter := map[string]interface{}{
11982 "rootURL": SakuraCloudAPIRoot,
11983 "pathSuffix": o.PathSuffix,
11984 "pathName": o.PathName,
11985 "zone": APIDefaultZone,
11986 "id": id,
11987 "param": param,
11988 }
11989
11990 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}", pathBuildParameter)
11991 if err != nil {
11992 return nil, err
11993 }
11994 // build request body
11995 var body interface{}
11996 v, err := o.transformUpdateSettingsArgs(id, param)
11997 if err != nil {
11998 return nil, err
11999 }
12000 body = v
12001
12002 // do request
12003 data, err := o.Client.Do(ctx, "PUT", url, body)
12004 if err != nil {
12005 return nil, err
12006 }
12007
12008 // build results
12009 results, err := o.transformUpdateSettingsResults(data)
12010 if err != nil {
12011 return nil, err
12012 }
12013 return results.SimpleMonitor, nil
12014 }
12015
12016 // Delete is API call
12017 func (o *SimpleMonitorOp) Delete(ctx context.Context, id types.ID) error {
12018 // build request URL
12019 pathBuildParameter := map[string]interface{}{
12020 "rootURL": SakuraCloudAPIRoot,
12021 "pathSuffix": o.PathSuffix,
12022 "pathName": o.PathName,
12023 "zone": APIDefaultZone,
12024 "id": id,
12025 }
12026
12027 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}", pathBuildParameter)
12028 if err != nil {
12029 return err
12030 }
12031 // build request body
12032 var body interface{}
12033
12034 // do request
12035 _, err = o.Client.Do(ctx, "DELETE", url, body)
12036 if err != nil {
12037 return err
12038 }
12039
12040 // build results
12041
12042 return nil
12043 }
12044
12045 // MonitorResponseTime is API call
12046 func (o *SimpleMonitorOp) MonitorResponseTime(ctx context.Context, id types.ID, condition *MonitorCondition) (*ResponseTimeSecActivity, error) {
12047 // build request URL
12048 pathBuildParameter := map[string]interface{}{
12049 "rootURL": SakuraCloudAPIRoot,
12050 "pathSuffix": o.PathSuffix,
12051 "pathName": o.PathName,
12052 "zone": APIDefaultZone,
12053 "id": id,
12054 "condition": condition,
12055 }
12056
12057 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}//activity/responsetimesec/monitor", pathBuildParameter)
12058 if err != nil {
12059 return nil, err
12060 }
12061 // build request body
12062 var body interface{}
12063 v, err := o.transformMonitorResponseTimeArgs(id, condition)
12064 if err != nil {
12065 return nil, err
12066 }
12067 body = v
12068
12069 // do request
12070 data, err := o.Client.Do(ctx, "GET", url, body)
12071 if err != nil {
12072 return nil, err
12073 }
12074
12075 // build results
12076 results, err := o.transformMonitorResponseTimeResults(data)
12077 if err != nil {
12078 return nil, err
12079 }
12080 return results.ResponseTimeSecActivity, nil
12081 }
12082
12083 // HealthStatus is API call
12084 func (o *SimpleMonitorOp) HealthStatus(ctx context.Context, id types.ID) (*SimpleMonitorHealthStatus, error) {
12085 // build request URL
12086 pathBuildParameter := map[string]interface{}{
12087 "rootURL": SakuraCloudAPIRoot,
12088 "pathSuffix": o.PathSuffix,
12089 "pathName": o.PathName,
12090 "zone": APIDefaultZone,
12091 "id": id,
12092 }
12093
12094 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}/health", pathBuildParameter)
12095 if err != nil {
12096 return nil, err
12097 }
12098 // build request body
12099 var body interface{}
12100
12101 // do request
12102 data, err := o.Client.Do(ctx, "GET", url, body)
12103 if err != nil {
12104 return nil, err
12105 }
12106
12107 // build results
12108 results, err := o.transformHealthStatusResults(data)
12109 if err != nil {
12110 return nil, err
12111 }
12112 return results.SimpleMonitorHealthStatus, nil
12113 }
12114
12115 /*************************************************
12116 * SimpleNotificationDestinationOp
12117 *************************************************/
12118
12119 // SimpleNotificationDestinationOp implements SimpleNotificationDestinationAPI interface
12120 type SimpleNotificationDestinationOp struct {
12121 // Client APICaller
12122 Client APICaller
12123 // PathSuffix is used when building URL
12124 PathSuffix string
12125 // PathName is used when building URL
12126 PathName string
12127 }
12128
12129 // NewSimpleNotificationDestinationOp creates new SimpleNotificationDestinationOp instance
12130 func NewSimpleNotificationDestinationOp(caller APICaller) SimpleNotificationDestinationAPI {
12131 return GetClientFactoryFunc("SimpleNotificationDestination")(caller).(SimpleNotificationDestinationAPI)
12132 }
12133
12134 // Find is API call
12135 func (o *SimpleNotificationDestinationOp) Find(ctx context.Context, conditions *FindCondition) (*SimpleNotificationDestinationFindResult, error) {
12136 // build request URL
12137 pathBuildParameter := map[string]interface{}{
12138 "rootURL": SakuraCloudAPIRoot,
12139 "pathSuffix": o.PathSuffix,
12140 "pathName": o.PathName,
12141 "zone": APIDefaultZone,
12142 "conditions": conditions,
12143 }
12144
12145 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}", pathBuildParameter)
12146 if err != nil {
12147 return nil, err
12148 }
12149 // build request body
12150 var body interface{}
12151 v, err := o.transformFindArgs(conditions)
12152 if err != nil {
12153 return nil, err
12154 }
12155 body = v
12156
12157 // do request
12158 data, err := o.Client.Do(ctx, "GET", url, body)
12159 if err != nil {
12160 return nil, err
12161 }
12162
12163 // build results
12164 results, err := o.transformFindResults(data)
12165 if err != nil {
12166 return nil, err
12167 }
12168 return results, err
12169 }
12170
12171 // Create is API call
12172 func (o *SimpleNotificationDestinationOp) Create(ctx context.Context, param *SimpleNotificationDestinationCreateRequest) (*SimpleNotificationDestination, error) {
12173 // build request URL
12174 pathBuildParameter := map[string]interface{}{
12175 "rootURL": SakuraCloudAPIRoot,
12176 "pathSuffix": o.PathSuffix,
12177 "pathName": o.PathName,
12178 "zone": APIDefaultZone,
12179 "param": param,
12180 }
12181
12182 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}", pathBuildParameter)
12183 if err != nil {
12184 return nil, err
12185 }
12186 // build request body
12187 var body interface{}
12188 v, err := o.transformCreateArgs(param)
12189 if err != nil {
12190 return nil, err
12191 }
12192 body = v
12193
12194 // do request
12195 data, err := o.Client.Do(ctx, "POST", url, body)
12196 if err != nil {
12197 return nil, err
12198 }
12199
12200 // build results
12201 results, err := o.transformCreateResults(data)
12202 if err != nil {
12203 return nil, err
12204 }
12205 return results.SimpleNotificationDestination, nil
12206 }
12207
12208 // Read is API call
12209 func (o *SimpleNotificationDestinationOp) Read(ctx context.Context, id types.ID) (*SimpleNotificationDestination, error) {
12210 // build request URL
12211 pathBuildParameter := map[string]interface{}{
12212 "rootURL": SakuraCloudAPIRoot,
12213 "pathSuffix": o.PathSuffix,
12214 "pathName": o.PathName,
12215 "zone": APIDefaultZone,
12216 "id": id,
12217 }
12218
12219 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}", pathBuildParameter)
12220 if err != nil {
12221 return nil, err
12222 }
12223 // build request body
12224 var body interface{}
12225
12226 // do request
12227 data, err := o.Client.Do(ctx, "GET", url, body)
12228 if err != nil {
12229 return nil, err
12230 }
12231
12232 // build results
12233 results, err := o.transformReadResults(data)
12234 if err != nil {
12235 return nil, err
12236 }
12237 return results.SimpleNotificationDestination, nil
12238 }
12239
12240 // Update is API call
12241 func (o *SimpleNotificationDestinationOp) Update(ctx context.Context, id types.ID, param *SimpleNotificationDestinationUpdateRequest) (*SimpleNotificationDestination, error) {
12242 // build request URL
12243 pathBuildParameter := map[string]interface{}{
12244 "rootURL": SakuraCloudAPIRoot,
12245 "pathSuffix": o.PathSuffix,
12246 "pathName": o.PathName,
12247 "zone": APIDefaultZone,
12248 "id": id,
12249 "param": param,
12250 }
12251
12252 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}", pathBuildParameter)
12253 if err != nil {
12254 return nil, err
12255 }
12256 // build request body
12257 var body interface{}
12258 v, err := o.transformUpdateArgs(id, param)
12259 if err != nil {
12260 return nil, err
12261 }
12262 body = v
12263
12264 // do request
12265 data, err := o.Client.Do(ctx, "PUT", url, body)
12266 if err != nil {
12267 return nil, err
12268 }
12269
12270 // build results
12271 results, err := o.transformUpdateResults(data)
12272 if err != nil {
12273 return nil, err
12274 }
12275 return results.SimpleNotificationDestination, nil
12276 }
12277
12278 // UpdateSettings is API call
12279 func (o *SimpleNotificationDestinationOp) UpdateSettings(ctx context.Context, id types.ID, param *SimpleNotificationDestinationUpdateSettingsRequest) (*SimpleNotificationDestination, error) {
12280 // build request URL
12281 pathBuildParameter := map[string]interface{}{
12282 "rootURL": SakuraCloudAPIRoot,
12283 "pathSuffix": o.PathSuffix,
12284 "pathName": o.PathName,
12285 "zone": APIDefaultZone,
12286 "id": id,
12287 "param": param,
12288 }
12289
12290 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}", pathBuildParameter)
12291 if err != nil {
12292 return nil, err
12293 }
12294 // build request body
12295 var body interface{}
12296 v, err := o.transformUpdateSettingsArgs(id, param)
12297 if err != nil {
12298 return nil, err
12299 }
12300 body = v
12301
12302 // do request
12303 data, err := o.Client.Do(ctx, "PUT", url, body)
12304 if err != nil {
12305 return nil, err
12306 }
12307
12308 // build results
12309 results, err := o.transformUpdateSettingsResults(data)
12310 if err != nil {
12311 return nil, err
12312 }
12313 return results.SimpleNotificationDestination, nil
12314 }
12315
12316 // Delete is API call
12317 func (o *SimpleNotificationDestinationOp) Delete(ctx context.Context, id types.ID) error {
12318 // build request URL
12319 pathBuildParameter := map[string]interface{}{
12320 "rootURL": SakuraCloudAPIRoot,
12321 "pathSuffix": o.PathSuffix,
12322 "pathName": o.PathName,
12323 "zone": APIDefaultZone,
12324 "id": id,
12325 }
12326
12327 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}", pathBuildParameter)
12328 if err != nil {
12329 return err
12330 }
12331 // build request body
12332 var body interface{}
12333
12334 // do request
12335 _, err = o.Client.Do(ctx, "DELETE", url, body)
12336 if err != nil {
12337 return err
12338 }
12339
12340 // build results
12341
12342 return nil
12343 }
12344
12345 // Status is API call
12346 func (o *SimpleNotificationDestinationOp) Status(ctx context.Context, id types.ID) (*SimpleNotificationDestinationStatus, error) {
12347 // build request URL
12348 pathBuildParameter := map[string]interface{}{
12349 "rootURL": SakuraCloudAPIRoot,
12350 "pathSuffix": o.PathSuffix,
12351 "pathName": o.PathName,
12352 "zone": APIDefaultZone,
12353 "id": id,
12354 }
12355
12356 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}/simplenotification/status", pathBuildParameter)
12357 if err != nil {
12358 return nil, err
12359 }
12360 // build request body
12361 var body interface{}
12362
12363 // do request
12364 data, err := o.Client.Do(ctx, "GET", url, body)
12365 if err != nil {
12366 return nil, err
12367 }
12368
12369 // build results
12370 results, err := o.transformStatusResults(data)
12371 if err != nil {
12372 return nil, err
12373 }
12374 return results.SimpleNotificationDestinationStatus, nil
12375 }
12376
12377 /*************************************************
12378 * SimpleNotificationGroupOp
12379 *************************************************/
12380
12381 // SimpleNotificationGroupOp implements SimpleNotificationGroupAPI interface
12382 type SimpleNotificationGroupOp struct {
12383 // Client APICaller
12384 Client APICaller
12385 // PathSuffix is used when building URL
12386 PathSuffix string
12387 // PathName is used when building URL
12388 PathName string
12389 }
12390
12391 // NewSimpleNotificationGroupOp creates new SimpleNotificationGroupOp instance
12392 func NewSimpleNotificationGroupOp(caller APICaller) SimpleNotificationGroupAPI {
12393 return GetClientFactoryFunc("SimpleNotificationGroup")(caller).(SimpleNotificationGroupAPI)
12394 }
12395
12396 // Find is API call
12397 func (o *SimpleNotificationGroupOp) Find(ctx context.Context, conditions *FindCondition) (*SimpleNotificationGroupFindResult, error) {
12398 // build request URL
12399 pathBuildParameter := map[string]interface{}{
12400 "rootURL": SakuraCloudAPIRoot,
12401 "pathSuffix": o.PathSuffix,
12402 "pathName": o.PathName,
12403 "zone": APIDefaultZone,
12404 "conditions": conditions,
12405 }
12406
12407 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}", pathBuildParameter)
12408 if err != nil {
12409 return nil, err
12410 }
12411 // build request body
12412 var body interface{}
12413 v, err := o.transformFindArgs(conditions)
12414 if err != nil {
12415 return nil, err
12416 }
12417 body = v
12418
12419 // do request
12420 data, err := o.Client.Do(ctx, "GET", url, body)
12421 if err != nil {
12422 return nil, err
12423 }
12424
12425 // build results
12426 results, err := o.transformFindResults(data)
12427 if err != nil {
12428 return nil, err
12429 }
12430 return results, err
12431 }
12432
12433 // Create is API call
12434 func (o *SimpleNotificationGroupOp) Create(ctx context.Context, param *SimpleNotificationGroupCreateRequest) (*SimpleNotificationGroup, error) {
12435 // build request URL
12436 pathBuildParameter := map[string]interface{}{
12437 "rootURL": SakuraCloudAPIRoot,
12438 "pathSuffix": o.PathSuffix,
12439 "pathName": o.PathName,
12440 "zone": APIDefaultZone,
12441 "param": param,
12442 }
12443
12444 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}", pathBuildParameter)
12445 if err != nil {
12446 return nil, err
12447 }
12448 // build request body
12449 var body interface{}
12450 v, err := o.transformCreateArgs(param)
12451 if err != nil {
12452 return nil, err
12453 }
12454 body = v
12455
12456 // do request
12457 data, err := o.Client.Do(ctx, "POST", url, body)
12458 if err != nil {
12459 return nil, err
12460 }
12461
12462 // build results
12463 results, err := o.transformCreateResults(data)
12464 if err != nil {
12465 return nil, err
12466 }
12467 return results.SimpleNotificationGroup, nil
12468 }
12469
12470 // Read is API call
12471 func (o *SimpleNotificationGroupOp) Read(ctx context.Context, id types.ID) (*SimpleNotificationGroup, error) {
12472 // build request URL
12473 pathBuildParameter := map[string]interface{}{
12474 "rootURL": SakuraCloudAPIRoot,
12475 "pathSuffix": o.PathSuffix,
12476 "pathName": o.PathName,
12477 "zone": APIDefaultZone,
12478 "id": id,
12479 }
12480
12481 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}", pathBuildParameter)
12482 if err != nil {
12483 return nil, err
12484 }
12485 // build request body
12486 var body interface{}
12487
12488 // do request
12489 data, err := o.Client.Do(ctx, "GET", url, body)
12490 if err != nil {
12491 return nil, err
12492 }
12493
12494 // build results
12495 results, err := o.transformReadResults(data)
12496 if err != nil {
12497 return nil, err
12498 }
12499 return results.SimpleNotificationGroup, nil
12500 }
12501
12502 // Update is API call
12503 func (o *SimpleNotificationGroupOp) Update(ctx context.Context, id types.ID, param *SimpleNotificationGroupUpdateRequest) (*SimpleNotificationGroup, error) {
12504 // build request URL
12505 pathBuildParameter := map[string]interface{}{
12506 "rootURL": SakuraCloudAPIRoot,
12507 "pathSuffix": o.PathSuffix,
12508 "pathName": o.PathName,
12509 "zone": APIDefaultZone,
12510 "id": id,
12511 "param": param,
12512 }
12513
12514 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}", pathBuildParameter)
12515 if err != nil {
12516 return nil, err
12517 }
12518 // build request body
12519 var body interface{}
12520 v, err := o.transformUpdateArgs(id, param)
12521 if err != nil {
12522 return nil, err
12523 }
12524 body = v
12525
12526 // do request
12527 data, err := o.Client.Do(ctx, "PUT", url, body)
12528 if err != nil {
12529 return nil, err
12530 }
12531
12532 // build results
12533 results, err := o.transformUpdateResults(data)
12534 if err != nil {
12535 return nil, err
12536 }
12537 return results.SimpleNotificationGroup, nil
12538 }
12539
12540 // UpdateSettings is API call
12541 func (o *SimpleNotificationGroupOp) UpdateSettings(ctx context.Context, id types.ID, param *SimpleNotificationGroupUpdateSettingsRequest) (*SimpleNotificationGroup, error) {
12542 // build request URL
12543 pathBuildParameter := map[string]interface{}{
12544 "rootURL": SakuraCloudAPIRoot,
12545 "pathSuffix": o.PathSuffix,
12546 "pathName": o.PathName,
12547 "zone": APIDefaultZone,
12548 "id": id,
12549 "param": param,
12550 }
12551
12552 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}", pathBuildParameter)
12553 if err != nil {
12554 return nil, err
12555 }
12556 // build request body
12557 var body interface{}
12558 v, err := o.transformUpdateSettingsArgs(id, param)
12559 if err != nil {
12560 return nil, err
12561 }
12562 body = v
12563
12564 // do request
12565 data, err := o.Client.Do(ctx, "PUT", url, body)
12566 if err != nil {
12567 return nil, err
12568 }
12569
12570 // build results
12571 results, err := o.transformUpdateSettingsResults(data)
12572 if err != nil {
12573 return nil, err
12574 }
12575 return results.SimpleNotificationGroup, nil
12576 }
12577
12578 // Delete is API call
12579 func (o *SimpleNotificationGroupOp) Delete(ctx context.Context, id types.ID) error {
12580 // build request URL
12581 pathBuildParameter := map[string]interface{}{
12582 "rootURL": SakuraCloudAPIRoot,
12583 "pathSuffix": o.PathSuffix,
12584 "pathName": o.PathName,
12585 "zone": APIDefaultZone,
12586 "id": id,
12587 }
12588
12589 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}", pathBuildParameter)
12590 if err != nil {
12591 return err
12592 }
12593 // build request body
12594 var body interface{}
12595
12596 // do request
12597 _, err = o.Client.Do(ctx, "DELETE", url, body)
12598 if err != nil {
12599 return err
12600 }
12601
12602 // build results
12603
12604 return nil
12605 }
12606
12607 // PostMessage is API call
12608 func (o *SimpleNotificationGroupOp) PostMessage(ctx context.Context, id types.ID, message string) error {
12609 // build request URL
12610 pathBuildParameter := map[string]interface{}{
12611 "rootURL": SakuraCloudAPIRoot,
12612 "pathSuffix": o.PathSuffix,
12613 "pathName": o.PathName,
12614 "zone": APIDefaultZone,
12615 "id": id,
12616 "message": message,
12617 }
12618
12619 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}/simplenotification/message", pathBuildParameter)
12620 if err != nil {
12621 return err
12622 }
12623 // build request body
12624 var body interface{}
12625 v, err := o.transformPostMessageArgs(id, message)
12626 if err != nil {
12627 return err
12628 }
12629 body = v
12630
12631 // do request
12632 _, err = o.Client.Do(ctx, "POST", url, body)
12633 if err != nil {
12634 return err
12635 }
12636
12637 // build results
12638
12639 return nil
12640 }
12641
12642 // History is API call
12643 func (o *SimpleNotificationGroupOp) History(ctx context.Context) (*SimpleNotificationHistories, error) {
12644 // build request URL
12645 pathBuildParameter := map[string]interface{}{
12646 "rootURL": SakuraCloudAPIRoot,
12647 "pathSuffix": o.PathSuffix,
12648 "pathName": o.PathName,
12649 "zone": APIDefaultZone,
12650 }
12651
12652 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/simplenotification/history", pathBuildParameter)
12653 if err != nil {
12654 return nil, err
12655 }
12656 // build request body
12657 var body interface{}
12658
12659 // do request
12660 data, err := o.Client.Do(ctx, "GET", url, body)
12661 if err != nil {
12662 return nil, err
12663 }
12664
12665 // build results
12666 results, err := o.transformHistoryResults(data)
12667 if err != nil {
12668 return nil, err
12669 }
12670 return results.SimpleNotificationHistories, nil
12671 }
12672
12673 /*************************************************
12674 * SSHKeyOp
12675 *************************************************/
12676
12677 // SSHKeyOp implements SSHKeyAPI interface
12678 type SSHKeyOp struct {
12679 // Client APICaller
12680 Client APICaller
12681 // PathSuffix is used when building URL
12682 PathSuffix string
12683 // PathName is used when building URL
12684 PathName string
12685 }
12686
12687 // NewSSHKeyOp creates new SSHKeyOp instance
12688 func NewSSHKeyOp(caller APICaller) SSHKeyAPI {
12689 return GetClientFactoryFunc("SSHKey")(caller).(SSHKeyAPI)
12690 }
12691
12692 // Find is API call
12693 func (o *SSHKeyOp) Find(ctx context.Context, conditions *FindCondition) (*SSHKeyFindResult, error) {
12694 // build request URL
12695 pathBuildParameter := map[string]interface{}{
12696 "rootURL": SakuraCloudAPIRoot,
12697 "pathSuffix": o.PathSuffix,
12698 "pathName": o.PathName,
12699 "zone": APIDefaultZone,
12700 "conditions": conditions,
12701 }
12702
12703 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}", pathBuildParameter)
12704 if err != nil {
12705 return nil, err
12706 }
12707 // build request body
12708 var body interface{}
12709 v, err := o.transformFindArgs(conditions)
12710 if err != nil {
12711 return nil, err
12712 }
12713 body = v
12714
12715 // do request
12716 data, err := o.Client.Do(ctx, "GET", url, body)
12717 if err != nil {
12718 return nil, err
12719 }
12720
12721 // build results
12722 results, err := o.transformFindResults(data)
12723 if err != nil {
12724 return nil, err
12725 }
12726 return results, err
12727 }
12728
12729 // Create is API call
12730 func (o *SSHKeyOp) Create(ctx context.Context, param *SSHKeyCreateRequest) (*SSHKey, error) {
12731 // build request URL
12732 pathBuildParameter := map[string]interface{}{
12733 "rootURL": SakuraCloudAPIRoot,
12734 "pathSuffix": o.PathSuffix,
12735 "pathName": o.PathName,
12736 "zone": APIDefaultZone,
12737 "param": param,
12738 }
12739
12740 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}", pathBuildParameter)
12741 if err != nil {
12742 return nil, err
12743 }
12744 // build request body
12745 var body interface{}
12746 v, err := o.transformCreateArgs(param)
12747 if err != nil {
12748 return nil, err
12749 }
12750 body = v
12751
12752 // do request
12753 data, err := o.Client.Do(ctx, "POST", url, body)
12754 if err != nil {
12755 return nil, err
12756 }
12757
12758 // build results
12759 results, err := o.transformCreateResults(data)
12760 if err != nil {
12761 return nil, err
12762 }
12763 return results.SSHKey, nil
12764 }
12765
12766 // Read is API call
12767 func (o *SSHKeyOp) Read(ctx context.Context, id types.ID) (*SSHKey, error) {
12768 // build request URL
12769 pathBuildParameter := map[string]interface{}{
12770 "rootURL": SakuraCloudAPIRoot,
12771 "pathSuffix": o.PathSuffix,
12772 "pathName": o.PathName,
12773 "zone": APIDefaultZone,
12774 "id": id,
12775 }
12776
12777 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}", pathBuildParameter)
12778 if err != nil {
12779 return nil, err
12780 }
12781 // build request body
12782 var body interface{}
12783
12784 // do request
12785 data, err := o.Client.Do(ctx, "GET", url, body)
12786 if err != nil {
12787 return nil, err
12788 }
12789
12790 // build results
12791 results, err := o.transformReadResults(data)
12792 if err != nil {
12793 return nil, err
12794 }
12795 return results.SSHKey, nil
12796 }
12797
12798 // Update is API call
12799 func (o *SSHKeyOp) Update(ctx context.Context, id types.ID, param *SSHKeyUpdateRequest) (*SSHKey, error) {
12800 // build request URL
12801 pathBuildParameter := map[string]interface{}{
12802 "rootURL": SakuraCloudAPIRoot,
12803 "pathSuffix": o.PathSuffix,
12804 "pathName": o.PathName,
12805 "zone": APIDefaultZone,
12806 "id": id,
12807 "param": param,
12808 }
12809
12810 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}", pathBuildParameter)
12811 if err != nil {
12812 return nil, err
12813 }
12814 // build request body
12815 var body interface{}
12816 v, err := o.transformUpdateArgs(id, param)
12817 if err != nil {
12818 return nil, err
12819 }
12820 body = v
12821
12822 // do request
12823 data, err := o.Client.Do(ctx, "PUT", url, body)
12824 if err != nil {
12825 return nil, err
12826 }
12827
12828 // build results
12829 results, err := o.transformUpdateResults(data)
12830 if err != nil {
12831 return nil, err
12832 }
12833 return results.SSHKey, nil
12834 }
12835
12836 // Delete is API call
12837 func (o *SSHKeyOp) Delete(ctx context.Context, id types.ID) error {
12838 // build request URL
12839 pathBuildParameter := map[string]interface{}{
12840 "rootURL": SakuraCloudAPIRoot,
12841 "pathSuffix": o.PathSuffix,
12842 "pathName": o.PathName,
12843 "zone": APIDefaultZone,
12844 "id": id,
12845 }
12846
12847 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}", pathBuildParameter)
12848 if err != nil {
12849 return err
12850 }
12851 // build request body
12852 var body interface{}
12853
12854 // do request
12855 _, err = o.Client.Do(ctx, "DELETE", url, body)
12856 if err != nil {
12857 return err
12858 }
12859
12860 // build results
12861
12862 return nil
12863 }
12864
12865 /*************************************************
12866 * SubnetOp
12867 *************************************************/
12868
12869 // SubnetOp implements SubnetAPI interface
12870 type SubnetOp struct {
12871 // Client APICaller
12872 Client APICaller
12873 // PathSuffix is used when building URL
12874 PathSuffix string
12875 // PathName is used when building URL
12876 PathName string
12877 }
12878
12879 // NewSubnetOp creates new SubnetOp instance
12880 func NewSubnetOp(caller APICaller) SubnetAPI {
12881 return GetClientFactoryFunc("Subnet")(caller).(SubnetAPI)
12882 }
12883
12884 // Find is API call
12885 func (o *SubnetOp) Find(ctx context.Context, zone string, conditions *FindCondition) (*SubnetFindResult, error) {
12886 // build request URL
12887 pathBuildParameter := map[string]interface{}{
12888 "rootURL": SakuraCloudAPIRoot,
12889 "pathSuffix": o.PathSuffix,
12890 "pathName": o.PathName,
12891 "zone": zone,
12892 "conditions": conditions,
12893 }
12894
12895 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}", pathBuildParameter)
12896 if err != nil {
12897 return nil, err
12898 }
12899 // build request body
12900 var body interface{}
12901 v, err := o.transformFindArgs(conditions)
12902 if err != nil {
12903 return nil, err
12904 }
12905 body = v
12906
12907 // do request
12908 data, err := o.Client.Do(ctx, "GET", url, body)
12909 if err != nil {
12910 return nil, err
12911 }
12912
12913 // build results
12914 results, err := o.transformFindResults(data)
12915 if err != nil {
12916 return nil, err
12917 }
12918 return results, err
12919 }
12920
12921 // Read is API call
12922 func (o *SubnetOp) Read(ctx context.Context, zone string, id types.ID) (*Subnet, error) {
12923 // build request URL
12924 pathBuildParameter := map[string]interface{}{
12925 "rootURL": SakuraCloudAPIRoot,
12926 "pathSuffix": o.PathSuffix,
12927 "pathName": o.PathName,
12928 "zone": zone,
12929 "id": id,
12930 }
12931
12932 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}", pathBuildParameter)
12933 if err != nil {
12934 return nil, err
12935 }
12936 // build request body
12937 var body interface{}
12938
12939 // do request
12940 data, err := o.Client.Do(ctx, "GET", url, body)
12941 if err != nil {
12942 return nil, err
12943 }
12944
12945 // build results
12946 results, err := o.transformReadResults(data)
12947 if err != nil {
12948 return nil, err
12949 }
12950 return results.Subnet, nil
12951 }
12952
12953 /*************************************************
12954 * SwitchOp
12955 *************************************************/
12956
12957 // SwitchOp implements SwitchAPI interface
12958 type SwitchOp struct {
12959 // Client APICaller
12960 Client APICaller
12961 // PathSuffix is used when building URL
12962 PathSuffix string
12963 // PathName is used when building URL
12964 PathName string
12965 }
12966
12967 // NewSwitchOp creates new SwitchOp instance
12968 func NewSwitchOp(caller APICaller) SwitchAPI {
12969 return GetClientFactoryFunc("Switch")(caller).(SwitchAPI)
12970 }
12971
12972 // Find is API call
12973 func (o *SwitchOp) Find(ctx context.Context, zone string, conditions *FindCondition) (*SwitchFindResult, error) {
12974 // build request URL
12975 pathBuildParameter := map[string]interface{}{
12976 "rootURL": SakuraCloudAPIRoot,
12977 "pathSuffix": o.PathSuffix,
12978 "pathName": o.PathName,
12979 "zone": zone,
12980 "conditions": conditions,
12981 }
12982
12983 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}", pathBuildParameter)
12984 if err != nil {
12985 return nil, err
12986 }
12987 // build request body
12988 var body interface{}
12989 v, err := o.transformFindArgs(conditions)
12990 if err != nil {
12991 return nil, err
12992 }
12993 body = v
12994
12995 // do request
12996 data, err := o.Client.Do(ctx, "GET", url, body)
12997 if err != nil {
12998 return nil, err
12999 }
13000
13001 // build results
13002 results, err := o.transformFindResults(data)
13003 if err != nil {
13004 return nil, err
13005 }
13006 return results, err
13007 }
13008
13009 // Create is API call
13010 func (o *SwitchOp) Create(ctx context.Context, zone string, param *SwitchCreateRequest) (*Switch, error) {
13011 // build request URL
13012 pathBuildParameter := map[string]interface{}{
13013 "rootURL": SakuraCloudAPIRoot,
13014 "pathSuffix": o.PathSuffix,
13015 "pathName": o.PathName,
13016 "zone": zone,
13017 "param": param,
13018 }
13019
13020 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}", pathBuildParameter)
13021 if err != nil {
13022 return nil, err
13023 }
13024 // build request body
13025 var body interface{}
13026 v, err := o.transformCreateArgs(param)
13027 if err != nil {
13028 return nil, err
13029 }
13030 body = v
13031
13032 // do request
13033 data, err := o.Client.Do(ctx, "POST", url, body)
13034 if err != nil {
13035 return nil, err
13036 }
13037
13038 // build results
13039 results, err := o.transformCreateResults(data)
13040 if err != nil {
13041 return nil, err
13042 }
13043 return results.Switch, nil
13044 }
13045
13046 // Read is API call
13047 func (o *SwitchOp) Read(ctx context.Context, zone string, id types.ID) (*Switch, error) {
13048 // build request URL
13049 pathBuildParameter := map[string]interface{}{
13050 "rootURL": SakuraCloudAPIRoot,
13051 "pathSuffix": o.PathSuffix,
13052 "pathName": o.PathName,
13053 "zone": zone,
13054 "id": id,
13055 }
13056
13057 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}", pathBuildParameter)
13058 if err != nil {
13059 return nil, err
13060 }
13061 // build request body
13062 var body interface{}
13063
13064 // do request
13065 data, err := o.Client.Do(ctx, "GET", url, body)
13066 if err != nil {
13067 return nil, err
13068 }
13069
13070 // build results
13071 results, err := o.transformReadResults(data)
13072 if err != nil {
13073 return nil, err
13074 }
13075 return results.Switch, nil
13076 }
13077
13078 // Update is API call
13079 func (o *SwitchOp) Update(ctx context.Context, zone string, id types.ID, param *SwitchUpdateRequest) (*Switch, error) {
13080 // build request URL
13081 pathBuildParameter := map[string]interface{}{
13082 "rootURL": SakuraCloudAPIRoot,
13083 "pathSuffix": o.PathSuffix,
13084 "pathName": o.PathName,
13085 "zone": zone,
13086 "id": id,
13087 "param": param,
13088 }
13089
13090 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}", pathBuildParameter)
13091 if err != nil {
13092 return nil, err
13093 }
13094 // build request body
13095 var body interface{}
13096 v, err := o.transformUpdateArgs(id, param)
13097 if err != nil {
13098 return nil, err
13099 }
13100 body = v
13101
13102 // do request
13103 data, err := o.Client.Do(ctx, "PUT", url, body)
13104 if err != nil {
13105 return nil, err
13106 }
13107
13108 // build results
13109 results, err := o.transformUpdateResults(data)
13110 if err != nil {
13111 return nil, err
13112 }
13113 return results.Switch, nil
13114 }
13115
13116 // Delete is API call
13117 func (o *SwitchOp) Delete(ctx context.Context, zone string, id types.ID) error {
13118 // build request URL
13119 pathBuildParameter := map[string]interface{}{
13120 "rootURL": SakuraCloudAPIRoot,
13121 "pathSuffix": o.PathSuffix,
13122 "pathName": o.PathName,
13123 "zone": zone,
13124 "id": id,
13125 }
13126
13127 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}", pathBuildParameter)
13128 if err != nil {
13129 return err
13130 }
13131 // build request body
13132 var body interface{}
13133
13134 // do request
13135 _, err = o.Client.Do(ctx, "DELETE", url, body)
13136 if err != nil {
13137 return err
13138 }
13139
13140 // build results
13141
13142 return nil
13143 }
13144
13145 // ConnectToBridge is API call
13146 func (o *SwitchOp) ConnectToBridge(ctx context.Context, zone string, id types.ID, bridgeID types.ID) error {
13147 // build request URL
13148 pathBuildParameter := map[string]interface{}{
13149 "rootURL": SakuraCloudAPIRoot,
13150 "pathSuffix": o.PathSuffix,
13151 "pathName": o.PathName,
13152 "zone": zone,
13153 "id": id,
13154 "bridgeID": bridgeID,
13155 }
13156
13157 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}/to/bridge/{{.bridgeID}}", pathBuildParameter)
13158 if err != nil {
13159 return err
13160 }
13161 // build request body
13162 var body interface{}
13163
13164 // do request
13165 _, err = o.Client.Do(ctx, "PUT", url, body)
13166 if err != nil {
13167 return err
13168 }
13169
13170 // build results
13171
13172 return nil
13173 }
13174
13175 // DisconnectFromBridge is API call
13176 func (o *SwitchOp) DisconnectFromBridge(ctx context.Context, zone string, id types.ID) error {
13177 // build request URL
13178 pathBuildParameter := map[string]interface{}{
13179 "rootURL": SakuraCloudAPIRoot,
13180 "pathSuffix": o.PathSuffix,
13181 "pathName": o.PathName,
13182 "zone": zone,
13183 "id": id,
13184 }
13185
13186 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}/to/bridge/", pathBuildParameter)
13187 if err != nil {
13188 return err
13189 }
13190 // build request body
13191 var body interface{}
13192
13193 // do request
13194 _, err = o.Client.Do(ctx, "DELETE", url, body)
13195 if err != nil {
13196 return err
13197 }
13198
13199 // build results
13200
13201 return nil
13202 }
13203
13204 // GetServers is API call
13205 func (o *SwitchOp) GetServers(ctx context.Context, zone string, id types.ID) (*SwitchGetServersResult, error) {
13206 // build request URL
13207 pathBuildParameter := map[string]interface{}{
13208 "rootURL": SakuraCloudAPIRoot,
13209 "pathSuffix": o.PathSuffix,
13210 "pathName": o.PathName,
13211 "zone": zone,
13212 "id": id,
13213 }
13214
13215 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}/server", pathBuildParameter)
13216 if err != nil {
13217 return nil, err
13218 }
13219 // build request body
13220 var body interface{}
13221
13222 // do request
13223 data, err := o.Client.Do(ctx, "GET", url, body)
13224 if err != nil {
13225 return nil, err
13226 }
13227
13228 // build results
13229 results, err := o.transformGetServersResults(data)
13230 if err != nil {
13231 return nil, err
13232 }
13233 return results, err
13234 }
13235
13236 /*************************************************
13237 * VPCRouterOp
13238 *************************************************/
13239
13240 // VPCRouterOp implements VPCRouterAPI interface
13241 type VPCRouterOp struct {
13242 // Client APICaller
13243 Client APICaller
13244 // PathSuffix is used when building URL
13245 PathSuffix string
13246 // PathName is used when building URL
13247 PathName string
13248 }
13249
13250 // NewVPCRouterOp creates new VPCRouterOp instance
13251 func NewVPCRouterOp(caller APICaller) VPCRouterAPI {
13252 return GetClientFactoryFunc("VPCRouter")(caller).(VPCRouterAPI)
13253 }
13254
13255 // Find is API call
13256 func (o *VPCRouterOp) Find(ctx context.Context, zone string, conditions *FindCondition) (*VPCRouterFindResult, error) {
13257 // build request URL
13258 pathBuildParameter := map[string]interface{}{
13259 "rootURL": SakuraCloudAPIRoot,
13260 "pathSuffix": o.PathSuffix,
13261 "pathName": o.PathName,
13262 "zone": zone,
13263 "conditions": conditions,
13264 }
13265
13266 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}", pathBuildParameter)
13267 if err != nil {
13268 return nil, err
13269 }
13270 // build request body
13271 var body interface{}
13272 v, err := o.transformFindArgs(conditions)
13273 if err != nil {
13274 return nil, err
13275 }
13276 body = v
13277
13278 // do request
13279 data, err := o.Client.Do(ctx, "GET", url, body)
13280 if err != nil {
13281 return nil, err
13282 }
13283
13284 // build results
13285 results, err := o.transformFindResults(data)
13286 if err != nil {
13287 return nil, err
13288 }
13289 return results, err
13290 }
13291
13292 // Create is API call
13293 func (o *VPCRouterOp) Create(ctx context.Context, zone string, param *VPCRouterCreateRequest) (*VPCRouter, error) {
13294 // build request URL
13295 pathBuildParameter := map[string]interface{}{
13296 "rootURL": SakuraCloudAPIRoot,
13297 "pathSuffix": o.PathSuffix,
13298 "pathName": o.PathName,
13299 "zone": zone,
13300 "param": param,
13301 }
13302
13303 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}", pathBuildParameter)
13304 if err != nil {
13305 return nil, err
13306 }
13307 // build request body
13308 var body interface{}
13309 v, err := o.transformCreateArgs(param)
13310 if err != nil {
13311 return nil, err
13312 }
13313 body = v
13314
13315 // do request
13316 data, err := o.Client.Do(ctx, "POST", url, body)
13317 if err != nil {
13318 return nil, err
13319 }
13320
13321 // build results
13322 results, err := o.transformCreateResults(data)
13323 if err != nil {
13324 return nil, err
13325 }
13326 return results.VPCRouter, nil
13327 }
13328
13329 // Read is API call
13330 func (o *VPCRouterOp) Read(ctx context.Context, zone string, id types.ID) (*VPCRouter, error) {
13331 // build request URL
13332 pathBuildParameter := map[string]interface{}{
13333 "rootURL": SakuraCloudAPIRoot,
13334 "pathSuffix": o.PathSuffix,
13335 "pathName": o.PathName,
13336 "zone": zone,
13337 "id": id,
13338 }
13339
13340 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}", pathBuildParameter)
13341 if err != nil {
13342 return nil, err
13343 }
13344 // build request body
13345 var body interface{}
13346
13347 // do request
13348 data, err := o.Client.Do(ctx, "GET", url, body)
13349 if err != nil {
13350 return nil, err
13351 }
13352
13353 // build results
13354 results, err := o.transformReadResults(data)
13355 if err != nil {
13356 return nil, err
13357 }
13358 return results.VPCRouter, nil
13359 }
13360
13361 // Update is API call
13362 func (o *VPCRouterOp) Update(ctx context.Context, zone string, id types.ID, param *VPCRouterUpdateRequest) (*VPCRouter, error) {
13363 // build request URL
13364 pathBuildParameter := map[string]interface{}{
13365 "rootURL": SakuraCloudAPIRoot,
13366 "pathSuffix": o.PathSuffix,
13367 "pathName": o.PathName,
13368 "zone": zone,
13369 "id": id,
13370 "param": param,
13371 }
13372
13373 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}", pathBuildParameter)
13374 if err != nil {
13375 return nil, err
13376 }
13377 // build request body
13378 var body interface{}
13379 v, err := o.transformUpdateArgs(id, param)
13380 if err != nil {
13381 return nil, err
13382 }
13383 body = v
13384
13385 // do request
13386 data, err := o.Client.Do(ctx, "PUT", url, body)
13387 if err != nil {
13388 return nil, err
13389 }
13390
13391 // build results
13392 results, err := o.transformUpdateResults(data)
13393 if err != nil {
13394 return nil, err
13395 }
13396 return results.VPCRouter, nil
13397 }
13398
13399 // UpdateSettings is API call
13400 func (o *VPCRouterOp) UpdateSettings(ctx context.Context, zone string, id types.ID, param *VPCRouterUpdateSettingsRequest) (*VPCRouter, error) {
13401 // build request URL
13402 pathBuildParameter := map[string]interface{}{
13403 "rootURL": SakuraCloudAPIRoot,
13404 "pathSuffix": o.PathSuffix,
13405 "pathName": o.PathName,
13406 "zone": zone,
13407 "id": id,
13408 "param": param,
13409 }
13410
13411 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}", pathBuildParameter)
13412 if err != nil {
13413 return nil, err
13414 }
13415 // build request body
13416 var body interface{}
13417 v, err := o.transformUpdateSettingsArgs(id, param)
13418 if err != nil {
13419 return nil, err
13420 }
13421 body = v
13422
13423 // do request
13424 data, err := o.Client.Do(ctx, "PUT", url, body)
13425 if err != nil {
13426 return nil, err
13427 }
13428
13429 // build results
13430 results, err := o.transformUpdateSettingsResults(data)
13431 if err != nil {
13432 return nil, err
13433 }
13434 return results.VPCRouter, nil
13435 }
13436
13437 // Delete is API call
13438 func (o *VPCRouterOp) Delete(ctx context.Context, zone string, id types.ID) error {
13439 // build request URL
13440 pathBuildParameter := map[string]interface{}{
13441 "rootURL": SakuraCloudAPIRoot,
13442 "pathSuffix": o.PathSuffix,
13443 "pathName": o.PathName,
13444 "zone": zone,
13445 "id": id,
13446 }
13447
13448 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}", pathBuildParameter)
13449 if err != nil {
13450 return err
13451 }
13452 // build request body
13453 var body interface{}
13454
13455 // do request
13456 _, err = o.Client.Do(ctx, "DELETE", url, body)
13457 if err != nil {
13458 return err
13459 }
13460
13461 // build results
13462
13463 return nil
13464 }
13465
13466 // Config is API call
13467 func (o *VPCRouterOp) Config(ctx context.Context, zone string, id types.ID) error {
13468 // build request URL
13469 pathBuildParameter := map[string]interface{}{
13470 "rootURL": SakuraCloudAPIRoot,
13471 "pathSuffix": o.PathSuffix,
13472 "pathName": o.PathName,
13473 "zone": zone,
13474 "id": id,
13475 }
13476
13477 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}/config", pathBuildParameter)
13478 if err != nil {
13479 return err
13480 }
13481 // build request body
13482 var body interface{}
13483
13484 // do request
13485 _, err = o.Client.Do(ctx, "PUT", url, body)
13486 if err != nil {
13487 return err
13488 }
13489
13490 // build results
13491
13492 return nil
13493 }
13494
13495 // Boot is API call
13496 func (o *VPCRouterOp) Boot(ctx context.Context, zone string, id types.ID) error {
13497 // build request URL
13498 pathBuildParameter := map[string]interface{}{
13499 "rootURL": SakuraCloudAPIRoot,
13500 "pathSuffix": o.PathSuffix,
13501 "pathName": o.PathName,
13502 "zone": zone,
13503 "id": id,
13504 }
13505
13506 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}/power", pathBuildParameter)
13507 if err != nil {
13508 return err
13509 }
13510 lockKey, err := buildURL("GlobalLock", pathBuildParameter)
13511 if err != nil {
13512 return err
13513 }
13514 apiLocker.Lock(lockKey)
13515 defer apiLocker.Unlock(lockKey)
13516 // build request body
13517 var body interface{}
13518
13519 // do request
13520 _, err = o.Client.Do(ctx, "PUT", url, body)
13521 if err != nil {
13522 return err
13523 }
13524
13525 // build results
13526
13527 return nil
13528 }
13529
13530 // Shutdown is API call
13531 func (o *VPCRouterOp) Shutdown(ctx context.Context, zone string, id types.ID, shutdownOption *ShutdownOption) error {
13532 // build request URL
13533 pathBuildParameter := map[string]interface{}{
13534 "rootURL": SakuraCloudAPIRoot,
13535 "pathSuffix": o.PathSuffix,
13536 "pathName": o.PathName,
13537 "zone": zone,
13538 "id": id,
13539 "shutdownOption": shutdownOption,
13540 }
13541
13542 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}/power", pathBuildParameter)
13543 if err != nil {
13544 return err
13545 }
13546 lockKey, err := buildURL("GlobalLock", pathBuildParameter)
13547 if err != nil {
13548 return err
13549 }
13550 apiLocker.Lock(lockKey)
13551 defer apiLocker.Unlock(lockKey)
13552 // build request body
13553 var body interface{}
13554 v, err := o.transformShutdownArgs(id, shutdownOption)
13555 if err != nil {
13556 return err
13557 }
13558 body = v
13559
13560 // do request
13561 _, err = o.Client.Do(ctx, "DELETE", url, body)
13562 if err != nil {
13563 return err
13564 }
13565
13566 // build results
13567
13568 return nil
13569 }
13570
13571 // Reset is API call
13572 func (o *VPCRouterOp) Reset(ctx context.Context, zone string, id types.ID) error {
13573 // build request URL
13574 pathBuildParameter := map[string]interface{}{
13575 "rootURL": SakuraCloudAPIRoot,
13576 "pathSuffix": o.PathSuffix,
13577 "pathName": o.PathName,
13578 "zone": zone,
13579 "id": id,
13580 }
13581
13582 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}/reset", pathBuildParameter)
13583 if err != nil {
13584 return err
13585 }
13586 lockKey, err := buildURL("GlobalLock", pathBuildParameter)
13587 if err != nil {
13588 return err
13589 }
13590 apiLocker.Lock(lockKey)
13591 defer apiLocker.Unlock(lockKey)
13592 // build request body
13593 var body interface{}
13594
13595 // do request
13596 _, err = o.Client.Do(ctx, "PUT", url, body)
13597 if err != nil {
13598 return err
13599 }
13600
13601 // build results
13602
13603 return nil
13604 }
13605
13606 // ConnectToSwitch is API call
13607 func (o *VPCRouterOp) ConnectToSwitch(ctx context.Context, zone string, id types.ID, nicIndex int, switchID types.ID) error {
13608 // build request URL
13609 pathBuildParameter := map[string]interface{}{
13610 "rootURL": SakuraCloudAPIRoot,
13611 "pathSuffix": o.PathSuffix,
13612 "pathName": o.PathName,
13613 "zone": zone,
13614 "id": id,
13615 "nicIndex": nicIndex,
13616 "switchID": switchID,
13617 }
13618
13619 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}/interface/{{.nicIndex}}/to/switch/{{.switchID}}", pathBuildParameter)
13620 if err != nil {
13621 return err
13622 }
13623 // build request body
13624 var body interface{}
13625
13626 // do request
13627 _, err = o.Client.Do(ctx, "PUT", url, body)
13628 if err != nil {
13629 return err
13630 }
13631
13632 // build results
13633
13634 return nil
13635 }
13636
13637 // DisconnectFromSwitch is API call
13638 func (o *VPCRouterOp) DisconnectFromSwitch(ctx context.Context, zone string, id types.ID, nicIndex int) error {
13639 // build request URL
13640 pathBuildParameter := map[string]interface{}{
13641 "rootURL": SakuraCloudAPIRoot,
13642 "pathSuffix": o.PathSuffix,
13643 "pathName": o.PathName,
13644 "zone": zone,
13645 "id": id,
13646 "nicIndex": nicIndex,
13647 }
13648
13649 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}/interface/{{.nicIndex}}/to/switch", pathBuildParameter)
13650 if err != nil {
13651 return err
13652 }
13653 // build request body
13654 var body interface{}
13655
13656 // do request
13657 _, err = o.Client.Do(ctx, "DELETE", url, body)
13658 if err != nil {
13659 return err
13660 }
13661
13662 // build results
13663
13664 return nil
13665 }
13666
13667 // MonitorCPU is API call
13668 func (o *VPCRouterOp) MonitorCPU(ctx context.Context, zone string, id types.ID, condition *MonitorCondition) (*CPUTimeActivity, error) {
13669 // build request URL
13670 pathBuildParameter := map[string]interface{}{
13671 "rootURL": SakuraCloudAPIRoot,
13672 "pathSuffix": o.PathSuffix,
13673 "pathName": o.PathName,
13674 "zone": zone,
13675 "id": id,
13676 "condition": condition,
13677 }
13678
13679 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}/cpu/monitor", pathBuildParameter)
13680 if err != nil {
13681 return nil, err
13682 }
13683 // build request body
13684 var body interface{}
13685 v, err := o.transformMonitorCPUArgs(id, condition)
13686 if err != nil {
13687 return nil, err
13688 }
13689 body = v
13690
13691 // do request
13692 data, err := o.Client.Do(ctx, "GET", url, body)
13693 if err != nil {
13694 return nil, err
13695 }
13696
13697 // build results
13698 results, err := o.transformMonitorCPUResults(data)
13699 if err != nil {
13700 return nil, err
13701 }
13702 return results.CPUTimeActivity, nil
13703 }
13704
13705 // MonitorInterface is API call
13706 func (o *VPCRouterOp) MonitorInterface(ctx context.Context, zone string, id types.ID, index int, condition *MonitorCondition) (*InterfaceActivity, error) {
13707 // build request URL
13708 pathBuildParameter := map[string]interface{}{
13709 "rootURL": SakuraCloudAPIRoot,
13710 "pathSuffix": o.PathSuffix,
13711 "pathName": o.PathName,
13712 "zone": zone,
13713 "id": id,
13714 "index": index,
13715 "condition": condition,
13716 }
13717
13718 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}/interface{{if ne .index 0}}/{{.index}}{{end}}/monitor", pathBuildParameter)
13719 if err != nil {
13720 return nil, err
13721 }
13722 // build request body
13723 var body interface{}
13724 v, err := o.transformMonitorInterfaceArgs(id, index, condition)
13725 if err != nil {
13726 return nil, err
13727 }
13728 body = v
13729
13730 // do request
13731 data, err := o.Client.Do(ctx, "GET", url, body)
13732 if err != nil {
13733 return nil, err
13734 }
13735
13736 // build results
13737 results, err := o.transformMonitorInterfaceResults(data)
13738 if err != nil {
13739 return nil, err
13740 }
13741 return results.InterfaceActivity, nil
13742 }
13743
13744 // Status is API call
13745 func (o *VPCRouterOp) Status(ctx context.Context, zone string, id types.ID) (*VPCRouterStatus, error) {
13746 // build request URL
13747 pathBuildParameter := map[string]interface{}{
13748 "rootURL": SakuraCloudAPIRoot,
13749 "pathSuffix": o.PathSuffix,
13750 "pathName": o.PathName,
13751 "zone": zone,
13752 "id": id,
13753 }
13754
13755 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}/status", pathBuildParameter)
13756 if err != nil {
13757 return nil, err
13758 }
13759 // build request body
13760 var body interface{}
13761
13762 // do request
13763 data, err := o.Client.Do(ctx, "GET", url, body)
13764 if err != nil {
13765 return nil, err
13766 }
13767
13768 // build results
13769 results, err := o.transformStatusResults(data)
13770 if err != nil {
13771 return nil, err
13772 }
13773 return results.VPCRouterStatus, nil
13774 }
13775
13776 // Logs is API call
13777 func (o *VPCRouterOp) Logs(ctx context.Context, zone string, id types.ID) (*VPCRouterLog, error) {
13778 // build request URL
13779 pathBuildParameter := map[string]interface{}{
13780 "rootURL": SakuraCloudAPIRoot,
13781 "pathSuffix": o.PathSuffix,
13782 "pathName": o.PathName,
13783 "zone": zone,
13784 "id": id,
13785 }
13786
13787 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}/download/log/VPNLogs", pathBuildParameter)
13788 if err != nil {
13789 return nil, err
13790 }
13791 // build request body
13792 var body interface{}
13793
13794 // do request
13795 data, err := o.Client.Do(ctx, "GET", url, body)
13796 if err != nil {
13797 return nil, err
13798 }
13799
13800 // build results
13801 results, err := o.transformLogsResults(data)
13802 if err != nil {
13803 return nil, err
13804 }
13805 return results.VPCRouterLog, nil
13806 }
13807
13808 // Ping is API call
13809 func (o *VPCRouterOp) Ping(ctx context.Context, zone string, id types.ID, destination string) (*VPCRouterPingResults, error) {
13810 // build request URL
13811 pathBuildParameter := map[string]interface{}{
13812 "rootURL": SakuraCloudAPIRoot,
13813 "pathSuffix": o.PathSuffix,
13814 "pathName": o.PathName,
13815 "zone": zone,
13816 "id": id,
13817 "destination": destination,
13818 }
13819
13820 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}/vpcrouter/ping/{{.destination}}", pathBuildParameter)
13821 if err != nil {
13822 return nil, err
13823 }
13824 // build request body
13825 var body interface{}
13826
13827 // do request
13828 data, err := o.Client.Do(ctx, "POST", url, body)
13829 if err != nil {
13830 return nil, err
13831 }
13832
13833 // build results
13834 results, err := o.transformPingResults(data)
13835 if err != nil {
13836 return nil, err
13837 }
13838 return results.VPCRouterPingResults, nil
13839 }
13840
13841 /*************************************************
13842 * ZoneOp
13843 *************************************************/
13844
13845 // ZoneOp implements ZoneAPI interface
13846 type ZoneOp struct {
13847 // Client APICaller
13848 Client APICaller
13849 // PathSuffix is used when building URL
13850 PathSuffix string
13851 // PathName is used when building URL
13852 PathName string
13853 }
13854
13855 // NewZoneOp creates new ZoneOp instance
13856 func NewZoneOp(caller APICaller) ZoneAPI {
13857 return GetClientFactoryFunc("Zone")(caller).(ZoneAPI)
13858 }
13859
13860 // Find is API call
13861 func (o *ZoneOp) Find(ctx context.Context, conditions *FindCondition) (*ZoneFindResult, error) {
13862 // build request URL
13863 pathBuildParameter := map[string]interface{}{
13864 "rootURL": SakuraCloudAPIRoot,
13865 "pathSuffix": o.PathSuffix,
13866 "pathName": o.PathName,
13867 "zone": APIDefaultZone,
13868 "conditions": conditions,
13869 }
13870
13871 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}", pathBuildParameter)
13872 if err != nil {
13873 return nil, err
13874 }
13875 // build request body
13876 var body interface{}
13877 v, err := o.transformFindArgs(conditions)
13878 if err != nil {
13879 return nil, err
13880 }
13881 body = v
13882
13883 // do request
13884 data, err := o.Client.Do(ctx, "GET", url, body)
13885 if err != nil {
13886 return nil, err
13887 }
13888
13889 // build results
13890 results, err := o.transformFindResults(data)
13891 if err != nil {
13892 return nil, err
13893 }
13894 return results, err
13895 }
13896
13897 // Read is API call
13898 func (o *ZoneOp) Read(ctx context.Context, id types.ID) (*Zone, error) {
13899 // build request URL
13900 pathBuildParameter := map[string]interface{}{
13901 "rootURL": SakuraCloudAPIRoot,
13902 "pathSuffix": o.PathSuffix,
13903 "pathName": o.PathName,
13904 "zone": APIDefaultZone,
13905 "id": id,
13906 }
13907
13908 url, err := buildURL("{{.rootURL}}/{{.zone}}/{{.pathSuffix}}/{{.pathName}}/{{.id}}", pathBuildParameter)
13909 if err != nil {
13910 return nil, err
13911 }
13912 // build request body
13913 var body interface{}
13914
13915 // do request
13916 data, err := o.Client.Do(ctx, "GET", url, body)
13917 if err != nil {
13918 return nil, err
13919 }
13920
13921 // build results
13922 results, err := o.transformReadResults(data)
13923 if err != nil {
13924 return nil, err
13925 }
13926 return results.Zone, nil
13927 }
13928