zz_api_tracer.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-tracer'; DO NOT EDIT
16
17 package trace
18
19 import (
20 "context"
21 "encoding/json"
22 "log"
23 "sync"
24
25 "github.com/sacloud/iaas-api-go"
26 "github.com/sacloud/iaas-api-go/types"
27 )
28
29 var initOnce sync.Once
30
31 // AddClientFactoryHooks add client factory hooks
32 func AddClientFactoryHooks() {
33 initOnce.Do(func() {
34 addClientFactoryHooks()
35 })
36 }
37
38 func addClientFactoryHooks() {
39 iaas.AddClientFacotyHookFunc("Archive", func(in interface{}) interface{} {
40 return NewArchiveTracer(in.(iaas.ArchiveAPI))
41 })
42 iaas.AddClientFacotyHookFunc("AuthStatus", func(in interface{}) interface{} {
43 return NewAuthStatusTracer(in.(iaas.AuthStatusAPI))
44 })
45 iaas.AddClientFacotyHookFunc("AutoBackup", func(in interface{}) interface{} {
46 return NewAutoBackupTracer(in.(iaas.AutoBackupAPI))
47 })
48 iaas.AddClientFacotyHookFunc("AutoScale", func(in interface{}) interface{} {
49 return NewAutoScaleTracer(in.(iaas.AutoScaleAPI))
50 })
51 iaas.AddClientFacotyHookFunc("Bill", func(in interface{}) interface{} {
52 return NewBillTracer(in.(iaas.BillAPI))
53 })
54 iaas.AddClientFacotyHookFunc("Bridge", func(in interface{}) interface{} {
55 return NewBridgeTracer(in.(iaas.BridgeAPI))
56 })
57 iaas.AddClientFacotyHookFunc("CDROM", func(in interface{}) interface{} {
58 return NewCDROMTracer(in.(iaas.CDROMAPI))
59 })
60 iaas.AddClientFacotyHookFunc("CertificateAuthority", func(in interface{}) interface{} {
61 return NewCertificateAuthorityTracer(in.(iaas.CertificateAuthorityAPI))
62 })
63 iaas.AddClientFacotyHookFunc("ContainerRegistry", func(in interface{}) interface{} {
64 return NewContainerRegistryTracer(in.(iaas.ContainerRegistryAPI))
65 })
66 iaas.AddClientFacotyHookFunc("Coupon", func(in interface{}) interface{} {
67 return NewCouponTracer(in.(iaas.CouponAPI))
68 })
69 iaas.AddClientFacotyHookFunc("Database", func(in interface{}) interface{} {
70 return NewDatabaseTracer(in.(iaas.DatabaseAPI))
71 })
72 iaas.AddClientFacotyHookFunc("Disk", func(in interface{}) interface{} {
73 return NewDiskTracer(in.(iaas.DiskAPI))
74 })
75 iaas.AddClientFacotyHookFunc("DiskPlan", func(in interface{}) interface{} {
76 return NewDiskPlanTracer(in.(iaas.DiskPlanAPI))
77 })
78 iaas.AddClientFacotyHookFunc("DNS", func(in interface{}) interface{} {
79 return NewDNSTracer(in.(iaas.DNSAPI))
80 })
81 iaas.AddClientFacotyHookFunc("EnhancedDB", func(in interface{}) interface{} {
82 return NewEnhancedDBTracer(in.(iaas.EnhancedDBAPI))
83 })
84 iaas.AddClientFacotyHookFunc("ESME", func(in interface{}) interface{} {
85 return NewESMETracer(in.(iaas.ESMEAPI))
86 })
87 iaas.AddClientFacotyHookFunc("GSLB", func(in interface{}) interface{} {
88 return NewGSLBTracer(in.(iaas.GSLBAPI))
89 })
90 iaas.AddClientFacotyHookFunc("Icon", func(in interface{}) interface{} {
91 return NewIconTracer(in.(iaas.IconAPI))
92 })
93 iaas.AddClientFacotyHookFunc("Interface", func(in interface{}) interface{} {
94 return NewInterfaceTracer(in.(iaas.InterfaceAPI))
95 })
96 iaas.AddClientFacotyHookFunc("Internet", func(in interface{}) interface{} {
97 return NewInternetTracer(in.(iaas.InternetAPI))
98 })
99 iaas.AddClientFacotyHookFunc("InternetPlan", func(in interface{}) interface{} {
100 return NewInternetPlanTracer(in.(iaas.InternetPlanAPI))
101 })
102 iaas.AddClientFacotyHookFunc("IPAddress", func(in interface{}) interface{} {
103 return NewIPAddressTracer(in.(iaas.IPAddressAPI))
104 })
105 iaas.AddClientFacotyHookFunc("IPv6Net", func(in interface{}) interface{} {
106 return NewIPv6NetTracer(in.(iaas.IPv6NetAPI))
107 })
108 iaas.AddClientFacotyHookFunc("IPv6Addr", func(in interface{}) interface{} {
109 return NewIPv6AddrTracer(in.(iaas.IPv6AddrAPI))
110 })
111 iaas.AddClientFacotyHookFunc("License", func(in interface{}) interface{} {
112 return NewLicenseTracer(in.(iaas.LicenseAPI))
113 })
114 iaas.AddClientFacotyHookFunc("LicenseInfo", func(in interface{}) interface{} {
115 return NewLicenseInfoTracer(in.(iaas.LicenseInfoAPI))
116 })
117 iaas.AddClientFacotyHookFunc("LoadBalancer", func(in interface{}) interface{} {
118 return NewLoadBalancerTracer(in.(iaas.LoadBalancerAPI))
119 })
120 iaas.AddClientFacotyHookFunc("LocalRouter", func(in interface{}) interface{} {
121 return NewLocalRouterTracer(in.(iaas.LocalRouterAPI))
122 })
123 iaas.AddClientFacotyHookFunc("MobileGateway", func(in interface{}) interface{} {
124 return NewMobileGatewayTracer(in.(iaas.MobileGatewayAPI))
125 })
126 iaas.AddClientFacotyHookFunc("NFS", func(in interface{}) interface{} {
127 return NewNFSTracer(in.(iaas.NFSAPI))
128 })
129 iaas.AddClientFacotyHookFunc("Note", func(in interface{}) interface{} {
130 return NewNoteTracer(in.(iaas.NoteAPI))
131 })
132 iaas.AddClientFacotyHookFunc("PacketFilter", func(in interface{}) interface{} {
133 return NewPacketFilterTracer(in.(iaas.PacketFilterAPI))
134 })
135 iaas.AddClientFacotyHookFunc("PrivateHost", func(in interface{}) interface{} {
136 return NewPrivateHostTracer(in.(iaas.PrivateHostAPI))
137 })
138 iaas.AddClientFacotyHookFunc("PrivateHostPlan", func(in interface{}) interface{} {
139 return NewPrivateHostPlanTracer(in.(iaas.PrivateHostPlanAPI))
140 })
141 iaas.AddClientFacotyHookFunc("ProxyLB", func(in interface{}) interface{} {
142 return NewProxyLBTracer(in.(iaas.ProxyLBAPI))
143 })
144 iaas.AddClientFacotyHookFunc("Region", func(in interface{}) interface{} {
145 return NewRegionTracer(in.(iaas.RegionAPI))
146 })
147 iaas.AddClientFacotyHookFunc("Server", func(in interface{}) interface{} {
148 return NewServerTracer(in.(iaas.ServerAPI))
149 })
150 iaas.AddClientFacotyHookFunc("ServerPlan", func(in interface{}) interface{} {
151 return NewServerPlanTracer(in.(iaas.ServerPlanAPI))
152 })
153 iaas.AddClientFacotyHookFunc("ServiceClass", func(in interface{}) interface{} {
154 return NewServiceClassTracer(in.(iaas.ServiceClassAPI))
155 })
156 iaas.AddClientFacotyHookFunc("SIM", func(in interface{}) interface{} {
157 return NewSIMTracer(in.(iaas.SIMAPI))
158 })
159 iaas.AddClientFacotyHookFunc("SimpleMonitor", func(in interface{}) interface{} {
160 return NewSimpleMonitorTracer(in.(iaas.SimpleMonitorAPI))
161 })
162 iaas.AddClientFacotyHookFunc("SimpleNotificationDestination", func(in interface{}) interface{} {
163 return NewSimpleNotificationDestinationTracer(in.(iaas.SimpleNotificationDestinationAPI))
164 })
165 iaas.AddClientFacotyHookFunc("SimpleNotificationGroup", func(in interface{}) interface{} {
166 return NewSimpleNotificationGroupTracer(in.(iaas.SimpleNotificationGroupAPI))
167 })
168 iaas.AddClientFacotyHookFunc("SSHKey", func(in interface{}) interface{} {
169 return NewSSHKeyTracer(in.(iaas.SSHKeyAPI))
170 })
171 iaas.AddClientFacotyHookFunc("Subnet", func(in interface{}) interface{} {
172 return NewSubnetTracer(in.(iaas.SubnetAPI))
173 })
174 iaas.AddClientFacotyHookFunc("Switch", func(in interface{}) interface{} {
175 return NewSwitchTracer(in.(iaas.SwitchAPI))
176 })
177 iaas.AddClientFacotyHookFunc("VPCRouter", func(in interface{}) interface{} {
178 return NewVPCRouterTracer(in.(iaas.VPCRouterAPI))
179 })
180 iaas.AddClientFacotyHookFunc("Zone", func(in interface{}) interface{} {
181 return NewZoneTracer(in.(iaas.ZoneAPI))
182 })
183 }
184
185 /*************************************************
186 * ArchiveTracer
187 *************************************************/
188
189 // ArchiveTracer is for trace ArchiveOp operations
190 type ArchiveTracer struct {
191 Internal iaas.ArchiveAPI
192 }
193
194 // NewArchiveTracer creates new ArchiveTracer instance
195 func NewArchiveTracer(in iaas.ArchiveAPI) iaas.ArchiveAPI {
196 return &ArchiveTracer{
197 Internal: in,
198 }
199 }
200
201 // Find is API call with trace log
202 func (t *ArchiveTracer) Find(ctx context.Context, zone string, conditions *iaas.FindCondition) (*iaas.ArchiveFindResult, error) {
203 log.Println("[TRACE] ArchiveAPI.Find start")
204 targetArguments := struct {
205 Argzone string
206 Argconditions *iaas.FindCondition `json:"conditions"`
207 }{
208 Argzone: zone,
209 Argconditions: conditions,
210 }
211 if d, err := json.Marshal(targetArguments); err == nil {
212 log.Printf("[TRACE] \targs: %s\n", string(d))
213 }
214
215 defer func() {
216 log.Println("[TRACE] ArchiveAPI.Find end")
217 }()
218
219 result, err := t.Internal.Find(ctx, zone, conditions)
220 targetResults := struct {
221 Result *iaas.ArchiveFindResult
222 Error error
223 }{
224 Result: result,
225 Error: err,
226 }
227 if d, err := json.Marshal(targetResults); err == nil {
228 log.Printf("[TRACE] \tresults: %s\n", string(d))
229 }
230
231 return result, err
232 }
233
234 // Create is API call with trace log
235 func (t *ArchiveTracer) Create(ctx context.Context, zone string, param *iaas.ArchiveCreateRequest) (*iaas.Archive, error) {
236 log.Println("[TRACE] ArchiveAPI.Create start")
237 targetArguments := struct {
238 Argzone string
239 Argparam *iaas.ArchiveCreateRequest `json:"param"`
240 }{
241 Argzone: zone,
242 Argparam: param,
243 }
244 if d, err := json.Marshal(targetArguments); err == nil {
245 log.Printf("[TRACE] \targs: %s\n", string(d))
246 }
247
248 defer func() {
249 log.Println("[TRACE] ArchiveAPI.Create end")
250 }()
251
252 resultArchive, err := t.Internal.Create(ctx, zone, param)
253 targetResults := struct {
254 Archive *iaas.Archive
255 Error error
256 }{
257 Archive: resultArchive,
258 Error: err,
259 }
260 if d, err := json.Marshal(targetResults); err == nil {
261 log.Printf("[TRACE] \tresults: %s\n", string(d))
262 }
263
264 return resultArchive, err
265 }
266
267 // CreateBlank is API call with trace log
268 func (t *ArchiveTracer) CreateBlank(ctx context.Context, zone string, param *iaas.ArchiveCreateBlankRequest) (*iaas.Archive, *iaas.FTPServer, error) {
269 log.Println("[TRACE] ArchiveAPI.CreateBlank start")
270 targetArguments := struct {
271 Argzone string
272 Argparam *iaas.ArchiveCreateBlankRequest `json:"param"`
273 }{
274 Argzone: zone,
275 Argparam: param,
276 }
277 if d, err := json.Marshal(targetArguments); err == nil {
278 log.Printf("[TRACE] \targs: %s\n", string(d))
279 }
280
281 defer func() {
282 log.Println("[TRACE] ArchiveAPI.CreateBlank end")
283 }()
284
285 resultArchive, resultFTPServer, err := t.Internal.CreateBlank(ctx, zone, param)
286 targetResults := struct {
287 Archive *iaas.Archive
288 FTPServer *iaas.FTPServer
289 Error error
290 }{
291 Archive: resultArchive,
292 FTPServer: resultFTPServer,
293 Error: err,
294 }
295 if d, err := json.Marshal(targetResults); err == nil {
296 log.Printf("[TRACE] \tresults: %s\n", string(d))
297 }
298
299 return resultArchive, resultFTPServer, err
300 }
301
302 // Read is API call with trace log
303 func (t *ArchiveTracer) Read(ctx context.Context, zone string, id types.ID) (*iaas.Archive, error) {
304 log.Println("[TRACE] ArchiveAPI.Read start")
305 targetArguments := struct {
306 Argzone string
307 Argid types.ID `json:"id"`
308 }{
309 Argzone: zone,
310 Argid: id,
311 }
312 if d, err := json.Marshal(targetArguments); err == nil {
313 log.Printf("[TRACE] \targs: %s\n", string(d))
314 }
315
316 defer func() {
317 log.Println("[TRACE] ArchiveAPI.Read end")
318 }()
319
320 resultArchive, err := t.Internal.Read(ctx, zone, id)
321 targetResults := struct {
322 Archive *iaas.Archive
323 Error error
324 }{
325 Archive: resultArchive,
326 Error: err,
327 }
328 if d, err := json.Marshal(targetResults); err == nil {
329 log.Printf("[TRACE] \tresults: %s\n", string(d))
330 }
331
332 return resultArchive, err
333 }
334
335 // Update is API call with trace log
336 func (t *ArchiveTracer) Update(ctx context.Context, zone string, id types.ID, param *iaas.ArchiveUpdateRequest) (*iaas.Archive, error) {
337 log.Println("[TRACE] ArchiveAPI.Update start")
338 targetArguments := struct {
339 Argzone string
340 Argid types.ID `json:"id"`
341 Argparam *iaas.ArchiveUpdateRequest `json:"param"`
342 }{
343 Argzone: zone,
344 Argid: id,
345 Argparam: param,
346 }
347 if d, err := json.Marshal(targetArguments); err == nil {
348 log.Printf("[TRACE] \targs: %s\n", string(d))
349 }
350
351 defer func() {
352 log.Println("[TRACE] ArchiveAPI.Update end")
353 }()
354
355 resultArchive, err := t.Internal.Update(ctx, zone, id, param)
356 targetResults := struct {
357 Archive *iaas.Archive
358 Error error
359 }{
360 Archive: resultArchive,
361 Error: err,
362 }
363 if d, err := json.Marshal(targetResults); err == nil {
364 log.Printf("[TRACE] \tresults: %s\n", string(d))
365 }
366
367 return resultArchive, err
368 }
369
370 // Delete is API call with trace log
371 func (t *ArchiveTracer) Delete(ctx context.Context, zone string, id types.ID) error {
372 log.Println("[TRACE] ArchiveAPI.Delete start")
373 targetArguments := struct {
374 Argzone string
375 Argid types.ID `json:"id"`
376 }{
377 Argzone: zone,
378 Argid: id,
379 }
380 if d, err := json.Marshal(targetArguments); err == nil {
381 log.Printf("[TRACE] \targs: %s\n", string(d))
382 }
383
384 defer func() {
385 log.Println("[TRACE] ArchiveAPI.Delete end")
386 }()
387
388 err := t.Internal.Delete(ctx, zone, id)
389 targetResults := struct {
390 Error error
391 }{
392 Error: err,
393 }
394 if d, err := json.Marshal(targetResults); err == nil {
395 log.Printf("[TRACE] \tresults: %s\n", string(d))
396 }
397
398 return err
399 }
400
401 // OpenFTP is API call with trace log
402 func (t *ArchiveTracer) OpenFTP(ctx context.Context, zone string, id types.ID, openOption *iaas.OpenFTPRequest) (*iaas.FTPServer, error) {
403 log.Println("[TRACE] ArchiveAPI.OpenFTP start")
404 targetArguments := struct {
405 Argzone string
406 Argid types.ID `json:"id"`
407 ArgopenOption *iaas.OpenFTPRequest `json:"openOption"`
408 }{
409 Argzone: zone,
410 Argid: id,
411 ArgopenOption: openOption,
412 }
413 if d, err := json.Marshal(targetArguments); err == nil {
414 log.Printf("[TRACE] \targs: %s\n", string(d))
415 }
416
417 defer func() {
418 log.Println("[TRACE] ArchiveAPI.OpenFTP end")
419 }()
420
421 resultFTPServer, err := t.Internal.OpenFTP(ctx, zone, id, openOption)
422 targetResults := struct {
423 FTPServer *iaas.FTPServer
424 Error error
425 }{
426 FTPServer: resultFTPServer,
427 Error: err,
428 }
429 if d, err := json.Marshal(targetResults); err == nil {
430 log.Printf("[TRACE] \tresults: %s\n", string(d))
431 }
432
433 return resultFTPServer, err
434 }
435
436 // CloseFTP is API call with trace log
437 func (t *ArchiveTracer) CloseFTP(ctx context.Context, zone string, id types.ID) error {
438 log.Println("[TRACE] ArchiveAPI.CloseFTP start")
439 targetArguments := struct {
440 Argzone string
441 Argid types.ID `json:"id"`
442 }{
443 Argzone: zone,
444 Argid: id,
445 }
446 if d, err := json.Marshal(targetArguments); err == nil {
447 log.Printf("[TRACE] \targs: %s\n", string(d))
448 }
449
450 defer func() {
451 log.Println("[TRACE] ArchiveAPI.CloseFTP end")
452 }()
453
454 err := t.Internal.CloseFTP(ctx, zone, id)
455 targetResults := struct {
456 Error error
457 }{
458 Error: err,
459 }
460 if d, err := json.Marshal(targetResults); err == nil {
461 log.Printf("[TRACE] \tresults: %s\n", string(d))
462 }
463
464 return err
465 }
466
467 // Share is API call with trace log
468 func (t *ArchiveTracer) Share(ctx context.Context, zone string, id types.ID) (*iaas.ArchiveShareInfo, error) {
469 log.Println("[TRACE] ArchiveAPI.Share start")
470 targetArguments := struct {
471 Argzone string
472 Argid types.ID `json:"id"`
473 }{
474 Argzone: zone,
475 Argid: id,
476 }
477 if d, err := json.Marshal(targetArguments); err == nil {
478 log.Printf("[TRACE] \targs: %s\n", string(d))
479 }
480
481 defer func() {
482 log.Println("[TRACE] ArchiveAPI.Share end")
483 }()
484
485 resultArchiveShareInfo, err := t.Internal.Share(ctx, zone, id)
486 targetResults := struct {
487 ArchiveShareInfo *iaas.ArchiveShareInfo
488 Error error
489 }{
490 ArchiveShareInfo: resultArchiveShareInfo,
491 Error: err,
492 }
493 if d, err := json.Marshal(targetResults); err == nil {
494 log.Printf("[TRACE] \tresults: %s\n", string(d))
495 }
496
497 return resultArchiveShareInfo, err
498 }
499
500 // CreateFromShared is API call with trace log
501 func (t *ArchiveTracer) CreateFromShared(ctx context.Context, zone string, sourceArchiveID types.ID, destZoneID types.ID, param *iaas.ArchiveCreateRequestFromShared) (*iaas.Archive, error) {
502 log.Println("[TRACE] ArchiveAPI.CreateFromShared start")
503 targetArguments := struct {
504 Argzone string
505 ArgsourceArchiveID types.ID `json:"sourceArchiveID"`
506 ArgdestZoneID types.ID `json:"destZoneID"`
507 Argparam *iaas.ArchiveCreateRequestFromShared `json:"param"`
508 }{
509 Argzone: zone,
510 ArgsourceArchiveID: sourceArchiveID,
511 ArgdestZoneID: destZoneID,
512 Argparam: param,
513 }
514 if d, err := json.Marshal(targetArguments); err == nil {
515 log.Printf("[TRACE] \targs: %s\n", string(d))
516 }
517
518 defer func() {
519 log.Println("[TRACE] ArchiveAPI.CreateFromShared end")
520 }()
521
522 resultArchive, err := t.Internal.CreateFromShared(ctx, zone, sourceArchiveID, destZoneID, param)
523 targetResults := struct {
524 Archive *iaas.Archive
525 Error error
526 }{
527 Archive: resultArchive,
528 Error: err,
529 }
530 if d, err := json.Marshal(targetResults); err == nil {
531 log.Printf("[TRACE] \tresults: %s\n", string(d))
532 }
533
534 return resultArchive, err
535 }
536
537 // Transfer is API call with trace log
538 func (t *ArchiveTracer) Transfer(ctx context.Context, zone string, sourceArchiveID types.ID, destZoneID types.ID, param *iaas.ArchiveTransferRequest) (*iaas.Archive, error) {
539 log.Println("[TRACE] ArchiveAPI.Transfer start")
540 targetArguments := struct {
541 Argzone string
542 ArgsourceArchiveID types.ID `json:"sourceArchiveID"`
543 ArgdestZoneID types.ID `json:"destZoneID"`
544 Argparam *iaas.ArchiveTransferRequest `json:"param"`
545 }{
546 Argzone: zone,
547 ArgsourceArchiveID: sourceArchiveID,
548 ArgdestZoneID: destZoneID,
549 Argparam: param,
550 }
551 if d, err := json.Marshal(targetArguments); err == nil {
552 log.Printf("[TRACE] \targs: %s\n", string(d))
553 }
554
555 defer func() {
556 log.Println("[TRACE] ArchiveAPI.Transfer end")
557 }()
558
559 resultArchive, err := t.Internal.Transfer(ctx, zone, sourceArchiveID, destZoneID, param)
560 targetResults := struct {
561 Archive *iaas.Archive
562 Error error
563 }{
564 Archive: resultArchive,
565 Error: err,
566 }
567 if d, err := json.Marshal(targetResults); err == nil {
568 log.Printf("[TRACE] \tresults: %s\n", string(d))
569 }
570
571 return resultArchive, err
572 }
573
574 /*************************************************
575 * AuthStatusTracer
576 *************************************************/
577
578 // AuthStatusTracer is for trace AuthStatusOp operations
579 type AuthStatusTracer struct {
580 Internal iaas.AuthStatusAPI
581 }
582
583 // NewAuthStatusTracer creates new AuthStatusTracer instance
584 func NewAuthStatusTracer(in iaas.AuthStatusAPI) iaas.AuthStatusAPI {
585 return &AuthStatusTracer{
586 Internal: in,
587 }
588 }
589
590 // Read is API call with trace log
591 func (t *AuthStatusTracer) Read(ctx context.Context) (*iaas.AuthStatus, error) {
592 log.Println("[TRACE] AuthStatusAPI.Read start")
593 targetArguments := struct {
594 }{}
595 if d, err := json.Marshal(targetArguments); err == nil {
596 log.Printf("[TRACE] \targs: %s\n", string(d))
597 }
598
599 defer func() {
600 log.Println("[TRACE] AuthStatusAPI.Read end")
601 }()
602
603 resultAuthStatus, err := t.Internal.Read(ctx)
604 targetResults := struct {
605 AuthStatus *iaas.AuthStatus
606 Error error
607 }{
608 AuthStatus: resultAuthStatus,
609 Error: err,
610 }
611 if d, err := json.Marshal(targetResults); err == nil {
612 log.Printf("[TRACE] \tresults: %s\n", string(d))
613 }
614
615 return resultAuthStatus, err
616 }
617
618 /*************************************************
619 * AutoBackupTracer
620 *************************************************/
621
622 // AutoBackupTracer is for trace AutoBackupOp operations
623 type AutoBackupTracer struct {
624 Internal iaas.AutoBackupAPI
625 }
626
627 // NewAutoBackupTracer creates new AutoBackupTracer instance
628 func NewAutoBackupTracer(in iaas.AutoBackupAPI) iaas.AutoBackupAPI {
629 return &AutoBackupTracer{
630 Internal: in,
631 }
632 }
633
634 // Find is API call with trace log
635 func (t *AutoBackupTracer) Find(ctx context.Context, zone string, conditions *iaas.FindCondition) (*iaas.AutoBackupFindResult, error) {
636 log.Println("[TRACE] AutoBackupAPI.Find start")
637 targetArguments := struct {
638 Argzone string
639 Argconditions *iaas.FindCondition `json:"conditions"`
640 }{
641 Argzone: zone,
642 Argconditions: conditions,
643 }
644 if d, err := json.Marshal(targetArguments); err == nil {
645 log.Printf("[TRACE] \targs: %s\n", string(d))
646 }
647
648 defer func() {
649 log.Println("[TRACE] AutoBackupAPI.Find end")
650 }()
651
652 result, err := t.Internal.Find(ctx, zone, conditions)
653 targetResults := struct {
654 Result *iaas.AutoBackupFindResult
655 Error error
656 }{
657 Result: result,
658 Error: err,
659 }
660 if d, err := json.Marshal(targetResults); err == nil {
661 log.Printf("[TRACE] \tresults: %s\n", string(d))
662 }
663
664 return result, err
665 }
666
667 // Create is API call with trace log
668 func (t *AutoBackupTracer) Create(ctx context.Context, zone string, param *iaas.AutoBackupCreateRequest) (*iaas.AutoBackup, error) {
669 log.Println("[TRACE] AutoBackupAPI.Create start")
670 targetArguments := struct {
671 Argzone string
672 Argparam *iaas.AutoBackupCreateRequest `json:"param"`
673 }{
674 Argzone: zone,
675 Argparam: param,
676 }
677 if d, err := json.Marshal(targetArguments); err == nil {
678 log.Printf("[TRACE] \targs: %s\n", string(d))
679 }
680
681 defer func() {
682 log.Println("[TRACE] AutoBackupAPI.Create end")
683 }()
684
685 resultAutoBackup, err := t.Internal.Create(ctx, zone, param)
686 targetResults := struct {
687 AutoBackup *iaas.AutoBackup
688 Error error
689 }{
690 AutoBackup: resultAutoBackup,
691 Error: err,
692 }
693 if d, err := json.Marshal(targetResults); err == nil {
694 log.Printf("[TRACE] \tresults: %s\n", string(d))
695 }
696
697 return resultAutoBackup, err
698 }
699
700 // Read is API call with trace log
701 func (t *AutoBackupTracer) Read(ctx context.Context, zone string, id types.ID) (*iaas.AutoBackup, error) {
702 log.Println("[TRACE] AutoBackupAPI.Read start")
703 targetArguments := struct {
704 Argzone string
705 Argid types.ID `json:"id"`
706 }{
707 Argzone: zone,
708 Argid: id,
709 }
710 if d, err := json.Marshal(targetArguments); err == nil {
711 log.Printf("[TRACE] \targs: %s\n", string(d))
712 }
713
714 defer func() {
715 log.Println("[TRACE] AutoBackupAPI.Read end")
716 }()
717
718 resultAutoBackup, err := t.Internal.Read(ctx, zone, id)
719 targetResults := struct {
720 AutoBackup *iaas.AutoBackup
721 Error error
722 }{
723 AutoBackup: resultAutoBackup,
724 Error: err,
725 }
726 if d, err := json.Marshal(targetResults); err == nil {
727 log.Printf("[TRACE] \tresults: %s\n", string(d))
728 }
729
730 return resultAutoBackup, err
731 }
732
733 // Update is API call with trace log
734 func (t *AutoBackupTracer) Update(ctx context.Context, zone string, id types.ID, param *iaas.AutoBackupUpdateRequest) (*iaas.AutoBackup, error) {
735 log.Println("[TRACE] AutoBackupAPI.Update start")
736 targetArguments := struct {
737 Argzone string
738 Argid types.ID `json:"id"`
739 Argparam *iaas.AutoBackupUpdateRequest `json:"param"`
740 }{
741 Argzone: zone,
742 Argid: id,
743 Argparam: param,
744 }
745 if d, err := json.Marshal(targetArguments); err == nil {
746 log.Printf("[TRACE] \targs: %s\n", string(d))
747 }
748
749 defer func() {
750 log.Println("[TRACE] AutoBackupAPI.Update end")
751 }()
752
753 resultAutoBackup, err := t.Internal.Update(ctx, zone, id, param)
754 targetResults := struct {
755 AutoBackup *iaas.AutoBackup
756 Error error
757 }{
758 AutoBackup: resultAutoBackup,
759 Error: err,
760 }
761 if d, err := json.Marshal(targetResults); err == nil {
762 log.Printf("[TRACE] \tresults: %s\n", string(d))
763 }
764
765 return resultAutoBackup, err
766 }
767
768 // UpdateSettings is API call with trace log
769 func (t *AutoBackupTracer) UpdateSettings(ctx context.Context, zone string, id types.ID, param *iaas.AutoBackupUpdateSettingsRequest) (*iaas.AutoBackup, error) {
770 log.Println("[TRACE] AutoBackupAPI.UpdateSettings start")
771 targetArguments := struct {
772 Argzone string
773 Argid types.ID `json:"id"`
774 Argparam *iaas.AutoBackupUpdateSettingsRequest `json:"param"`
775 }{
776 Argzone: zone,
777 Argid: id,
778 Argparam: param,
779 }
780 if d, err := json.Marshal(targetArguments); err == nil {
781 log.Printf("[TRACE] \targs: %s\n", string(d))
782 }
783
784 defer func() {
785 log.Println("[TRACE] AutoBackupAPI.UpdateSettings end")
786 }()
787
788 resultAutoBackup, err := t.Internal.UpdateSettings(ctx, zone, id, param)
789 targetResults := struct {
790 AutoBackup *iaas.AutoBackup
791 Error error
792 }{
793 AutoBackup: resultAutoBackup,
794 Error: err,
795 }
796 if d, err := json.Marshal(targetResults); err == nil {
797 log.Printf("[TRACE] \tresults: %s\n", string(d))
798 }
799
800 return resultAutoBackup, err
801 }
802
803 // Delete is API call with trace log
804 func (t *AutoBackupTracer) Delete(ctx context.Context, zone string, id types.ID) error {
805 log.Println("[TRACE] AutoBackupAPI.Delete start")
806 targetArguments := struct {
807 Argzone string
808 Argid types.ID `json:"id"`
809 }{
810 Argzone: zone,
811 Argid: id,
812 }
813 if d, err := json.Marshal(targetArguments); err == nil {
814 log.Printf("[TRACE] \targs: %s\n", string(d))
815 }
816
817 defer func() {
818 log.Println("[TRACE] AutoBackupAPI.Delete end")
819 }()
820
821 err := t.Internal.Delete(ctx, zone, id)
822 targetResults := struct {
823 Error error
824 }{
825 Error: err,
826 }
827 if d, err := json.Marshal(targetResults); err == nil {
828 log.Printf("[TRACE] \tresults: %s\n", string(d))
829 }
830
831 return err
832 }
833
834 /*************************************************
835 * AutoScaleTracer
836 *************************************************/
837
838 // AutoScaleTracer is for trace AutoScaleOp operations
839 type AutoScaleTracer struct {
840 Internal iaas.AutoScaleAPI
841 }
842
843 // NewAutoScaleTracer creates new AutoScaleTracer instance
844 func NewAutoScaleTracer(in iaas.AutoScaleAPI) iaas.AutoScaleAPI {
845 return &AutoScaleTracer{
846 Internal: in,
847 }
848 }
849
850 // Find is API call with trace log
851 func (t *AutoScaleTracer) Find(ctx context.Context, conditions *iaas.FindCondition) (*iaas.AutoScaleFindResult, error) {
852 log.Println("[TRACE] AutoScaleAPI.Find start")
853 targetArguments := struct {
854 Argconditions *iaas.FindCondition `json:"conditions"`
855 }{
856 Argconditions: conditions,
857 }
858 if d, err := json.Marshal(targetArguments); err == nil {
859 log.Printf("[TRACE] \targs: %s\n", string(d))
860 }
861
862 defer func() {
863 log.Println("[TRACE] AutoScaleAPI.Find end")
864 }()
865
866 result, err := t.Internal.Find(ctx, conditions)
867 targetResults := struct {
868 Result *iaas.AutoScaleFindResult
869 Error error
870 }{
871 Result: result,
872 Error: err,
873 }
874 if d, err := json.Marshal(targetResults); err == nil {
875 log.Printf("[TRACE] \tresults: %s\n", string(d))
876 }
877
878 return result, err
879 }
880
881 // Create is API call with trace log
882 func (t *AutoScaleTracer) Create(ctx context.Context, param *iaas.AutoScaleCreateRequest) (*iaas.AutoScale, error) {
883 log.Println("[TRACE] AutoScaleAPI.Create start")
884 targetArguments := struct {
885 Argparam *iaas.AutoScaleCreateRequest `json:"param"`
886 }{
887 Argparam: param,
888 }
889 if d, err := json.Marshal(targetArguments); err == nil {
890 log.Printf("[TRACE] \targs: %s\n", string(d))
891 }
892
893 defer func() {
894 log.Println("[TRACE] AutoScaleAPI.Create end")
895 }()
896
897 resultAutoScale, err := t.Internal.Create(ctx, param)
898 targetResults := struct {
899 AutoScale *iaas.AutoScale
900 Error error
901 }{
902 AutoScale: resultAutoScale,
903 Error: err,
904 }
905 if d, err := json.Marshal(targetResults); err == nil {
906 log.Printf("[TRACE] \tresults: %s\n", string(d))
907 }
908
909 return resultAutoScale, err
910 }
911
912 // Read is API call with trace log
913 func (t *AutoScaleTracer) Read(ctx context.Context, id types.ID) (*iaas.AutoScale, error) {
914 log.Println("[TRACE] AutoScaleAPI.Read start")
915 targetArguments := struct {
916 Argid types.ID `json:"id"`
917 }{
918 Argid: id,
919 }
920 if d, err := json.Marshal(targetArguments); err == nil {
921 log.Printf("[TRACE] \targs: %s\n", string(d))
922 }
923
924 defer func() {
925 log.Println("[TRACE] AutoScaleAPI.Read end")
926 }()
927
928 resultAutoScale, err := t.Internal.Read(ctx, id)
929 targetResults := struct {
930 AutoScale *iaas.AutoScale
931 Error error
932 }{
933 AutoScale: resultAutoScale,
934 Error: err,
935 }
936 if d, err := json.Marshal(targetResults); err == nil {
937 log.Printf("[TRACE] \tresults: %s\n", string(d))
938 }
939
940 return resultAutoScale, err
941 }
942
943 // Update is API call with trace log
944 func (t *AutoScaleTracer) Update(ctx context.Context, id types.ID, param *iaas.AutoScaleUpdateRequest) (*iaas.AutoScale, error) {
945 log.Println("[TRACE] AutoScaleAPI.Update start")
946 targetArguments := struct {
947 Argid types.ID `json:"id"`
948 Argparam *iaas.AutoScaleUpdateRequest `json:"param"`
949 }{
950 Argid: id,
951 Argparam: param,
952 }
953 if d, err := json.Marshal(targetArguments); err == nil {
954 log.Printf("[TRACE] \targs: %s\n", string(d))
955 }
956
957 defer func() {
958 log.Println("[TRACE] AutoScaleAPI.Update end")
959 }()
960
961 resultAutoScale, err := t.Internal.Update(ctx, id, param)
962 targetResults := struct {
963 AutoScale *iaas.AutoScale
964 Error error
965 }{
966 AutoScale: resultAutoScale,
967 Error: err,
968 }
969 if d, err := json.Marshal(targetResults); err == nil {
970 log.Printf("[TRACE] \tresults: %s\n", string(d))
971 }
972
973 return resultAutoScale, err
974 }
975
976 // UpdateSettings is API call with trace log
977 func (t *AutoScaleTracer) UpdateSettings(ctx context.Context, id types.ID, param *iaas.AutoScaleUpdateSettingsRequest) (*iaas.AutoScale, error) {
978 log.Println("[TRACE] AutoScaleAPI.UpdateSettings start")
979 targetArguments := struct {
980 Argid types.ID `json:"id"`
981 Argparam *iaas.AutoScaleUpdateSettingsRequest `json:"param"`
982 }{
983 Argid: id,
984 Argparam: param,
985 }
986 if d, err := json.Marshal(targetArguments); err == nil {
987 log.Printf("[TRACE] \targs: %s\n", string(d))
988 }
989
990 defer func() {
991 log.Println("[TRACE] AutoScaleAPI.UpdateSettings end")
992 }()
993
994 resultAutoScale, err := t.Internal.UpdateSettings(ctx, id, param)
995 targetResults := struct {
996 AutoScale *iaas.AutoScale
997 Error error
998 }{
999 AutoScale: resultAutoScale,
1000 Error: err,
1001 }
1002 if d, err := json.Marshal(targetResults); err == nil {
1003 log.Printf("[TRACE] \tresults: %s\n", string(d))
1004 }
1005
1006 return resultAutoScale, err
1007 }
1008
1009 // Delete is API call with trace log
1010 func (t *AutoScaleTracer) Delete(ctx context.Context, id types.ID) error {
1011 log.Println("[TRACE] AutoScaleAPI.Delete start")
1012 targetArguments := struct {
1013 Argid types.ID `json:"id"`
1014 }{
1015 Argid: id,
1016 }
1017 if d, err := json.Marshal(targetArguments); err == nil {
1018 log.Printf("[TRACE] \targs: %s\n", string(d))
1019 }
1020
1021 defer func() {
1022 log.Println("[TRACE] AutoScaleAPI.Delete end")
1023 }()
1024
1025 err := t.Internal.Delete(ctx, id)
1026 targetResults := struct {
1027 Error error
1028 }{
1029 Error: err,
1030 }
1031 if d, err := json.Marshal(targetResults); err == nil {
1032 log.Printf("[TRACE] \tresults: %s\n", string(d))
1033 }
1034
1035 return err
1036 }
1037
1038 // Status is API call with trace log
1039 func (t *AutoScaleTracer) Status(ctx context.Context, id types.ID) (*iaas.AutoScaleStatus, error) {
1040 log.Println("[TRACE] AutoScaleAPI.Status start")
1041 targetArguments := struct {
1042 Argid types.ID `json:"id"`
1043 }{
1044 Argid: id,
1045 }
1046 if d, err := json.Marshal(targetArguments); err == nil {
1047 log.Printf("[TRACE] \targs: %s\n", string(d))
1048 }
1049
1050 defer func() {
1051 log.Println("[TRACE] AutoScaleAPI.Status end")
1052 }()
1053
1054 resultAutoScaleStatus, err := t.Internal.Status(ctx, id)
1055 targetResults := struct {
1056 AutoScaleStatus *iaas.AutoScaleStatus
1057 Error error
1058 }{
1059 AutoScaleStatus: resultAutoScaleStatus,
1060 Error: err,
1061 }
1062 if d, err := json.Marshal(targetResults); err == nil {
1063 log.Printf("[TRACE] \tresults: %s\n", string(d))
1064 }
1065
1066 return resultAutoScaleStatus, err
1067 }
1068
1069 // ScaleUp is API call with trace log
1070 func (t *AutoScaleTracer) ScaleUp(ctx context.Context, id types.ID) error {
1071 log.Println("[TRACE] AutoScaleAPI.ScaleUp start")
1072 targetArguments := struct {
1073 Argid types.ID `json:"id"`
1074 }{
1075 Argid: id,
1076 }
1077 if d, err := json.Marshal(targetArguments); err == nil {
1078 log.Printf("[TRACE] \targs: %s\n", string(d))
1079 }
1080
1081 defer func() {
1082 log.Println("[TRACE] AutoScaleAPI.ScaleUp end")
1083 }()
1084
1085 err := t.Internal.ScaleUp(ctx, id)
1086 targetResults := struct {
1087 Error error
1088 }{
1089 Error: err,
1090 }
1091 if d, err := json.Marshal(targetResults); err == nil {
1092 log.Printf("[TRACE] \tresults: %s\n", string(d))
1093 }
1094
1095 return err
1096 }
1097
1098 // ScaleDown is API call with trace log
1099 func (t *AutoScaleTracer) ScaleDown(ctx context.Context, id types.ID) error {
1100 log.Println("[TRACE] AutoScaleAPI.ScaleDown start")
1101 targetArguments := struct {
1102 Argid types.ID `json:"id"`
1103 }{
1104 Argid: id,
1105 }
1106 if d, err := json.Marshal(targetArguments); err == nil {
1107 log.Printf("[TRACE] \targs: %s\n", string(d))
1108 }
1109
1110 defer func() {
1111 log.Println("[TRACE] AutoScaleAPI.ScaleDown end")
1112 }()
1113
1114 err := t.Internal.ScaleDown(ctx, id)
1115 targetResults := struct {
1116 Error error
1117 }{
1118 Error: err,
1119 }
1120 if d, err := json.Marshal(targetResults); err == nil {
1121 log.Printf("[TRACE] \tresults: %s\n", string(d))
1122 }
1123
1124 return err
1125 }
1126
1127 /*************************************************
1128 * BillTracer
1129 *************************************************/
1130
1131 // BillTracer is for trace BillOp operations
1132 type BillTracer struct {
1133 Internal iaas.BillAPI
1134 }
1135
1136 // NewBillTracer creates new BillTracer instance
1137 func NewBillTracer(in iaas.BillAPI) iaas.BillAPI {
1138 return &BillTracer{
1139 Internal: in,
1140 }
1141 }
1142
1143 // ByContract is API call with trace log
1144 func (t *BillTracer) ByContract(ctx context.Context, accountID types.ID) (*iaas.BillByContractResult, error) {
1145 log.Println("[TRACE] BillAPI.ByContract start")
1146 targetArguments := struct {
1147 ArgaccountID types.ID `json:"accountID"`
1148 }{
1149 ArgaccountID: accountID,
1150 }
1151 if d, err := json.Marshal(targetArguments); err == nil {
1152 log.Printf("[TRACE] \targs: %s\n", string(d))
1153 }
1154
1155 defer func() {
1156 log.Println("[TRACE] BillAPI.ByContract end")
1157 }()
1158
1159 result, err := t.Internal.ByContract(ctx, accountID)
1160 targetResults := struct {
1161 Result *iaas.BillByContractResult
1162 Error error
1163 }{
1164 Result: result,
1165 Error: err,
1166 }
1167 if d, err := json.Marshal(targetResults); err == nil {
1168 log.Printf("[TRACE] \tresults: %s\n", string(d))
1169 }
1170
1171 return result, err
1172 }
1173
1174 // ByContractYear is API call with trace log
1175 func (t *BillTracer) ByContractYear(ctx context.Context, accountID types.ID, year int) (*iaas.BillByContractYearResult, error) {
1176 log.Println("[TRACE] BillAPI.ByContractYear start")
1177 targetArguments := struct {
1178 ArgaccountID types.ID `json:"accountID"`
1179 Argyear int `json:"year"`
1180 }{
1181 ArgaccountID: accountID,
1182 Argyear: year,
1183 }
1184 if d, err := json.Marshal(targetArguments); err == nil {
1185 log.Printf("[TRACE] \targs: %s\n", string(d))
1186 }
1187
1188 defer func() {
1189 log.Println("[TRACE] BillAPI.ByContractYear end")
1190 }()
1191
1192 result, err := t.Internal.ByContractYear(ctx, accountID, year)
1193 targetResults := struct {
1194 Result *iaas.BillByContractYearResult
1195 Error error
1196 }{
1197 Result: result,
1198 Error: err,
1199 }
1200 if d, err := json.Marshal(targetResults); err == nil {
1201 log.Printf("[TRACE] \tresults: %s\n", string(d))
1202 }
1203
1204 return result, err
1205 }
1206
1207 // ByContractYearMonth is API call with trace log
1208 func (t *BillTracer) ByContractYearMonth(ctx context.Context, accountID types.ID, year int, month int) (*iaas.BillByContractYearMonthResult, error) {
1209 log.Println("[TRACE] BillAPI.ByContractYearMonth start")
1210 targetArguments := struct {
1211 ArgaccountID types.ID `json:"accountID"`
1212 Argyear int `json:"year"`
1213 Argmonth int `json:"month"`
1214 }{
1215 ArgaccountID: accountID,
1216 Argyear: year,
1217 Argmonth: month,
1218 }
1219 if d, err := json.Marshal(targetArguments); err == nil {
1220 log.Printf("[TRACE] \targs: %s\n", string(d))
1221 }
1222
1223 defer func() {
1224 log.Println("[TRACE] BillAPI.ByContractYearMonth end")
1225 }()
1226
1227 result, err := t.Internal.ByContractYearMonth(ctx, accountID, year, month)
1228 targetResults := struct {
1229 Result *iaas.BillByContractYearMonthResult
1230 Error error
1231 }{
1232 Result: result,
1233 Error: err,
1234 }
1235 if d, err := json.Marshal(targetResults); err == nil {
1236 log.Printf("[TRACE] \tresults: %s\n", string(d))
1237 }
1238
1239 return result, err
1240 }
1241
1242 // Read is API call with trace log
1243 func (t *BillTracer) Read(ctx context.Context, id types.ID) (*iaas.BillReadResult, error) {
1244 log.Println("[TRACE] BillAPI.Read start")
1245 targetArguments := struct {
1246 Argid types.ID `json:"id"`
1247 }{
1248 Argid: id,
1249 }
1250 if d, err := json.Marshal(targetArguments); err == nil {
1251 log.Printf("[TRACE] \targs: %s\n", string(d))
1252 }
1253
1254 defer func() {
1255 log.Println("[TRACE] BillAPI.Read end")
1256 }()
1257
1258 result, err := t.Internal.Read(ctx, id)
1259 targetResults := struct {
1260 Result *iaas.BillReadResult
1261 Error error
1262 }{
1263 Result: result,
1264 Error: err,
1265 }
1266 if d, err := json.Marshal(targetResults); err == nil {
1267 log.Printf("[TRACE] \tresults: %s\n", string(d))
1268 }
1269
1270 return result, err
1271 }
1272
1273 // Details is API call with trace log
1274 func (t *BillTracer) Details(ctx context.Context, MemberCode string, id types.ID) (*iaas.BillDetailsResult, error) {
1275 log.Println("[TRACE] BillAPI.Details start")
1276 targetArguments := struct {
1277 ArgMemberCode string `json:"MemberCode"`
1278 Argid types.ID `json:"id"`
1279 }{
1280 ArgMemberCode: MemberCode,
1281 Argid: id,
1282 }
1283 if d, err := json.Marshal(targetArguments); err == nil {
1284 log.Printf("[TRACE] \targs: %s\n", string(d))
1285 }
1286
1287 defer func() {
1288 log.Println("[TRACE] BillAPI.Details end")
1289 }()
1290
1291 result, err := t.Internal.Details(ctx, MemberCode, id)
1292 targetResults := struct {
1293 Result *iaas.BillDetailsResult
1294 Error error
1295 }{
1296 Result: result,
1297 Error: err,
1298 }
1299 if d, err := json.Marshal(targetResults); err == nil {
1300 log.Printf("[TRACE] \tresults: %s\n", string(d))
1301 }
1302
1303 return result, err
1304 }
1305
1306 // DetailsCSV is API call with trace log
1307 func (t *BillTracer) DetailsCSV(ctx context.Context, MemberCode string, id types.ID) (*iaas.BillDetailCSV, error) {
1308 log.Println("[TRACE] BillAPI.DetailsCSV start")
1309 targetArguments := struct {
1310 ArgMemberCode string `json:"MemberCode"`
1311 Argid types.ID `json:"id"`
1312 }{
1313 ArgMemberCode: MemberCode,
1314 Argid: id,
1315 }
1316 if d, err := json.Marshal(targetArguments); err == nil {
1317 log.Printf("[TRACE] \targs: %s\n", string(d))
1318 }
1319
1320 defer func() {
1321 log.Println("[TRACE] BillAPI.DetailsCSV end")
1322 }()
1323
1324 resultBillDetailCSV, err := t.Internal.DetailsCSV(ctx, MemberCode, id)
1325 targetResults := struct {
1326 BillDetailCSV *iaas.BillDetailCSV
1327 Error error
1328 }{
1329 BillDetailCSV: resultBillDetailCSV,
1330 Error: err,
1331 }
1332 if d, err := json.Marshal(targetResults); err == nil {
1333 log.Printf("[TRACE] \tresults: %s\n", string(d))
1334 }
1335
1336 return resultBillDetailCSV, err
1337 }
1338
1339 /*************************************************
1340 * BridgeTracer
1341 *************************************************/
1342
1343 // BridgeTracer is for trace BridgeOp operations
1344 type BridgeTracer struct {
1345 Internal iaas.BridgeAPI
1346 }
1347
1348 // NewBridgeTracer creates new BridgeTracer instance
1349 func NewBridgeTracer(in iaas.BridgeAPI) iaas.BridgeAPI {
1350 return &BridgeTracer{
1351 Internal: in,
1352 }
1353 }
1354
1355 // Find is API call with trace log
1356 func (t *BridgeTracer) Find(ctx context.Context, zone string, conditions *iaas.FindCondition) (*iaas.BridgeFindResult, error) {
1357 log.Println("[TRACE] BridgeAPI.Find start")
1358 targetArguments := struct {
1359 Argzone string
1360 Argconditions *iaas.FindCondition `json:"conditions"`
1361 }{
1362 Argzone: zone,
1363 Argconditions: conditions,
1364 }
1365 if d, err := json.Marshal(targetArguments); err == nil {
1366 log.Printf("[TRACE] \targs: %s\n", string(d))
1367 }
1368
1369 defer func() {
1370 log.Println("[TRACE] BridgeAPI.Find end")
1371 }()
1372
1373 result, err := t.Internal.Find(ctx, zone, conditions)
1374 targetResults := struct {
1375 Result *iaas.BridgeFindResult
1376 Error error
1377 }{
1378 Result: result,
1379 Error: err,
1380 }
1381 if d, err := json.Marshal(targetResults); err == nil {
1382 log.Printf("[TRACE] \tresults: %s\n", string(d))
1383 }
1384
1385 return result, err
1386 }
1387
1388 // Create is API call with trace log
1389 func (t *BridgeTracer) Create(ctx context.Context, zone string, param *iaas.BridgeCreateRequest) (*iaas.Bridge, error) {
1390 log.Println("[TRACE] BridgeAPI.Create start")
1391 targetArguments := struct {
1392 Argzone string
1393 Argparam *iaas.BridgeCreateRequest `json:"param"`
1394 }{
1395 Argzone: zone,
1396 Argparam: param,
1397 }
1398 if d, err := json.Marshal(targetArguments); err == nil {
1399 log.Printf("[TRACE] \targs: %s\n", string(d))
1400 }
1401
1402 defer func() {
1403 log.Println("[TRACE] BridgeAPI.Create end")
1404 }()
1405
1406 resultBridge, err := t.Internal.Create(ctx, zone, param)
1407 targetResults := struct {
1408 Bridge *iaas.Bridge
1409 Error error
1410 }{
1411 Bridge: resultBridge,
1412 Error: err,
1413 }
1414 if d, err := json.Marshal(targetResults); err == nil {
1415 log.Printf("[TRACE] \tresults: %s\n", string(d))
1416 }
1417
1418 return resultBridge, err
1419 }
1420
1421 // Read is API call with trace log
1422 func (t *BridgeTracer) Read(ctx context.Context, zone string, id types.ID) (*iaas.Bridge, error) {
1423 log.Println("[TRACE] BridgeAPI.Read start")
1424 targetArguments := struct {
1425 Argzone string
1426 Argid types.ID `json:"id"`
1427 }{
1428 Argzone: zone,
1429 Argid: id,
1430 }
1431 if d, err := json.Marshal(targetArguments); err == nil {
1432 log.Printf("[TRACE] \targs: %s\n", string(d))
1433 }
1434
1435 defer func() {
1436 log.Println("[TRACE] BridgeAPI.Read end")
1437 }()
1438
1439 resultBridge, err := t.Internal.Read(ctx, zone, id)
1440 targetResults := struct {
1441 Bridge *iaas.Bridge
1442 Error error
1443 }{
1444 Bridge: resultBridge,
1445 Error: err,
1446 }
1447 if d, err := json.Marshal(targetResults); err == nil {
1448 log.Printf("[TRACE] \tresults: %s\n", string(d))
1449 }
1450
1451 return resultBridge, err
1452 }
1453
1454 // Update is API call with trace log
1455 func (t *BridgeTracer) Update(ctx context.Context, zone string, id types.ID, param *iaas.BridgeUpdateRequest) (*iaas.Bridge, error) {
1456 log.Println("[TRACE] BridgeAPI.Update start")
1457 targetArguments := struct {
1458 Argzone string
1459 Argid types.ID `json:"id"`
1460 Argparam *iaas.BridgeUpdateRequest `json:"param"`
1461 }{
1462 Argzone: zone,
1463 Argid: id,
1464 Argparam: param,
1465 }
1466 if d, err := json.Marshal(targetArguments); err == nil {
1467 log.Printf("[TRACE] \targs: %s\n", string(d))
1468 }
1469
1470 defer func() {
1471 log.Println("[TRACE] BridgeAPI.Update end")
1472 }()
1473
1474 resultBridge, err := t.Internal.Update(ctx, zone, id, param)
1475 targetResults := struct {
1476 Bridge *iaas.Bridge
1477 Error error
1478 }{
1479 Bridge: resultBridge,
1480 Error: err,
1481 }
1482 if d, err := json.Marshal(targetResults); err == nil {
1483 log.Printf("[TRACE] \tresults: %s\n", string(d))
1484 }
1485
1486 return resultBridge, err
1487 }
1488
1489 // Delete is API call with trace log
1490 func (t *BridgeTracer) Delete(ctx context.Context, zone string, id types.ID) error {
1491 log.Println("[TRACE] BridgeAPI.Delete start")
1492 targetArguments := struct {
1493 Argzone string
1494 Argid types.ID `json:"id"`
1495 }{
1496 Argzone: zone,
1497 Argid: id,
1498 }
1499 if d, err := json.Marshal(targetArguments); err == nil {
1500 log.Printf("[TRACE] \targs: %s\n", string(d))
1501 }
1502
1503 defer func() {
1504 log.Println("[TRACE] BridgeAPI.Delete end")
1505 }()
1506
1507 err := t.Internal.Delete(ctx, zone, id)
1508 targetResults := struct {
1509 Error error
1510 }{
1511 Error: err,
1512 }
1513 if d, err := json.Marshal(targetResults); err == nil {
1514 log.Printf("[TRACE] \tresults: %s\n", string(d))
1515 }
1516
1517 return err
1518 }
1519
1520 /*************************************************
1521 * CDROMTracer
1522 *************************************************/
1523
1524 // CDROMTracer is for trace CDROMOp operations
1525 type CDROMTracer struct {
1526 Internal iaas.CDROMAPI
1527 }
1528
1529 // NewCDROMTracer creates new CDROMTracer instance
1530 func NewCDROMTracer(in iaas.CDROMAPI) iaas.CDROMAPI {
1531 return &CDROMTracer{
1532 Internal: in,
1533 }
1534 }
1535
1536 // Find is API call with trace log
1537 func (t *CDROMTracer) Find(ctx context.Context, zone string, conditions *iaas.FindCondition) (*iaas.CDROMFindResult, error) {
1538 log.Println("[TRACE] CDROMAPI.Find start")
1539 targetArguments := struct {
1540 Argzone string
1541 Argconditions *iaas.FindCondition `json:"conditions"`
1542 }{
1543 Argzone: zone,
1544 Argconditions: conditions,
1545 }
1546 if d, err := json.Marshal(targetArguments); err == nil {
1547 log.Printf("[TRACE] \targs: %s\n", string(d))
1548 }
1549
1550 defer func() {
1551 log.Println("[TRACE] CDROMAPI.Find end")
1552 }()
1553
1554 result, err := t.Internal.Find(ctx, zone, conditions)
1555 targetResults := struct {
1556 Result *iaas.CDROMFindResult
1557 Error error
1558 }{
1559 Result: result,
1560 Error: err,
1561 }
1562 if d, err := json.Marshal(targetResults); err == nil {
1563 log.Printf("[TRACE] \tresults: %s\n", string(d))
1564 }
1565
1566 return result, err
1567 }
1568
1569 // Create is API call with trace log
1570 func (t *CDROMTracer) Create(ctx context.Context, zone string, param *iaas.CDROMCreateRequest) (*iaas.CDROM, *iaas.FTPServer, error) {
1571 log.Println("[TRACE] CDROMAPI.Create start")
1572 targetArguments := struct {
1573 Argzone string
1574 Argparam *iaas.CDROMCreateRequest `json:"param"`
1575 }{
1576 Argzone: zone,
1577 Argparam: param,
1578 }
1579 if d, err := json.Marshal(targetArguments); err == nil {
1580 log.Printf("[TRACE] \targs: %s\n", string(d))
1581 }
1582
1583 defer func() {
1584 log.Println("[TRACE] CDROMAPI.Create end")
1585 }()
1586
1587 resultCDROM, resultFTPServer, err := t.Internal.Create(ctx, zone, param)
1588 targetResults := struct {
1589 CDROM *iaas.CDROM
1590 FTPServer *iaas.FTPServer
1591 Error error
1592 }{
1593 CDROM: resultCDROM,
1594 FTPServer: resultFTPServer,
1595 Error: err,
1596 }
1597 if d, err := json.Marshal(targetResults); err == nil {
1598 log.Printf("[TRACE] \tresults: %s\n", string(d))
1599 }
1600
1601 return resultCDROM, resultFTPServer, err
1602 }
1603
1604 // Read is API call with trace log
1605 func (t *CDROMTracer) Read(ctx context.Context, zone string, id types.ID) (*iaas.CDROM, error) {
1606 log.Println("[TRACE] CDROMAPI.Read start")
1607 targetArguments := struct {
1608 Argzone string
1609 Argid types.ID `json:"id"`
1610 }{
1611 Argzone: zone,
1612 Argid: id,
1613 }
1614 if d, err := json.Marshal(targetArguments); err == nil {
1615 log.Printf("[TRACE] \targs: %s\n", string(d))
1616 }
1617
1618 defer func() {
1619 log.Println("[TRACE] CDROMAPI.Read end")
1620 }()
1621
1622 resultCDROM, err := t.Internal.Read(ctx, zone, id)
1623 targetResults := struct {
1624 CDROM *iaas.CDROM
1625 Error error
1626 }{
1627 CDROM: resultCDROM,
1628 Error: err,
1629 }
1630 if d, err := json.Marshal(targetResults); err == nil {
1631 log.Printf("[TRACE] \tresults: %s\n", string(d))
1632 }
1633
1634 return resultCDROM, err
1635 }
1636
1637 // Update is API call with trace log
1638 func (t *CDROMTracer) Update(ctx context.Context, zone string, id types.ID, param *iaas.CDROMUpdateRequest) (*iaas.CDROM, error) {
1639 log.Println("[TRACE] CDROMAPI.Update start")
1640 targetArguments := struct {
1641 Argzone string
1642 Argid types.ID `json:"id"`
1643 Argparam *iaas.CDROMUpdateRequest `json:"param"`
1644 }{
1645 Argzone: zone,
1646 Argid: id,
1647 Argparam: param,
1648 }
1649 if d, err := json.Marshal(targetArguments); err == nil {
1650 log.Printf("[TRACE] \targs: %s\n", string(d))
1651 }
1652
1653 defer func() {
1654 log.Println("[TRACE] CDROMAPI.Update end")
1655 }()
1656
1657 resultCDROM, err := t.Internal.Update(ctx, zone, id, param)
1658 targetResults := struct {
1659 CDROM *iaas.CDROM
1660 Error error
1661 }{
1662 CDROM: resultCDROM,
1663 Error: err,
1664 }
1665 if d, err := json.Marshal(targetResults); err == nil {
1666 log.Printf("[TRACE] \tresults: %s\n", string(d))
1667 }
1668
1669 return resultCDROM, err
1670 }
1671
1672 // Delete is API call with trace log
1673 func (t *CDROMTracer) Delete(ctx context.Context, zone string, id types.ID) error {
1674 log.Println("[TRACE] CDROMAPI.Delete start")
1675 targetArguments := struct {
1676 Argzone string
1677 Argid types.ID `json:"id"`
1678 }{
1679 Argzone: zone,
1680 Argid: id,
1681 }
1682 if d, err := json.Marshal(targetArguments); err == nil {
1683 log.Printf("[TRACE] \targs: %s\n", string(d))
1684 }
1685
1686 defer func() {
1687 log.Println("[TRACE] CDROMAPI.Delete end")
1688 }()
1689
1690 err := t.Internal.Delete(ctx, zone, id)
1691 targetResults := struct {
1692 Error error
1693 }{
1694 Error: err,
1695 }
1696 if d, err := json.Marshal(targetResults); err == nil {
1697 log.Printf("[TRACE] \tresults: %s\n", string(d))
1698 }
1699
1700 return err
1701 }
1702
1703 // OpenFTP is API call with trace log
1704 func (t *CDROMTracer) OpenFTP(ctx context.Context, zone string, id types.ID, openOption *iaas.OpenFTPRequest) (*iaas.FTPServer, error) {
1705 log.Println("[TRACE] CDROMAPI.OpenFTP start")
1706 targetArguments := struct {
1707 Argzone string
1708 Argid types.ID `json:"id"`
1709 ArgopenOption *iaas.OpenFTPRequest `json:"openOption"`
1710 }{
1711 Argzone: zone,
1712 Argid: id,
1713 ArgopenOption: openOption,
1714 }
1715 if d, err := json.Marshal(targetArguments); err == nil {
1716 log.Printf("[TRACE] \targs: %s\n", string(d))
1717 }
1718
1719 defer func() {
1720 log.Println("[TRACE] CDROMAPI.OpenFTP end")
1721 }()
1722
1723 resultFTPServer, err := t.Internal.OpenFTP(ctx, zone, id, openOption)
1724 targetResults := struct {
1725 FTPServer *iaas.FTPServer
1726 Error error
1727 }{
1728 FTPServer: resultFTPServer,
1729 Error: err,
1730 }
1731 if d, err := json.Marshal(targetResults); err == nil {
1732 log.Printf("[TRACE] \tresults: %s\n", string(d))
1733 }
1734
1735 return resultFTPServer, err
1736 }
1737
1738 // CloseFTP is API call with trace log
1739 func (t *CDROMTracer) CloseFTP(ctx context.Context, zone string, id types.ID) error {
1740 log.Println("[TRACE] CDROMAPI.CloseFTP start")
1741 targetArguments := struct {
1742 Argzone string
1743 Argid types.ID `json:"id"`
1744 }{
1745 Argzone: zone,
1746 Argid: id,
1747 }
1748 if d, err := json.Marshal(targetArguments); err == nil {
1749 log.Printf("[TRACE] \targs: %s\n", string(d))
1750 }
1751
1752 defer func() {
1753 log.Println("[TRACE] CDROMAPI.CloseFTP end")
1754 }()
1755
1756 err := t.Internal.CloseFTP(ctx, zone, id)
1757 targetResults := struct {
1758 Error error
1759 }{
1760 Error: err,
1761 }
1762 if d, err := json.Marshal(targetResults); err == nil {
1763 log.Printf("[TRACE] \tresults: %s\n", string(d))
1764 }
1765
1766 return err
1767 }
1768
1769 /*************************************************
1770 * CertificateAuthorityTracer
1771 *************************************************/
1772
1773 // CertificateAuthorityTracer is for trace CertificateAuthorityOp operations
1774 type CertificateAuthorityTracer struct {
1775 Internal iaas.CertificateAuthorityAPI
1776 }
1777
1778 // NewCertificateAuthorityTracer creates new CertificateAuthorityTracer instance
1779 func NewCertificateAuthorityTracer(in iaas.CertificateAuthorityAPI) iaas.CertificateAuthorityAPI {
1780 return &CertificateAuthorityTracer{
1781 Internal: in,
1782 }
1783 }
1784
1785 // Find is API call with trace log
1786 func (t *CertificateAuthorityTracer) Find(ctx context.Context, conditions *iaas.FindCondition) (*iaas.CertificateAuthorityFindResult, error) {
1787 log.Println("[TRACE] CertificateAuthorityAPI.Find start")
1788 targetArguments := struct {
1789 Argconditions *iaas.FindCondition `json:"conditions"`
1790 }{
1791 Argconditions: conditions,
1792 }
1793 if d, err := json.Marshal(targetArguments); err == nil {
1794 log.Printf("[TRACE] \targs: %s\n", string(d))
1795 }
1796
1797 defer func() {
1798 log.Println("[TRACE] CertificateAuthorityAPI.Find end")
1799 }()
1800
1801 result, err := t.Internal.Find(ctx, conditions)
1802 targetResults := struct {
1803 Result *iaas.CertificateAuthorityFindResult
1804 Error error
1805 }{
1806 Result: result,
1807 Error: err,
1808 }
1809 if d, err := json.Marshal(targetResults); err == nil {
1810 log.Printf("[TRACE] \tresults: %s\n", string(d))
1811 }
1812
1813 return result, err
1814 }
1815
1816 // Create is API call with trace log
1817 func (t *CertificateAuthorityTracer) Create(ctx context.Context, param *iaas.CertificateAuthorityCreateRequest) (*iaas.CertificateAuthority, error) {
1818 log.Println("[TRACE] CertificateAuthorityAPI.Create start")
1819 targetArguments := struct {
1820 Argparam *iaas.CertificateAuthorityCreateRequest `json:"param"`
1821 }{
1822 Argparam: param,
1823 }
1824 if d, err := json.Marshal(targetArguments); err == nil {
1825 log.Printf("[TRACE] \targs: %s\n", string(d))
1826 }
1827
1828 defer func() {
1829 log.Println("[TRACE] CertificateAuthorityAPI.Create end")
1830 }()
1831
1832 resultCertificateAuthority, err := t.Internal.Create(ctx, param)
1833 targetResults := struct {
1834 CertificateAuthority *iaas.CertificateAuthority
1835 Error error
1836 }{
1837 CertificateAuthority: resultCertificateAuthority,
1838 Error: err,
1839 }
1840 if d, err := json.Marshal(targetResults); err == nil {
1841 log.Printf("[TRACE] \tresults: %s\n", string(d))
1842 }
1843
1844 return resultCertificateAuthority, err
1845 }
1846
1847 // Read is API call with trace log
1848 func (t *CertificateAuthorityTracer) Read(ctx context.Context, id types.ID) (*iaas.CertificateAuthority, error) {
1849 log.Println("[TRACE] CertificateAuthorityAPI.Read start")
1850 targetArguments := struct {
1851 Argid types.ID `json:"id"`
1852 }{
1853 Argid: id,
1854 }
1855 if d, err := json.Marshal(targetArguments); err == nil {
1856 log.Printf("[TRACE] \targs: %s\n", string(d))
1857 }
1858
1859 defer func() {
1860 log.Println("[TRACE] CertificateAuthorityAPI.Read end")
1861 }()
1862
1863 resultCertificateAuthority, err := t.Internal.Read(ctx, id)
1864 targetResults := struct {
1865 CertificateAuthority *iaas.CertificateAuthority
1866 Error error
1867 }{
1868 CertificateAuthority: resultCertificateAuthority,
1869 Error: err,
1870 }
1871 if d, err := json.Marshal(targetResults); err == nil {
1872 log.Printf("[TRACE] \tresults: %s\n", string(d))
1873 }
1874
1875 return resultCertificateAuthority, err
1876 }
1877
1878 // Update is API call with trace log
1879 func (t *CertificateAuthorityTracer) Update(ctx context.Context, id types.ID, param *iaas.CertificateAuthorityUpdateRequest) (*iaas.CertificateAuthority, error) {
1880 log.Println("[TRACE] CertificateAuthorityAPI.Update start")
1881 targetArguments := struct {
1882 Argid types.ID `json:"id"`
1883 Argparam *iaas.CertificateAuthorityUpdateRequest `json:"param"`
1884 }{
1885 Argid: id,
1886 Argparam: param,
1887 }
1888 if d, err := json.Marshal(targetArguments); err == nil {
1889 log.Printf("[TRACE] \targs: %s\n", string(d))
1890 }
1891
1892 defer func() {
1893 log.Println("[TRACE] CertificateAuthorityAPI.Update end")
1894 }()
1895
1896 resultCertificateAuthority, err := t.Internal.Update(ctx, id, param)
1897 targetResults := struct {
1898 CertificateAuthority *iaas.CertificateAuthority
1899 Error error
1900 }{
1901 CertificateAuthority: resultCertificateAuthority,
1902 Error: err,
1903 }
1904 if d, err := json.Marshal(targetResults); err == nil {
1905 log.Printf("[TRACE] \tresults: %s\n", string(d))
1906 }
1907
1908 return resultCertificateAuthority, err
1909 }
1910
1911 // Delete is API call with trace log
1912 func (t *CertificateAuthorityTracer) Delete(ctx context.Context, id types.ID) error {
1913 log.Println("[TRACE] CertificateAuthorityAPI.Delete start")
1914 targetArguments := struct {
1915 Argid types.ID `json:"id"`
1916 }{
1917 Argid: id,
1918 }
1919 if d, err := json.Marshal(targetArguments); err == nil {
1920 log.Printf("[TRACE] \targs: %s\n", string(d))
1921 }
1922
1923 defer func() {
1924 log.Println("[TRACE] CertificateAuthorityAPI.Delete end")
1925 }()
1926
1927 err := t.Internal.Delete(ctx, id)
1928 targetResults := struct {
1929 Error error
1930 }{
1931 Error: err,
1932 }
1933 if d, err := json.Marshal(targetResults); err == nil {
1934 log.Printf("[TRACE] \tresults: %s\n", string(d))
1935 }
1936
1937 return err
1938 }
1939
1940 // Detail is API call with trace log
1941 func (t *CertificateAuthorityTracer) Detail(ctx context.Context, id types.ID) (*iaas.CertificateAuthorityDetail, error) {
1942 log.Println("[TRACE] CertificateAuthorityAPI.Detail start")
1943 targetArguments := struct {
1944 Argid types.ID `json:"id"`
1945 }{
1946 Argid: id,
1947 }
1948 if d, err := json.Marshal(targetArguments); err == nil {
1949 log.Printf("[TRACE] \targs: %s\n", string(d))
1950 }
1951
1952 defer func() {
1953 log.Println("[TRACE] CertificateAuthorityAPI.Detail end")
1954 }()
1955
1956 resultCertificateAuthority, err := t.Internal.Detail(ctx, id)
1957 targetResults := struct {
1958 CertificateAuthority *iaas.CertificateAuthorityDetail
1959 Error error
1960 }{
1961 CertificateAuthority: resultCertificateAuthority,
1962 Error: err,
1963 }
1964 if d, err := json.Marshal(targetResults); err == nil {
1965 log.Printf("[TRACE] \tresults: %s\n", string(d))
1966 }
1967
1968 return resultCertificateAuthority, err
1969 }
1970
1971 // AddClient is API call with trace log
1972 func (t *CertificateAuthorityTracer) AddClient(ctx context.Context, id types.ID, param *iaas.CertificateAuthorityAddClientParam) (*iaas.CertificateAuthorityAddClientOrServerResult, error) {
1973 log.Println("[TRACE] CertificateAuthorityAPI.AddClient start")
1974 targetArguments := struct {
1975 Argid types.ID `json:"id"`
1976 Argparam *iaas.CertificateAuthorityAddClientParam `json:"param"`
1977 }{
1978 Argid: id,
1979 Argparam: param,
1980 }
1981 if d, err := json.Marshal(targetArguments); err == nil {
1982 log.Printf("[TRACE] \targs: %s\n", string(d))
1983 }
1984
1985 defer func() {
1986 log.Println("[TRACE] CertificateAuthorityAPI.AddClient end")
1987 }()
1988
1989 resultCertificateAuthority, err := t.Internal.AddClient(ctx, id, param)
1990 targetResults := struct {
1991 CertificateAuthority *iaas.CertificateAuthorityAddClientOrServerResult
1992 Error error
1993 }{
1994 CertificateAuthority: resultCertificateAuthority,
1995 Error: err,
1996 }
1997 if d, err := json.Marshal(targetResults); err == nil {
1998 log.Printf("[TRACE] \tresults: %s\n", string(d))
1999 }
2000
2001 return resultCertificateAuthority, err
2002 }
2003
2004 // ListClients is API call with trace log
2005 func (t *CertificateAuthorityTracer) ListClients(ctx context.Context, id types.ID) (*iaas.CertificateAuthorityListClientsResult, error) {
2006 log.Println("[TRACE] CertificateAuthorityAPI.ListClients start")
2007 targetArguments := struct {
2008 Argid types.ID `json:"id"`
2009 }{
2010 Argid: id,
2011 }
2012 if d, err := json.Marshal(targetArguments); err == nil {
2013 log.Printf("[TRACE] \targs: %s\n", string(d))
2014 }
2015
2016 defer func() {
2017 log.Println("[TRACE] CertificateAuthorityAPI.ListClients end")
2018 }()
2019
2020 result, err := t.Internal.ListClients(ctx, id)
2021 targetResults := struct {
2022 Result *iaas.CertificateAuthorityListClientsResult
2023 Error error
2024 }{
2025 Result: result,
2026 Error: err,
2027 }
2028 if d, err := json.Marshal(targetResults); err == nil {
2029 log.Printf("[TRACE] \tresults: %s\n", string(d))
2030 }
2031
2032 return result, err
2033 }
2034
2035 // ReadClient is API call with trace log
2036 func (t *CertificateAuthorityTracer) ReadClient(ctx context.Context, id types.ID, clientID string) (*iaas.CertificateAuthorityClient, error) {
2037 log.Println("[TRACE] CertificateAuthorityAPI.ReadClient start")
2038 targetArguments := struct {
2039 Argid types.ID `json:"id"`
2040 ArgclientID string `json:"clientID"`
2041 }{
2042 Argid: id,
2043 ArgclientID: clientID,
2044 }
2045 if d, err := json.Marshal(targetArguments); err == nil {
2046 log.Printf("[TRACE] \targs: %s\n", string(d))
2047 }
2048
2049 defer func() {
2050 log.Println("[TRACE] CertificateAuthorityAPI.ReadClient end")
2051 }()
2052
2053 resultCertificateAuthority, err := t.Internal.ReadClient(ctx, id, clientID)
2054 targetResults := struct {
2055 CertificateAuthority *iaas.CertificateAuthorityClient
2056 Error error
2057 }{
2058 CertificateAuthority: resultCertificateAuthority,
2059 Error: err,
2060 }
2061 if d, err := json.Marshal(targetResults); err == nil {
2062 log.Printf("[TRACE] \tresults: %s\n", string(d))
2063 }
2064
2065 return resultCertificateAuthority, err
2066 }
2067
2068 // RevokeClient is API call with trace log
2069 func (t *CertificateAuthorityTracer) RevokeClient(ctx context.Context, id types.ID, clientID string) error {
2070 log.Println("[TRACE] CertificateAuthorityAPI.RevokeClient start")
2071 targetArguments := struct {
2072 Argid types.ID `json:"id"`
2073 ArgclientID string `json:"clientID"`
2074 }{
2075 Argid: id,
2076 ArgclientID: clientID,
2077 }
2078 if d, err := json.Marshal(targetArguments); err == nil {
2079 log.Printf("[TRACE] \targs: %s\n", string(d))
2080 }
2081
2082 defer func() {
2083 log.Println("[TRACE] CertificateAuthorityAPI.RevokeClient end")
2084 }()
2085
2086 err := t.Internal.RevokeClient(ctx, id, clientID)
2087 targetResults := struct {
2088 Error error
2089 }{
2090 Error: err,
2091 }
2092 if d, err := json.Marshal(targetResults); err == nil {
2093 log.Printf("[TRACE] \tresults: %s\n", string(d))
2094 }
2095
2096 return err
2097 }
2098
2099 // HoldClient is API call with trace log
2100 func (t *CertificateAuthorityTracer) HoldClient(ctx context.Context, id types.ID, clientID string) error {
2101 log.Println("[TRACE] CertificateAuthorityAPI.HoldClient start")
2102 targetArguments := struct {
2103 Argid types.ID `json:"id"`
2104 ArgclientID string `json:"clientID"`
2105 }{
2106 Argid: id,
2107 ArgclientID: clientID,
2108 }
2109 if d, err := json.Marshal(targetArguments); err == nil {
2110 log.Printf("[TRACE] \targs: %s\n", string(d))
2111 }
2112
2113 defer func() {
2114 log.Println("[TRACE] CertificateAuthorityAPI.HoldClient end")
2115 }()
2116
2117 err := t.Internal.HoldClient(ctx, id, clientID)
2118 targetResults := struct {
2119 Error error
2120 }{
2121 Error: err,
2122 }
2123 if d, err := json.Marshal(targetResults); err == nil {
2124 log.Printf("[TRACE] \tresults: %s\n", string(d))
2125 }
2126
2127 return err
2128 }
2129
2130 // ResumeClient is API call with trace log
2131 func (t *CertificateAuthorityTracer) ResumeClient(ctx context.Context, id types.ID, clientID string) error {
2132 log.Println("[TRACE] CertificateAuthorityAPI.ResumeClient start")
2133 targetArguments := struct {
2134 Argid types.ID `json:"id"`
2135 ArgclientID string `json:"clientID"`
2136 }{
2137 Argid: id,
2138 ArgclientID: clientID,
2139 }
2140 if d, err := json.Marshal(targetArguments); err == nil {
2141 log.Printf("[TRACE] \targs: %s\n", string(d))
2142 }
2143
2144 defer func() {
2145 log.Println("[TRACE] CertificateAuthorityAPI.ResumeClient end")
2146 }()
2147
2148 err := t.Internal.ResumeClient(ctx, id, clientID)
2149 targetResults := struct {
2150 Error error
2151 }{
2152 Error: err,
2153 }
2154 if d, err := json.Marshal(targetResults); err == nil {
2155 log.Printf("[TRACE] \tresults: %s\n", string(d))
2156 }
2157
2158 return err
2159 }
2160
2161 // DenyClient is API call with trace log
2162 func (t *CertificateAuthorityTracer) DenyClient(ctx context.Context, id types.ID, clientID string) error {
2163 log.Println("[TRACE] CertificateAuthorityAPI.DenyClient start")
2164 targetArguments := struct {
2165 Argid types.ID `json:"id"`
2166 ArgclientID string `json:"clientID"`
2167 }{
2168 Argid: id,
2169 ArgclientID: clientID,
2170 }
2171 if d, err := json.Marshal(targetArguments); err == nil {
2172 log.Printf("[TRACE] \targs: %s\n", string(d))
2173 }
2174
2175 defer func() {
2176 log.Println("[TRACE] CertificateAuthorityAPI.DenyClient end")
2177 }()
2178
2179 err := t.Internal.DenyClient(ctx, id, clientID)
2180 targetResults := struct {
2181 Error error
2182 }{
2183 Error: err,
2184 }
2185 if d, err := json.Marshal(targetResults); err == nil {
2186 log.Printf("[TRACE] \tresults: %s\n", string(d))
2187 }
2188
2189 return err
2190 }
2191
2192 // AddServer is API call with trace log
2193 func (t *CertificateAuthorityTracer) AddServer(ctx context.Context, id types.ID, param *iaas.CertificateAuthorityAddServerParam) (*iaas.CertificateAuthorityAddClientOrServerResult, error) {
2194 log.Println("[TRACE] CertificateAuthorityAPI.AddServer start")
2195 targetArguments := struct {
2196 Argid types.ID `json:"id"`
2197 Argparam *iaas.CertificateAuthorityAddServerParam `json:"param"`
2198 }{
2199 Argid: id,
2200 Argparam: param,
2201 }
2202 if d, err := json.Marshal(targetArguments); err == nil {
2203 log.Printf("[TRACE] \targs: %s\n", string(d))
2204 }
2205
2206 defer func() {
2207 log.Println("[TRACE] CertificateAuthorityAPI.AddServer end")
2208 }()
2209
2210 resultCertificateAuthority, err := t.Internal.AddServer(ctx, id, param)
2211 targetResults := struct {
2212 CertificateAuthority *iaas.CertificateAuthorityAddClientOrServerResult
2213 Error error
2214 }{
2215 CertificateAuthority: resultCertificateAuthority,
2216 Error: err,
2217 }
2218 if d, err := json.Marshal(targetResults); err == nil {
2219 log.Printf("[TRACE] \tresults: %s\n", string(d))
2220 }
2221
2222 return resultCertificateAuthority, err
2223 }
2224
2225 // ListServers is API call with trace log
2226 func (t *CertificateAuthorityTracer) ListServers(ctx context.Context, id types.ID) (*iaas.CertificateAuthorityListServersResult, error) {
2227 log.Println("[TRACE] CertificateAuthorityAPI.ListServers start")
2228 targetArguments := struct {
2229 Argid types.ID `json:"id"`
2230 }{
2231 Argid: id,
2232 }
2233 if d, err := json.Marshal(targetArguments); err == nil {
2234 log.Printf("[TRACE] \targs: %s\n", string(d))
2235 }
2236
2237 defer func() {
2238 log.Println("[TRACE] CertificateAuthorityAPI.ListServers end")
2239 }()
2240
2241 result, err := t.Internal.ListServers(ctx, id)
2242 targetResults := struct {
2243 Result *iaas.CertificateAuthorityListServersResult
2244 Error error
2245 }{
2246 Result: result,
2247 Error: err,
2248 }
2249 if d, err := json.Marshal(targetResults); err == nil {
2250 log.Printf("[TRACE] \tresults: %s\n", string(d))
2251 }
2252
2253 return result, err
2254 }
2255
2256 // ReadServer is API call with trace log
2257 func (t *CertificateAuthorityTracer) ReadServer(ctx context.Context, id types.ID, serverID string) (*iaas.CertificateAuthorityServer, error) {
2258 log.Println("[TRACE] CertificateAuthorityAPI.ReadServer start")
2259 targetArguments := struct {
2260 Argid types.ID `json:"id"`
2261 ArgserverID string `json:"serverID"`
2262 }{
2263 Argid: id,
2264 ArgserverID: serverID,
2265 }
2266 if d, err := json.Marshal(targetArguments); err == nil {
2267 log.Printf("[TRACE] \targs: %s\n", string(d))
2268 }
2269
2270 defer func() {
2271 log.Println("[TRACE] CertificateAuthorityAPI.ReadServer end")
2272 }()
2273
2274 resultCertificateAuthority, err := t.Internal.ReadServer(ctx, id, serverID)
2275 targetResults := struct {
2276 CertificateAuthority *iaas.CertificateAuthorityServer
2277 Error error
2278 }{
2279 CertificateAuthority: resultCertificateAuthority,
2280 Error: err,
2281 }
2282 if d, err := json.Marshal(targetResults); err == nil {
2283 log.Printf("[TRACE] \tresults: %s\n", string(d))
2284 }
2285
2286 return resultCertificateAuthority, err
2287 }
2288
2289 // RevokeServer is API call with trace log
2290 func (t *CertificateAuthorityTracer) RevokeServer(ctx context.Context, id types.ID, serverID string) error {
2291 log.Println("[TRACE] CertificateAuthorityAPI.RevokeServer start")
2292 targetArguments := struct {
2293 Argid types.ID `json:"id"`
2294 ArgserverID string `json:"serverID"`
2295 }{
2296 Argid: id,
2297 ArgserverID: serverID,
2298 }
2299 if d, err := json.Marshal(targetArguments); err == nil {
2300 log.Printf("[TRACE] \targs: %s\n", string(d))
2301 }
2302
2303 defer func() {
2304 log.Println("[TRACE] CertificateAuthorityAPI.RevokeServer end")
2305 }()
2306
2307 err := t.Internal.RevokeServer(ctx, id, serverID)
2308 targetResults := struct {
2309 Error error
2310 }{
2311 Error: err,
2312 }
2313 if d, err := json.Marshal(targetResults); err == nil {
2314 log.Printf("[TRACE] \tresults: %s\n", string(d))
2315 }
2316
2317 return err
2318 }
2319
2320 // HoldServer is API call with trace log
2321 func (t *CertificateAuthorityTracer) HoldServer(ctx context.Context, id types.ID, serverID string) error {
2322 log.Println("[TRACE] CertificateAuthorityAPI.HoldServer start")
2323 targetArguments := struct {
2324 Argid types.ID `json:"id"`
2325 ArgserverID string `json:"serverID"`
2326 }{
2327 Argid: id,
2328 ArgserverID: serverID,
2329 }
2330 if d, err := json.Marshal(targetArguments); err == nil {
2331 log.Printf("[TRACE] \targs: %s\n", string(d))
2332 }
2333
2334 defer func() {
2335 log.Println("[TRACE] CertificateAuthorityAPI.HoldServer end")
2336 }()
2337
2338 err := t.Internal.HoldServer(ctx, id, serverID)
2339 targetResults := struct {
2340 Error error
2341 }{
2342 Error: err,
2343 }
2344 if d, err := json.Marshal(targetResults); err == nil {
2345 log.Printf("[TRACE] \tresults: %s\n", string(d))
2346 }
2347
2348 return err
2349 }
2350
2351 // ResumeServer is API call with trace log
2352 func (t *CertificateAuthorityTracer) ResumeServer(ctx context.Context, id types.ID, serverID string) error {
2353 log.Println("[TRACE] CertificateAuthorityAPI.ResumeServer start")
2354 targetArguments := struct {
2355 Argid types.ID `json:"id"`
2356 ArgserverID string `json:"serverID"`
2357 }{
2358 Argid: id,
2359 ArgserverID: serverID,
2360 }
2361 if d, err := json.Marshal(targetArguments); err == nil {
2362 log.Printf("[TRACE] \targs: %s\n", string(d))
2363 }
2364
2365 defer func() {
2366 log.Println("[TRACE] CertificateAuthorityAPI.ResumeServer end")
2367 }()
2368
2369 err := t.Internal.ResumeServer(ctx, id, serverID)
2370 targetResults := struct {
2371 Error error
2372 }{
2373 Error: err,
2374 }
2375 if d, err := json.Marshal(targetResults); err == nil {
2376 log.Printf("[TRACE] \tresults: %s\n", string(d))
2377 }
2378
2379 return err
2380 }
2381
2382 /*************************************************
2383 * ContainerRegistryTracer
2384 *************************************************/
2385
2386 // ContainerRegistryTracer is for trace ContainerRegistryOp operations
2387 type ContainerRegistryTracer struct {
2388 Internal iaas.ContainerRegistryAPI
2389 }
2390
2391 // NewContainerRegistryTracer creates new ContainerRegistryTracer instance
2392 func NewContainerRegistryTracer(in iaas.ContainerRegistryAPI) iaas.ContainerRegistryAPI {
2393 return &ContainerRegistryTracer{
2394 Internal: in,
2395 }
2396 }
2397
2398 // Find is API call with trace log
2399 func (t *ContainerRegistryTracer) Find(ctx context.Context, conditions *iaas.FindCondition) (*iaas.ContainerRegistryFindResult, error) {
2400 log.Println("[TRACE] ContainerRegistryAPI.Find start")
2401 targetArguments := struct {
2402 Argconditions *iaas.FindCondition `json:"conditions"`
2403 }{
2404 Argconditions: conditions,
2405 }
2406 if d, err := json.Marshal(targetArguments); err == nil {
2407 log.Printf("[TRACE] \targs: %s\n", string(d))
2408 }
2409
2410 defer func() {
2411 log.Println("[TRACE] ContainerRegistryAPI.Find end")
2412 }()
2413
2414 result, err := t.Internal.Find(ctx, conditions)
2415 targetResults := struct {
2416 Result *iaas.ContainerRegistryFindResult
2417 Error error
2418 }{
2419 Result: result,
2420 Error: err,
2421 }
2422 if d, err := json.Marshal(targetResults); err == nil {
2423 log.Printf("[TRACE] \tresults: %s\n", string(d))
2424 }
2425
2426 return result, err
2427 }
2428
2429 // Create is API call with trace log
2430 func (t *ContainerRegistryTracer) Create(ctx context.Context, param *iaas.ContainerRegistryCreateRequest) (*iaas.ContainerRegistry, error) {
2431 log.Println("[TRACE] ContainerRegistryAPI.Create start")
2432 targetArguments := struct {
2433 Argparam *iaas.ContainerRegistryCreateRequest `json:"param"`
2434 }{
2435 Argparam: param,
2436 }
2437 if d, err := json.Marshal(targetArguments); err == nil {
2438 log.Printf("[TRACE] \targs: %s\n", string(d))
2439 }
2440
2441 defer func() {
2442 log.Println("[TRACE] ContainerRegistryAPI.Create end")
2443 }()
2444
2445 resultContainerRegistry, err := t.Internal.Create(ctx, param)
2446 targetResults := struct {
2447 ContainerRegistry *iaas.ContainerRegistry
2448 Error error
2449 }{
2450 ContainerRegistry: resultContainerRegistry,
2451 Error: err,
2452 }
2453 if d, err := json.Marshal(targetResults); err == nil {
2454 log.Printf("[TRACE] \tresults: %s\n", string(d))
2455 }
2456
2457 return resultContainerRegistry, err
2458 }
2459
2460 // Read is API call with trace log
2461 func (t *ContainerRegistryTracer) Read(ctx context.Context, id types.ID) (*iaas.ContainerRegistry, error) {
2462 log.Println("[TRACE] ContainerRegistryAPI.Read start")
2463 targetArguments := struct {
2464 Argid types.ID `json:"id"`
2465 }{
2466 Argid: id,
2467 }
2468 if d, err := json.Marshal(targetArguments); err == nil {
2469 log.Printf("[TRACE] \targs: %s\n", string(d))
2470 }
2471
2472 defer func() {
2473 log.Println("[TRACE] ContainerRegistryAPI.Read end")
2474 }()
2475
2476 resultContainerRegistry, err := t.Internal.Read(ctx, id)
2477 targetResults := struct {
2478 ContainerRegistry *iaas.ContainerRegistry
2479 Error error
2480 }{
2481 ContainerRegistry: resultContainerRegistry,
2482 Error: err,
2483 }
2484 if d, err := json.Marshal(targetResults); err == nil {
2485 log.Printf("[TRACE] \tresults: %s\n", string(d))
2486 }
2487
2488 return resultContainerRegistry, err
2489 }
2490
2491 // Update is API call with trace log
2492 func (t *ContainerRegistryTracer) Update(ctx context.Context, id types.ID, param *iaas.ContainerRegistryUpdateRequest) (*iaas.ContainerRegistry, error) {
2493 log.Println("[TRACE] ContainerRegistryAPI.Update start")
2494 targetArguments := struct {
2495 Argid types.ID `json:"id"`
2496 Argparam *iaas.ContainerRegistryUpdateRequest `json:"param"`
2497 }{
2498 Argid: id,
2499 Argparam: param,
2500 }
2501 if d, err := json.Marshal(targetArguments); err == nil {
2502 log.Printf("[TRACE] \targs: %s\n", string(d))
2503 }
2504
2505 defer func() {
2506 log.Println("[TRACE] ContainerRegistryAPI.Update end")
2507 }()
2508
2509 resultContainerRegistry, err := t.Internal.Update(ctx, id, param)
2510 targetResults := struct {
2511 ContainerRegistry *iaas.ContainerRegistry
2512 Error error
2513 }{
2514 ContainerRegistry: resultContainerRegistry,
2515 Error: err,
2516 }
2517 if d, err := json.Marshal(targetResults); err == nil {
2518 log.Printf("[TRACE] \tresults: %s\n", string(d))
2519 }
2520
2521 return resultContainerRegistry, err
2522 }
2523
2524 // UpdateSettings is API call with trace log
2525 func (t *ContainerRegistryTracer) UpdateSettings(ctx context.Context, id types.ID, param *iaas.ContainerRegistryUpdateSettingsRequest) (*iaas.ContainerRegistry, error) {
2526 log.Println("[TRACE] ContainerRegistryAPI.UpdateSettings start")
2527 targetArguments := struct {
2528 Argid types.ID `json:"id"`
2529 Argparam *iaas.ContainerRegistryUpdateSettingsRequest `json:"param"`
2530 }{
2531 Argid: id,
2532 Argparam: param,
2533 }
2534 if d, err := json.Marshal(targetArguments); err == nil {
2535 log.Printf("[TRACE] \targs: %s\n", string(d))
2536 }
2537
2538 defer func() {
2539 log.Println("[TRACE] ContainerRegistryAPI.UpdateSettings end")
2540 }()
2541
2542 resultContainerRegistry, err := t.Internal.UpdateSettings(ctx, id, param)
2543 targetResults := struct {
2544 ContainerRegistry *iaas.ContainerRegistry
2545 Error error
2546 }{
2547 ContainerRegistry: resultContainerRegistry,
2548 Error: err,
2549 }
2550 if d, err := json.Marshal(targetResults); err == nil {
2551 log.Printf("[TRACE] \tresults: %s\n", string(d))
2552 }
2553
2554 return resultContainerRegistry, err
2555 }
2556
2557 // Delete is API call with trace log
2558 func (t *ContainerRegistryTracer) Delete(ctx context.Context, id types.ID) error {
2559 log.Println("[TRACE] ContainerRegistryAPI.Delete start")
2560 targetArguments := struct {
2561 Argid types.ID `json:"id"`
2562 }{
2563 Argid: id,
2564 }
2565 if d, err := json.Marshal(targetArguments); err == nil {
2566 log.Printf("[TRACE] \targs: %s\n", string(d))
2567 }
2568
2569 defer func() {
2570 log.Println("[TRACE] ContainerRegistryAPI.Delete end")
2571 }()
2572
2573 err := t.Internal.Delete(ctx, id)
2574 targetResults := struct {
2575 Error error
2576 }{
2577 Error: err,
2578 }
2579 if d, err := json.Marshal(targetResults); err == nil {
2580 log.Printf("[TRACE] \tresults: %s\n", string(d))
2581 }
2582
2583 return err
2584 }
2585
2586 // ListUsers is API call with trace log
2587 func (t *ContainerRegistryTracer) ListUsers(ctx context.Context, id types.ID) (*iaas.ContainerRegistryUsers, error) {
2588 log.Println("[TRACE] ContainerRegistryAPI.ListUsers start")
2589 targetArguments := struct {
2590 Argid types.ID `json:"id"`
2591 }{
2592 Argid: id,
2593 }
2594 if d, err := json.Marshal(targetArguments); err == nil {
2595 log.Printf("[TRACE] \targs: %s\n", string(d))
2596 }
2597
2598 defer func() {
2599 log.Println("[TRACE] ContainerRegistryAPI.ListUsers end")
2600 }()
2601
2602 resultContainerRegistryUsers, err := t.Internal.ListUsers(ctx, id)
2603 targetResults := struct {
2604 ContainerRegistryUsers *iaas.ContainerRegistryUsers
2605 Error error
2606 }{
2607 ContainerRegistryUsers: resultContainerRegistryUsers,
2608 Error: err,
2609 }
2610 if d, err := json.Marshal(targetResults); err == nil {
2611 log.Printf("[TRACE] \tresults: %s\n", string(d))
2612 }
2613
2614 return resultContainerRegistryUsers, err
2615 }
2616
2617 // AddUser is API call with trace log
2618 func (t *ContainerRegistryTracer) AddUser(ctx context.Context, id types.ID, param *iaas.ContainerRegistryUserCreateRequest) error {
2619 log.Println("[TRACE] ContainerRegistryAPI.AddUser start")
2620 targetArguments := struct {
2621 Argid types.ID `json:"id"`
2622 Argparam *iaas.ContainerRegistryUserCreateRequest `json:"param"`
2623 }{
2624 Argid: id,
2625 Argparam: param,
2626 }
2627 if d, err := json.Marshal(targetArguments); err == nil {
2628 log.Printf("[TRACE] \targs: %s\n", string(d))
2629 }
2630
2631 defer func() {
2632 log.Println("[TRACE] ContainerRegistryAPI.AddUser end")
2633 }()
2634
2635 err := t.Internal.AddUser(ctx, id, param)
2636 targetResults := struct {
2637 Error error
2638 }{
2639 Error: err,
2640 }
2641 if d, err := json.Marshal(targetResults); err == nil {
2642 log.Printf("[TRACE] \tresults: %s\n", string(d))
2643 }
2644
2645 return err
2646 }
2647
2648 // UpdateUser is API call with trace log
2649 func (t *ContainerRegistryTracer) UpdateUser(ctx context.Context, id types.ID, username string, param *iaas.ContainerRegistryUserUpdateRequest) error {
2650 log.Println("[TRACE] ContainerRegistryAPI.UpdateUser start")
2651 targetArguments := struct {
2652 Argid types.ID `json:"id"`
2653 Argusername string `json:"username"`
2654 Argparam *iaas.ContainerRegistryUserUpdateRequest `json:"param"`
2655 }{
2656 Argid: id,
2657 Argusername: username,
2658 Argparam: param,
2659 }
2660 if d, err := json.Marshal(targetArguments); err == nil {
2661 log.Printf("[TRACE] \targs: %s\n", string(d))
2662 }
2663
2664 defer func() {
2665 log.Println("[TRACE] ContainerRegistryAPI.UpdateUser end")
2666 }()
2667
2668 err := t.Internal.UpdateUser(ctx, id, username, param)
2669 targetResults := struct {
2670 Error error
2671 }{
2672 Error: err,
2673 }
2674 if d, err := json.Marshal(targetResults); err == nil {
2675 log.Printf("[TRACE] \tresults: %s\n", string(d))
2676 }
2677
2678 return err
2679 }
2680
2681 // DeleteUser is API call with trace log
2682 func (t *ContainerRegistryTracer) DeleteUser(ctx context.Context, id types.ID, username string) error {
2683 log.Println("[TRACE] ContainerRegistryAPI.DeleteUser start")
2684 targetArguments := struct {
2685 Argid types.ID `json:"id"`
2686 Argusername string `json:"username"`
2687 }{
2688 Argid: id,
2689 Argusername: username,
2690 }
2691 if d, err := json.Marshal(targetArguments); err == nil {
2692 log.Printf("[TRACE] \targs: %s\n", string(d))
2693 }
2694
2695 defer func() {
2696 log.Println("[TRACE] ContainerRegistryAPI.DeleteUser end")
2697 }()
2698
2699 err := t.Internal.DeleteUser(ctx, id, username)
2700 targetResults := struct {
2701 Error error
2702 }{
2703 Error: err,
2704 }
2705 if d, err := json.Marshal(targetResults); err == nil {
2706 log.Printf("[TRACE] \tresults: %s\n", string(d))
2707 }
2708
2709 return err
2710 }
2711
2712 /*************************************************
2713 * CouponTracer
2714 *************************************************/
2715
2716 // CouponTracer is for trace CouponOp operations
2717 type CouponTracer struct {
2718 Internal iaas.CouponAPI
2719 }
2720
2721 // NewCouponTracer creates new CouponTracer instance
2722 func NewCouponTracer(in iaas.CouponAPI) iaas.CouponAPI {
2723 return &CouponTracer{
2724 Internal: in,
2725 }
2726 }
2727
2728 // Find is API call with trace log
2729 func (t *CouponTracer) Find(ctx context.Context, accountID types.ID) (*iaas.CouponFindResult, error) {
2730 log.Println("[TRACE] CouponAPI.Find start")
2731 targetArguments := struct {
2732 ArgaccountID types.ID `json:"accountID"`
2733 }{
2734 ArgaccountID: accountID,
2735 }
2736 if d, err := json.Marshal(targetArguments); err == nil {
2737 log.Printf("[TRACE] \targs: %s\n", string(d))
2738 }
2739
2740 defer func() {
2741 log.Println("[TRACE] CouponAPI.Find end")
2742 }()
2743
2744 result, err := t.Internal.Find(ctx, accountID)
2745 targetResults := struct {
2746 Result *iaas.CouponFindResult
2747 Error error
2748 }{
2749 Result: result,
2750 Error: err,
2751 }
2752 if d, err := json.Marshal(targetResults); err == nil {
2753 log.Printf("[TRACE] \tresults: %s\n", string(d))
2754 }
2755
2756 return result, err
2757 }
2758
2759 /*************************************************
2760 * DatabaseTracer
2761 *************************************************/
2762
2763 // DatabaseTracer is for trace DatabaseOp operations
2764 type DatabaseTracer struct {
2765 Internal iaas.DatabaseAPI
2766 }
2767
2768 // NewDatabaseTracer creates new DatabaseTracer instance
2769 func NewDatabaseTracer(in iaas.DatabaseAPI) iaas.DatabaseAPI {
2770 return &DatabaseTracer{
2771 Internal: in,
2772 }
2773 }
2774
2775 // Find is API call with trace log
2776 func (t *DatabaseTracer) Find(ctx context.Context, zone string, conditions *iaas.FindCondition) (*iaas.DatabaseFindResult, error) {
2777 log.Println("[TRACE] DatabaseAPI.Find start")
2778 targetArguments := struct {
2779 Argzone string
2780 Argconditions *iaas.FindCondition `json:"conditions"`
2781 }{
2782 Argzone: zone,
2783 Argconditions: conditions,
2784 }
2785 if d, err := json.Marshal(targetArguments); err == nil {
2786 log.Printf("[TRACE] \targs: %s\n", string(d))
2787 }
2788
2789 defer func() {
2790 log.Println("[TRACE] DatabaseAPI.Find end")
2791 }()
2792
2793 result, err := t.Internal.Find(ctx, zone, conditions)
2794 targetResults := struct {
2795 Result *iaas.DatabaseFindResult
2796 Error error
2797 }{
2798 Result: result,
2799 Error: err,
2800 }
2801 if d, err := json.Marshal(targetResults); err == nil {
2802 log.Printf("[TRACE] \tresults: %s\n", string(d))
2803 }
2804
2805 return result, err
2806 }
2807
2808 // Create is API call with trace log
2809 func (t *DatabaseTracer) Create(ctx context.Context, zone string, param *iaas.DatabaseCreateRequest) (*iaas.Database, error) {
2810 log.Println("[TRACE] DatabaseAPI.Create start")
2811 targetArguments := struct {
2812 Argzone string
2813 Argparam *iaas.DatabaseCreateRequest `json:"param"`
2814 }{
2815 Argzone: zone,
2816 Argparam: param,
2817 }
2818 if d, err := json.Marshal(targetArguments); err == nil {
2819 log.Printf("[TRACE] \targs: %s\n", string(d))
2820 }
2821
2822 defer func() {
2823 log.Println("[TRACE] DatabaseAPI.Create end")
2824 }()
2825
2826 resultDatabase, err := t.Internal.Create(ctx, zone, param)
2827 targetResults := struct {
2828 Database *iaas.Database
2829 Error error
2830 }{
2831 Database: resultDatabase,
2832 Error: err,
2833 }
2834 if d, err := json.Marshal(targetResults); err == nil {
2835 log.Printf("[TRACE] \tresults: %s\n", string(d))
2836 }
2837
2838 return resultDatabase, err
2839 }
2840
2841 // Read is API call with trace log
2842 func (t *DatabaseTracer) Read(ctx context.Context, zone string, id types.ID) (*iaas.Database, error) {
2843 log.Println("[TRACE] DatabaseAPI.Read start")
2844 targetArguments := struct {
2845 Argzone string
2846 Argid types.ID `json:"id"`
2847 }{
2848 Argzone: zone,
2849 Argid: id,
2850 }
2851 if d, err := json.Marshal(targetArguments); err == nil {
2852 log.Printf("[TRACE] \targs: %s\n", string(d))
2853 }
2854
2855 defer func() {
2856 log.Println("[TRACE] DatabaseAPI.Read end")
2857 }()
2858
2859 resultDatabase, err := t.Internal.Read(ctx, zone, id)
2860 targetResults := struct {
2861 Database *iaas.Database
2862 Error error
2863 }{
2864 Database: resultDatabase,
2865 Error: err,
2866 }
2867 if d, err := json.Marshal(targetResults); err == nil {
2868 log.Printf("[TRACE] \tresults: %s\n", string(d))
2869 }
2870
2871 return resultDatabase, err
2872 }
2873
2874 // Update is API call with trace log
2875 func (t *DatabaseTracer) Update(ctx context.Context, zone string, id types.ID, param *iaas.DatabaseUpdateRequest) (*iaas.Database, error) {
2876 log.Println("[TRACE] DatabaseAPI.Update start")
2877 targetArguments := struct {
2878 Argzone string
2879 Argid types.ID `json:"id"`
2880 Argparam *iaas.DatabaseUpdateRequest `json:"param"`
2881 }{
2882 Argzone: zone,
2883 Argid: id,
2884 Argparam: param,
2885 }
2886 if d, err := json.Marshal(targetArguments); err == nil {
2887 log.Printf("[TRACE] \targs: %s\n", string(d))
2888 }
2889
2890 defer func() {
2891 log.Println("[TRACE] DatabaseAPI.Update end")
2892 }()
2893
2894 resultDatabase, err := t.Internal.Update(ctx, zone, id, param)
2895 targetResults := struct {
2896 Database *iaas.Database
2897 Error error
2898 }{
2899 Database: resultDatabase,
2900 Error: err,
2901 }
2902 if d, err := json.Marshal(targetResults); err == nil {
2903 log.Printf("[TRACE] \tresults: %s\n", string(d))
2904 }
2905
2906 return resultDatabase, err
2907 }
2908
2909 // UpdateSettings is API call with trace log
2910 func (t *DatabaseTracer) UpdateSettings(ctx context.Context, zone string, id types.ID, param *iaas.DatabaseUpdateSettingsRequest) (*iaas.Database, error) {
2911 log.Println("[TRACE] DatabaseAPI.UpdateSettings start")
2912 targetArguments := struct {
2913 Argzone string
2914 Argid types.ID `json:"id"`
2915 Argparam *iaas.DatabaseUpdateSettingsRequest `json:"param"`
2916 }{
2917 Argzone: zone,
2918 Argid: id,
2919 Argparam: param,
2920 }
2921 if d, err := json.Marshal(targetArguments); err == nil {
2922 log.Printf("[TRACE] \targs: %s\n", string(d))
2923 }
2924
2925 defer func() {
2926 log.Println("[TRACE] DatabaseAPI.UpdateSettings end")
2927 }()
2928
2929 resultDatabase, err := t.Internal.UpdateSettings(ctx, zone, id, param)
2930 targetResults := struct {
2931 Database *iaas.Database
2932 Error error
2933 }{
2934 Database: resultDatabase,
2935 Error: err,
2936 }
2937 if d, err := json.Marshal(targetResults); err == nil {
2938 log.Printf("[TRACE] \tresults: %s\n", string(d))
2939 }
2940
2941 return resultDatabase, err
2942 }
2943
2944 // Delete is API call with trace log
2945 func (t *DatabaseTracer) Delete(ctx context.Context, zone string, id types.ID) error {
2946 log.Println("[TRACE] DatabaseAPI.Delete start")
2947 targetArguments := struct {
2948 Argzone string
2949 Argid types.ID `json:"id"`
2950 }{
2951 Argzone: zone,
2952 Argid: id,
2953 }
2954 if d, err := json.Marshal(targetArguments); err == nil {
2955 log.Printf("[TRACE] \targs: %s\n", string(d))
2956 }
2957
2958 defer func() {
2959 log.Println("[TRACE] DatabaseAPI.Delete end")
2960 }()
2961
2962 err := t.Internal.Delete(ctx, zone, id)
2963 targetResults := struct {
2964 Error error
2965 }{
2966 Error: err,
2967 }
2968 if d, err := json.Marshal(targetResults); err == nil {
2969 log.Printf("[TRACE] \tresults: %s\n", string(d))
2970 }
2971
2972 return err
2973 }
2974
2975 // Config is API call with trace log
2976 func (t *DatabaseTracer) Config(ctx context.Context, zone string, id types.ID) error {
2977 log.Println("[TRACE] DatabaseAPI.Config start")
2978 targetArguments := struct {
2979 Argzone string
2980 Argid types.ID `json:"id"`
2981 }{
2982 Argzone: zone,
2983 Argid: id,
2984 }
2985 if d, err := json.Marshal(targetArguments); err == nil {
2986 log.Printf("[TRACE] \targs: %s\n", string(d))
2987 }
2988
2989 defer func() {
2990 log.Println("[TRACE] DatabaseAPI.Config end")
2991 }()
2992
2993 err := t.Internal.Config(ctx, zone, id)
2994 targetResults := struct {
2995 Error error
2996 }{
2997 Error: err,
2998 }
2999 if d, err := json.Marshal(targetResults); err == nil {
3000 log.Printf("[TRACE] \tresults: %s\n", string(d))
3001 }
3002
3003 return err
3004 }
3005
3006 // Boot is API call with trace log
3007 func (t *DatabaseTracer) Boot(ctx context.Context, zone string, id types.ID) error {
3008 log.Println("[TRACE] DatabaseAPI.Boot start")
3009 targetArguments := struct {
3010 Argzone string
3011 Argid types.ID `json:"id"`
3012 }{
3013 Argzone: zone,
3014 Argid: id,
3015 }
3016 if d, err := json.Marshal(targetArguments); err == nil {
3017 log.Printf("[TRACE] \targs: %s\n", string(d))
3018 }
3019
3020 defer func() {
3021 log.Println("[TRACE] DatabaseAPI.Boot end")
3022 }()
3023
3024 err := t.Internal.Boot(ctx, zone, id)
3025 targetResults := struct {
3026 Error error
3027 }{
3028 Error: err,
3029 }
3030 if d, err := json.Marshal(targetResults); err == nil {
3031 log.Printf("[TRACE] \tresults: %s\n", string(d))
3032 }
3033
3034 return err
3035 }
3036
3037 // Shutdown is API call with trace log
3038 func (t *DatabaseTracer) Shutdown(ctx context.Context, zone string, id types.ID, shutdownOption *iaas.ShutdownOption) error {
3039 log.Println("[TRACE] DatabaseAPI.Shutdown start")
3040 targetArguments := struct {
3041 Argzone string
3042 Argid types.ID `json:"id"`
3043 ArgshutdownOption *iaas.ShutdownOption `json:"shutdownOption"`
3044 }{
3045 Argzone: zone,
3046 Argid: id,
3047 ArgshutdownOption: shutdownOption,
3048 }
3049 if d, err := json.Marshal(targetArguments); err == nil {
3050 log.Printf("[TRACE] \targs: %s\n", string(d))
3051 }
3052
3053 defer func() {
3054 log.Println("[TRACE] DatabaseAPI.Shutdown end")
3055 }()
3056
3057 err := t.Internal.Shutdown(ctx, zone, id, shutdownOption)
3058 targetResults := struct {
3059 Error error
3060 }{
3061 Error: err,
3062 }
3063 if d, err := json.Marshal(targetResults); err == nil {
3064 log.Printf("[TRACE] \tresults: %s\n", string(d))
3065 }
3066
3067 return err
3068 }
3069
3070 // Reset is API call with trace log
3071 func (t *DatabaseTracer) Reset(ctx context.Context, zone string, id types.ID) error {
3072 log.Println("[TRACE] DatabaseAPI.Reset start")
3073 targetArguments := struct {
3074 Argzone string
3075 Argid types.ID `json:"id"`
3076 }{
3077 Argzone: zone,
3078 Argid: id,
3079 }
3080 if d, err := json.Marshal(targetArguments); err == nil {
3081 log.Printf("[TRACE] \targs: %s\n", string(d))
3082 }
3083
3084 defer func() {
3085 log.Println("[TRACE] DatabaseAPI.Reset end")
3086 }()
3087
3088 err := t.Internal.Reset(ctx, zone, id)
3089 targetResults := struct {
3090 Error error
3091 }{
3092 Error: err,
3093 }
3094 if d, err := json.Marshal(targetResults); err == nil {
3095 log.Printf("[TRACE] \tresults: %s\n", string(d))
3096 }
3097
3098 return err
3099 }
3100
3101 // MonitorCPU is API call with trace log
3102 func (t *DatabaseTracer) MonitorCPU(ctx context.Context, zone string, id types.ID, condition *iaas.MonitorCondition) (*iaas.CPUTimeActivity, error) {
3103 log.Println("[TRACE] DatabaseAPI.MonitorCPU start")
3104 targetArguments := struct {
3105 Argzone string
3106 Argid types.ID `json:"id"`
3107 Argcondition *iaas.MonitorCondition `json:"condition"`
3108 }{
3109 Argzone: zone,
3110 Argid: id,
3111 Argcondition: condition,
3112 }
3113 if d, err := json.Marshal(targetArguments); err == nil {
3114 log.Printf("[TRACE] \targs: %s\n", string(d))
3115 }
3116
3117 defer func() {
3118 log.Println("[TRACE] DatabaseAPI.MonitorCPU end")
3119 }()
3120
3121 resultCPUTimeActivity, err := t.Internal.MonitorCPU(ctx, zone, id, condition)
3122 targetResults := struct {
3123 CPUTimeActivity *iaas.CPUTimeActivity
3124 Error error
3125 }{
3126 CPUTimeActivity: resultCPUTimeActivity,
3127 Error: err,
3128 }
3129 if d, err := json.Marshal(targetResults); err == nil {
3130 log.Printf("[TRACE] \tresults: %s\n", string(d))
3131 }
3132
3133 return resultCPUTimeActivity, err
3134 }
3135
3136 // MonitorDisk is API call with trace log
3137 func (t *DatabaseTracer) MonitorDisk(ctx context.Context, zone string, id types.ID, condition *iaas.MonitorCondition) (*iaas.DiskActivity, error) {
3138 log.Println("[TRACE] DatabaseAPI.MonitorDisk start")
3139 targetArguments := struct {
3140 Argzone string
3141 Argid types.ID `json:"id"`
3142 Argcondition *iaas.MonitorCondition `json:"condition"`
3143 }{
3144 Argzone: zone,
3145 Argid: id,
3146 Argcondition: condition,
3147 }
3148 if d, err := json.Marshal(targetArguments); err == nil {
3149 log.Printf("[TRACE] \targs: %s\n", string(d))
3150 }
3151
3152 defer func() {
3153 log.Println("[TRACE] DatabaseAPI.MonitorDisk end")
3154 }()
3155
3156 resultDiskActivity, err := t.Internal.MonitorDisk(ctx, zone, id, condition)
3157 targetResults := struct {
3158 DiskActivity *iaas.DiskActivity
3159 Error error
3160 }{
3161 DiskActivity: resultDiskActivity,
3162 Error: err,
3163 }
3164 if d, err := json.Marshal(targetResults); err == nil {
3165 log.Printf("[TRACE] \tresults: %s\n", string(d))
3166 }
3167
3168 return resultDiskActivity, err
3169 }
3170
3171 // MonitorInterface is API call with trace log
3172 func (t *DatabaseTracer) MonitorInterface(ctx context.Context, zone string, id types.ID, condition *iaas.MonitorCondition) (*iaas.InterfaceActivity, error) {
3173 log.Println("[TRACE] DatabaseAPI.MonitorInterface start")
3174 targetArguments := struct {
3175 Argzone string
3176 Argid types.ID `json:"id"`
3177 Argcondition *iaas.MonitorCondition `json:"condition"`
3178 }{
3179 Argzone: zone,
3180 Argid: id,
3181 Argcondition: condition,
3182 }
3183 if d, err := json.Marshal(targetArguments); err == nil {
3184 log.Printf("[TRACE] \targs: %s\n", string(d))
3185 }
3186
3187 defer func() {
3188 log.Println("[TRACE] DatabaseAPI.MonitorInterface end")
3189 }()
3190
3191 resultInterfaceActivity, err := t.Internal.MonitorInterface(ctx, zone, id, condition)
3192 targetResults := struct {
3193 InterfaceActivity *iaas.InterfaceActivity
3194 Error error
3195 }{
3196 InterfaceActivity: resultInterfaceActivity,
3197 Error: err,
3198 }
3199 if d, err := json.Marshal(targetResults); err == nil {
3200 log.Printf("[TRACE] \tresults: %s\n", string(d))
3201 }
3202
3203 return resultInterfaceActivity, err
3204 }
3205
3206 // MonitorDatabase is API call with trace log
3207 func (t *DatabaseTracer) MonitorDatabase(ctx context.Context, zone string, id types.ID, condition *iaas.MonitorCondition) (*iaas.DatabaseActivity, error) {
3208 log.Println("[TRACE] DatabaseAPI.MonitorDatabase start")
3209 targetArguments := struct {
3210 Argzone string
3211 Argid types.ID `json:"id"`
3212 Argcondition *iaas.MonitorCondition `json:"condition"`
3213 }{
3214 Argzone: zone,
3215 Argid: id,
3216 Argcondition: condition,
3217 }
3218 if d, err := json.Marshal(targetArguments); err == nil {
3219 log.Printf("[TRACE] \targs: %s\n", string(d))
3220 }
3221
3222 defer func() {
3223 log.Println("[TRACE] DatabaseAPI.MonitorDatabase end")
3224 }()
3225
3226 resultDatabaseActivity, err := t.Internal.MonitorDatabase(ctx, zone, id, condition)
3227 targetResults := struct {
3228 DatabaseActivity *iaas.DatabaseActivity
3229 Error error
3230 }{
3231 DatabaseActivity: resultDatabaseActivity,
3232 Error: err,
3233 }
3234 if d, err := json.Marshal(targetResults); err == nil {
3235 log.Printf("[TRACE] \tresults: %s\n", string(d))
3236 }
3237
3238 return resultDatabaseActivity, err
3239 }
3240
3241 // Status is API call with trace log
3242 func (t *DatabaseTracer) Status(ctx context.Context, zone string, id types.ID) (*iaas.DatabaseStatus, error) {
3243 log.Println("[TRACE] DatabaseAPI.Status start")
3244 targetArguments := struct {
3245 Argzone string
3246 Argid types.ID `json:"id"`
3247 }{
3248 Argzone: zone,
3249 Argid: id,
3250 }
3251 if d, err := json.Marshal(targetArguments); err == nil {
3252 log.Printf("[TRACE] \targs: %s\n", string(d))
3253 }
3254
3255 defer func() {
3256 log.Println("[TRACE] DatabaseAPI.Status end")
3257 }()
3258
3259 resultDatabaseStatus, err := t.Internal.Status(ctx, zone, id)
3260 targetResults := struct {
3261 DatabaseStatus *iaas.DatabaseStatus
3262 Error error
3263 }{
3264 DatabaseStatus: resultDatabaseStatus,
3265 Error: err,
3266 }
3267 if d, err := json.Marshal(targetResults); err == nil {
3268 log.Printf("[TRACE] \tresults: %s\n", string(d))
3269 }
3270
3271 return resultDatabaseStatus, err
3272 }
3273
3274 // GetParameter is API call with trace log
3275 func (t *DatabaseTracer) GetParameter(ctx context.Context, zone string, id types.ID) (*iaas.DatabaseParameter, error) {
3276 log.Println("[TRACE] DatabaseAPI.GetParameter start")
3277 targetArguments := struct {
3278 Argzone string
3279 Argid types.ID `json:"id"`
3280 }{
3281 Argzone: zone,
3282 Argid: id,
3283 }
3284 if d, err := json.Marshal(targetArguments); err == nil {
3285 log.Printf("[TRACE] \targs: %s\n", string(d))
3286 }
3287
3288 defer func() {
3289 log.Println("[TRACE] DatabaseAPI.GetParameter end")
3290 }()
3291
3292 resultDatabaseParameter, err := t.Internal.GetParameter(ctx, zone, id)
3293 targetResults := struct {
3294 DatabaseParameter *iaas.DatabaseParameter
3295 Error error
3296 }{
3297 DatabaseParameter: resultDatabaseParameter,
3298 Error: err,
3299 }
3300 if d, err := json.Marshal(targetResults); err == nil {
3301 log.Printf("[TRACE] \tresults: %s\n", string(d))
3302 }
3303
3304 return resultDatabaseParameter, err
3305 }
3306
3307 // SetParameter is API call with trace log
3308 func (t *DatabaseTracer) SetParameter(ctx context.Context, zone string, id types.ID, param map[string]interface{}) error {
3309 log.Println("[TRACE] DatabaseAPI.SetParameter start")
3310 targetArguments := struct {
3311 Argzone string
3312 Argid types.ID `json:"id"`
3313 Argparam map[string]interface{} `json:"param"`
3314 }{
3315 Argzone: zone,
3316 Argid: id,
3317 Argparam: param,
3318 }
3319 if d, err := json.Marshal(targetArguments); err == nil {
3320 log.Printf("[TRACE] \targs: %s\n", string(d))
3321 }
3322
3323 defer func() {
3324 log.Println("[TRACE] DatabaseAPI.SetParameter end")
3325 }()
3326
3327 err := t.Internal.SetParameter(ctx, zone, id, param)
3328 targetResults := struct {
3329 Error error
3330 }{
3331 Error: err,
3332 }
3333 if d, err := json.Marshal(targetResults); err == nil {
3334 log.Printf("[TRACE] \tresults: %s\n", string(d))
3335 }
3336
3337 return err
3338 }
3339
3340 /*************************************************
3341 * DiskTracer
3342 *************************************************/
3343
3344 // DiskTracer is for trace DiskOp operations
3345 type DiskTracer struct {
3346 Internal iaas.DiskAPI
3347 }
3348
3349 // NewDiskTracer creates new DiskTracer instance
3350 func NewDiskTracer(in iaas.DiskAPI) iaas.DiskAPI {
3351 return &DiskTracer{
3352 Internal: in,
3353 }
3354 }
3355
3356 // Find is API call with trace log
3357 func (t *DiskTracer) Find(ctx context.Context, zone string, conditions *iaas.FindCondition) (*iaas.DiskFindResult, error) {
3358 log.Println("[TRACE] DiskAPI.Find start")
3359 targetArguments := struct {
3360 Argzone string
3361 Argconditions *iaas.FindCondition `json:"conditions"`
3362 }{
3363 Argzone: zone,
3364 Argconditions: conditions,
3365 }
3366 if d, err := json.Marshal(targetArguments); err == nil {
3367 log.Printf("[TRACE] \targs: %s\n", string(d))
3368 }
3369
3370 defer func() {
3371 log.Println("[TRACE] DiskAPI.Find end")
3372 }()
3373
3374 result, err := t.Internal.Find(ctx, zone, conditions)
3375 targetResults := struct {
3376 Result *iaas.DiskFindResult
3377 Error error
3378 }{
3379 Result: result,
3380 Error: err,
3381 }
3382 if d, err := json.Marshal(targetResults); err == nil {
3383 log.Printf("[TRACE] \tresults: %s\n", string(d))
3384 }
3385
3386 return result, err
3387 }
3388
3389 // Create is API call with trace log
3390 func (t *DiskTracer) Create(ctx context.Context, zone string, createParam *iaas.DiskCreateRequest, distantFrom []types.ID, kmeKeyID types.ID) (*iaas.Disk, error) {
3391 log.Println("[TRACE] DiskAPI.Create start")
3392 targetArguments := struct {
3393 Argzone string
3394 ArgcreateParam *iaas.DiskCreateRequest `json:"createParam"`
3395 ArgdistantFrom []types.ID `json:"distantFrom"`
3396 ArgkmeKeyID types.ID `json:"kmeKeyID"`
3397 }{
3398 Argzone: zone,
3399 ArgcreateParam: createParam,
3400 ArgdistantFrom: distantFrom,
3401 ArgkmeKeyID: kmeKeyID,
3402 }
3403 if d, err := json.Marshal(targetArguments); err == nil {
3404 log.Printf("[TRACE] \targs: %s\n", string(d))
3405 }
3406
3407 defer func() {
3408 log.Println("[TRACE] DiskAPI.Create end")
3409 }()
3410
3411 resultDisk, err := t.Internal.Create(ctx, zone, createParam, distantFrom, kmeKeyID)
3412 targetResults := struct {
3413 Disk *iaas.Disk
3414 Error error
3415 }{
3416 Disk: resultDisk,
3417 Error: err,
3418 }
3419 if d, err := json.Marshal(targetResults); err == nil {
3420 log.Printf("[TRACE] \tresults: %s\n", string(d))
3421 }
3422
3423 return resultDisk, err
3424 }
3425
3426 // Config is API call with trace log
3427 func (t *DiskTracer) Config(ctx context.Context, zone string, id types.ID, edit *iaas.DiskEditRequest) error {
3428 log.Println("[TRACE] DiskAPI.Config start")
3429 targetArguments := struct {
3430 Argzone string
3431 Argid types.ID `json:"id"`
3432 Argedit *iaas.DiskEditRequest `json:"edit"`
3433 }{
3434 Argzone: zone,
3435 Argid: id,
3436 Argedit: edit,
3437 }
3438 if d, err := json.Marshal(targetArguments); err == nil {
3439 log.Printf("[TRACE] \targs: %s\n", string(d))
3440 }
3441
3442 defer func() {
3443 log.Println("[TRACE] DiskAPI.Config end")
3444 }()
3445
3446 err := t.Internal.Config(ctx, zone, id, edit)
3447 targetResults := struct {
3448 Error error
3449 }{
3450 Error: err,
3451 }
3452 if d, err := json.Marshal(targetResults); err == nil {
3453 log.Printf("[TRACE] \tresults: %s\n", string(d))
3454 }
3455
3456 return err
3457 }
3458
3459 // CreateWithConfig is API call with trace log
3460 func (t *DiskTracer) CreateWithConfig(ctx context.Context, zone string, createParam *iaas.DiskCreateRequest, editParam *iaas.DiskEditRequest, bootAtAvailable bool, distantFrom []types.ID, kmeKeyID types.ID) (*iaas.Disk, error) {
3461 log.Println("[TRACE] DiskAPI.CreateWithConfig start")
3462 targetArguments := struct {
3463 Argzone string
3464 ArgcreateParam *iaas.DiskCreateRequest `json:"createParam"`
3465 ArgeditParam *iaas.DiskEditRequest `json:"editParam"`
3466 ArgbootAtAvailable bool `json:"bootAtAvailable"`
3467 ArgdistantFrom []types.ID `json:"distantFrom"`
3468 ArgkmeKeyID types.ID `json:"kmeKeyID"`
3469 }{
3470 Argzone: zone,
3471 ArgcreateParam: createParam,
3472 ArgeditParam: editParam,
3473 ArgbootAtAvailable: bootAtAvailable,
3474 ArgdistantFrom: distantFrom,
3475 ArgkmeKeyID: kmeKeyID,
3476 }
3477 if d, err := json.Marshal(targetArguments); err == nil {
3478 log.Printf("[TRACE] \targs: %s\n", string(d))
3479 }
3480
3481 defer func() {
3482 log.Println("[TRACE] DiskAPI.CreateWithConfig end")
3483 }()
3484
3485 resultDisk, err := t.Internal.CreateWithConfig(ctx, zone, createParam, editParam, bootAtAvailable, distantFrom, kmeKeyID)
3486 targetResults := struct {
3487 Disk *iaas.Disk
3488 Error error
3489 }{
3490 Disk: resultDisk,
3491 Error: err,
3492 }
3493 if d, err := json.Marshal(targetResults); err == nil {
3494 log.Printf("[TRACE] \tresults: %s\n", string(d))
3495 }
3496
3497 return resultDisk, err
3498 }
3499
3500 // ResizePartition is API call with trace log
3501 func (t *DiskTracer) ResizePartition(ctx context.Context, zone string, id types.ID, param *iaas.DiskResizePartitionRequest) error {
3502 log.Println("[TRACE] DiskAPI.ResizePartition start")
3503 targetArguments := struct {
3504 Argzone string
3505 Argid types.ID `json:"id"`
3506 Argparam *iaas.DiskResizePartitionRequest `json:"param"`
3507 }{
3508 Argzone: zone,
3509 Argid: id,
3510 Argparam: param,
3511 }
3512 if d, err := json.Marshal(targetArguments); err == nil {
3513 log.Printf("[TRACE] \targs: %s\n", string(d))
3514 }
3515
3516 defer func() {
3517 log.Println("[TRACE] DiskAPI.ResizePartition end")
3518 }()
3519
3520 err := t.Internal.ResizePartition(ctx, zone, id, param)
3521 targetResults := struct {
3522 Error error
3523 }{
3524 Error: err,
3525 }
3526 if d, err := json.Marshal(targetResults); err == nil {
3527 log.Printf("[TRACE] \tresults: %s\n", string(d))
3528 }
3529
3530 return err
3531 }
3532
3533 // ConnectToServer is API call with trace log
3534 func (t *DiskTracer) ConnectToServer(ctx context.Context, zone string, id types.ID, serverID types.ID) error {
3535 log.Println("[TRACE] DiskAPI.ConnectToServer start")
3536 targetArguments := struct {
3537 Argzone string
3538 Argid types.ID `json:"id"`
3539 ArgserverID types.ID `json:"serverID"`
3540 }{
3541 Argzone: zone,
3542 Argid: id,
3543 ArgserverID: serverID,
3544 }
3545 if d, err := json.Marshal(targetArguments); err == nil {
3546 log.Printf("[TRACE] \targs: %s\n", string(d))
3547 }
3548
3549 defer func() {
3550 log.Println("[TRACE] DiskAPI.ConnectToServer end")
3551 }()
3552
3553 err := t.Internal.ConnectToServer(ctx, zone, id, serverID)
3554 targetResults := struct {
3555 Error error
3556 }{
3557 Error: err,
3558 }
3559 if d, err := json.Marshal(targetResults); err == nil {
3560 log.Printf("[TRACE] \tresults: %s\n", string(d))
3561 }
3562
3563 return err
3564 }
3565
3566 // DisconnectFromServer is API call with trace log
3567 func (t *DiskTracer) DisconnectFromServer(ctx context.Context, zone string, id types.ID) error {
3568 log.Println("[TRACE] DiskAPI.DisconnectFromServer start")
3569 targetArguments := struct {
3570 Argzone string
3571 Argid types.ID `json:"id"`
3572 }{
3573 Argzone: zone,
3574 Argid: id,
3575 }
3576 if d, err := json.Marshal(targetArguments); err == nil {
3577 log.Printf("[TRACE] \targs: %s\n", string(d))
3578 }
3579
3580 defer func() {
3581 log.Println("[TRACE] DiskAPI.DisconnectFromServer end")
3582 }()
3583
3584 err := t.Internal.DisconnectFromServer(ctx, zone, id)
3585 targetResults := struct {
3586 Error error
3587 }{
3588 Error: err,
3589 }
3590 if d, err := json.Marshal(targetResults); err == nil {
3591 log.Printf("[TRACE] \tresults: %s\n", string(d))
3592 }
3593
3594 return err
3595 }
3596
3597 // Read is API call with trace log
3598 func (t *DiskTracer) Read(ctx context.Context, zone string, id types.ID) (*iaas.Disk, error) {
3599 log.Println("[TRACE] DiskAPI.Read start")
3600 targetArguments := struct {
3601 Argzone string
3602 Argid types.ID `json:"id"`
3603 }{
3604 Argzone: zone,
3605 Argid: id,
3606 }
3607 if d, err := json.Marshal(targetArguments); err == nil {
3608 log.Printf("[TRACE] \targs: %s\n", string(d))
3609 }
3610
3611 defer func() {
3612 log.Println("[TRACE] DiskAPI.Read end")
3613 }()
3614
3615 resultDisk, err := t.Internal.Read(ctx, zone, id)
3616 targetResults := struct {
3617 Disk *iaas.Disk
3618 Error error
3619 }{
3620 Disk: resultDisk,
3621 Error: err,
3622 }
3623 if d, err := json.Marshal(targetResults); err == nil {
3624 log.Printf("[TRACE] \tresults: %s\n", string(d))
3625 }
3626
3627 return resultDisk, err
3628 }
3629
3630 // Update is API call with trace log
3631 func (t *DiskTracer) Update(ctx context.Context, zone string, id types.ID, param *iaas.DiskUpdateRequest) (*iaas.Disk, error) {
3632 log.Println("[TRACE] DiskAPI.Update start")
3633 targetArguments := struct {
3634 Argzone string
3635 Argid types.ID `json:"id"`
3636 Argparam *iaas.DiskUpdateRequest `json:"param"`
3637 }{
3638 Argzone: zone,
3639 Argid: id,
3640 Argparam: param,
3641 }
3642 if d, err := json.Marshal(targetArguments); err == nil {
3643 log.Printf("[TRACE] \targs: %s\n", string(d))
3644 }
3645
3646 defer func() {
3647 log.Println("[TRACE] DiskAPI.Update end")
3648 }()
3649
3650 resultDisk, err := t.Internal.Update(ctx, zone, id, param)
3651 targetResults := struct {
3652 Disk *iaas.Disk
3653 Error error
3654 }{
3655 Disk: resultDisk,
3656 Error: err,
3657 }
3658 if d, err := json.Marshal(targetResults); err == nil {
3659 log.Printf("[TRACE] \tresults: %s\n", string(d))
3660 }
3661
3662 return resultDisk, err
3663 }
3664
3665 // Delete is API call with trace log
3666 func (t *DiskTracer) Delete(ctx context.Context, zone string, id types.ID) error {
3667 log.Println("[TRACE] DiskAPI.Delete start")
3668 targetArguments := struct {
3669 Argzone string
3670 Argid types.ID `json:"id"`
3671 }{
3672 Argzone: zone,
3673 Argid: id,
3674 }
3675 if d, err := json.Marshal(targetArguments); err == nil {
3676 log.Printf("[TRACE] \targs: %s\n", string(d))
3677 }
3678
3679 defer func() {
3680 log.Println("[TRACE] DiskAPI.Delete end")
3681 }()
3682
3683 err := t.Internal.Delete(ctx, zone, id)
3684 targetResults := struct {
3685 Error error
3686 }{
3687 Error: err,
3688 }
3689 if d, err := json.Marshal(targetResults); err == nil {
3690 log.Printf("[TRACE] \tresults: %s\n", string(d))
3691 }
3692
3693 return err
3694 }
3695
3696 // Monitor is API call with trace log
3697 func (t *DiskTracer) Monitor(ctx context.Context, zone string, id types.ID, condition *iaas.MonitorCondition) (*iaas.DiskActivity, error) {
3698 log.Println("[TRACE] DiskAPI.Monitor start")
3699 targetArguments := struct {
3700 Argzone string
3701 Argid types.ID `json:"id"`
3702 Argcondition *iaas.MonitorCondition `json:"condition"`
3703 }{
3704 Argzone: zone,
3705 Argid: id,
3706 Argcondition: condition,
3707 }
3708 if d, err := json.Marshal(targetArguments); err == nil {
3709 log.Printf("[TRACE] \targs: %s\n", string(d))
3710 }
3711
3712 defer func() {
3713 log.Println("[TRACE] DiskAPI.Monitor end")
3714 }()
3715
3716 resultDiskActivity, err := t.Internal.Monitor(ctx, zone, id, condition)
3717 targetResults := struct {
3718 DiskActivity *iaas.DiskActivity
3719 Error error
3720 }{
3721 DiskActivity: resultDiskActivity,
3722 Error: err,
3723 }
3724 if d, err := json.Marshal(targetResults); err == nil {
3725 log.Printf("[TRACE] \tresults: %s\n", string(d))
3726 }
3727
3728 return resultDiskActivity, err
3729 }
3730
3731 // MonitorDisk is API call with trace log
3732 func (t *DiskTracer) MonitorDisk(ctx context.Context, zone string, id types.ID, condition *iaas.MonitorCondition) (*iaas.DiskActivity, error) {
3733 log.Println("[TRACE] DiskAPI.MonitorDisk start")
3734 targetArguments := struct {
3735 Argzone string
3736 Argid types.ID `json:"id"`
3737 Argcondition *iaas.MonitorCondition `json:"condition"`
3738 }{
3739 Argzone: zone,
3740 Argid: id,
3741 Argcondition: condition,
3742 }
3743 if d, err := json.Marshal(targetArguments); err == nil {
3744 log.Printf("[TRACE] \targs: %s\n", string(d))
3745 }
3746
3747 defer func() {
3748 log.Println("[TRACE] DiskAPI.MonitorDisk end")
3749 }()
3750
3751 resultDiskActivity, err := t.Internal.MonitorDisk(ctx, zone, id, condition)
3752 targetResults := struct {
3753 DiskActivity *iaas.DiskActivity
3754 Error error
3755 }{
3756 DiskActivity: resultDiskActivity,
3757 Error: err,
3758 }
3759 if d, err := json.Marshal(targetResults); err == nil {
3760 log.Printf("[TRACE] \tresults: %s\n", string(d))
3761 }
3762
3763 return resultDiskActivity, err
3764 }
3765
3766 /*************************************************
3767 * DiskPlanTracer
3768 *************************************************/
3769
3770 // DiskPlanTracer is for trace DiskPlanOp operations
3771 type DiskPlanTracer struct {
3772 Internal iaas.DiskPlanAPI
3773 }
3774
3775 // NewDiskPlanTracer creates new DiskPlanTracer instance
3776 func NewDiskPlanTracer(in iaas.DiskPlanAPI) iaas.DiskPlanAPI {
3777 return &DiskPlanTracer{
3778 Internal: in,
3779 }
3780 }
3781
3782 // Find is API call with trace log
3783 func (t *DiskPlanTracer) Find(ctx context.Context, zone string, conditions *iaas.FindCondition) (*iaas.DiskPlanFindResult, error) {
3784 log.Println("[TRACE] DiskPlanAPI.Find start")
3785 targetArguments := struct {
3786 Argzone string
3787 Argconditions *iaas.FindCondition `json:"conditions"`
3788 }{
3789 Argzone: zone,
3790 Argconditions: conditions,
3791 }
3792 if d, err := json.Marshal(targetArguments); err == nil {
3793 log.Printf("[TRACE] \targs: %s\n", string(d))
3794 }
3795
3796 defer func() {
3797 log.Println("[TRACE] DiskPlanAPI.Find end")
3798 }()
3799
3800 result, err := t.Internal.Find(ctx, zone, conditions)
3801 targetResults := struct {
3802 Result *iaas.DiskPlanFindResult
3803 Error error
3804 }{
3805 Result: result,
3806 Error: err,
3807 }
3808 if d, err := json.Marshal(targetResults); err == nil {
3809 log.Printf("[TRACE] \tresults: %s\n", string(d))
3810 }
3811
3812 return result, err
3813 }
3814
3815 // Read is API call with trace log
3816 func (t *DiskPlanTracer) Read(ctx context.Context, zone string, id types.ID) (*iaas.DiskPlan, error) {
3817 log.Println("[TRACE] DiskPlanAPI.Read start")
3818 targetArguments := struct {
3819 Argzone string
3820 Argid types.ID `json:"id"`
3821 }{
3822 Argzone: zone,
3823 Argid: id,
3824 }
3825 if d, err := json.Marshal(targetArguments); err == nil {
3826 log.Printf("[TRACE] \targs: %s\n", string(d))
3827 }
3828
3829 defer func() {
3830 log.Println("[TRACE] DiskPlanAPI.Read end")
3831 }()
3832
3833 resultDiskPlan, err := t.Internal.Read(ctx, zone, id)
3834 targetResults := struct {
3835 DiskPlan *iaas.DiskPlan
3836 Error error
3837 }{
3838 DiskPlan: resultDiskPlan,
3839 Error: err,
3840 }
3841 if d, err := json.Marshal(targetResults); err == nil {
3842 log.Printf("[TRACE] \tresults: %s\n", string(d))
3843 }
3844
3845 return resultDiskPlan, err
3846 }
3847
3848 /*************************************************
3849 * DNSTracer
3850 *************************************************/
3851
3852 // DNSTracer is for trace DNSOp operations
3853 type DNSTracer struct {
3854 Internal iaas.DNSAPI
3855 }
3856
3857 // NewDNSTracer creates new DNSTracer instance
3858 func NewDNSTracer(in iaas.DNSAPI) iaas.DNSAPI {
3859 return &DNSTracer{
3860 Internal: in,
3861 }
3862 }
3863
3864 // Find is API call with trace log
3865 func (t *DNSTracer) Find(ctx context.Context, conditions *iaas.FindCondition) (*iaas.DNSFindResult, error) {
3866 log.Println("[TRACE] DNSAPI.Find start")
3867 targetArguments := struct {
3868 Argconditions *iaas.FindCondition `json:"conditions"`
3869 }{
3870 Argconditions: conditions,
3871 }
3872 if d, err := json.Marshal(targetArguments); err == nil {
3873 log.Printf("[TRACE] \targs: %s\n", string(d))
3874 }
3875
3876 defer func() {
3877 log.Println("[TRACE] DNSAPI.Find end")
3878 }()
3879
3880 result, err := t.Internal.Find(ctx, conditions)
3881 targetResults := struct {
3882 Result *iaas.DNSFindResult
3883 Error error
3884 }{
3885 Result: result,
3886 Error: err,
3887 }
3888 if d, err := json.Marshal(targetResults); err == nil {
3889 log.Printf("[TRACE] \tresults: %s\n", string(d))
3890 }
3891
3892 return result, err
3893 }
3894
3895 // Create is API call with trace log
3896 func (t *DNSTracer) Create(ctx context.Context, param *iaas.DNSCreateRequest) (*iaas.DNS, error) {
3897 log.Println("[TRACE] DNSAPI.Create start")
3898 targetArguments := struct {
3899 Argparam *iaas.DNSCreateRequest `json:"param"`
3900 }{
3901 Argparam: param,
3902 }
3903 if d, err := json.Marshal(targetArguments); err == nil {
3904 log.Printf("[TRACE] \targs: %s\n", string(d))
3905 }
3906
3907 defer func() {
3908 log.Println("[TRACE] DNSAPI.Create end")
3909 }()
3910
3911 resultDNS, err := t.Internal.Create(ctx, param)
3912 targetResults := struct {
3913 DNS *iaas.DNS
3914 Error error
3915 }{
3916 DNS: resultDNS,
3917 Error: err,
3918 }
3919 if d, err := json.Marshal(targetResults); err == nil {
3920 log.Printf("[TRACE] \tresults: %s\n", string(d))
3921 }
3922
3923 return resultDNS, err
3924 }
3925
3926 // Read is API call with trace log
3927 func (t *DNSTracer) Read(ctx context.Context, id types.ID) (*iaas.DNS, error) {
3928 log.Println("[TRACE] DNSAPI.Read start")
3929 targetArguments := struct {
3930 Argid types.ID `json:"id"`
3931 }{
3932 Argid: id,
3933 }
3934 if d, err := json.Marshal(targetArguments); err == nil {
3935 log.Printf("[TRACE] \targs: %s\n", string(d))
3936 }
3937
3938 defer func() {
3939 log.Println("[TRACE] DNSAPI.Read end")
3940 }()
3941
3942 resultDNS, err := t.Internal.Read(ctx, id)
3943 targetResults := struct {
3944 DNS *iaas.DNS
3945 Error error
3946 }{
3947 DNS: resultDNS,
3948 Error: err,
3949 }
3950 if d, err := json.Marshal(targetResults); err == nil {
3951 log.Printf("[TRACE] \tresults: %s\n", string(d))
3952 }
3953
3954 return resultDNS, err
3955 }
3956
3957 // Update is API call with trace log
3958 func (t *DNSTracer) Update(ctx context.Context, id types.ID, param *iaas.DNSUpdateRequest) (*iaas.DNS, error) {
3959 log.Println("[TRACE] DNSAPI.Update start")
3960 targetArguments := struct {
3961 Argid types.ID `json:"id"`
3962 Argparam *iaas.DNSUpdateRequest `json:"param"`
3963 }{
3964 Argid: id,
3965 Argparam: param,
3966 }
3967 if d, err := json.Marshal(targetArguments); err == nil {
3968 log.Printf("[TRACE] \targs: %s\n", string(d))
3969 }
3970
3971 defer func() {
3972 log.Println("[TRACE] DNSAPI.Update end")
3973 }()
3974
3975 resultDNS, err := t.Internal.Update(ctx, id, param)
3976 targetResults := struct {
3977 DNS *iaas.DNS
3978 Error error
3979 }{
3980 DNS: resultDNS,
3981 Error: err,
3982 }
3983 if d, err := json.Marshal(targetResults); err == nil {
3984 log.Printf("[TRACE] \tresults: %s\n", string(d))
3985 }
3986
3987 return resultDNS, err
3988 }
3989
3990 // UpdateSettings is API call with trace log
3991 func (t *DNSTracer) UpdateSettings(ctx context.Context, id types.ID, param *iaas.DNSUpdateSettingsRequest) (*iaas.DNS, error) {
3992 log.Println("[TRACE] DNSAPI.UpdateSettings start")
3993 targetArguments := struct {
3994 Argid types.ID `json:"id"`
3995 Argparam *iaas.DNSUpdateSettingsRequest `json:"param"`
3996 }{
3997 Argid: id,
3998 Argparam: param,
3999 }
4000 if d, err := json.Marshal(targetArguments); err == nil {
4001 log.Printf("[TRACE] \targs: %s\n", string(d))
4002 }
4003
4004 defer func() {
4005 log.Println("[TRACE] DNSAPI.UpdateSettings end")
4006 }()
4007
4008 resultDNS, err := t.Internal.UpdateSettings(ctx, id, param)
4009 targetResults := struct {
4010 DNS *iaas.DNS
4011 Error error
4012 }{
4013 DNS: resultDNS,
4014 Error: err,
4015 }
4016 if d, err := json.Marshal(targetResults); err == nil {
4017 log.Printf("[TRACE] \tresults: %s\n", string(d))
4018 }
4019
4020 return resultDNS, err
4021 }
4022
4023 // Delete is API call with trace log
4024 func (t *DNSTracer) Delete(ctx context.Context, id types.ID) error {
4025 log.Println("[TRACE] DNSAPI.Delete start")
4026 targetArguments := struct {
4027 Argid types.ID `json:"id"`
4028 }{
4029 Argid: id,
4030 }
4031 if d, err := json.Marshal(targetArguments); err == nil {
4032 log.Printf("[TRACE] \targs: %s\n", string(d))
4033 }
4034
4035 defer func() {
4036 log.Println("[TRACE] DNSAPI.Delete end")
4037 }()
4038
4039 err := t.Internal.Delete(ctx, id)
4040 targetResults := struct {
4041 Error error
4042 }{
4043 Error: err,
4044 }
4045 if d, err := json.Marshal(targetResults); err == nil {
4046 log.Printf("[TRACE] \tresults: %s\n", string(d))
4047 }
4048
4049 return err
4050 }
4051
4052 /*************************************************
4053 * EnhancedDBTracer
4054 *************************************************/
4055
4056 // EnhancedDBTracer is for trace EnhancedDBOp operations
4057 type EnhancedDBTracer struct {
4058 Internal iaas.EnhancedDBAPI
4059 }
4060
4061 // NewEnhancedDBTracer creates new EnhancedDBTracer instance
4062 func NewEnhancedDBTracer(in iaas.EnhancedDBAPI) iaas.EnhancedDBAPI {
4063 return &EnhancedDBTracer{
4064 Internal: in,
4065 }
4066 }
4067
4068 // Find is API call with trace log
4069 func (t *EnhancedDBTracer) Find(ctx context.Context, conditions *iaas.FindCondition) (*iaas.EnhancedDBFindResult, error) {
4070 log.Println("[TRACE] EnhancedDBAPI.Find start")
4071 targetArguments := struct {
4072 Argconditions *iaas.FindCondition `json:"conditions"`
4073 }{
4074 Argconditions: conditions,
4075 }
4076 if d, err := json.Marshal(targetArguments); err == nil {
4077 log.Printf("[TRACE] \targs: %s\n", string(d))
4078 }
4079
4080 defer func() {
4081 log.Println("[TRACE] EnhancedDBAPI.Find end")
4082 }()
4083
4084 result, err := t.Internal.Find(ctx, conditions)
4085 targetResults := struct {
4086 Result *iaas.EnhancedDBFindResult
4087 Error error
4088 }{
4089 Result: result,
4090 Error: err,
4091 }
4092 if d, err := json.Marshal(targetResults); err == nil {
4093 log.Printf("[TRACE] \tresults: %s\n", string(d))
4094 }
4095
4096 return result, err
4097 }
4098
4099 // Create is API call with trace log
4100 func (t *EnhancedDBTracer) Create(ctx context.Context, param *iaas.EnhancedDBCreateRequest) (*iaas.EnhancedDB, error) {
4101 log.Println("[TRACE] EnhancedDBAPI.Create start")
4102 targetArguments := struct {
4103 Argparam *iaas.EnhancedDBCreateRequest `json:"param"`
4104 }{
4105 Argparam: param,
4106 }
4107 if d, err := json.Marshal(targetArguments); err == nil {
4108 log.Printf("[TRACE] \targs: %s\n", string(d))
4109 }
4110
4111 defer func() {
4112 log.Println("[TRACE] EnhancedDBAPI.Create end")
4113 }()
4114
4115 resultEnhancedDB, err := t.Internal.Create(ctx, param)
4116 targetResults := struct {
4117 EnhancedDB *iaas.EnhancedDB
4118 Error error
4119 }{
4120 EnhancedDB: resultEnhancedDB,
4121 Error: err,
4122 }
4123 if d, err := json.Marshal(targetResults); err == nil {
4124 log.Printf("[TRACE] \tresults: %s\n", string(d))
4125 }
4126
4127 return resultEnhancedDB, err
4128 }
4129
4130 // Read is API call with trace log
4131 func (t *EnhancedDBTracer) Read(ctx context.Context, id types.ID) (*iaas.EnhancedDB, error) {
4132 log.Println("[TRACE] EnhancedDBAPI.Read start")
4133 targetArguments := struct {
4134 Argid types.ID `json:"id"`
4135 }{
4136 Argid: id,
4137 }
4138 if d, err := json.Marshal(targetArguments); err == nil {
4139 log.Printf("[TRACE] \targs: %s\n", string(d))
4140 }
4141
4142 defer func() {
4143 log.Println("[TRACE] EnhancedDBAPI.Read end")
4144 }()
4145
4146 resultEnhancedDB, err := t.Internal.Read(ctx, id)
4147 targetResults := struct {
4148 EnhancedDB *iaas.EnhancedDB
4149 Error error
4150 }{
4151 EnhancedDB: resultEnhancedDB,
4152 Error: err,
4153 }
4154 if d, err := json.Marshal(targetResults); err == nil {
4155 log.Printf("[TRACE] \tresults: %s\n", string(d))
4156 }
4157
4158 return resultEnhancedDB, err
4159 }
4160
4161 // Update is API call with trace log
4162 func (t *EnhancedDBTracer) Update(ctx context.Context, id types.ID, param *iaas.EnhancedDBUpdateRequest) (*iaas.EnhancedDB, error) {
4163 log.Println("[TRACE] EnhancedDBAPI.Update start")
4164 targetArguments := struct {
4165 Argid types.ID `json:"id"`
4166 Argparam *iaas.EnhancedDBUpdateRequest `json:"param"`
4167 }{
4168 Argid: id,
4169 Argparam: param,
4170 }
4171 if d, err := json.Marshal(targetArguments); err == nil {
4172 log.Printf("[TRACE] \targs: %s\n", string(d))
4173 }
4174
4175 defer func() {
4176 log.Println("[TRACE] EnhancedDBAPI.Update end")
4177 }()
4178
4179 resultEnhancedDB, err := t.Internal.Update(ctx, id, param)
4180 targetResults := struct {
4181 EnhancedDB *iaas.EnhancedDB
4182 Error error
4183 }{
4184 EnhancedDB: resultEnhancedDB,
4185 Error: err,
4186 }
4187 if d, err := json.Marshal(targetResults); err == nil {
4188 log.Printf("[TRACE] \tresults: %s\n", string(d))
4189 }
4190
4191 return resultEnhancedDB, err
4192 }
4193
4194 // Delete is API call with trace log
4195 func (t *EnhancedDBTracer) Delete(ctx context.Context, id types.ID) error {
4196 log.Println("[TRACE] EnhancedDBAPI.Delete start")
4197 targetArguments := struct {
4198 Argid types.ID `json:"id"`
4199 }{
4200 Argid: id,
4201 }
4202 if d, err := json.Marshal(targetArguments); err == nil {
4203 log.Printf("[TRACE] \targs: %s\n", string(d))
4204 }
4205
4206 defer func() {
4207 log.Println("[TRACE] EnhancedDBAPI.Delete end")
4208 }()
4209
4210 err := t.Internal.Delete(ctx, id)
4211 targetResults := struct {
4212 Error error
4213 }{
4214 Error: err,
4215 }
4216 if d, err := json.Marshal(targetResults); err == nil {
4217 log.Printf("[TRACE] \tresults: %s\n", string(d))
4218 }
4219
4220 return err
4221 }
4222
4223 // SetPassword is API call with trace log
4224 func (t *EnhancedDBTracer) SetPassword(ctx context.Context, id types.ID, param *iaas.EnhancedDBSetPasswordRequest) error {
4225 log.Println("[TRACE] EnhancedDBAPI.SetPassword start")
4226 targetArguments := struct {
4227 Argid types.ID `json:"id"`
4228 Argparam *iaas.EnhancedDBSetPasswordRequest `json:"param"`
4229 }{
4230 Argid: id,
4231 Argparam: param,
4232 }
4233 if d, err := json.Marshal(targetArguments); err == nil {
4234 log.Printf("[TRACE] \targs: %s\n", string(d))
4235 }
4236
4237 defer func() {
4238 log.Println("[TRACE] EnhancedDBAPI.SetPassword end")
4239 }()
4240
4241 err := t.Internal.SetPassword(ctx, id, param)
4242 targetResults := struct {
4243 Error error
4244 }{
4245 Error: err,
4246 }
4247 if d, err := json.Marshal(targetResults); err == nil {
4248 log.Printf("[TRACE] \tresults: %s\n", string(d))
4249 }
4250
4251 return err
4252 }
4253
4254 // GetConfig is API call with trace log
4255 func (t *EnhancedDBTracer) GetConfig(ctx context.Context, id types.ID) (*iaas.EnhancedDBConfig, error) {
4256 log.Println("[TRACE] EnhancedDBAPI.GetConfig start")
4257 targetArguments := struct {
4258 Argid types.ID `json:"id"`
4259 }{
4260 Argid: id,
4261 }
4262 if d, err := json.Marshal(targetArguments); err == nil {
4263 log.Printf("[TRACE] \targs: %s\n", string(d))
4264 }
4265
4266 defer func() {
4267 log.Println("[TRACE] EnhancedDBAPI.GetConfig end")
4268 }()
4269
4270 resultEnhancedDBConfig, err := t.Internal.GetConfig(ctx, id)
4271 targetResults := struct {
4272 EnhancedDBConfig *iaas.EnhancedDBConfig
4273 Error error
4274 }{
4275 EnhancedDBConfig: resultEnhancedDBConfig,
4276 Error: err,
4277 }
4278 if d, err := json.Marshal(targetResults); err == nil {
4279 log.Printf("[TRACE] \tresults: %s\n", string(d))
4280 }
4281
4282 return resultEnhancedDBConfig, err
4283 }
4284
4285 // SetConfig is API call with trace log
4286 func (t *EnhancedDBTracer) SetConfig(ctx context.Context, id types.ID, param *iaas.EnhancedDBSetConfigRequest) error {
4287 log.Println("[TRACE] EnhancedDBAPI.SetConfig start")
4288 targetArguments := struct {
4289 Argid types.ID `json:"id"`
4290 Argparam *iaas.EnhancedDBSetConfigRequest `json:"param"`
4291 }{
4292 Argid: id,
4293 Argparam: param,
4294 }
4295 if d, err := json.Marshal(targetArguments); err == nil {
4296 log.Printf("[TRACE] \targs: %s\n", string(d))
4297 }
4298
4299 defer func() {
4300 log.Println("[TRACE] EnhancedDBAPI.SetConfig end")
4301 }()
4302
4303 err := t.Internal.SetConfig(ctx, id, param)
4304 targetResults := struct {
4305 Error error
4306 }{
4307 Error: err,
4308 }
4309 if d, err := json.Marshal(targetResults); err == nil {
4310 log.Printf("[TRACE] \tresults: %s\n", string(d))
4311 }
4312
4313 return err
4314 }
4315
4316 /*************************************************
4317 * ESMETracer
4318 *************************************************/
4319
4320 // ESMETracer is for trace ESMEOp operations
4321 type ESMETracer struct {
4322 Internal iaas.ESMEAPI
4323 }
4324
4325 // NewESMETracer creates new ESMETracer instance
4326 func NewESMETracer(in iaas.ESMEAPI) iaas.ESMEAPI {
4327 return &ESMETracer{
4328 Internal: in,
4329 }
4330 }
4331
4332 // Find is API call with trace log
4333 func (t *ESMETracer) Find(ctx context.Context, conditions *iaas.FindCondition) (*iaas.ESMEFindResult, error) {
4334 log.Println("[TRACE] ESMEAPI.Find start")
4335 targetArguments := struct {
4336 Argconditions *iaas.FindCondition `json:"conditions"`
4337 }{
4338 Argconditions: conditions,
4339 }
4340 if d, err := json.Marshal(targetArguments); err == nil {
4341 log.Printf("[TRACE] \targs: %s\n", string(d))
4342 }
4343
4344 defer func() {
4345 log.Println("[TRACE] ESMEAPI.Find end")
4346 }()
4347
4348 result, err := t.Internal.Find(ctx, conditions)
4349 targetResults := struct {
4350 Result *iaas.ESMEFindResult
4351 Error error
4352 }{
4353 Result: result,
4354 Error: err,
4355 }
4356 if d, err := json.Marshal(targetResults); err == nil {
4357 log.Printf("[TRACE] \tresults: %s\n", string(d))
4358 }
4359
4360 return result, err
4361 }
4362
4363 // Create is API call with trace log
4364 func (t *ESMETracer) Create(ctx context.Context, param *iaas.ESMECreateRequest) (*iaas.ESME, error) {
4365 log.Println("[TRACE] ESMEAPI.Create start")
4366 targetArguments := struct {
4367 Argparam *iaas.ESMECreateRequest `json:"param"`
4368 }{
4369 Argparam: param,
4370 }
4371 if d, err := json.Marshal(targetArguments); err == nil {
4372 log.Printf("[TRACE] \targs: %s\n", string(d))
4373 }
4374
4375 defer func() {
4376 log.Println("[TRACE] ESMEAPI.Create end")
4377 }()
4378
4379 resultESME, err := t.Internal.Create(ctx, param)
4380 targetResults := struct {
4381 ESME *iaas.ESME
4382 Error error
4383 }{
4384 ESME: resultESME,
4385 Error: err,
4386 }
4387 if d, err := json.Marshal(targetResults); err == nil {
4388 log.Printf("[TRACE] \tresults: %s\n", string(d))
4389 }
4390
4391 return resultESME, err
4392 }
4393
4394 // Read is API call with trace log
4395 func (t *ESMETracer) Read(ctx context.Context, id types.ID) (*iaas.ESME, error) {
4396 log.Println("[TRACE] ESMEAPI.Read start")
4397 targetArguments := struct {
4398 Argid types.ID `json:"id"`
4399 }{
4400 Argid: id,
4401 }
4402 if d, err := json.Marshal(targetArguments); err == nil {
4403 log.Printf("[TRACE] \targs: %s\n", string(d))
4404 }
4405
4406 defer func() {
4407 log.Println("[TRACE] ESMEAPI.Read end")
4408 }()
4409
4410 resultESME, err := t.Internal.Read(ctx, id)
4411 targetResults := struct {
4412 ESME *iaas.ESME
4413 Error error
4414 }{
4415 ESME: resultESME,
4416 Error: err,
4417 }
4418 if d, err := json.Marshal(targetResults); err == nil {
4419 log.Printf("[TRACE] \tresults: %s\n", string(d))
4420 }
4421
4422 return resultESME, err
4423 }
4424
4425 // Update is API call with trace log
4426 func (t *ESMETracer) Update(ctx context.Context, id types.ID, param *iaas.ESMEUpdateRequest) (*iaas.ESME, error) {
4427 log.Println("[TRACE] ESMEAPI.Update start")
4428 targetArguments := struct {
4429 Argid types.ID `json:"id"`
4430 Argparam *iaas.ESMEUpdateRequest `json:"param"`
4431 }{
4432 Argid: id,
4433 Argparam: param,
4434 }
4435 if d, err := json.Marshal(targetArguments); err == nil {
4436 log.Printf("[TRACE] \targs: %s\n", string(d))
4437 }
4438
4439 defer func() {
4440 log.Println("[TRACE] ESMEAPI.Update end")
4441 }()
4442
4443 resultESME, err := t.Internal.Update(ctx, id, param)
4444 targetResults := struct {
4445 ESME *iaas.ESME
4446 Error error
4447 }{
4448 ESME: resultESME,
4449 Error: err,
4450 }
4451 if d, err := json.Marshal(targetResults); err == nil {
4452 log.Printf("[TRACE] \tresults: %s\n", string(d))
4453 }
4454
4455 return resultESME, err
4456 }
4457
4458 // Delete is API call with trace log
4459 func (t *ESMETracer) Delete(ctx context.Context, id types.ID) error {
4460 log.Println("[TRACE] ESMEAPI.Delete start")
4461 targetArguments := struct {
4462 Argid types.ID `json:"id"`
4463 }{
4464 Argid: id,
4465 }
4466 if d, err := json.Marshal(targetArguments); err == nil {
4467 log.Printf("[TRACE] \targs: %s\n", string(d))
4468 }
4469
4470 defer func() {
4471 log.Println("[TRACE] ESMEAPI.Delete end")
4472 }()
4473
4474 err := t.Internal.Delete(ctx, id)
4475 targetResults := struct {
4476 Error error
4477 }{
4478 Error: err,
4479 }
4480 if d, err := json.Marshal(targetResults); err == nil {
4481 log.Printf("[TRACE] \tresults: %s\n", string(d))
4482 }
4483
4484 return err
4485 }
4486
4487 // SendMessageWithGeneratedOTP is API call with trace log
4488 func (t *ESMETracer) SendMessageWithGeneratedOTP(ctx context.Context, id types.ID, param *iaas.ESMESendMessageWithGeneratedOTPRequest) (*iaas.ESMESendMessageResult, error) {
4489 log.Println("[TRACE] ESMEAPI.SendMessageWithGeneratedOTP start")
4490 targetArguments := struct {
4491 Argid types.ID `json:"id"`
4492 Argparam *iaas.ESMESendMessageWithGeneratedOTPRequest `json:"param"`
4493 }{
4494 Argid: id,
4495 Argparam: param,
4496 }
4497 if d, err := json.Marshal(targetArguments); err == nil {
4498 log.Printf("[TRACE] \targs: %s\n", string(d))
4499 }
4500
4501 defer func() {
4502 log.Println("[TRACE] ESMEAPI.SendMessageWithGeneratedOTP end")
4503 }()
4504
4505 resultESMESendMessageResult, err := t.Internal.SendMessageWithGeneratedOTP(ctx, id, param)
4506 targetResults := struct {
4507 ESMESendMessageResult *iaas.ESMESendMessageResult
4508 Error error
4509 }{
4510 ESMESendMessageResult: resultESMESendMessageResult,
4511 Error: err,
4512 }
4513 if d, err := json.Marshal(targetResults); err == nil {
4514 log.Printf("[TRACE] \tresults: %s\n", string(d))
4515 }
4516
4517 return resultESMESendMessageResult, err
4518 }
4519
4520 // SendMessageWithInputtedOTP is API call with trace log
4521 func (t *ESMETracer) SendMessageWithInputtedOTP(ctx context.Context, id types.ID, param *iaas.ESMESendMessageWithInputtedOTPRequest) (*iaas.ESMESendMessageResult, error) {
4522 log.Println("[TRACE] ESMEAPI.SendMessageWithInputtedOTP start")
4523 targetArguments := struct {
4524 Argid types.ID `json:"id"`
4525 Argparam *iaas.ESMESendMessageWithInputtedOTPRequest `json:"param"`
4526 }{
4527 Argid: id,
4528 Argparam: param,
4529 }
4530 if d, err := json.Marshal(targetArguments); err == nil {
4531 log.Printf("[TRACE] \targs: %s\n", string(d))
4532 }
4533
4534 defer func() {
4535 log.Println("[TRACE] ESMEAPI.SendMessageWithInputtedOTP end")
4536 }()
4537
4538 resultESMESendMessageResult, err := t.Internal.SendMessageWithInputtedOTP(ctx, id, param)
4539 targetResults := struct {
4540 ESMESendMessageResult *iaas.ESMESendMessageResult
4541 Error error
4542 }{
4543 ESMESendMessageResult: resultESMESendMessageResult,
4544 Error: err,
4545 }
4546 if d, err := json.Marshal(targetResults); err == nil {
4547 log.Printf("[TRACE] \tresults: %s\n", string(d))
4548 }
4549
4550 return resultESMESendMessageResult, err
4551 }
4552
4553 // Logs is API call with trace log
4554 func (t *ESMETracer) Logs(ctx context.Context, id types.ID) ([]*iaas.ESMELogs, error) {
4555 log.Println("[TRACE] ESMEAPI.Logs start")
4556 targetArguments := struct {
4557 Argid types.ID `json:"id"`
4558 }{
4559 Argid: id,
4560 }
4561 if d, err := json.Marshal(targetArguments); err == nil {
4562 log.Printf("[TRACE] \targs: %s\n", string(d))
4563 }
4564
4565 defer func() {
4566 log.Println("[TRACE] ESMEAPI.Logs end")
4567 }()
4568
4569 resultLogs, err := t.Internal.Logs(ctx, id)
4570 targetResults := struct {
4571 Logs []*iaas.ESMELogs
4572 Error error
4573 }{
4574 Logs: resultLogs,
4575 Error: err,
4576 }
4577 if d, err := json.Marshal(targetResults); err == nil {
4578 log.Printf("[TRACE] \tresults: %s\n", string(d))
4579 }
4580
4581 return resultLogs, err
4582 }
4583
4584 /*************************************************
4585 * GSLBTracer
4586 *************************************************/
4587
4588 // GSLBTracer is for trace GSLBOp operations
4589 type GSLBTracer struct {
4590 Internal iaas.GSLBAPI
4591 }
4592
4593 // NewGSLBTracer creates new GSLBTracer instance
4594 func NewGSLBTracer(in iaas.GSLBAPI) iaas.GSLBAPI {
4595 return &GSLBTracer{
4596 Internal: in,
4597 }
4598 }
4599
4600 // Find is API call with trace log
4601 func (t *GSLBTracer) Find(ctx context.Context, conditions *iaas.FindCondition) (*iaas.GSLBFindResult, error) {
4602 log.Println("[TRACE] GSLBAPI.Find start")
4603 targetArguments := struct {
4604 Argconditions *iaas.FindCondition `json:"conditions"`
4605 }{
4606 Argconditions: conditions,
4607 }
4608 if d, err := json.Marshal(targetArguments); err == nil {
4609 log.Printf("[TRACE] \targs: %s\n", string(d))
4610 }
4611
4612 defer func() {
4613 log.Println("[TRACE] GSLBAPI.Find end")
4614 }()
4615
4616 result, err := t.Internal.Find(ctx, conditions)
4617 targetResults := struct {
4618 Result *iaas.GSLBFindResult
4619 Error error
4620 }{
4621 Result: result,
4622 Error: err,
4623 }
4624 if d, err := json.Marshal(targetResults); err == nil {
4625 log.Printf("[TRACE] \tresults: %s\n", string(d))
4626 }
4627
4628 return result, err
4629 }
4630
4631 // Create is API call with trace log
4632 func (t *GSLBTracer) Create(ctx context.Context, param *iaas.GSLBCreateRequest) (*iaas.GSLB, error) {
4633 log.Println("[TRACE] GSLBAPI.Create start")
4634 targetArguments := struct {
4635 Argparam *iaas.GSLBCreateRequest `json:"param"`
4636 }{
4637 Argparam: param,
4638 }
4639 if d, err := json.Marshal(targetArguments); err == nil {
4640 log.Printf("[TRACE] \targs: %s\n", string(d))
4641 }
4642
4643 defer func() {
4644 log.Println("[TRACE] GSLBAPI.Create end")
4645 }()
4646
4647 resultGSLB, err := t.Internal.Create(ctx, param)
4648 targetResults := struct {
4649 GSLB *iaas.GSLB
4650 Error error
4651 }{
4652 GSLB: resultGSLB,
4653 Error: err,
4654 }
4655 if d, err := json.Marshal(targetResults); err == nil {
4656 log.Printf("[TRACE] \tresults: %s\n", string(d))
4657 }
4658
4659 return resultGSLB, err
4660 }
4661
4662 // Read is API call with trace log
4663 func (t *GSLBTracer) Read(ctx context.Context, id types.ID) (*iaas.GSLB, error) {
4664 log.Println("[TRACE] GSLBAPI.Read start")
4665 targetArguments := struct {
4666 Argid types.ID `json:"id"`
4667 }{
4668 Argid: id,
4669 }
4670 if d, err := json.Marshal(targetArguments); err == nil {
4671 log.Printf("[TRACE] \targs: %s\n", string(d))
4672 }
4673
4674 defer func() {
4675 log.Println("[TRACE] GSLBAPI.Read end")
4676 }()
4677
4678 resultGSLB, err := t.Internal.Read(ctx, id)
4679 targetResults := struct {
4680 GSLB *iaas.GSLB
4681 Error error
4682 }{
4683 GSLB: resultGSLB,
4684 Error: err,
4685 }
4686 if d, err := json.Marshal(targetResults); err == nil {
4687 log.Printf("[TRACE] \tresults: %s\n", string(d))
4688 }
4689
4690 return resultGSLB, err
4691 }
4692
4693 // Update is API call with trace log
4694 func (t *GSLBTracer) Update(ctx context.Context, id types.ID, param *iaas.GSLBUpdateRequest) (*iaas.GSLB, error) {
4695 log.Println("[TRACE] GSLBAPI.Update start")
4696 targetArguments := struct {
4697 Argid types.ID `json:"id"`
4698 Argparam *iaas.GSLBUpdateRequest `json:"param"`
4699 }{
4700 Argid: id,
4701 Argparam: param,
4702 }
4703 if d, err := json.Marshal(targetArguments); err == nil {
4704 log.Printf("[TRACE] \targs: %s\n", string(d))
4705 }
4706
4707 defer func() {
4708 log.Println("[TRACE] GSLBAPI.Update end")
4709 }()
4710
4711 resultGSLB, err := t.Internal.Update(ctx, id, param)
4712 targetResults := struct {
4713 GSLB *iaas.GSLB
4714 Error error
4715 }{
4716 GSLB: resultGSLB,
4717 Error: err,
4718 }
4719 if d, err := json.Marshal(targetResults); err == nil {
4720 log.Printf("[TRACE] \tresults: %s\n", string(d))
4721 }
4722
4723 return resultGSLB, err
4724 }
4725
4726 // UpdateSettings is API call with trace log
4727 func (t *GSLBTracer) UpdateSettings(ctx context.Context, id types.ID, param *iaas.GSLBUpdateSettingsRequest) (*iaas.GSLB, error) {
4728 log.Println("[TRACE] GSLBAPI.UpdateSettings start")
4729 targetArguments := struct {
4730 Argid types.ID `json:"id"`
4731 Argparam *iaas.GSLBUpdateSettingsRequest `json:"param"`
4732 }{
4733 Argid: id,
4734 Argparam: param,
4735 }
4736 if d, err := json.Marshal(targetArguments); err == nil {
4737 log.Printf("[TRACE] \targs: %s\n", string(d))
4738 }
4739
4740 defer func() {
4741 log.Println("[TRACE] GSLBAPI.UpdateSettings end")
4742 }()
4743
4744 resultGSLB, err := t.Internal.UpdateSettings(ctx, id, param)
4745 targetResults := struct {
4746 GSLB *iaas.GSLB
4747 Error error
4748 }{
4749 GSLB: resultGSLB,
4750 Error: err,
4751 }
4752 if d, err := json.Marshal(targetResults); err == nil {
4753 log.Printf("[TRACE] \tresults: %s\n", string(d))
4754 }
4755
4756 return resultGSLB, err
4757 }
4758
4759 // Delete is API call with trace log
4760 func (t *GSLBTracer) Delete(ctx context.Context, id types.ID) error {
4761 log.Println("[TRACE] GSLBAPI.Delete start")
4762 targetArguments := struct {
4763 Argid types.ID `json:"id"`
4764 }{
4765 Argid: id,
4766 }
4767 if d, err := json.Marshal(targetArguments); err == nil {
4768 log.Printf("[TRACE] \targs: %s\n", string(d))
4769 }
4770
4771 defer func() {
4772 log.Println("[TRACE] GSLBAPI.Delete end")
4773 }()
4774
4775 err := t.Internal.Delete(ctx, id)
4776 targetResults := struct {
4777 Error error
4778 }{
4779 Error: err,
4780 }
4781 if d, err := json.Marshal(targetResults); err == nil {
4782 log.Printf("[TRACE] \tresults: %s\n", string(d))
4783 }
4784
4785 return err
4786 }
4787
4788 /*************************************************
4789 * IconTracer
4790 *************************************************/
4791
4792 // IconTracer is for trace IconOp operations
4793 type IconTracer struct {
4794 Internal iaas.IconAPI
4795 }
4796
4797 // NewIconTracer creates new IconTracer instance
4798 func NewIconTracer(in iaas.IconAPI) iaas.IconAPI {
4799 return &IconTracer{
4800 Internal: in,
4801 }
4802 }
4803
4804 // Find is API call with trace log
4805 func (t *IconTracer) Find(ctx context.Context, conditions *iaas.FindCondition) (*iaas.IconFindResult, error) {
4806 log.Println("[TRACE] IconAPI.Find start")
4807 targetArguments := struct {
4808 Argconditions *iaas.FindCondition `json:"conditions"`
4809 }{
4810 Argconditions: conditions,
4811 }
4812 if d, err := json.Marshal(targetArguments); err == nil {
4813 log.Printf("[TRACE] \targs: %s\n", string(d))
4814 }
4815
4816 defer func() {
4817 log.Println("[TRACE] IconAPI.Find end")
4818 }()
4819
4820 result, err := t.Internal.Find(ctx, conditions)
4821 targetResults := struct {
4822 Result *iaas.IconFindResult
4823 Error error
4824 }{
4825 Result: result,
4826 Error: err,
4827 }
4828 if d, err := json.Marshal(targetResults); err == nil {
4829 log.Printf("[TRACE] \tresults: %s\n", string(d))
4830 }
4831
4832 return result, err
4833 }
4834
4835 // Create is API call with trace log
4836 func (t *IconTracer) Create(ctx context.Context, param *iaas.IconCreateRequest) (*iaas.Icon, error) {
4837 log.Println("[TRACE] IconAPI.Create start")
4838 targetArguments := struct {
4839 Argparam *iaas.IconCreateRequest `json:"param"`
4840 }{
4841 Argparam: param,
4842 }
4843 if d, err := json.Marshal(targetArguments); err == nil {
4844 log.Printf("[TRACE] \targs: %s\n", string(d))
4845 }
4846
4847 defer func() {
4848 log.Println("[TRACE] IconAPI.Create end")
4849 }()
4850
4851 resultIcon, err := t.Internal.Create(ctx, param)
4852 targetResults := struct {
4853 Icon *iaas.Icon
4854 Error error
4855 }{
4856 Icon: resultIcon,
4857 Error: err,
4858 }
4859 if d, err := json.Marshal(targetResults); err == nil {
4860 log.Printf("[TRACE] \tresults: %s\n", string(d))
4861 }
4862
4863 return resultIcon, err
4864 }
4865
4866 // Read is API call with trace log
4867 func (t *IconTracer) Read(ctx context.Context, id types.ID) (*iaas.Icon, error) {
4868 log.Println("[TRACE] IconAPI.Read start")
4869 targetArguments := struct {
4870 Argid types.ID `json:"id"`
4871 }{
4872 Argid: id,
4873 }
4874 if d, err := json.Marshal(targetArguments); err == nil {
4875 log.Printf("[TRACE] \targs: %s\n", string(d))
4876 }
4877
4878 defer func() {
4879 log.Println("[TRACE] IconAPI.Read end")
4880 }()
4881
4882 resultIcon, err := t.Internal.Read(ctx, id)
4883 targetResults := struct {
4884 Icon *iaas.Icon
4885 Error error
4886 }{
4887 Icon: resultIcon,
4888 Error: err,
4889 }
4890 if d, err := json.Marshal(targetResults); err == nil {
4891 log.Printf("[TRACE] \tresults: %s\n", string(d))
4892 }
4893
4894 return resultIcon, err
4895 }
4896
4897 // Update is API call with trace log
4898 func (t *IconTracer) Update(ctx context.Context, id types.ID, param *iaas.IconUpdateRequest) (*iaas.Icon, error) {
4899 log.Println("[TRACE] IconAPI.Update start")
4900 targetArguments := struct {
4901 Argid types.ID `json:"id"`
4902 Argparam *iaas.IconUpdateRequest `json:"param"`
4903 }{
4904 Argid: id,
4905 Argparam: param,
4906 }
4907 if d, err := json.Marshal(targetArguments); err == nil {
4908 log.Printf("[TRACE] \targs: %s\n", string(d))
4909 }
4910
4911 defer func() {
4912 log.Println("[TRACE] IconAPI.Update end")
4913 }()
4914
4915 resultIcon, err := t.Internal.Update(ctx, id, param)
4916 targetResults := struct {
4917 Icon *iaas.Icon
4918 Error error
4919 }{
4920 Icon: resultIcon,
4921 Error: err,
4922 }
4923 if d, err := json.Marshal(targetResults); err == nil {
4924 log.Printf("[TRACE] \tresults: %s\n", string(d))
4925 }
4926
4927 return resultIcon, err
4928 }
4929
4930 // Delete is API call with trace log
4931 func (t *IconTracer) Delete(ctx context.Context, id types.ID) error {
4932 log.Println("[TRACE] IconAPI.Delete start")
4933 targetArguments := struct {
4934 Argid types.ID `json:"id"`
4935 }{
4936 Argid: id,
4937 }
4938 if d, err := json.Marshal(targetArguments); err == nil {
4939 log.Printf("[TRACE] \targs: %s\n", string(d))
4940 }
4941
4942 defer func() {
4943 log.Println("[TRACE] IconAPI.Delete end")
4944 }()
4945
4946 err := t.Internal.Delete(ctx, id)
4947 targetResults := struct {
4948 Error error
4949 }{
4950 Error: err,
4951 }
4952 if d, err := json.Marshal(targetResults); err == nil {
4953 log.Printf("[TRACE] \tresults: %s\n", string(d))
4954 }
4955
4956 return err
4957 }
4958
4959 /*************************************************
4960 * InterfaceTracer
4961 *************************************************/
4962
4963 // InterfaceTracer is for trace InterfaceOp operations
4964 type InterfaceTracer struct {
4965 Internal iaas.InterfaceAPI
4966 }
4967
4968 // NewInterfaceTracer creates new InterfaceTracer instance
4969 func NewInterfaceTracer(in iaas.InterfaceAPI) iaas.InterfaceAPI {
4970 return &InterfaceTracer{
4971 Internal: in,
4972 }
4973 }
4974
4975 // Find is API call with trace log
4976 func (t *InterfaceTracer) Find(ctx context.Context, zone string, conditions *iaas.FindCondition) (*iaas.InterfaceFindResult, error) {
4977 log.Println("[TRACE] InterfaceAPI.Find start")
4978 targetArguments := struct {
4979 Argzone string
4980 Argconditions *iaas.FindCondition `json:"conditions"`
4981 }{
4982 Argzone: zone,
4983 Argconditions: conditions,
4984 }
4985 if d, err := json.Marshal(targetArguments); err == nil {
4986 log.Printf("[TRACE] \targs: %s\n", string(d))
4987 }
4988
4989 defer func() {
4990 log.Println("[TRACE] InterfaceAPI.Find end")
4991 }()
4992
4993 result, err := t.Internal.Find(ctx, zone, conditions)
4994 targetResults := struct {
4995 Result *iaas.InterfaceFindResult
4996 Error error
4997 }{
4998 Result: result,
4999 Error: err,
5000 }
5001 if d, err := json.Marshal(targetResults); err == nil {
5002 log.Printf("[TRACE] \tresults: %s\n", string(d))
5003 }
5004
5005 return result, err
5006 }
5007
5008 // Create is API call with trace log
5009 func (t *InterfaceTracer) Create(ctx context.Context, zone string, param *iaas.InterfaceCreateRequest) (*iaas.Interface, error) {
5010 log.Println("[TRACE] InterfaceAPI.Create start")
5011 targetArguments := struct {
5012 Argzone string
5013 Argparam *iaas.InterfaceCreateRequest `json:"param"`
5014 }{
5015 Argzone: zone,
5016 Argparam: param,
5017 }
5018 if d, err := json.Marshal(targetArguments); err == nil {
5019 log.Printf("[TRACE] \targs: %s\n", string(d))
5020 }
5021
5022 defer func() {
5023 log.Println("[TRACE] InterfaceAPI.Create end")
5024 }()
5025
5026 resultInterface, err := t.Internal.Create(ctx, zone, param)
5027 targetResults := struct {
5028 Interface *iaas.Interface
5029 Error error
5030 }{
5031 Interface: resultInterface,
5032 Error: err,
5033 }
5034 if d, err := json.Marshal(targetResults); err == nil {
5035 log.Printf("[TRACE] \tresults: %s\n", string(d))
5036 }
5037
5038 return resultInterface, err
5039 }
5040
5041 // Read is API call with trace log
5042 func (t *InterfaceTracer) Read(ctx context.Context, zone string, id types.ID) (*iaas.Interface, error) {
5043 log.Println("[TRACE] InterfaceAPI.Read start")
5044 targetArguments := struct {
5045 Argzone string
5046 Argid types.ID `json:"id"`
5047 }{
5048 Argzone: zone,
5049 Argid: id,
5050 }
5051 if d, err := json.Marshal(targetArguments); err == nil {
5052 log.Printf("[TRACE] \targs: %s\n", string(d))
5053 }
5054
5055 defer func() {
5056 log.Println("[TRACE] InterfaceAPI.Read end")
5057 }()
5058
5059 resultInterface, err := t.Internal.Read(ctx, zone, id)
5060 targetResults := struct {
5061 Interface *iaas.Interface
5062 Error error
5063 }{
5064 Interface: resultInterface,
5065 Error: err,
5066 }
5067 if d, err := json.Marshal(targetResults); err == nil {
5068 log.Printf("[TRACE] \tresults: %s\n", string(d))
5069 }
5070
5071 return resultInterface, err
5072 }
5073
5074 // Update is API call with trace log
5075 func (t *InterfaceTracer) Update(ctx context.Context, zone string, id types.ID, param *iaas.InterfaceUpdateRequest) (*iaas.Interface, error) {
5076 log.Println("[TRACE] InterfaceAPI.Update start")
5077 targetArguments := struct {
5078 Argzone string
5079 Argid types.ID `json:"id"`
5080 Argparam *iaas.InterfaceUpdateRequest `json:"param"`
5081 }{
5082 Argzone: zone,
5083 Argid: id,
5084 Argparam: param,
5085 }
5086 if d, err := json.Marshal(targetArguments); err == nil {
5087 log.Printf("[TRACE] \targs: %s\n", string(d))
5088 }
5089
5090 defer func() {
5091 log.Println("[TRACE] InterfaceAPI.Update end")
5092 }()
5093
5094 resultInterface, err := t.Internal.Update(ctx, zone, id, param)
5095 targetResults := struct {
5096 Interface *iaas.Interface
5097 Error error
5098 }{
5099 Interface: resultInterface,
5100 Error: err,
5101 }
5102 if d, err := json.Marshal(targetResults); err == nil {
5103 log.Printf("[TRACE] \tresults: %s\n", string(d))
5104 }
5105
5106 return resultInterface, err
5107 }
5108
5109 // Delete is API call with trace log
5110 func (t *InterfaceTracer) Delete(ctx context.Context, zone string, id types.ID) error {
5111 log.Println("[TRACE] InterfaceAPI.Delete start")
5112 targetArguments := struct {
5113 Argzone string
5114 Argid types.ID `json:"id"`
5115 }{
5116 Argzone: zone,
5117 Argid: id,
5118 }
5119 if d, err := json.Marshal(targetArguments); err == nil {
5120 log.Printf("[TRACE] \targs: %s\n", string(d))
5121 }
5122
5123 defer func() {
5124 log.Println("[TRACE] InterfaceAPI.Delete end")
5125 }()
5126
5127 err := t.Internal.Delete(ctx, zone, id)
5128 targetResults := struct {
5129 Error error
5130 }{
5131 Error: err,
5132 }
5133 if d, err := json.Marshal(targetResults); err == nil {
5134 log.Printf("[TRACE] \tresults: %s\n", string(d))
5135 }
5136
5137 return err
5138 }
5139
5140 // Monitor is API call with trace log
5141 func (t *InterfaceTracer) Monitor(ctx context.Context, zone string, id types.ID, condition *iaas.MonitorCondition) (*iaas.InterfaceActivity, error) {
5142 log.Println("[TRACE] InterfaceAPI.Monitor start")
5143 targetArguments := struct {
5144 Argzone string
5145 Argid types.ID `json:"id"`
5146 Argcondition *iaas.MonitorCondition `json:"condition"`
5147 }{
5148 Argzone: zone,
5149 Argid: id,
5150 Argcondition: condition,
5151 }
5152 if d, err := json.Marshal(targetArguments); err == nil {
5153 log.Printf("[TRACE] \targs: %s\n", string(d))
5154 }
5155
5156 defer func() {
5157 log.Println("[TRACE] InterfaceAPI.Monitor end")
5158 }()
5159
5160 resultInterfaceActivity, err := t.Internal.Monitor(ctx, zone, id, condition)
5161 targetResults := struct {
5162 InterfaceActivity *iaas.InterfaceActivity
5163 Error error
5164 }{
5165 InterfaceActivity: resultInterfaceActivity,
5166 Error: err,
5167 }
5168 if d, err := json.Marshal(targetResults); err == nil {
5169 log.Printf("[TRACE] \tresults: %s\n", string(d))
5170 }
5171
5172 return resultInterfaceActivity, err
5173 }
5174
5175 // ConnectToSharedSegment is API call with trace log
5176 func (t *InterfaceTracer) ConnectToSharedSegment(ctx context.Context, zone string, id types.ID) error {
5177 log.Println("[TRACE] InterfaceAPI.ConnectToSharedSegment start")
5178 targetArguments := struct {
5179 Argzone string
5180 Argid types.ID `json:"id"`
5181 }{
5182 Argzone: zone,
5183 Argid: id,
5184 }
5185 if d, err := json.Marshal(targetArguments); err == nil {
5186 log.Printf("[TRACE] \targs: %s\n", string(d))
5187 }
5188
5189 defer func() {
5190 log.Println("[TRACE] InterfaceAPI.ConnectToSharedSegment end")
5191 }()
5192
5193 err := t.Internal.ConnectToSharedSegment(ctx, zone, id)
5194 targetResults := struct {
5195 Error error
5196 }{
5197 Error: err,
5198 }
5199 if d, err := json.Marshal(targetResults); err == nil {
5200 log.Printf("[TRACE] \tresults: %s\n", string(d))
5201 }
5202
5203 return err
5204 }
5205
5206 // ConnectToSwitch is API call with trace log
5207 func (t *InterfaceTracer) ConnectToSwitch(ctx context.Context, zone string, id types.ID, switchID types.ID) error {
5208 log.Println("[TRACE] InterfaceAPI.ConnectToSwitch start")
5209 targetArguments := struct {
5210 Argzone string
5211 Argid types.ID `json:"id"`
5212 ArgswitchID types.ID `json:"switchID"`
5213 }{
5214 Argzone: zone,
5215 Argid: id,
5216 ArgswitchID: switchID,
5217 }
5218 if d, err := json.Marshal(targetArguments); err == nil {
5219 log.Printf("[TRACE] \targs: %s\n", string(d))
5220 }
5221
5222 defer func() {
5223 log.Println("[TRACE] InterfaceAPI.ConnectToSwitch end")
5224 }()
5225
5226 err := t.Internal.ConnectToSwitch(ctx, zone, id, switchID)
5227 targetResults := struct {
5228 Error error
5229 }{
5230 Error: err,
5231 }
5232 if d, err := json.Marshal(targetResults); err == nil {
5233 log.Printf("[TRACE] \tresults: %s\n", string(d))
5234 }
5235
5236 return err
5237 }
5238
5239 // DisconnectFromSwitch is API call with trace log
5240 func (t *InterfaceTracer) DisconnectFromSwitch(ctx context.Context, zone string, id types.ID) error {
5241 log.Println("[TRACE] InterfaceAPI.DisconnectFromSwitch start")
5242 targetArguments := struct {
5243 Argzone string
5244 Argid types.ID `json:"id"`
5245 }{
5246 Argzone: zone,
5247 Argid: id,
5248 }
5249 if d, err := json.Marshal(targetArguments); err == nil {
5250 log.Printf("[TRACE] \targs: %s\n", string(d))
5251 }
5252
5253 defer func() {
5254 log.Println("[TRACE] InterfaceAPI.DisconnectFromSwitch end")
5255 }()
5256
5257 err := t.Internal.DisconnectFromSwitch(ctx, zone, id)
5258 targetResults := struct {
5259 Error error
5260 }{
5261 Error: err,
5262 }
5263 if d, err := json.Marshal(targetResults); err == nil {
5264 log.Printf("[TRACE] \tresults: %s\n", string(d))
5265 }
5266
5267 return err
5268 }
5269
5270 // ConnectToPacketFilter is API call with trace log
5271 func (t *InterfaceTracer) ConnectToPacketFilter(ctx context.Context, zone string, id types.ID, packetFilterID types.ID) error {
5272 log.Println("[TRACE] InterfaceAPI.ConnectToPacketFilter start")
5273 targetArguments := struct {
5274 Argzone string
5275 Argid types.ID `json:"id"`
5276 ArgpacketFilterID types.ID `json:"packetFilterID"`
5277 }{
5278 Argzone: zone,
5279 Argid: id,
5280 ArgpacketFilterID: packetFilterID,
5281 }
5282 if d, err := json.Marshal(targetArguments); err == nil {
5283 log.Printf("[TRACE] \targs: %s\n", string(d))
5284 }
5285
5286 defer func() {
5287 log.Println("[TRACE] InterfaceAPI.ConnectToPacketFilter end")
5288 }()
5289
5290 err := t.Internal.ConnectToPacketFilter(ctx, zone, id, packetFilterID)
5291 targetResults := struct {
5292 Error error
5293 }{
5294 Error: err,
5295 }
5296 if d, err := json.Marshal(targetResults); err == nil {
5297 log.Printf("[TRACE] \tresults: %s\n", string(d))
5298 }
5299
5300 return err
5301 }
5302
5303 // DisconnectFromPacketFilter is API call with trace log
5304 func (t *InterfaceTracer) DisconnectFromPacketFilter(ctx context.Context, zone string, id types.ID) error {
5305 log.Println("[TRACE] InterfaceAPI.DisconnectFromPacketFilter start")
5306 targetArguments := struct {
5307 Argzone string
5308 Argid types.ID `json:"id"`
5309 }{
5310 Argzone: zone,
5311 Argid: id,
5312 }
5313 if d, err := json.Marshal(targetArguments); err == nil {
5314 log.Printf("[TRACE] \targs: %s\n", string(d))
5315 }
5316
5317 defer func() {
5318 log.Println("[TRACE] InterfaceAPI.DisconnectFromPacketFilter end")
5319 }()
5320
5321 err := t.Internal.DisconnectFromPacketFilter(ctx, zone, id)
5322 targetResults := struct {
5323 Error error
5324 }{
5325 Error: err,
5326 }
5327 if d, err := json.Marshal(targetResults); err == nil {
5328 log.Printf("[TRACE] \tresults: %s\n", string(d))
5329 }
5330
5331 return err
5332 }
5333
5334 /*************************************************
5335 * InternetTracer
5336 *************************************************/
5337
5338 // InternetTracer is for trace InternetOp operations
5339 type InternetTracer struct {
5340 Internal iaas.InternetAPI
5341 }
5342
5343 // NewInternetTracer creates new InternetTracer instance
5344 func NewInternetTracer(in iaas.InternetAPI) iaas.InternetAPI {
5345 return &InternetTracer{
5346 Internal: in,
5347 }
5348 }
5349
5350 // Find is API call with trace log
5351 func (t *InternetTracer) Find(ctx context.Context, zone string, conditions *iaas.FindCondition) (*iaas.InternetFindResult, error) {
5352 log.Println("[TRACE] InternetAPI.Find start")
5353 targetArguments := struct {
5354 Argzone string
5355 Argconditions *iaas.FindCondition `json:"conditions"`
5356 }{
5357 Argzone: zone,
5358 Argconditions: conditions,
5359 }
5360 if d, err := json.Marshal(targetArguments); err == nil {
5361 log.Printf("[TRACE] \targs: %s\n", string(d))
5362 }
5363
5364 defer func() {
5365 log.Println("[TRACE] InternetAPI.Find end")
5366 }()
5367
5368 result, err := t.Internal.Find(ctx, zone, conditions)
5369 targetResults := struct {
5370 Result *iaas.InternetFindResult
5371 Error error
5372 }{
5373 Result: result,
5374 Error: err,
5375 }
5376 if d, err := json.Marshal(targetResults); err == nil {
5377 log.Printf("[TRACE] \tresults: %s\n", string(d))
5378 }
5379
5380 return result, err
5381 }
5382
5383 // Create is API call with trace log
5384 func (t *InternetTracer) Create(ctx context.Context, zone string, param *iaas.InternetCreateRequest) (*iaas.Internet, error) {
5385 log.Println("[TRACE] InternetAPI.Create start")
5386 targetArguments := struct {
5387 Argzone string
5388 Argparam *iaas.InternetCreateRequest `json:"param"`
5389 }{
5390 Argzone: zone,
5391 Argparam: param,
5392 }
5393 if d, err := json.Marshal(targetArguments); err == nil {
5394 log.Printf("[TRACE] \targs: %s\n", string(d))
5395 }
5396
5397 defer func() {
5398 log.Println("[TRACE] InternetAPI.Create end")
5399 }()
5400
5401 resultInternet, err := t.Internal.Create(ctx, zone, param)
5402 targetResults := struct {
5403 Internet *iaas.Internet
5404 Error error
5405 }{
5406 Internet: resultInternet,
5407 Error: err,
5408 }
5409 if d, err := json.Marshal(targetResults); err == nil {
5410 log.Printf("[TRACE] \tresults: %s\n", string(d))
5411 }
5412
5413 return resultInternet, err
5414 }
5415
5416 // Read is API call with trace log
5417 func (t *InternetTracer) Read(ctx context.Context, zone string, id types.ID) (*iaas.Internet, error) {
5418 log.Println("[TRACE] InternetAPI.Read start")
5419 targetArguments := struct {
5420 Argzone string
5421 Argid types.ID `json:"id"`
5422 }{
5423 Argzone: zone,
5424 Argid: id,
5425 }
5426 if d, err := json.Marshal(targetArguments); err == nil {
5427 log.Printf("[TRACE] \targs: %s\n", string(d))
5428 }
5429
5430 defer func() {
5431 log.Println("[TRACE] InternetAPI.Read end")
5432 }()
5433
5434 resultInternet, err := t.Internal.Read(ctx, zone, id)
5435 targetResults := struct {
5436 Internet *iaas.Internet
5437 Error error
5438 }{
5439 Internet: resultInternet,
5440 Error: err,
5441 }
5442 if d, err := json.Marshal(targetResults); err == nil {
5443 log.Printf("[TRACE] \tresults: %s\n", string(d))
5444 }
5445
5446 return resultInternet, err
5447 }
5448
5449 // Update is API call with trace log
5450 func (t *InternetTracer) Update(ctx context.Context, zone string, id types.ID, param *iaas.InternetUpdateRequest) (*iaas.Internet, error) {
5451 log.Println("[TRACE] InternetAPI.Update start")
5452 targetArguments := struct {
5453 Argzone string
5454 Argid types.ID `json:"id"`
5455 Argparam *iaas.InternetUpdateRequest `json:"param"`
5456 }{
5457 Argzone: zone,
5458 Argid: id,
5459 Argparam: param,
5460 }
5461 if d, err := json.Marshal(targetArguments); err == nil {
5462 log.Printf("[TRACE] \targs: %s\n", string(d))
5463 }
5464
5465 defer func() {
5466 log.Println("[TRACE] InternetAPI.Update end")
5467 }()
5468
5469 resultInternet, err := t.Internal.Update(ctx, zone, id, param)
5470 targetResults := struct {
5471 Internet *iaas.Internet
5472 Error error
5473 }{
5474 Internet: resultInternet,
5475 Error: err,
5476 }
5477 if d, err := json.Marshal(targetResults); err == nil {
5478 log.Printf("[TRACE] \tresults: %s\n", string(d))
5479 }
5480
5481 return resultInternet, err
5482 }
5483
5484 // Delete is API call with trace log
5485 func (t *InternetTracer) Delete(ctx context.Context, zone string, id types.ID) error {
5486 log.Println("[TRACE] InternetAPI.Delete start")
5487 targetArguments := struct {
5488 Argzone string
5489 Argid types.ID `json:"id"`
5490 }{
5491 Argzone: zone,
5492 Argid: id,
5493 }
5494 if d, err := json.Marshal(targetArguments); err == nil {
5495 log.Printf("[TRACE] \targs: %s\n", string(d))
5496 }
5497
5498 defer func() {
5499 log.Println("[TRACE] InternetAPI.Delete end")
5500 }()
5501
5502 err := t.Internal.Delete(ctx, zone, id)
5503 targetResults := struct {
5504 Error error
5505 }{
5506 Error: err,
5507 }
5508 if d, err := json.Marshal(targetResults); err == nil {
5509 log.Printf("[TRACE] \tresults: %s\n", string(d))
5510 }
5511
5512 return err
5513 }
5514
5515 // UpdateBandWidth is API call with trace log
5516 func (t *InternetTracer) UpdateBandWidth(ctx context.Context, zone string, id types.ID, param *iaas.InternetUpdateBandWidthRequest) (*iaas.Internet, error) {
5517 log.Println("[TRACE] InternetAPI.UpdateBandWidth start")
5518 targetArguments := struct {
5519 Argzone string
5520 Argid types.ID `json:"id"`
5521 Argparam *iaas.InternetUpdateBandWidthRequest `json:"param"`
5522 }{
5523 Argzone: zone,
5524 Argid: id,
5525 Argparam: param,
5526 }
5527 if d, err := json.Marshal(targetArguments); err == nil {
5528 log.Printf("[TRACE] \targs: %s\n", string(d))
5529 }
5530
5531 defer func() {
5532 log.Println("[TRACE] InternetAPI.UpdateBandWidth end")
5533 }()
5534
5535 resultInternet, err := t.Internal.UpdateBandWidth(ctx, zone, id, param)
5536 targetResults := struct {
5537 Internet *iaas.Internet
5538 Error error
5539 }{
5540 Internet: resultInternet,
5541 Error: err,
5542 }
5543 if d, err := json.Marshal(targetResults); err == nil {
5544 log.Printf("[TRACE] \tresults: %s\n", string(d))
5545 }
5546
5547 return resultInternet, err
5548 }
5549
5550 // AddSubnet is API call with trace log
5551 func (t *InternetTracer) AddSubnet(ctx context.Context, zone string, id types.ID, param *iaas.InternetAddSubnetRequest) (*iaas.InternetSubnetOperationResult, error) {
5552 log.Println("[TRACE] InternetAPI.AddSubnet start")
5553 targetArguments := struct {
5554 Argzone string
5555 Argid types.ID `json:"id"`
5556 Argparam *iaas.InternetAddSubnetRequest `json:"param"`
5557 }{
5558 Argzone: zone,
5559 Argid: id,
5560 Argparam: param,
5561 }
5562 if d, err := json.Marshal(targetArguments); err == nil {
5563 log.Printf("[TRACE] \targs: %s\n", string(d))
5564 }
5565
5566 defer func() {
5567 log.Println("[TRACE] InternetAPI.AddSubnet end")
5568 }()
5569
5570 resultSubnet, err := t.Internal.AddSubnet(ctx, zone, id, param)
5571 targetResults := struct {
5572 Subnet *iaas.InternetSubnetOperationResult
5573 Error error
5574 }{
5575 Subnet: resultSubnet,
5576 Error: err,
5577 }
5578 if d, err := json.Marshal(targetResults); err == nil {
5579 log.Printf("[TRACE] \tresults: %s\n", string(d))
5580 }
5581
5582 return resultSubnet, err
5583 }
5584
5585 // UpdateSubnet is API call with trace log
5586 func (t *InternetTracer) UpdateSubnet(ctx context.Context, zone string, id types.ID, subnetID types.ID, param *iaas.InternetUpdateSubnetRequest) (*iaas.InternetSubnetOperationResult, error) {
5587 log.Println("[TRACE] InternetAPI.UpdateSubnet start")
5588 targetArguments := struct {
5589 Argzone string
5590 Argid types.ID `json:"id"`
5591 ArgsubnetID types.ID `json:"subnetID"`
5592 Argparam *iaas.InternetUpdateSubnetRequest `json:"param"`
5593 }{
5594 Argzone: zone,
5595 Argid: id,
5596 ArgsubnetID: subnetID,
5597 Argparam: param,
5598 }
5599 if d, err := json.Marshal(targetArguments); err == nil {
5600 log.Printf("[TRACE] \targs: %s\n", string(d))
5601 }
5602
5603 defer func() {
5604 log.Println("[TRACE] InternetAPI.UpdateSubnet end")
5605 }()
5606
5607 resultSubnet, err := t.Internal.UpdateSubnet(ctx, zone, id, subnetID, param)
5608 targetResults := struct {
5609 Subnet *iaas.InternetSubnetOperationResult
5610 Error error
5611 }{
5612 Subnet: resultSubnet,
5613 Error: err,
5614 }
5615 if d, err := json.Marshal(targetResults); err == nil {
5616 log.Printf("[TRACE] \tresults: %s\n", string(d))
5617 }
5618
5619 return resultSubnet, err
5620 }
5621
5622 // DeleteSubnet is API call with trace log
5623 func (t *InternetTracer) DeleteSubnet(ctx context.Context, zone string, id types.ID, subnetID types.ID) error {
5624 log.Println("[TRACE] InternetAPI.DeleteSubnet start")
5625 targetArguments := struct {
5626 Argzone string
5627 Argid types.ID `json:"id"`
5628 ArgsubnetID types.ID `json:"subnetID"`
5629 }{
5630 Argzone: zone,
5631 Argid: id,
5632 ArgsubnetID: subnetID,
5633 }
5634 if d, err := json.Marshal(targetArguments); err == nil {
5635 log.Printf("[TRACE] \targs: %s\n", string(d))
5636 }
5637
5638 defer func() {
5639 log.Println("[TRACE] InternetAPI.DeleteSubnet end")
5640 }()
5641
5642 err := t.Internal.DeleteSubnet(ctx, zone, id, subnetID)
5643 targetResults := struct {
5644 Error error
5645 }{
5646 Error: err,
5647 }
5648 if d, err := json.Marshal(targetResults); err == nil {
5649 log.Printf("[TRACE] \tresults: %s\n", string(d))
5650 }
5651
5652 return err
5653 }
5654
5655 // Monitor is API call with trace log
5656 func (t *InternetTracer) Monitor(ctx context.Context, zone string, id types.ID, condition *iaas.MonitorCondition) (*iaas.RouterActivity, error) {
5657 log.Println("[TRACE] InternetAPI.Monitor start")
5658 targetArguments := struct {
5659 Argzone string
5660 Argid types.ID `json:"id"`
5661 Argcondition *iaas.MonitorCondition `json:"condition"`
5662 }{
5663 Argzone: zone,
5664 Argid: id,
5665 Argcondition: condition,
5666 }
5667 if d, err := json.Marshal(targetArguments); err == nil {
5668 log.Printf("[TRACE] \targs: %s\n", string(d))
5669 }
5670
5671 defer func() {
5672 log.Println("[TRACE] InternetAPI.Monitor end")
5673 }()
5674
5675 resultRouterActivity, err := t.Internal.Monitor(ctx, zone, id, condition)
5676 targetResults := struct {
5677 RouterActivity *iaas.RouterActivity
5678 Error error
5679 }{
5680 RouterActivity: resultRouterActivity,
5681 Error: err,
5682 }
5683 if d, err := json.Marshal(targetResults); err == nil {
5684 log.Printf("[TRACE] \tresults: %s\n", string(d))
5685 }
5686
5687 return resultRouterActivity, err
5688 }
5689
5690 // MonitorRouter is API call with trace log
5691 func (t *InternetTracer) MonitorRouter(ctx context.Context, zone string, id types.ID, condition *iaas.MonitorCondition) (*iaas.RouterActivity, error) {
5692 log.Println("[TRACE] InternetAPI.MonitorRouter start")
5693 targetArguments := struct {
5694 Argzone string
5695 Argid types.ID `json:"id"`
5696 Argcondition *iaas.MonitorCondition `json:"condition"`
5697 }{
5698 Argzone: zone,
5699 Argid: id,
5700 Argcondition: condition,
5701 }
5702 if d, err := json.Marshal(targetArguments); err == nil {
5703 log.Printf("[TRACE] \targs: %s\n", string(d))
5704 }
5705
5706 defer func() {
5707 log.Println("[TRACE] InternetAPI.MonitorRouter end")
5708 }()
5709
5710 resultRouterActivity, err := t.Internal.MonitorRouter(ctx, zone, id, condition)
5711 targetResults := struct {
5712 RouterActivity *iaas.RouterActivity
5713 Error error
5714 }{
5715 RouterActivity: resultRouterActivity,
5716 Error: err,
5717 }
5718 if d, err := json.Marshal(targetResults); err == nil {
5719 log.Printf("[TRACE] \tresults: %s\n", string(d))
5720 }
5721
5722 return resultRouterActivity, err
5723 }
5724
5725 // EnableIPv6 is API call with trace log
5726 func (t *InternetTracer) EnableIPv6(ctx context.Context, zone string, id types.ID) (*iaas.IPv6NetInfo, error) {
5727 log.Println("[TRACE] InternetAPI.EnableIPv6 start")
5728 targetArguments := struct {
5729 Argzone string
5730 Argid types.ID `json:"id"`
5731 }{
5732 Argzone: zone,
5733 Argid: id,
5734 }
5735 if d, err := json.Marshal(targetArguments); err == nil {
5736 log.Printf("[TRACE] \targs: %s\n", string(d))
5737 }
5738
5739 defer func() {
5740 log.Println("[TRACE] InternetAPI.EnableIPv6 end")
5741 }()
5742
5743 resultIPv6Net, err := t.Internal.EnableIPv6(ctx, zone, id)
5744 targetResults := struct {
5745 IPv6Net *iaas.IPv6NetInfo
5746 Error error
5747 }{
5748 IPv6Net: resultIPv6Net,
5749 Error: err,
5750 }
5751 if d, err := json.Marshal(targetResults); err == nil {
5752 log.Printf("[TRACE] \tresults: %s\n", string(d))
5753 }
5754
5755 return resultIPv6Net, err
5756 }
5757
5758 // DisableIPv6 is API call with trace log
5759 func (t *InternetTracer) DisableIPv6(ctx context.Context, zone string, id types.ID, ipv6netID types.ID) error {
5760 log.Println("[TRACE] InternetAPI.DisableIPv6 start")
5761 targetArguments := struct {
5762 Argzone string
5763 Argid types.ID `json:"id"`
5764 Argipv6netID types.ID `json:"ipv6netID"`
5765 }{
5766 Argzone: zone,
5767 Argid: id,
5768 Argipv6netID: ipv6netID,
5769 }
5770 if d, err := json.Marshal(targetArguments); err == nil {
5771 log.Printf("[TRACE] \targs: %s\n", string(d))
5772 }
5773
5774 defer func() {
5775 log.Println("[TRACE] InternetAPI.DisableIPv6 end")
5776 }()
5777
5778 err := t.Internal.DisableIPv6(ctx, zone, id, ipv6netID)
5779 targetResults := struct {
5780 Error error
5781 }{
5782 Error: err,
5783 }
5784 if d, err := json.Marshal(targetResults); err == nil {
5785 log.Printf("[TRACE] \tresults: %s\n", string(d))
5786 }
5787
5788 return err
5789 }
5790
5791 /*************************************************
5792 * InternetPlanTracer
5793 *************************************************/
5794
5795 // InternetPlanTracer is for trace InternetPlanOp operations
5796 type InternetPlanTracer struct {
5797 Internal iaas.InternetPlanAPI
5798 }
5799
5800 // NewInternetPlanTracer creates new InternetPlanTracer instance
5801 func NewInternetPlanTracer(in iaas.InternetPlanAPI) iaas.InternetPlanAPI {
5802 return &InternetPlanTracer{
5803 Internal: in,
5804 }
5805 }
5806
5807 // Find is API call with trace log
5808 func (t *InternetPlanTracer) Find(ctx context.Context, zone string, conditions *iaas.FindCondition) (*iaas.InternetPlanFindResult, error) {
5809 log.Println("[TRACE] InternetPlanAPI.Find start")
5810 targetArguments := struct {
5811 Argzone string
5812 Argconditions *iaas.FindCondition `json:"conditions"`
5813 }{
5814 Argzone: zone,
5815 Argconditions: conditions,
5816 }
5817 if d, err := json.Marshal(targetArguments); err == nil {
5818 log.Printf("[TRACE] \targs: %s\n", string(d))
5819 }
5820
5821 defer func() {
5822 log.Println("[TRACE] InternetPlanAPI.Find end")
5823 }()
5824
5825 result, err := t.Internal.Find(ctx, zone, conditions)
5826 targetResults := struct {
5827 Result *iaas.InternetPlanFindResult
5828 Error error
5829 }{
5830 Result: result,
5831 Error: err,
5832 }
5833 if d, err := json.Marshal(targetResults); err == nil {
5834 log.Printf("[TRACE] \tresults: %s\n", string(d))
5835 }
5836
5837 return result, err
5838 }
5839
5840 // Read is API call with trace log
5841 func (t *InternetPlanTracer) Read(ctx context.Context, zone string, id types.ID) (*iaas.InternetPlan, error) {
5842 log.Println("[TRACE] InternetPlanAPI.Read start")
5843 targetArguments := struct {
5844 Argzone string
5845 Argid types.ID `json:"id"`
5846 }{
5847 Argzone: zone,
5848 Argid: id,
5849 }
5850 if d, err := json.Marshal(targetArguments); err == nil {
5851 log.Printf("[TRACE] \targs: %s\n", string(d))
5852 }
5853
5854 defer func() {
5855 log.Println("[TRACE] InternetPlanAPI.Read end")
5856 }()
5857
5858 resultInternetPlan, err := t.Internal.Read(ctx, zone, id)
5859 targetResults := struct {
5860 InternetPlan *iaas.InternetPlan
5861 Error error
5862 }{
5863 InternetPlan: resultInternetPlan,
5864 Error: err,
5865 }
5866 if d, err := json.Marshal(targetResults); err == nil {
5867 log.Printf("[TRACE] \tresults: %s\n", string(d))
5868 }
5869
5870 return resultInternetPlan, err
5871 }
5872
5873 /*************************************************
5874 * IPAddressTracer
5875 *************************************************/
5876
5877 // IPAddressTracer is for trace IPAddressOp operations
5878 type IPAddressTracer struct {
5879 Internal iaas.IPAddressAPI
5880 }
5881
5882 // NewIPAddressTracer creates new IPAddressTracer instance
5883 func NewIPAddressTracer(in iaas.IPAddressAPI) iaas.IPAddressAPI {
5884 return &IPAddressTracer{
5885 Internal: in,
5886 }
5887 }
5888
5889 // List is API call with trace log
5890 func (t *IPAddressTracer) List(ctx context.Context, zone string) (*iaas.IPAddressListResult, error) {
5891 log.Println("[TRACE] IPAddressAPI.List start")
5892 targetArguments := struct {
5893 Argzone string
5894 }{
5895 Argzone: zone,
5896 }
5897 if d, err := json.Marshal(targetArguments); err == nil {
5898 log.Printf("[TRACE] \targs: %s\n", string(d))
5899 }
5900
5901 defer func() {
5902 log.Println("[TRACE] IPAddressAPI.List end")
5903 }()
5904
5905 result, err := t.Internal.List(ctx, zone)
5906 targetResults := struct {
5907 Result *iaas.IPAddressListResult
5908 Error error
5909 }{
5910 Result: result,
5911 Error: err,
5912 }
5913 if d, err := json.Marshal(targetResults); err == nil {
5914 log.Printf("[TRACE] \tresults: %s\n", string(d))
5915 }
5916
5917 return result, err
5918 }
5919
5920 // Read is API call with trace log
5921 func (t *IPAddressTracer) Read(ctx context.Context, zone string, ipAddress string) (*iaas.IPAddress, error) {
5922 log.Println("[TRACE] IPAddressAPI.Read start")
5923 targetArguments := struct {
5924 Argzone string
5925 ArgipAddress string `json:"ipAddress"`
5926 }{
5927 Argzone: zone,
5928 ArgipAddress: ipAddress,
5929 }
5930 if d, err := json.Marshal(targetArguments); err == nil {
5931 log.Printf("[TRACE] \targs: %s\n", string(d))
5932 }
5933
5934 defer func() {
5935 log.Println("[TRACE] IPAddressAPI.Read end")
5936 }()
5937
5938 resultIPAddress, err := t.Internal.Read(ctx, zone, ipAddress)
5939 targetResults := struct {
5940 IPAddress *iaas.IPAddress
5941 Error error
5942 }{
5943 IPAddress: resultIPAddress,
5944 Error: err,
5945 }
5946 if d, err := json.Marshal(targetResults); err == nil {
5947 log.Printf("[TRACE] \tresults: %s\n", string(d))
5948 }
5949
5950 return resultIPAddress, err
5951 }
5952
5953 // UpdateHostName is API call with trace log
5954 func (t *IPAddressTracer) UpdateHostName(ctx context.Context, zone string, ipAddress string, hostName string) (*iaas.IPAddress, error) {
5955 log.Println("[TRACE] IPAddressAPI.UpdateHostName start")
5956 targetArguments := struct {
5957 Argzone string
5958 ArgipAddress string `json:"ipAddress"`
5959 ArghostName string `json:"hostName"`
5960 }{
5961 Argzone: zone,
5962 ArgipAddress: ipAddress,
5963 ArghostName: hostName,
5964 }
5965 if d, err := json.Marshal(targetArguments); err == nil {
5966 log.Printf("[TRACE] \targs: %s\n", string(d))
5967 }
5968
5969 defer func() {
5970 log.Println("[TRACE] IPAddressAPI.UpdateHostName end")
5971 }()
5972
5973 resultIPAddress, err := t.Internal.UpdateHostName(ctx, zone, ipAddress, hostName)
5974 targetResults := struct {
5975 IPAddress *iaas.IPAddress
5976 Error error
5977 }{
5978 IPAddress: resultIPAddress,
5979 Error: err,
5980 }
5981 if d, err := json.Marshal(targetResults); err == nil {
5982 log.Printf("[TRACE] \tresults: %s\n", string(d))
5983 }
5984
5985 return resultIPAddress, err
5986 }
5987
5988 /*************************************************
5989 * IPv6NetTracer
5990 *************************************************/
5991
5992 // IPv6NetTracer is for trace IPv6NetOp operations
5993 type IPv6NetTracer struct {
5994 Internal iaas.IPv6NetAPI
5995 }
5996
5997 // NewIPv6NetTracer creates new IPv6NetTracer instance
5998 func NewIPv6NetTracer(in iaas.IPv6NetAPI) iaas.IPv6NetAPI {
5999 return &IPv6NetTracer{
6000 Internal: in,
6001 }
6002 }
6003
6004 // List is API call with trace log
6005 func (t *IPv6NetTracer) List(ctx context.Context, zone string) (*iaas.IPv6NetListResult, error) {
6006 log.Println("[TRACE] IPv6NetAPI.List start")
6007 targetArguments := struct {
6008 Argzone string
6009 }{
6010 Argzone: zone,
6011 }
6012 if d, err := json.Marshal(targetArguments); err == nil {
6013 log.Printf("[TRACE] \targs: %s\n", string(d))
6014 }
6015
6016 defer func() {
6017 log.Println("[TRACE] IPv6NetAPI.List end")
6018 }()
6019
6020 result, err := t.Internal.List(ctx, zone)
6021 targetResults := struct {
6022 Result *iaas.IPv6NetListResult
6023 Error error
6024 }{
6025 Result: result,
6026 Error: err,
6027 }
6028 if d, err := json.Marshal(targetResults); err == nil {
6029 log.Printf("[TRACE] \tresults: %s\n", string(d))
6030 }
6031
6032 return result, err
6033 }
6034
6035 // Find is API call with trace log
6036 func (t *IPv6NetTracer) Find(ctx context.Context, zone string, conditions *iaas.FindCondition) (*iaas.IPv6NetFindResult, error) {
6037 log.Println("[TRACE] IPv6NetAPI.Find start")
6038 targetArguments := struct {
6039 Argzone string
6040 Argconditions *iaas.FindCondition `json:"conditions"`
6041 }{
6042 Argzone: zone,
6043 Argconditions: conditions,
6044 }
6045 if d, err := json.Marshal(targetArguments); err == nil {
6046 log.Printf("[TRACE] \targs: %s\n", string(d))
6047 }
6048
6049 defer func() {
6050 log.Println("[TRACE] IPv6NetAPI.Find end")
6051 }()
6052
6053 result, err := t.Internal.Find(ctx, zone, conditions)
6054 targetResults := struct {
6055 Result *iaas.IPv6NetFindResult
6056 Error error
6057 }{
6058 Result: result,
6059 Error: err,
6060 }
6061 if d, err := json.Marshal(targetResults); err == nil {
6062 log.Printf("[TRACE] \tresults: %s\n", string(d))
6063 }
6064
6065 return result, err
6066 }
6067
6068 // Read is API call with trace log
6069 func (t *IPv6NetTracer) Read(ctx context.Context, zone string, id types.ID) (*iaas.IPv6Net, error) {
6070 log.Println("[TRACE] IPv6NetAPI.Read start")
6071 targetArguments := struct {
6072 Argzone string
6073 Argid types.ID `json:"id"`
6074 }{
6075 Argzone: zone,
6076 Argid: id,
6077 }
6078 if d, err := json.Marshal(targetArguments); err == nil {
6079 log.Printf("[TRACE] \targs: %s\n", string(d))
6080 }
6081
6082 defer func() {
6083 log.Println("[TRACE] IPv6NetAPI.Read end")
6084 }()
6085
6086 resultIPv6Net, err := t.Internal.Read(ctx, zone, id)
6087 targetResults := struct {
6088 IPv6Net *iaas.IPv6Net
6089 Error error
6090 }{
6091 IPv6Net: resultIPv6Net,
6092 Error: err,
6093 }
6094 if d, err := json.Marshal(targetResults); err == nil {
6095 log.Printf("[TRACE] \tresults: %s\n", string(d))
6096 }
6097
6098 return resultIPv6Net, err
6099 }
6100
6101 /*************************************************
6102 * IPv6AddrTracer
6103 *************************************************/
6104
6105 // IPv6AddrTracer is for trace IPv6AddrOp operations
6106 type IPv6AddrTracer struct {
6107 Internal iaas.IPv6AddrAPI
6108 }
6109
6110 // NewIPv6AddrTracer creates new IPv6AddrTracer instance
6111 func NewIPv6AddrTracer(in iaas.IPv6AddrAPI) iaas.IPv6AddrAPI {
6112 return &IPv6AddrTracer{
6113 Internal: in,
6114 }
6115 }
6116
6117 // Find is API call with trace log
6118 func (t *IPv6AddrTracer) Find(ctx context.Context, zone string, conditions *iaas.FindCondition) (*iaas.IPv6AddrFindResult, error) {
6119 log.Println("[TRACE] IPv6AddrAPI.Find start")
6120 targetArguments := struct {
6121 Argzone string
6122 Argconditions *iaas.FindCondition `json:"conditions"`
6123 }{
6124 Argzone: zone,
6125 Argconditions: conditions,
6126 }
6127 if d, err := json.Marshal(targetArguments); err == nil {
6128 log.Printf("[TRACE] \targs: %s\n", string(d))
6129 }
6130
6131 defer func() {
6132 log.Println("[TRACE] IPv6AddrAPI.Find end")
6133 }()
6134
6135 result, err := t.Internal.Find(ctx, zone, conditions)
6136 targetResults := struct {
6137 Result *iaas.IPv6AddrFindResult
6138 Error error
6139 }{
6140 Result: result,
6141 Error: err,
6142 }
6143 if d, err := json.Marshal(targetResults); err == nil {
6144 log.Printf("[TRACE] \tresults: %s\n", string(d))
6145 }
6146
6147 return result, err
6148 }
6149
6150 // Create is API call with trace log
6151 func (t *IPv6AddrTracer) Create(ctx context.Context, zone string, param *iaas.IPv6AddrCreateRequest) (*iaas.IPv6Addr, error) {
6152 log.Println("[TRACE] IPv6AddrAPI.Create start")
6153 targetArguments := struct {
6154 Argzone string
6155 Argparam *iaas.IPv6AddrCreateRequest `json:"param"`
6156 }{
6157 Argzone: zone,
6158 Argparam: param,
6159 }
6160 if d, err := json.Marshal(targetArguments); err == nil {
6161 log.Printf("[TRACE] \targs: %s\n", string(d))
6162 }
6163
6164 defer func() {
6165 log.Println("[TRACE] IPv6AddrAPI.Create end")
6166 }()
6167
6168 resultIPv6Addr, err := t.Internal.Create(ctx, zone, param)
6169 targetResults := struct {
6170 IPv6Addr *iaas.IPv6Addr
6171 Error error
6172 }{
6173 IPv6Addr: resultIPv6Addr,
6174 Error: err,
6175 }
6176 if d, err := json.Marshal(targetResults); err == nil {
6177 log.Printf("[TRACE] \tresults: %s\n", string(d))
6178 }
6179
6180 return resultIPv6Addr, err
6181 }
6182
6183 // Read is API call with trace log
6184 func (t *IPv6AddrTracer) Read(ctx context.Context, zone string, ipv6addr string) (*iaas.IPv6Addr, error) {
6185 log.Println("[TRACE] IPv6AddrAPI.Read start")
6186 targetArguments := struct {
6187 Argzone string
6188 Argipv6addr string `json:"ipv6addr"`
6189 }{
6190 Argzone: zone,
6191 Argipv6addr: ipv6addr,
6192 }
6193 if d, err := json.Marshal(targetArguments); err == nil {
6194 log.Printf("[TRACE] \targs: %s\n", string(d))
6195 }
6196
6197 defer func() {
6198 log.Println("[TRACE] IPv6AddrAPI.Read end")
6199 }()
6200
6201 resultIPv6Addr, err := t.Internal.Read(ctx, zone, ipv6addr)
6202 targetResults := struct {
6203 IPv6Addr *iaas.IPv6Addr
6204 Error error
6205 }{
6206 IPv6Addr: resultIPv6Addr,
6207 Error: err,
6208 }
6209 if d, err := json.Marshal(targetResults); err == nil {
6210 log.Printf("[TRACE] \tresults: %s\n", string(d))
6211 }
6212
6213 return resultIPv6Addr, err
6214 }
6215
6216 // Update is API call with trace log
6217 func (t *IPv6AddrTracer) Update(ctx context.Context, zone string, ipv6addr string, param *iaas.IPv6AddrUpdateRequest) (*iaas.IPv6Addr, error) {
6218 log.Println("[TRACE] IPv6AddrAPI.Update start")
6219 targetArguments := struct {
6220 Argzone string
6221 Argipv6addr string `json:"ipv6addr"`
6222 Argparam *iaas.IPv6AddrUpdateRequest `json:"param"`
6223 }{
6224 Argzone: zone,
6225 Argipv6addr: ipv6addr,
6226 Argparam: param,
6227 }
6228 if d, err := json.Marshal(targetArguments); err == nil {
6229 log.Printf("[TRACE] \targs: %s\n", string(d))
6230 }
6231
6232 defer func() {
6233 log.Println("[TRACE] IPv6AddrAPI.Update end")
6234 }()
6235
6236 resultIPv6Addr, err := t.Internal.Update(ctx, zone, ipv6addr, param)
6237 targetResults := struct {
6238 IPv6Addr *iaas.IPv6Addr
6239 Error error
6240 }{
6241 IPv6Addr: resultIPv6Addr,
6242 Error: err,
6243 }
6244 if d, err := json.Marshal(targetResults); err == nil {
6245 log.Printf("[TRACE] \tresults: %s\n", string(d))
6246 }
6247
6248 return resultIPv6Addr, err
6249 }
6250
6251 // Delete is API call with trace log
6252 func (t *IPv6AddrTracer) Delete(ctx context.Context, zone string, ipv6addr string) error {
6253 log.Println("[TRACE] IPv6AddrAPI.Delete start")
6254 targetArguments := struct {
6255 Argzone string
6256 Argipv6addr string `json:"ipv6addr"`
6257 }{
6258 Argzone: zone,
6259 Argipv6addr: ipv6addr,
6260 }
6261 if d, err := json.Marshal(targetArguments); err == nil {
6262 log.Printf("[TRACE] \targs: %s\n", string(d))
6263 }
6264
6265 defer func() {
6266 log.Println("[TRACE] IPv6AddrAPI.Delete end")
6267 }()
6268
6269 err := t.Internal.Delete(ctx, zone, ipv6addr)
6270 targetResults := struct {
6271 Error error
6272 }{
6273 Error: err,
6274 }
6275 if d, err := json.Marshal(targetResults); err == nil {
6276 log.Printf("[TRACE] \tresults: %s\n", string(d))
6277 }
6278
6279 return err
6280 }
6281
6282 /*************************************************
6283 * LicenseTracer
6284 *************************************************/
6285
6286 // LicenseTracer is for trace LicenseOp operations
6287 type LicenseTracer struct {
6288 Internal iaas.LicenseAPI
6289 }
6290
6291 // NewLicenseTracer creates new LicenseTracer instance
6292 func NewLicenseTracer(in iaas.LicenseAPI) iaas.LicenseAPI {
6293 return &LicenseTracer{
6294 Internal: in,
6295 }
6296 }
6297
6298 // Find is API call with trace log
6299 func (t *LicenseTracer) Find(ctx context.Context, conditions *iaas.FindCondition) (*iaas.LicenseFindResult, error) {
6300 log.Println("[TRACE] LicenseAPI.Find start")
6301 targetArguments := struct {
6302 Argconditions *iaas.FindCondition `json:"conditions"`
6303 }{
6304 Argconditions: conditions,
6305 }
6306 if d, err := json.Marshal(targetArguments); err == nil {
6307 log.Printf("[TRACE] \targs: %s\n", string(d))
6308 }
6309
6310 defer func() {
6311 log.Println("[TRACE] LicenseAPI.Find end")
6312 }()
6313
6314 result, err := t.Internal.Find(ctx, conditions)
6315 targetResults := struct {
6316 Result *iaas.LicenseFindResult
6317 Error error
6318 }{
6319 Result: result,
6320 Error: err,
6321 }
6322 if d, err := json.Marshal(targetResults); err == nil {
6323 log.Printf("[TRACE] \tresults: %s\n", string(d))
6324 }
6325
6326 return result, err
6327 }
6328
6329 // Create is API call with trace log
6330 func (t *LicenseTracer) Create(ctx context.Context, param *iaas.LicenseCreateRequest) (*iaas.License, error) {
6331 log.Println("[TRACE] LicenseAPI.Create start")
6332 targetArguments := struct {
6333 Argparam *iaas.LicenseCreateRequest `json:"param"`
6334 }{
6335 Argparam: param,
6336 }
6337 if d, err := json.Marshal(targetArguments); err == nil {
6338 log.Printf("[TRACE] \targs: %s\n", string(d))
6339 }
6340
6341 defer func() {
6342 log.Println("[TRACE] LicenseAPI.Create end")
6343 }()
6344
6345 resultLicense, err := t.Internal.Create(ctx, param)
6346 targetResults := struct {
6347 License *iaas.License
6348 Error error
6349 }{
6350 License: resultLicense,
6351 Error: err,
6352 }
6353 if d, err := json.Marshal(targetResults); err == nil {
6354 log.Printf("[TRACE] \tresults: %s\n", string(d))
6355 }
6356
6357 return resultLicense, err
6358 }
6359
6360 // Read is API call with trace log
6361 func (t *LicenseTracer) Read(ctx context.Context, id types.ID) (*iaas.License, error) {
6362 log.Println("[TRACE] LicenseAPI.Read start")
6363 targetArguments := struct {
6364 Argid types.ID `json:"id"`
6365 }{
6366 Argid: id,
6367 }
6368 if d, err := json.Marshal(targetArguments); err == nil {
6369 log.Printf("[TRACE] \targs: %s\n", string(d))
6370 }
6371
6372 defer func() {
6373 log.Println("[TRACE] LicenseAPI.Read end")
6374 }()
6375
6376 resultLicense, err := t.Internal.Read(ctx, id)
6377 targetResults := struct {
6378 License *iaas.License
6379 Error error
6380 }{
6381 License: resultLicense,
6382 Error: err,
6383 }
6384 if d, err := json.Marshal(targetResults); err == nil {
6385 log.Printf("[TRACE] \tresults: %s\n", string(d))
6386 }
6387
6388 return resultLicense, err
6389 }
6390
6391 // Update is API call with trace log
6392 func (t *LicenseTracer) Update(ctx context.Context, id types.ID, param *iaas.LicenseUpdateRequest) (*iaas.License, error) {
6393 log.Println("[TRACE] LicenseAPI.Update start")
6394 targetArguments := struct {
6395 Argid types.ID `json:"id"`
6396 Argparam *iaas.LicenseUpdateRequest `json:"param"`
6397 }{
6398 Argid: id,
6399 Argparam: param,
6400 }
6401 if d, err := json.Marshal(targetArguments); err == nil {
6402 log.Printf("[TRACE] \targs: %s\n", string(d))
6403 }
6404
6405 defer func() {
6406 log.Println("[TRACE] LicenseAPI.Update end")
6407 }()
6408
6409 resultLicense, err := t.Internal.Update(ctx, id, param)
6410 targetResults := struct {
6411 License *iaas.License
6412 Error error
6413 }{
6414 License: resultLicense,
6415 Error: err,
6416 }
6417 if d, err := json.Marshal(targetResults); err == nil {
6418 log.Printf("[TRACE] \tresults: %s\n", string(d))
6419 }
6420
6421 return resultLicense, err
6422 }
6423
6424 // Delete is API call with trace log
6425 func (t *LicenseTracer) Delete(ctx context.Context, id types.ID) error {
6426 log.Println("[TRACE] LicenseAPI.Delete start")
6427 targetArguments := struct {
6428 Argid types.ID `json:"id"`
6429 }{
6430 Argid: id,
6431 }
6432 if d, err := json.Marshal(targetArguments); err == nil {
6433 log.Printf("[TRACE] \targs: %s\n", string(d))
6434 }
6435
6436 defer func() {
6437 log.Println("[TRACE] LicenseAPI.Delete end")
6438 }()
6439
6440 err := t.Internal.Delete(ctx, id)
6441 targetResults := struct {
6442 Error error
6443 }{
6444 Error: err,
6445 }
6446 if d, err := json.Marshal(targetResults); err == nil {
6447 log.Printf("[TRACE] \tresults: %s\n", string(d))
6448 }
6449
6450 return err
6451 }
6452
6453 /*************************************************
6454 * LicenseInfoTracer
6455 *************************************************/
6456
6457 // LicenseInfoTracer is for trace LicenseInfoOp operations
6458 type LicenseInfoTracer struct {
6459 Internal iaas.LicenseInfoAPI
6460 }
6461
6462 // NewLicenseInfoTracer creates new LicenseInfoTracer instance
6463 func NewLicenseInfoTracer(in iaas.LicenseInfoAPI) iaas.LicenseInfoAPI {
6464 return &LicenseInfoTracer{
6465 Internal: in,
6466 }
6467 }
6468
6469 // Find is API call with trace log
6470 func (t *LicenseInfoTracer) Find(ctx context.Context, conditions *iaas.FindCondition) (*iaas.LicenseInfoFindResult, error) {
6471 log.Println("[TRACE] LicenseInfoAPI.Find start")
6472 targetArguments := struct {
6473 Argconditions *iaas.FindCondition `json:"conditions"`
6474 }{
6475 Argconditions: conditions,
6476 }
6477 if d, err := json.Marshal(targetArguments); err == nil {
6478 log.Printf("[TRACE] \targs: %s\n", string(d))
6479 }
6480
6481 defer func() {
6482 log.Println("[TRACE] LicenseInfoAPI.Find end")
6483 }()
6484
6485 result, err := t.Internal.Find(ctx, conditions)
6486 targetResults := struct {
6487 Result *iaas.LicenseInfoFindResult
6488 Error error
6489 }{
6490 Result: result,
6491 Error: err,
6492 }
6493 if d, err := json.Marshal(targetResults); err == nil {
6494 log.Printf("[TRACE] \tresults: %s\n", string(d))
6495 }
6496
6497 return result, err
6498 }
6499
6500 // Read is API call with trace log
6501 func (t *LicenseInfoTracer) Read(ctx context.Context, id types.ID) (*iaas.LicenseInfo, error) {
6502 log.Println("[TRACE] LicenseInfoAPI.Read start")
6503 targetArguments := struct {
6504 Argid types.ID `json:"id"`
6505 }{
6506 Argid: id,
6507 }
6508 if d, err := json.Marshal(targetArguments); err == nil {
6509 log.Printf("[TRACE] \targs: %s\n", string(d))
6510 }
6511
6512 defer func() {
6513 log.Println("[TRACE] LicenseInfoAPI.Read end")
6514 }()
6515
6516 resultLicenseInfo, err := t.Internal.Read(ctx, id)
6517 targetResults := struct {
6518 LicenseInfo *iaas.LicenseInfo
6519 Error error
6520 }{
6521 LicenseInfo: resultLicenseInfo,
6522 Error: err,
6523 }
6524 if d, err := json.Marshal(targetResults); err == nil {
6525 log.Printf("[TRACE] \tresults: %s\n", string(d))
6526 }
6527
6528 return resultLicenseInfo, err
6529 }
6530
6531 /*************************************************
6532 * LoadBalancerTracer
6533 *************************************************/
6534
6535 // LoadBalancerTracer is for trace LoadBalancerOp operations
6536 type LoadBalancerTracer struct {
6537 Internal iaas.LoadBalancerAPI
6538 }
6539
6540 // NewLoadBalancerTracer creates new LoadBalancerTracer instance
6541 func NewLoadBalancerTracer(in iaas.LoadBalancerAPI) iaas.LoadBalancerAPI {
6542 return &LoadBalancerTracer{
6543 Internal: in,
6544 }
6545 }
6546
6547 // Find is API call with trace log
6548 func (t *LoadBalancerTracer) Find(ctx context.Context, zone string, conditions *iaas.FindCondition) (*iaas.LoadBalancerFindResult, error) {
6549 log.Println("[TRACE] LoadBalancerAPI.Find start")
6550 targetArguments := struct {
6551 Argzone string
6552 Argconditions *iaas.FindCondition `json:"conditions"`
6553 }{
6554 Argzone: zone,
6555 Argconditions: conditions,
6556 }
6557 if d, err := json.Marshal(targetArguments); err == nil {
6558 log.Printf("[TRACE] \targs: %s\n", string(d))
6559 }
6560
6561 defer func() {
6562 log.Println("[TRACE] LoadBalancerAPI.Find end")
6563 }()
6564
6565 result, err := t.Internal.Find(ctx, zone, conditions)
6566 targetResults := struct {
6567 Result *iaas.LoadBalancerFindResult
6568 Error error
6569 }{
6570 Result: result,
6571 Error: err,
6572 }
6573 if d, err := json.Marshal(targetResults); err == nil {
6574 log.Printf("[TRACE] \tresults: %s\n", string(d))
6575 }
6576
6577 return result, err
6578 }
6579
6580 // Create is API call with trace log
6581 func (t *LoadBalancerTracer) Create(ctx context.Context, zone string, param *iaas.LoadBalancerCreateRequest) (*iaas.LoadBalancer, error) {
6582 log.Println("[TRACE] LoadBalancerAPI.Create start")
6583 targetArguments := struct {
6584 Argzone string
6585 Argparam *iaas.LoadBalancerCreateRequest `json:"param"`
6586 }{
6587 Argzone: zone,
6588 Argparam: param,
6589 }
6590 if d, err := json.Marshal(targetArguments); err == nil {
6591 log.Printf("[TRACE] \targs: %s\n", string(d))
6592 }
6593
6594 defer func() {
6595 log.Println("[TRACE] LoadBalancerAPI.Create end")
6596 }()
6597
6598 resultLoadBalancer, err := t.Internal.Create(ctx, zone, param)
6599 targetResults := struct {
6600 LoadBalancer *iaas.LoadBalancer
6601 Error error
6602 }{
6603 LoadBalancer: resultLoadBalancer,
6604 Error: err,
6605 }
6606 if d, err := json.Marshal(targetResults); err == nil {
6607 log.Printf("[TRACE] \tresults: %s\n", string(d))
6608 }
6609
6610 return resultLoadBalancer, err
6611 }
6612
6613 // Read is API call with trace log
6614 func (t *LoadBalancerTracer) Read(ctx context.Context, zone string, id types.ID) (*iaas.LoadBalancer, error) {
6615 log.Println("[TRACE] LoadBalancerAPI.Read start")
6616 targetArguments := struct {
6617 Argzone string
6618 Argid types.ID `json:"id"`
6619 }{
6620 Argzone: zone,
6621 Argid: id,
6622 }
6623 if d, err := json.Marshal(targetArguments); err == nil {
6624 log.Printf("[TRACE] \targs: %s\n", string(d))
6625 }
6626
6627 defer func() {
6628 log.Println("[TRACE] LoadBalancerAPI.Read end")
6629 }()
6630
6631 resultLoadBalancer, err := t.Internal.Read(ctx, zone, id)
6632 targetResults := struct {
6633 LoadBalancer *iaas.LoadBalancer
6634 Error error
6635 }{
6636 LoadBalancer: resultLoadBalancer,
6637 Error: err,
6638 }
6639 if d, err := json.Marshal(targetResults); err == nil {
6640 log.Printf("[TRACE] \tresults: %s\n", string(d))
6641 }
6642
6643 return resultLoadBalancer, err
6644 }
6645
6646 // Update is API call with trace log
6647 func (t *LoadBalancerTracer) Update(ctx context.Context, zone string, id types.ID, param *iaas.LoadBalancerUpdateRequest) (*iaas.LoadBalancer, error) {
6648 log.Println("[TRACE] LoadBalancerAPI.Update start")
6649 targetArguments := struct {
6650 Argzone string
6651 Argid types.ID `json:"id"`
6652 Argparam *iaas.LoadBalancerUpdateRequest `json:"param"`
6653 }{
6654 Argzone: zone,
6655 Argid: id,
6656 Argparam: param,
6657 }
6658 if d, err := json.Marshal(targetArguments); err == nil {
6659 log.Printf("[TRACE] \targs: %s\n", string(d))
6660 }
6661
6662 defer func() {
6663 log.Println("[TRACE] LoadBalancerAPI.Update end")
6664 }()
6665
6666 resultLoadBalancer, err := t.Internal.Update(ctx, zone, id, param)
6667 targetResults := struct {
6668 LoadBalancer *iaas.LoadBalancer
6669 Error error
6670 }{
6671 LoadBalancer: resultLoadBalancer,
6672 Error: err,
6673 }
6674 if d, err := json.Marshal(targetResults); err == nil {
6675 log.Printf("[TRACE] \tresults: %s\n", string(d))
6676 }
6677
6678 return resultLoadBalancer, err
6679 }
6680
6681 // UpdateSettings is API call with trace log
6682 func (t *LoadBalancerTracer) UpdateSettings(ctx context.Context, zone string, id types.ID, param *iaas.LoadBalancerUpdateSettingsRequest) (*iaas.LoadBalancer, error) {
6683 log.Println("[TRACE] LoadBalancerAPI.UpdateSettings start")
6684 targetArguments := struct {
6685 Argzone string
6686 Argid types.ID `json:"id"`
6687 Argparam *iaas.LoadBalancerUpdateSettingsRequest `json:"param"`
6688 }{
6689 Argzone: zone,
6690 Argid: id,
6691 Argparam: param,
6692 }
6693 if d, err := json.Marshal(targetArguments); err == nil {
6694 log.Printf("[TRACE] \targs: %s\n", string(d))
6695 }
6696
6697 defer func() {
6698 log.Println("[TRACE] LoadBalancerAPI.UpdateSettings end")
6699 }()
6700
6701 resultLoadBalancer, err := t.Internal.UpdateSettings(ctx, zone, id, param)
6702 targetResults := struct {
6703 LoadBalancer *iaas.LoadBalancer
6704 Error error
6705 }{
6706 LoadBalancer: resultLoadBalancer,
6707 Error: err,
6708 }
6709 if d, err := json.Marshal(targetResults); err == nil {
6710 log.Printf("[TRACE] \tresults: %s\n", string(d))
6711 }
6712
6713 return resultLoadBalancer, err
6714 }
6715
6716 // Delete is API call with trace log
6717 func (t *LoadBalancerTracer) Delete(ctx context.Context, zone string, id types.ID) error {
6718 log.Println("[TRACE] LoadBalancerAPI.Delete start")
6719 targetArguments := struct {
6720 Argzone string
6721 Argid types.ID `json:"id"`
6722 }{
6723 Argzone: zone,
6724 Argid: id,
6725 }
6726 if d, err := json.Marshal(targetArguments); err == nil {
6727 log.Printf("[TRACE] \targs: %s\n", string(d))
6728 }
6729
6730 defer func() {
6731 log.Println("[TRACE] LoadBalancerAPI.Delete end")
6732 }()
6733
6734 err := t.Internal.Delete(ctx, zone, id)
6735 targetResults := struct {
6736 Error error
6737 }{
6738 Error: err,
6739 }
6740 if d, err := json.Marshal(targetResults); err == nil {
6741 log.Printf("[TRACE] \tresults: %s\n", string(d))
6742 }
6743
6744 return err
6745 }
6746
6747 // Config is API call with trace log
6748 func (t *LoadBalancerTracer) Config(ctx context.Context, zone string, id types.ID) error {
6749 log.Println("[TRACE] LoadBalancerAPI.Config start")
6750 targetArguments := struct {
6751 Argzone string
6752 Argid types.ID `json:"id"`
6753 }{
6754 Argzone: zone,
6755 Argid: id,
6756 }
6757 if d, err := json.Marshal(targetArguments); err == nil {
6758 log.Printf("[TRACE] \targs: %s\n", string(d))
6759 }
6760
6761 defer func() {
6762 log.Println("[TRACE] LoadBalancerAPI.Config end")
6763 }()
6764
6765 err := t.Internal.Config(ctx, zone, id)
6766 targetResults := struct {
6767 Error error
6768 }{
6769 Error: err,
6770 }
6771 if d, err := json.Marshal(targetResults); err == nil {
6772 log.Printf("[TRACE] \tresults: %s\n", string(d))
6773 }
6774
6775 return err
6776 }
6777
6778 // Boot is API call with trace log
6779 func (t *LoadBalancerTracer) Boot(ctx context.Context, zone string, id types.ID) error {
6780 log.Println("[TRACE] LoadBalancerAPI.Boot start")
6781 targetArguments := struct {
6782 Argzone string
6783 Argid types.ID `json:"id"`
6784 }{
6785 Argzone: zone,
6786 Argid: id,
6787 }
6788 if d, err := json.Marshal(targetArguments); err == nil {
6789 log.Printf("[TRACE] \targs: %s\n", string(d))
6790 }
6791
6792 defer func() {
6793 log.Println("[TRACE] LoadBalancerAPI.Boot end")
6794 }()
6795
6796 err := t.Internal.Boot(ctx, zone, id)
6797 targetResults := struct {
6798 Error error
6799 }{
6800 Error: err,
6801 }
6802 if d, err := json.Marshal(targetResults); err == nil {
6803 log.Printf("[TRACE] \tresults: %s\n", string(d))
6804 }
6805
6806 return err
6807 }
6808
6809 // Shutdown is API call with trace log
6810 func (t *LoadBalancerTracer) Shutdown(ctx context.Context, zone string, id types.ID, shutdownOption *iaas.ShutdownOption) error {
6811 log.Println("[TRACE] LoadBalancerAPI.Shutdown start")
6812 targetArguments := struct {
6813 Argzone string
6814 Argid types.ID `json:"id"`
6815 ArgshutdownOption *iaas.ShutdownOption `json:"shutdownOption"`
6816 }{
6817 Argzone: zone,
6818 Argid: id,
6819 ArgshutdownOption: shutdownOption,
6820 }
6821 if d, err := json.Marshal(targetArguments); err == nil {
6822 log.Printf("[TRACE] \targs: %s\n", string(d))
6823 }
6824
6825 defer func() {
6826 log.Println("[TRACE] LoadBalancerAPI.Shutdown end")
6827 }()
6828
6829 err := t.Internal.Shutdown(ctx, zone, id, shutdownOption)
6830 targetResults := struct {
6831 Error error
6832 }{
6833 Error: err,
6834 }
6835 if d, err := json.Marshal(targetResults); err == nil {
6836 log.Printf("[TRACE] \tresults: %s\n", string(d))
6837 }
6838
6839 return err
6840 }
6841
6842 // Reset is API call with trace log
6843 func (t *LoadBalancerTracer) Reset(ctx context.Context, zone string, id types.ID) error {
6844 log.Println("[TRACE] LoadBalancerAPI.Reset start")
6845 targetArguments := struct {
6846 Argzone string
6847 Argid types.ID `json:"id"`
6848 }{
6849 Argzone: zone,
6850 Argid: id,
6851 }
6852 if d, err := json.Marshal(targetArguments); err == nil {
6853 log.Printf("[TRACE] \targs: %s\n", string(d))
6854 }
6855
6856 defer func() {
6857 log.Println("[TRACE] LoadBalancerAPI.Reset end")
6858 }()
6859
6860 err := t.Internal.Reset(ctx, zone, id)
6861 targetResults := struct {
6862 Error error
6863 }{
6864 Error: err,
6865 }
6866 if d, err := json.Marshal(targetResults); err == nil {
6867 log.Printf("[TRACE] \tresults: %s\n", string(d))
6868 }
6869
6870 return err
6871 }
6872
6873 // MonitorCPU is API call with trace log
6874 func (t *LoadBalancerTracer) MonitorCPU(ctx context.Context, zone string, id types.ID, condition *iaas.MonitorCondition) (*iaas.CPUTimeActivity, error) {
6875 log.Println("[TRACE] LoadBalancerAPI.MonitorCPU start")
6876 targetArguments := struct {
6877 Argzone string
6878 Argid types.ID `json:"id"`
6879 Argcondition *iaas.MonitorCondition `json:"condition"`
6880 }{
6881 Argzone: zone,
6882 Argid: id,
6883 Argcondition: condition,
6884 }
6885 if d, err := json.Marshal(targetArguments); err == nil {
6886 log.Printf("[TRACE] \targs: %s\n", string(d))
6887 }
6888
6889 defer func() {
6890 log.Println("[TRACE] LoadBalancerAPI.MonitorCPU end")
6891 }()
6892
6893 resultCPUTimeActivity, err := t.Internal.MonitorCPU(ctx, zone, id, condition)
6894 targetResults := struct {
6895 CPUTimeActivity *iaas.CPUTimeActivity
6896 Error error
6897 }{
6898 CPUTimeActivity: resultCPUTimeActivity,
6899 Error: err,
6900 }
6901 if d, err := json.Marshal(targetResults); err == nil {
6902 log.Printf("[TRACE] \tresults: %s\n", string(d))
6903 }
6904
6905 return resultCPUTimeActivity, err
6906 }
6907
6908 // MonitorInterface is API call with trace log
6909 func (t *LoadBalancerTracer) MonitorInterface(ctx context.Context, zone string, id types.ID, condition *iaas.MonitorCondition) (*iaas.InterfaceActivity, error) {
6910 log.Println("[TRACE] LoadBalancerAPI.MonitorInterface start")
6911 targetArguments := struct {
6912 Argzone string
6913 Argid types.ID `json:"id"`
6914 Argcondition *iaas.MonitorCondition `json:"condition"`
6915 }{
6916 Argzone: zone,
6917 Argid: id,
6918 Argcondition: condition,
6919 }
6920 if d, err := json.Marshal(targetArguments); err == nil {
6921 log.Printf("[TRACE] \targs: %s\n", string(d))
6922 }
6923
6924 defer func() {
6925 log.Println("[TRACE] LoadBalancerAPI.MonitorInterface end")
6926 }()
6927
6928 resultInterfaceActivity, err := t.Internal.MonitorInterface(ctx, zone, id, condition)
6929 targetResults := struct {
6930 InterfaceActivity *iaas.InterfaceActivity
6931 Error error
6932 }{
6933 InterfaceActivity: resultInterfaceActivity,
6934 Error: err,
6935 }
6936 if d, err := json.Marshal(targetResults); err == nil {
6937 log.Printf("[TRACE] \tresults: %s\n", string(d))
6938 }
6939
6940 return resultInterfaceActivity, err
6941 }
6942
6943 // Status is API call with trace log
6944 func (t *LoadBalancerTracer) Status(ctx context.Context, zone string, id types.ID) (*iaas.LoadBalancerStatusResult, error) {
6945 log.Println("[TRACE] LoadBalancerAPI.Status start")
6946 targetArguments := struct {
6947 Argzone string
6948 Argid types.ID `json:"id"`
6949 }{
6950 Argzone: zone,
6951 Argid: id,
6952 }
6953 if d, err := json.Marshal(targetArguments); err == nil {
6954 log.Printf("[TRACE] \targs: %s\n", string(d))
6955 }
6956
6957 defer func() {
6958 log.Println("[TRACE] LoadBalancerAPI.Status end")
6959 }()
6960
6961 result, err := t.Internal.Status(ctx, zone, id)
6962 targetResults := struct {
6963 Result *iaas.LoadBalancerStatusResult
6964 Error error
6965 }{
6966 Result: result,
6967 Error: err,
6968 }
6969 if d, err := json.Marshal(targetResults); err == nil {
6970 log.Printf("[TRACE] \tresults: %s\n", string(d))
6971 }
6972
6973 return result, err
6974 }
6975
6976 /*************************************************
6977 * LocalRouterTracer
6978 *************************************************/
6979
6980 // LocalRouterTracer is for trace LocalRouterOp operations
6981 type LocalRouterTracer struct {
6982 Internal iaas.LocalRouterAPI
6983 }
6984
6985 // NewLocalRouterTracer creates new LocalRouterTracer instance
6986 func NewLocalRouterTracer(in iaas.LocalRouterAPI) iaas.LocalRouterAPI {
6987 return &LocalRouterTracer{
6988 Internal: in,
6989 }
6990 }
6991
6992 // Find is API call with trace log
6993 func (t *LocalRouterTracer) Find(ctx context.Context, conditions *iaas.FindCondition) (*iaas.LocalRouterFindResult, error) {
6994 log.Println("[TRACE] LocalRouterAPI.Find start")
6995 targetArguments := struct {
6996 Argconditions *iaas.FindCondition `json:"conditions"`
6997 }{
6998 Argconditions: conditions,
6999 }
7000 if d, err := json.Marshal(targetArguments); err == nil {
7001 log.Printf("[TRACE] \targs: %s\n", string(d))
7002 }
7003
7004 defer func() {
7005 log.Println("[TRACE] LocalRouterAPI.Find end")
7006 }()
7007
7008 result, err := t.Internal.Find(ctx, conditions)
7009 targetResults := struct {
7010 Result *iaas.LocalRouterFindResult
7011 Error error
7012 }{
7013 Result: result,
7014 Error: err,
7015 }
7016 if d, err := json.Marshal(targetResults); err == nil {
7017 log.Printf("[TRACE] \tresults: %s\n", string(d))
7018 }
7019
7020 return result, err
7021 }
7022
7023 // Create is API call with trace log
7024 func (t *LocalRouterTracer) Create(ctx context.Context, param *iaas.LocalRouterCreateRequest) (*iaas.LocalRouter, error) {
7025 log.Println("[TRACE] LocalRouterAPI.Create start")
7026 targetArguments := struct {
7027 Argparam *iaas.LocalRouterCreateRequest `json:"param"`
7028 }{
7029 Argparam: param,
7030 }
7031 if d, err := json.Marshal(targetArguments); err == nil {
7032 log.Printf("[TRACE] \targs: %s\n", string(d))
7033 }
7034
7035 defer func() {
7036 log.Println("[TRACE] LocalRouterAPI.Create end")
7037 }()
7038
7039 resultLocalRouter, err := t.Internal.Create(ctx, param)
7040 targetResults := struct {
7041 LocalRouter *iaas.LocalRouter
7042 Error error
7043 }{
7044 LocalRouter: resultLocalRouter,
7045 Error: err,
7046 }
7047 if d, err := json.Marshal(targetResults); err == nil {
7048 log.Printf("[TRACE] \tresults: %s\n", string(d))
7049 }
7050
7051 return resultLocalRouter, err
7052 }
7053
7054 // Read is API call with trace log
7055 func (t *LocalRouterTracer) Read(ctx context.Context, id types.ID) (*iaas.LocalRouter, error) {
7056 log.Println("[TRACE] LocalRouterAPI.Read start")
7057 targetArguments := struct {
7058 Argid types.ID `json:"id"`
7059 }{
7060 Argid: id,
7061 }
7062 if d, err := json.Marshal(targetArguments); err == nil {
7063 log.Printf("[TRACE] \targs: %s\n", string(d))
7064 }
7065
7066 defer func() {
7067 log.Println("[TRACE] LocalRouterAPI.Read end")
7068 }()
7069
7070 resultLocalRouter, err := t.Internal.Read(ctx, id)
7071 targetResults := struct {
7072 LocalRouter *iaas.LocalRouter
7073 Error error
7074 }{
7075 LocalRouter: resultLocalRouter,
7076 Error: err,
7077 }
7078 if d, err := json.Marshal(targetResults); err == nil {
7079 log.Printf("[TRACE] \tresults: %s\n", string(d))
7080 }
7081
7082 return resultLocalRouter, err
7083 }
7084
7085 // Update is API call with trace log
7086 func (t *LocalRouterTracer) Update(ctx context.Context, id types.ID, param *iaas.LocalRouterUpdateRequest) (*iaas.LocalRouter, error) {
7087 log.Println("[TRACE] LocalRouterAPI.Update start")
7088 targetArguments := struct {
7089 Argid types.ID `json:"id"`
7090 Argparam *iaas.LocalRouterUpdateRequest `json:"param"`
7091 }{
7092 Argid: id,
7093 Argparam: param,
7094 }
7095 if d, err := json.Marshal(targetArguments); err == nil {
7096 log.Printf("[TRACE] \targs: %s\n", string(d))
7097 }
7098
7099 defer func() {
7100 log.Println("[TRACE] LocalRouterAPI.Update end")
7101 }()
7102
7103 resultLocalRouter, err := t.Internal.Update(ctx, id, param)
7104 targetResults := struct {
7105 LocalRouter *iaas.LocalRouter
7106 Error error
7107 }{
7108 LocalRouter: resultLocalRouter,
7109 Error: err,
7110 }
7111 if d, err := json.Marshal(targetResults); err == nil {
7112 log.Printf("[TRACE] \tresults: %s\n", string(d))
7113 }
7114
7115 return resultLocalRouter, err
7116 }
7117
7118 // UpdateSettings is API call with trace log
7119 func (t *LocalRouterTracer) UpdateSettings(ctx context.Context, id types.ID, param *iaas.LocalRouterUpdateSettingsRequest) (*iaas.LocalRouter, error) {
7120 log.Println("[TRACE] LocalRouterAPI.UpdateSettings start")
7121 targetArguments := struct {
7122 Argid types.ID `json:"id"`
7123 Argparam *iaas.LocalRouterUpdateSettingsRequest `json:"param"`
7124 }{
7125 Argid: id,
7126 Argparam: param,
7127 }
7128 if d, err := json.Marshal(targetArguments); err == nil {
7129 log.Printf("[TRACE] \targs: %s\n", string(d))
7130 }
7131
7132 defer func() {
7133 log.Println("[TRACE] LocalRouterAPI.UpdateSettings end")
7134 }()
7135
7136 resultLocalRouter, err := t.Internal.UpdateSettings(ctx, id, param)
7137 targetResults := struct {
7138 LocalRouter *iaas.LocalRouter
7139 Error error
7140 }{
7141 LocalRouter: resultLocalRouter,
7142 Error: err,
7143 }
7144 if d, err := json.Marshal(targetResults); err == nil {
7145 log.Printf("[TRACE] \tresults: %s\n", string(d))
7146 }
7147
7148 return resultLocalRouter, err
7149 }
7150
7151 // Delete is API call with trace log
7152 func (t *LocalRouterTracer) Delete(ctx context.Context, id types.ID) error {
7153 log.Println("[TRACE] LocalRouterAPI.Delete start")
7154 targetArguments := struct {
7155 Argid types.ID `json:"id"`
7156 }{
7157 Argid: id,
7158 }
7159 if d, err := json.Marshal(targetArguments); err == nil {
7160 log.Printf("[TRACE] \targs: %s\n", string(d))
7161 }
7162
7163 defer func() {
7164 log.Println("[TRACE] LocalRouterAPI.Delete end")
7165 }()
7166
7167 err := t.Internal.Delete(ctx, id)
7168 targetResults := struct {
7169 Error error
7170 }{
7171 Error: err,
7172 }
7173 if d, err := json.Marshal(targetResults); err == nil {
7174 log.Printf("[TRACE] \tresults: %s\n", string(d))
7175 }
7176
7177 return err
7178 }
7179
7180 // HealthStatus is API call with trace log
7181 func (t *LocalRouterTracer) HealthStatus(ctx context.Context, id types.ID) (*iaas.LocalRouterHealth, error) {
7182 log.Println("[TRACE] LocalRouterAPI.HealthStatus start")
7183 targetArguments := struct {
7184 Argid types.ID `json:"id"`
7185 }{
7186 Argid: id,
7187 }
7188 if d, err := json.Marshal(targetArguments); err == nil {
7189 log.Printf("[TRACE] \targs: %s\n", string(d))
7190 }
7191
7192 defer func() {
7193 log.Println("[TRACE] LocalRouterAPI.HealthStatus end")
7194 }()
7195
7196 resultLocalRouterHealth, err := t.Internal.HealthStatus(ctx, id)
7197 targetResults := struct {
7198 LocalRouterHealth *iaas.LocalRouterHealth
7199 Error error
7200 }{
7201 LocalRouterHealth: resultLocalRouterHealth,
7202 Error: err,
7203 }
7204 if d, err := json.Marshal(targetResults); err == nil {
7205 log.Printf("[TRACE] \tresults: %s\n", string(d))
7206 }
7207
7208 return resultLocalRouterHealth, err
7209 }
7210
7211 // MonitorLocalRouter is API call with trace log
7212 func (t *LocalRouterTracer) MonitorLocalRouter(ctx context.Context, id types.ID, condition *iaas.MonitorCondition) (*iaas.LocalRouterActivity, error) {
7213 log.Println("[TRACE] LocalRouterAPI.MonitorLocalRouter start")
7214 targetArguments := struct {
7215 Argid types.ID `json:"id"`
7216 Argcondition *iaas.MonitorCondition `json:"condition"`
7217 }{
7218 Argid: id,
7219 Argcondition: condition,
7220 }
7221 if d, err := json.Marshal(targetArguments); err == nil {
7222 log.Printf("[TRACE] \targs: %s\n", string(d))
7223 }
7224
7225 defer func() {
7226 log.Println("[TRACE] LocalRouterAPI.MonitorLocalRouter end")
7227 }()
7228
7229 resultLocalRouterActivity, err := t.Internal.MonitorLocalRouter(ctx, id, condition)
7230 targetResults := struct {
7231 LocalRouterActivity *iaas.LocalRouterActivity
7232 Error error
7233 }{
7234 LocalRouterActivity: resultLocalRouterActivity,
7235 Error: err,
7236 }
7237 if d, err := json.Marshal(targetResults); err == nil {
7238 log.Printf("[TRACE] \tresults: %s\n", string(d))
7239 }
7240
7241 return resultLocalRouterActivity, err
7242 }
7243
7244 /*************************************************
7245 * MobileGatewayTracer
7246 *************************************************/
7247
7248 // MobileGatewayTracer is for trace MobileGatewayOp operations
7249 type MobileGatewayTracer struct {
7250 Internal iaas.MobileGatewayAPI
7251 }
7252
7253 // NewMobileGatewayTracer creates new MobileGatewayTracer instance
7254 func NewMobileGatewayTracer(in iaas.MobileGatewayAPI) iaas.MobileGatewayAPI {
7255 return &MobileGatewayTracer{
7256 Internal: in,
7257 }
7258 }
7259
7260 // Find is API call with trace log
7261 func (t *MobileGatewayTracer) Find(ctx context.Context, zone string, conditions *iaas.FindCondition) (*iaas.MobileGatewayFindResult, error) {
7262 log.Println("[TRACE] MobileGatewayAPI.Find start")
7263 targetArguments := struct {
7264 Argzone string
7265 Argconditions *iaas.FindCondition `json:"conditions"`
7266 }{
7267 Argzone: zone,
7268 Argconditions: conditions,
7269 }
7270 if d, err := json.Marshal(targetArguments); err == nil {
7271 log.Printf("[TRACE] \targs: %s\n", string(d))
7272 }
7273
7274 defer func() {
7275 log.Println("[TRACE] MobileGatewayAPI.Find end")
7276 }()
7277
7278 result, err := t.Internal.Find(ctx, zone, conditions)
7279 targetResults := struct {
7280 Result *iaas.MobileGatewayFindResult
7281 Error error
7282 }{
7283 Result: result,
7284 Error: err,
7285 }
7286 if d, err := json.Marshal(targetResults); err == nil {
7287 log.Printf("[TRACE] \tresults: %s\n", string(d))
7288 }
7289
7290 return result, err
7291 }
7292
7293 // Create is API call with trace log
7294 func (t *MobileGatewayTracer) Create(ctx context.Context, zone string, param *iaas.MobileGatewayCreateRequest) (*iaas.MobileGateway, error) {
7295 log.Println("[TRACE] MobileGatewayAPI.Create start")
7296 targetArguments := struct {
7297 Argzone string
7298 Argparam *iaas.MobileGatewayCreateRequest `json:"param"`
7299 }{
7300 Argzone: zone,
7301 Argparam: param,
7302 }
7303 if d, err := json.Marshal(targetArguments); err == nil {
7304 log.Printf("[TRACE] \targs: %s\n", string(d))
7305 }
7306
7307 defer func() {
7308 log.Println("[TRACE] MobileGatewayAPI.Create end")
7309 }()
7310
7311 resultMobileGateway, err := t.Internal.Create(ctx, zone, param)
7312 targetResults := struct {
7313 MobileGateway *iaas.MobileGateway
7314 Error error
7315 }{
7316 MobileGateway: resultMobileGateway,
7317 Error: err,
7318 }
7319 if d, err := json.Marshal(targetResults); err == nil {
7320 log.Printf("[TRACE] \tresults: %s\n", string(d))
7321 }
7322
7323 return resultMobileGateway, err
7324 }
7325
7326 // Read is API call with trace log
7327 func (t *MobileGatewayTracer) Read(ctx context.Context, zone string, id types.ID) (*iaas.MobileGateway, error) {
7328 log.Println("[TRACE] MobileGatewayAPI.Read start")
7329 targetArguments := struct {
7330 Argzone string
7331 Argid types.ID `json:"id"`
7332 }{
7333 Argzone: zone,
7334 Argid: id,
7335 }
7336 if d, err := json.Marshal(targetArguments); err == nil {
7337 log.Printf("[TRACE] \targs: %s\n", string(d))
7338 }
7339
7340 defer func() {
7341 log.Println("[TRACE] MobileGatewayAPI.Read end")
7342 }()
7343
7344 resultMobileGateway, err := t.Internal.Read(ctx, zone, id)
7345 targetResults := struct {
7346 MobileGateway *iaas.MobileGateway
7347 Error error
7348 }{
7349 MobileGateway: resultMobileGateway,
7350 Error: err,
7351 }
7352 if d, err := json.Marshal(targetResults); err == nil {
7353 log.Printf("[TRACE] \tresults: %s\n", string(d))
7354 }
7355
7356 return resultMobileGateway, err
7357 }
7358
7359 // Update is API call with trace log
7360 func (t *MobileGatewayTracer) Update(ctx context.Context, zone string, id types.ID, param *iaas.MobileGatewayUpdateRequest) (*iaas.MobileGateway, error) {
7361 log.Println("[TRACE] MobileGatewayAPI.Update start")
7362 targetArguments := struct {
7363 Argzone string
7364 Argid types.ID `json:"id"`
7365 Argparam *iaas.MobileGatewayUpdateRequest `json:"param"`
7366 }{
7367 Argzone: zone,
7368 Argid: id,
7369 Argparam: param,
7370 }
7371 if d, err := json.Marshal(targetArguments); err == nil {
7372 log.Printf("[TRACE] \targs: %s\n", string(d))
7373 }
7374
7375 defer func() {
7376 log.Println("[TRACE] MobileGatewayAPI.Update end")
7377 }()
7378
7379 resultMobileGateway, err := t.Internal.Update(ctx, zone, id, param)
7380 targetResults := struct {
7381 MobileGateway *iaas.MobileGateway
7382 Error error
7383 }{
7384 MobileGateway: resultMobileGateway,
7385 Error: err,
7386 }
7387 if d, err := json.Marshal(targetResults); err == nil {
7388 log.Printf("[TRACE] \tresults: %s\n", string(d))
7389 }
7390
7391 return resultMobileGateway, err
7392 }
7393
7394 // UpdateSettings is API call with trace log
7395 func (t *MobileGatewayTracer) UpdateSettings(ctx context.Context, zone string, id types.ID, param *iaas.MobileGatewayUpdateSettingsRequest) (*iaas.MobileGateway, error) {
7396 log.Println("[TRACE] MobileGatewayAPI.UpdateSettings start")
7397 targetArguments := struct {
7398 Argzone string
7399 Argid types.ID `json:"id"`
7400 Argparam *iaas.MobileGatewayUpdateSettingsRequest `json:"param"`
7401 }{
7402 Argzone: zone,
7403 Argid: id,
7404 Argparam: param,
7405 }
7406 if d, err := json.Marshal(targetArguments); err == nil {
7407 log.Printf("[TRACE] \targs: %s\n", string(d))
7408 }
7409
7410 defer func() {
7411 log.Println("[TRACE] MobileGatewayAPI.UpdateSettings end")
7412 }()
7413
7414 resultMobileGateway, err := t.Internal.UpdateSettings(ctx, zone, id, param)
7415 targetResults := struct {
7416 MobileGateway *iaas.MobileGateway
7417 Error error
7418 }{
7419 MobileGateway: resultMobileGateway,
7420 Error: err,
7421 }
7422 if d, err := json.Marshal(targetResults); err == nil {
7423 log.Printf("[TRACE] \tresults: %s\n", string(d))
7424 }
7425
7426 return resultMobileGateway, err
7427 }
7428
7429 // Delete is API call with trace log
7430 func (t *MobileGatewayTracer) Delete(ctx context.Context, zone string, id types.ID) error {
7431 log.Println("[TRACE] MobileGatewayAPI.Delete start")
7432 targetArguments := struct {
7433 Argzone string
7434 Argid types.ID `json:"id"`
7435 }{
7436 Argzone: zone,
7437 Argid: id,
7438 }
7439 if d, err := json.Marshal(targetArguments); err == nil {
7440 log.Printf("[TRACE] \targs: %s\n", string(d))
7441 }
7442
7443 defer func() {
7444 log.Println("[TRACE] MobileGatewayAPI.Delete end")
7445 }()
7446
7447 err := t.Internal.Delete(ctx, zone, id)
7448 targetResults := struct {
7449 Error error
7450 }{
7451 Error: err,
7452 }
7453 if d, err := json.Marshal(targetResults); err == nil {
7454 log.Printf("[TRACE] \tresults: %s\n", string(d))
7455 }
7456
7457 return err
7458 }
7459
7460 // Config is API call with trace log
7461 func (t *MobileGatewayTracer) Config(ctx context.Context, zone string, id types.ID) error {
7462 log.Println("[TRACE] MobileGatewayAPI.Config start")
7463 targetArguments := struct {
7464 Argzone string
7465 Argid types.ID `json:"id"`
7466 }{
7467 Argzone: zone,
7468 Argid: id,
7469 }
7470 if d, err := json.Marshal(targetArguments); err == nil {
7471 log.Printf("[TRACE] \targs: %s\n", string(d))
7472 }
7473
7474 defer func() {
7475 log.Println("[TRACE] MobileGatewayAPI.Config end")
7476 }()
7477
7478 err := t.Internal.Config(ctx, zone, id)
7479 targetResults := struct {
7480 Error error
7481 }{
7482 Error: err,
7483 }
7484 if d, err := json.Marshal(targetResults); err == nil {
7485 log.Printf("[TRACE] \tresults: %s\n", string(d))
7486 }
7487
7488 return err
7489 }
7490
7491 // Boot is API call with trace log
7492 func (t *MobileGatewayTracer) Boot(ctx context.Context, zone string, id types.ID) error {
7493 log.Println("[TRACE] MobileGatewayAPI.Boot start")
7494 targetArguments := struct {
7495 Argzone string
7496 Argid types.ID `json:"id"`
7497 }{
7498 Argzone: zone,
7499 Argid: id,
7500 }
7501 if d, err := json.Marshal(targetArguments); err == nil {
7502 log.Printf("[TRACE] \targs: %s\n", string(d))
7503 }
7504
7505 defer func() {
7506 log.Println("[TRACE] MobileGatewayAPI.Boot end")
7507 }()
7508
7509 err := t.Internal.Boot(ctx, zone, id)
7510 targetResults := struct {
7511 Error error
7512 }{
7513 Error: err,
7514 }
7515 if d, err := json.Marshal(targetResults); err == nil {
7516 log.Printf("[TRACE] \tresults: %s\n", string(d))
7517 }
7518
7519 return err
7520 }
7521
7522 // Shutdown is API call with trace log
7523 func (t *MobileGatewayTracer) Shutdown(ctx context.Context, zone string, id types.ID, shutdownOption *iaas.ShutdownOption) error {
7524 log.Println("[TRACE] MobileGatewayAPI.Shutdown start")
7525 targetArguments := struct {
7526 Argzone string
7527 Argid types.ID `json:"id"`
7528 ArgshutdownOption *iaas.ShutdownOption `json:"shutdownOption"`
7529 }{
7530 Argzone: zone,
7531 Argid: id,
7532 ArgshutdownOption: shutdownOption,
7533 }
7534 if d, err := json.Marshal(targetArguments); err == nil {
7535 log.Printf("[TRACE] \targs: %s\n", string(d))
7536 }
7537
7538 defer func() {
7539 log.Println("[TRACE] MobileGatewayAPI.Shutdown end")
7540 }()
7541
7542 err := t.Internal.Shutdown(ctx, zone, id, shutdownOption)
7543 targetResults := struct {
7544 Error error
7545 }{
7546 Error: err,
7547 }
7548 if d, err := json.Marshal(targetResults); err == nil {
7549 log.Printf("[TRACE] \tresults: %s\n", string(d))
7550 }
7551
7552 return err
7553 }
7554
7555 // Reset is API call with trace log
7556 func (t *MobileGatewayTracer) Reset(ctx context.Context, zone string, id types.ID) error {
7557 log.Println("[TRACE] MobileGatewayAPI.Reset start")
7558 targetArguments := struct {
7559 Argzone string
7560 Argid types.ID `json:"id"`
7561 }{
7562 Argzone: zone,
7563 Argid: id,
7564 }
7565 if d, err := json.Marshal(targetArguments); err == nil {
7566 log.Printf("[TRACE] \targs: %s\n", string(d))
7567 }
7568
7569 defer func() {
7570 log.Println("[TRACE] MobileGatewayAPI.Reset end")
7571 }()
7572
7573 err := t.Internal.Reset(ctx, zone, id)
7574 targetResults := struct {
7575 Error error
7576 }{
7577 Error: err,
7578 }
7579 if d, err := json.Marshal(targetResults); err == nil {
7580 log.Printf("[TRACE] \tresults: %s\n", string(d))
7581 }
7582
7583 return err
7584 }
7585
7586 // ConnectToSwitch is API call with trace log
7587 func (t *MobileGatewayTracer) ConnectToSwitch(ctx context.Context, zone string, id types.ID, switchID types.ID) error {
7588 log.Println("[TRACE] MobileGatewayAPI.ConnectToSwitch start")
7589 targetArguments := struct {
7590 Argzone string
7591 Argid types.ID `json:"id"`
7592 ArgswitchID types.ID `json:"switchID"`
7593 }{
7594 Argzone: zone,
7595 Argid: id,
7596 ArgswitchID: switchID,
7597 }
7598 if d, err := json.Marshal(targetArguments); err == nil {
7599 log.Printf("[TRACE] \targs: %s\n", string(d))
7600 }
7601
7602 defer func() {
7603 log.Println("[TRACE] MobileGatewayAPI.ConnectToSwitch end")
7604 }()
7605
7606 err := t.Internal.ConnectToSwitch(ctx, zone, id, switchID)
7607 targetResults := struct {
7608 Error error
7609 }{
7610 Error: err,
7611 }
7612 if d, err := json.Marshal(targetResults); err == nil {
7613 log.Printf("[TRACE] \tresults: %s\n", string(d))
7614 }
7615
7616 return err
7617 }
7618
7619 // DisconnectFromSwitch is API call with trace log
7620 func (t *MobileGatewayTracer) DisconnectFromSwitch(ctx context.Context, zone string, id types.ID) error {
7621 log.Println("[TRACE] MobileGatewayAPI.DisconnectFromSwitch start")
7622 targetArguments := struct {
7623 Argzone string
7624 Argid types.ID `json:"id"`
7625 }{
7626 Argzone: zone,
7627 Argid: id,
7628 }
7629 if d, err := json.Marshal(targetArguments); err == nil {
7630 log.Printf("[TRACE] \targs: %s\n", string(d))
7631 }
7632
7633 defer func() {
7634 log.Println("[TRACE] MobileGatewayAPI.DisconnectFromSwitch end")
7635 }()
7636
7637 err := t.Internal.DisconnectFromSwitch(ctx, zone, id)
7638 targetResults := struct {
7639 Error error
7640 }{
7641 Error: err,
7642 }
7643 if d, err := json.Marshal(targetResults); err == nil {
7644 log.Printf("[TRACE] \tresults: %s\n", string(d))
7645 }
7646
7647 return err
7648 }
7649
7650 // GetDNS is API call with trace log
7651 func (t *MobileGatewayTracer) GetDNS(ctx context.Context, zone string, id types.ID) (*iaas.MobileGatewayDNSSetting, error) {
7652 log.Println("[TRACE] MobileGatewayAPI.GetDNS start")
7653 targetArguments := struct {
7654 Argzone string
7655 Argid types.ID `json:"id"`
7656 }{
7657 Argzone: zone,
7658 Argid: id,
7659 }
7660 if d, err := json.Marshal(targetArguments); err == nil {
7661 log.Printf("[TRACE] \targs: %s\n", string(d))
7662 }
7663
7664 defer func() {
7665 log.Println("[TRACE] MobileGatewayAPI.GetDNS end")
7666 }()
7667
7668 resultSIMGroup, err := t.Internal.GetDNS(ctx, zone, id)
7669 targetResults := struct {
7670 SIMGroup *iaas.MobileGatewayDNSSetting
7671 Error error
7672 }{
7673 SIMGroup: resultSIMGroup,
7674 Error: err,
7675 }
7676 if d, err := json.Marshal(targetResults); err == nil {
7677 log.Printf("[TRACE] \tresults: %s\n", string(d))
7678 }
7679
7680 return resultSIMGroup, err
7681 }
7682
7683 // SetDNS is API call with trace log
7684 func (t *MobileGatewayTracer) SetDNS(ctx context.Context, zone string, id types.ID, param *iaas.MobileGatewayDNSSetting) error {
7685 log.Println("[TRACE] MobileGatewayAPI.SetDNS start")
7686 targetArguments := struct {
7687 Argzone string
7688 Argid types.ID `json:"id"`
7689 Argparam *iaas.MobileGatewayDNSSetting `json:"param"`
7690 }{
7691 Argzone: zone,
7692 Argid: id,
7693 Argparam: param,
7694 }
7695 if d, err := json.Marshal(targetArguments); err == nil {
7696 log.Printf("[TRACE] \targs: %s\n", string(d))
7697 }
7698
7699 defer func() {
7700 log.Println("[TRACE] MobileGatewayAPI.SetDNS end")
7701 }()
7702
7703 err := t.Internal.SetDNS(ctx, zone, id, param)
7704 targetResults := struct {
7705 Error error
7706 }{
7707 Error: err,
7708 }
7709 if d, err := json.Marshal(targetResults); err == nil {
7710 log.Printf("[TRACE] \tresults: %s\n", string(d))
7711 }
7712
7713 return err
7714 }
7715
7716 // GetSIMRoutes is API call with trace log
7717 func (t *MobileGatewayTracer) GetSIMRoutes(ctx context.Context, zone string, id types.ID) (iaas.MobileGatewaySIMRoutes, error) {
7718 log.Println("[TRACE] MobileGatewayAPI.GetSIMRoutes start")
7719 targetArguments := struct {
7720 Argzone string
7721 Argid types.ID `json:"id"`
7722 }{
7723 Argzone: zone,
7724 Argid: id,
7725 }
7726 if d, err := json.Marshal(targetArguments); err == nil {
7727 log.Printf("[TRACE] \targs: %s\n", string(d))
7728 }
7729
7730 defer func() {
7731 log.Println("[TRACE] MobileGatewayAPI.GetSIMRoutes end")
7732 }()
7733
7734 resultSIMRoutes, err := t.Internal.GetSIMRoutes(ctx, zone, id)
7735 targetResults := struct {
7736 SIMRoutes iaas.MobileGatewaySIMRoutes
7737 Error error
7738 }{
7739 SIMRoutes: resultSIMRoutes,
7740 Error: err,
7741 }
7742 if d, err := json.Marshal(targetResults); err == nil {
7743 log.Printf("[TRACE] \tresults: %s\n", string(d))
7744 }
7745
7746 return resultSIMRoutes, err
7747 }
7748
7749 // SetSIMRoutes is API call with trace log
7750 func (t *MobileGatewayTracer) SetSIMRoutes(ctx context.Context, zone string, id types.ID, param []*iaas.MobileGatewaySIMRouteParam) error {
7751 log.Println("[TRACE] MobileGatewayAPI.SetSIMRoutes start")
7752 targetArguments := struct {
7753 Argzone string
7754 Argid types.ID `json:"id"`
7755 Argparam []*iaas.MobileGatewaySIMRouteParam `json:"param"`
7756 }{
7757 Argzone: zone,
7758 Argid: id,
7759 Argparam: param,
7760 }
7761 if d, err := json.Marshal(targetArguments); err == nil {
7762 log.Printf("[TRACE] \targs: %s\n", string(d))
7763 }
7764
7765 defer func() {
7766 log.Println("[TRACE] MobileGatewayAPI.SetSIMRoutes end")
7767 }()
7768
7769 err := t.Internal.SetSIMRoutes(ctx, zone, id, param)
7770 targetResults := struct {
7771 Error error
7772 }{
7773 Error: err,
7774 }
7775 if d, err := json.Marshal(targetResults); err == nil {
7776 log.Printf("[TRACE] \tresults: %s\n", string(d))
7777 }
7778
7779 return err
7780 }
7781
7782 // ListSIM is API call with trace log
7783 func (t *MobileGatewayTracer) ListSIM(ctx context.Context, zone string, id types.ID) (iaas.MobileGatewaySIMs, error) {
7784 log.Println("[TRACE] MobileGatewayAPI.ListSIM start")
7785 targetArguments := struct {
7786 Argzone string
7787 Argid types.ID `json:"id"`
7788 }{
7789 Argzone: zone,
7790 Argid: id,
7791 }
7792 if d, err := json.Marshal(targetArguments); err == nil {
7793 log.Printf("[TRACE] \targs: %s\n", string(d))
7794 }
7795
7796 defer func() {
7797 log.Println("[TRACE] MobileGatewayAPI.ListSIM end")
7798 }()
7799
7800 resultSIM, err := t.Internal.ListSIM(ctx, zone, id)
7801 targetResults := struct {
7802 SIM iaas.MobileGatewaySIMs
7803 Error error
7804 }{
7805 SIM: resultSIM,
7806 Error: err,
7807 }
7808 if d, err := json.Marshal(targetResults); err == nil {
7809 log.Printf("[TRACE] \tresults: %s\n", string(d))
7810 }
7811
7812 return resultSIM, err
7813 }
7814
7815 // AddSIM is API call with trace log
7816 func (t *MobileGatewayTracer) AddSIM(ctx context.Context, zone string, id types.ID, param *iaas.MobileGatewayAddSIMRequest) error {
7817 log.Println("[TRACE] MobileGatewayAPI.AddSIM start")
7818 targetArguments := struct {
7819 Argzone string
7820 Argid types.ID `json:"id"`
7821 Argparam *iaas.MobileGatewayAddSIMRequest `json:"param"`
7822 }{
7823 Argzone: zone,
7824 Argid: id,
7825 Argparam: param,
7826 }
7827 if d, err := json.Marshal(targetArguments); err == nil {
7828 log.Printf("[TRACE] \targs: %s\n", string(d))
7829 }
7830
7831 defer func() {
7832 log.Println("[TRACE] MobileGatewayAPI.AddSIM end")
7833 }()
7834
7835 err := t.Internal.AddSIM(ctx, zone, id, param)
7836 targetResults := struct {
7837 Error error
7838 }{
7839 Error: err,
7840 }
7841 if d, err := json.Marshal(targetResults); err == nil {
7842 log.Printf("[TRACE] \tresults: %s\n", string(d))
7843 }
7844
7845 return err
7846 }
7847
7848 // DeleteSIM is API call with trace log
7849 func (t *MobileGatewayTracer) DeleteSIM(ctx context.Context, zone string, id types.ID, simID types.ID) error {
7850 log.Println("[TRACE] MobileGatewayAPI.DeleteSIM start")
7851 targetArguments := struct {
7852 Argzone string
7853 Argid types.ID `json:"id"`
7854 ArgsimID types.ID `json:"simID"`
7855 }{
7856 Argzone: zone,
7857 Argid: id,
7858 ArgsimID: simID,
7859 }
7860 if d, err := json.Marshal(targetArguments); err == nil {
7861 log.Printf("[TRACE] \targs: %s\n", string(d))
7862 }
7863
7864 defer func() {
7865 log.Println("[TRACE] MobileGatewayAPI.DeleteSIM end")
7866 }()
7867
7868 err := t.Internal.DeleteSIM(ctx, zone, id, simID)
7869 targetResults := struct {
7870 Error error
7871 }{
7872 Error: err,
7873 }
7874 if d, err := json.Marshal(targetResults); err == nil {
7875 log.Printf("[TRACE] \tresults: %s\n", string(d))
7876 }
7877
7878 return err
7879 }
7880
7881 // Logs is API call with trace log
7882 func (t *MobileGatewayTracer) Logs(ctx context.Context, zone string, id types.ID) ([]*iaas.MobileGatewaySIMLogs, error) {
7883 log.Println("[TRACE] MobileGatewayAPI.Logs start")
7884 targetArguments := struct {
7885 Argzone string
7886 Argid types.ID `json:"id"`
7887 }{
7888 Argzone: zone,
7889 Argid: id,
7890 }
7891 if d, err := json.Marshal(targetArguments); err == nil {
7892 log.Printf("[TRACE] \targs: %s\n", string(d))
7893 }
7894
7895 defer func() {
7896 log.Println("[TRACE] MobileGatewayAPI.Logs end")
7897 }()
7898
7899 resultLogs, err := t.Internal.Logs(ctx, zone, id)
7900 targetResults := struct {
7901 Logs []*iaas.MobileGatewaySIMLogs
7902 Error error
7903 }{
7904 Logs: resultLogs,
7905 Error: err,
7906 }
7907 if d, err := json.Marshal(targetResults); err == nil {
7908 log.Printf("[TRACE] \tresults: %s\n", string(d))
7909 }
7910
7911 return resultLogs, err
7912 }
7913
7914 // GetTrafficConfig is API call with trace log
7915 func (t *MobileGatewayTracer) GetTrafficConfig(ctx context.Context, zone string, id types.ID) (*iaas.MobileGatewayTrafficControl, error) {
7916 log.Println("[TRACE] MobileGatewayAPI.GetTrafficConfig start")
7917 targetArguments := struct {
7918 Argzone string
7919 Argid types.ID `json:"id"`
7920 }{
7921 Argzone: zone,
7922 Argid: id,
7923 }
7924 if d, err := json.Marshal(targetArguments); err == nil {
7925 log.Printf("[TRACE] \targs: %s\n", string(d))
7926 }
7927
7928 defer func() {
7929 log.Println("[TRACE] MobileGatewayAPI.GetTrafficConfig end")
7930 }()
7931
7932 resultTrafficMonitoring, err := t.Internal.GetTrafficConfig(ctx, zone, id)
7933 targetResults := struct {
7934 TrafficMonitoring *iaas.MobileGatewayTrafficControl
7935 Error error
7936 }{
7937 TrafficMonitoring: resultTrafficMonitoring,
7938 Error: err,
7939 }
7940 if d, err := json.Marshal(targetResults); err == nil {
7941 log.Printf("[TRACE] \tresults: %s\n", string(d))
7942 }
7943
7944 return resultTrafficMonitoring, err
7945 }
7946
7947 // SetTrafficConfig is API call with trace log
7948 func (t *MobileGatewayTracer) SetTrafficConfig(ctx context.Context, zone string, id types.ID, param *iaas.MobileGatewayTrafficControl) error {
7949 log.Println("[TRACE] MobileGatewayAPI.SetTrafficConfig start")
7950 targetArguments := struct {
7951 Argzone string
7952 Argid types.ID `json:"id"`
7953 Argparam *iaas.MobileGatewayTrafficControl `json:"param"`
7954 }{
7955 Argzone: zone,
7956 Argid: id,
7957 Argparam: param,
7958 }
7959 if d, err := json.Marshal(targetArguments); err == nil {
7960 log.Printf("[TRACE] \targs: %s\n", string(d))
7961 }
7962
7963 defer func() {
7964 log.Println("[TRACE] MobileGatewayAPI.SetTrafficConfig end")
7965 }()
7966
7967 err := t.Internal.SetTrafficConfig(ctx, zone, id, param)
7968 targetResults := struct {
7969 Error error
7970 }{
7971 Error: err,
7972 }
7973 if d, err := json.Marshal(targetResults); err == nil {
7974 log.Printf("[TRACE] \tresults: %s\n", string(d))
7975 }
7976
7977 return err
7978 }
7979
7980 // DeleteTrafficConfig is API call with trace log
7981 func (t *MobileGatewayTracer) DeleteTrafficConfig(ctx context.Context, zone string, id types.ID) error {
7982 log.Println("[TRACE] MobileGatewayAPI.DeleteTrafficConfig start")
7983 targetArguments := struct {
7984 Argzone string
7985 Argid types.ID `json:"id"`
7986 }{
7987 Argzone: zone,
7988 Argid: id,
7989 }
7990 if d, err := json.Marshal(targetArguments); err == nil {
7991 log.Printf("[TRACE] \targs: %s\n", string(d))
7992 }
7993
7994 defer func() {
7995 log.Println("[TRACE] MobileGatewayAPI.DeleteTrafficConfig end")
7996 }()
7997
7998 err := t.Internal.DeleteTrafficConfig(ctx, zone, id)
7999 targetResults := struct {
8000 Error error
8001 }{
8002 Error: err,
8003 }
8004 if d, err := json.Marshal(targetResults); err == nil {
8005 log.Printf("[TRACE] \tresults: %s\n", string(d))
8006 }
8007
8008 return err
8009 }
8010
8011 // TrafficStatus is API call with trace log
8012 func (t *MobileGatewayTracer) TrafficStatus(ctx context.Context, zone string, id types.ID) (*iaas.MobileGatewayTrafficStatus, error) {
8013 log.Println("[TRACE] MobileGatewayAPI.TrafficStatus start")
8014 targetArguments := struct {
8015 Argzone string
8016 Argid types.ID `json:"id"`
8017 }{
8018 Argzone: zone,
8019 Argid: id,
8020 }
8021 if d, err := json.Marshal(targetArguments); err == nil {
8022 log.Printf("[TRACE] \targs: %s\n", string(d))
8023 }
8024
8025 defer func() {
8026 log.Println("[TRACE] MobileGatewayAPI.TrafficStatus end")
8027 }()
8028
8029 resultTrafficStatus, err := t.Internal.TrafficStatus(ctx, zone, id)
8030 targetResults := struct {
8031 TrafficStatus *iaas.MobileGatewayTrafficStatus
8032 Error error
8033 }{
8034 TrafficStatus: resultTrafficStatus,
8035 Error: err,
8036 }
8037 if d, err := json.Marshal(targetResults); err == nil {
8038 log.Printf("[TRACE] \tresults: %s\n", string(d))
8039 }
8040
8041 return resultTrafficStatus, err
8042 }
8043
8044 // MonitorInterface is API call with trace log
8045 func (t *MobileGatewayTracer) MonitorInterface(ctx context.Context, zone string, id types.ID, index int, condition *iaas.MonitorCondition) (*iaas.InterfaceActivity, error) {
8046 log.Println("[TRACE] MobileGatewayAPI.MonitorInterface start")
8047 targetArguments := struct {
8048 Argzone string
8049 Argid types.ID `json:"id"`
8050 Argindex int `json:"index"`
8051 Argcondition *iaas.MonitorCondition `json:"condition"`
8052 }{
8053 Argzone: zone,
8054 Argid: id,
8055 Argindex: index,
8056 Argcondition: condition,
8057 }
8058 if d, err := json.Marshal(targetArguments); err == nil {
8059 log.Printf("[TRACE] \targs: %s\n", string(d))
8060 }
8061
8062 defer func() {
8063 log.Println("[TRACE] MobileGatewayAPI.MonitorInterface end")
8064 }()
8065
8066 resultInterfaceActivity, err := t.Internal.MonitorInterface(ctx, zone, id, index, condition)
8067 targetResults := struct {
8068 InterfaceActivity *iaas.InterfaceActivity
8069 Error error
8070 }{
8071 InterfaceActivity: resultInterfaceActivity,
8072 Error: err,
8073 }
8074 if d, err := json.Marshal(targetResults); err == nil {
8075 log.Printf("[TRACE] \tresults: %s\n", string(d))
8076 }
8077
8078 return resultInterfaceActivity, err
8079 }
8080
8081 /*************************************************
8082 * NFSTracer
8083 *************************************************/
8084
8085 // NFSTracer is for trace NFSOp operations
8086 type NFSTracer struct {
8087 Internal iaas.NFSAPI
8088 }
8089
8090 // NewNFSTracer creates new NFSTracer instance
8091 func NewNFSTracer(in iaas.NFSAPI) iaas.NFSAPI {
8092 return &NFSTracer{
8093 Internal: in,
8094 }
8095 }
8096
8097 // Find is API call with trace log
8098 func (t *NFSTracer) Find(ctx context.Context, zone string, conditions *iaas.FindCondition) (*iaas.NFSFindResult, error) {
8099 log.Println("[TRACE] NFSAPI.Find start")
8100 targetArguments := struct {
8101 Argzone string
8102 Argconditions *iaas.FindCondition `json:"conditions"`
8103 }{
8104 Argzone: zone,
8105 Argconditions: conditions,
8106 }
8107 if d, err := json.Marshal(targetArguments); err == nil {
8108 log.Printf("[TRACE] \targs: %s\n", string(d))
8109 }
8110
8111 defer func() {
8112 log.Println("[TRACE] NFSAPI.Find end")
8113 }()
8114
8115 result, err := t.Internal.Find(ctx, zone, conditions)
8116 targetResults := struct {
8117 Result *iaas.NFSFindResult
8118 Error error
8119 }{
8120 Result: result,
8121 Error: err,
8122 }
8123 if d, err := json.Marshal(targetResults); err == nil {
8124 log.Printf("[TRACE] \tresults: %s\n", string(d))
8125 }
8126
8127 return result, err
8128 }
8129
8130 // Create is API call with trace log
8131 func (t *NFSTracer) Create(ctx context.Context, zone string, param *iaas.NFSCreateRequest) (*iaas.NFS, error) {
8132 log.Println("[TRACE] NFSAPI.Create start")
8133 targetArguments := struct {
8134 Argzone string
8135 Argparam *iaas.NFSCreateRequest `json:"param"`
8136 }{
8137 Argzone: zone,
8138 Argparam: param,
8139 }
8140 if d, err := json.Marshal(targetArguments); err == nil {
8141 log.Printf("[TRACE] \targs: %s\n", string(d))
8142 }
8143
8144 defer func() {
8145 log.Println("[TRACE] NFSAPI.Create end")
8146 }()
8147
8148 resultNFS, err := t.Internal.Create(ctx, zone, param)
8149 targetResults := struct {
8150 NFS *iaas.NFS
8151 Error error
8152 }{
8153 NFS: resultNFS,
8154 Error: err,
8155 }
8156 if d, err := json.Marshal(targetResults); err == nil {
8157 log.Printf("[TRACE] \tresults: %s\n", string(d))
8158 }
8159
8160 return resultNFS, err
8161 }
8162
8163 // Read is API call with trace log
8164 func (t *NFSTracer) Read(ctx context.Context, zone string, id types.ID) (*iaas.NFS, error) {
8165 log.Println("[TRACE] NFSAPI.Read start")
8166 targetArguments := struct {
8167 Argzone string
8168 Argid types.ID `json:"id"`
8169 }{
8170 Argzone: zone,
8171 Argid: id,
8172 }
8173 if d, err := json.Marshal(targetArguments); err == nil {
8174 log.Printf("[TRACE] \targs: %s\n", string(d))
8175 }
8176
8177 defer func() {
8178 log.Println("[TRACE] NFSAPI.Read end")
8179 }()
8180
8181 resultNFS, err := t.Internal.Read(ctx, zone, id)
8182 targetResults := struct {
8183 NFS *iaas.NFS
8184 Error error
8185 }{
8186 NFS: resultNFS,
8187 Error: err,
8188 }
8189 if d, err := json.Marshal(targetResults); err == nil {
8190 log.Printf("[TRACE] \tresults: %s\n", string(d))
8191 }
8192
8193 return resultNFS, err
8194 }
8195
8196 // Update is API call with trace log
8197 func (t *NFSTracer) Update(ctx context.Context, zone string, id types.ID, param *iaas.NFSUpdateRequest) (*iaas.NFS, error) {
8198 log.Println("[TRACE] NFSAPI.Update start")
8199 targetArguments := struct {
8200 Argzone string
8201 Argid types.ID `json:"id"`
8202 Argparam *iaas.NFSUpdateRequest `json:"param"`
8203 }{
8204 Argzone: zone,
8205 Argid: id,
8206 Argparam: param,
8207 }
8208 if d, err := json.Marshal(targetArguments); err == nil {
8209 log.Printf("[TRACE] \targs: %s\n", string(d))
8210 }
8211
8212 defer func() {
8213 log.Println("[TRACE] NFSAPI.Update end")
8214 }()
8215
8216 resultNFS, err := t.Internal.Update(ctx, zone, id, param)
8217 targetResults := struct {
8218 NFS *iaas.NFS
8219 Error error
8220 }{
8221 NFS: resultNFS,
8222 Error: err,
8223 }
8224 if d, err := json.Marshal(targetResults); err == nil {
8225 log.Printf("[TRACE] \tresults: %s\n", string(d))
8226 }
8227
8228 return resultNFS, err
8229 }
8230
8231 // Delete is API call with trace log
8232 func (t *NFSTracer) Delete(ctx context.Context, zone string, id types.ID) error {
8233 log.Println("[TRACE] NFSAPI.Delete start")
8234 targetArguments := struct {
8235 Argzone string
8236 Argid types.ID `json:"id"`
8237 }{
8238 Argzone: zone,
8239 Argid: id,
8240 }
8241 if d, err := json.Marshal(targetArguments); err == nil {
8242 log.Printf("[TRACE] \targs: %s\n", string(d))
8243 }
8244
8245 defer func() {
8246 log.Println("[TRACE] NFSAPI.Delete end")
8247 }()
8248
8249 err := t.Internal.Delete(ctx, zone, id)
8250 targetResults := struct {
8251 Error error
8252 }{
8253 Error: err,
8254 }
8255 if d, err := json.Marshal(targetResults); err == nil {
8256 log.Printf("[TRACE] \tresults: %s\n", string(d))
8257 }
8258
8259 return err
8260 }
8261
8262 // Boot is API call with trace log
8263 func (t *NFSTracer) Boot(ctx context.Context, zone string, id types.ID) error {
8264 log.Println("[TRACE] NFSAPI.Boot start")
8265 targetArguments := struct {
8266 Argzone string
8267 Argid types.ID `json:"id"`
8268 }{
8269 Argzone: zone,
8270 Argid: id,
8271 }
8272 if d, err := json.Marshal(targetArguments); err == nil {
8273 log.Printf("[TRACE] \targs: %s\n", string(d))
8274 }
8275
8276 defer func() {
8277 log.Println("[TRACE] NFSAPI.Boot end")
8278 }()
8279
8280 err := t.Internal.Boot(ctx, zone, id)
8281 targetResults := struct {
8282 Error error
8283 }{
8284 Error: err,
8285 }
8286 if d, err := json.Marshal(targetResults); err == nil {
8287 log.Printf("[TRACE] \tresults: %s\n", string(d))
8288 }
8289
8290 return err
8291 }
8292
8293 // Shutdown is API call with trace log
8294 func (t *NFSTracer) Shutdown(ctx context.Context, zone string, id types.ID, shutdownOption *iaas.ShutdownOption) error {
8295 log.Println("[TRACE] NFSAPI.Shutdown start")
8296 targetArguments := struct {
8297 Argzone string
8298 Argid types.ID `json:"id"`
8299 ArgshutdownOption *iaas.ShutdownOption `json:"shutdownOption"`
8300 }{
8301 Argzone: zone,
8302 Argid: id,
8303 ArgshutdownOption: shutdownOption,
8304 }
8305 if d, err := json.Marshal(targetArguments); err == nil {
8306 log.Printf("[TRACE] \targs: %s\n", string(d))
8307 }
8308
8309 defer func() {
8310 log.Println("[TRACE] NFSAPI.Shutdown end")
8311 }()
8312
8313 err := t.Internal.Shutdown(ctx, zone, id, shutdownOption)
8314 targetResults := struct {
8315 Error error
8316 }{
8317 Error: err,
8318 }
8319 if d, err := json.Marshal(targetResults); err == nil {
8320 log.Printf("[TRACE] \tresults: %s\n", string(d))
8321 }
8322
8323 return err
8324 }
8325
8326 // Reset is API call with trace log
8327 func (t *NFSTracer) Reset(ctx context.Context, zone string, id types.ID) error {
8328 log.Println("[TRACE] NFSAPI.Reset start")
8329 targetArguments := struct {
8330 Argzone string
8331 Argid types.ID `json:"id"`
8332 }{
8333 Argzone: zone,
8334 Argid: id,
8335 }
8336 if d, err := json.Marshal(targetArguments); err == nil {
8337 log.Printf("[TRACE] \targs: %s\n", string(d))
8338 }
8339
8340 defer func() {
8341 log.Println("[TRACE] NFSAPI.Reset end")
8342 }()
8343
8344 err := t.Internal.Reset(ctx, zone, id)
8345 targetResults := struct {
8346 Error error
8347 }{
8348 Error: err,
8349 }
8350 if d, err := json.Marshal(targetResults); err == nil {
8351 log.Printf("[TRACE] \tresults: %s\n", string(d))
8352 }
8353
8354 return err
8355 }
8356
8357 // MonitorCPU is API call with trace log
8358 func (t *NFSTracer) MonitorCPU(ctx context.Context, zone string, id types.ID, condition *iaas.MonitorCondition) (*iaas.CPUTimeActivity, error) {
8359 log.Println("[TRACE] NFSAPI.MonitorCPU start")
8360 targetArguments := struct {
8361 Argzone string
8362 Argid types.ID `json:"id"`
8363 Argcondition *iaas.MonitorCondition `json:"condition"`
8364 }{
8365 Argzone: zone,
8366 Argid: id,
8367 Argcondition: condition,
8368 }
8369 if d, err := json.Marshal(targetArguments); err == nil {
8370 log.Printf("[TRACE] \targs: %s\n", string(d))
8371 }
8372
8373 defer func() {
8374 log.Println("[TRACE] NFSAPI.MonitorCPU end")
8375 }()
8376
8377 resultCPUTimeActivity, err := t.Internal.MonitorCPU(ctx, zone, id, condition)
8378 targetResults := struct {
8379 CPUTimeActivity *iaas.CPUTimeActivity
8380 Error error
8381 }{
8382 CPUTimeActivity: resultCPUTimeActivity,
8383 Error: err,
8384 }
8385 if d, err := json.Marshal(targetResults); err == nil {
8386 log.Printf("[TRACE] \tresults: %s\n", string(d))
8387 }
8388
8389 return resultCPUTimeActivity, err
8390 }
8391
8392 // MonitorFreeDiskSize is API call with trace log
8393 func (t *NFSTracer) MonitorFreeDiskSize(ctx context.Context, zone string, id types.ID, condition *iaas.MonitorCondition) (*iaas.FreeDiskSizeActivity, error) {
8394 log.Println("[TRACE] NFSAPI.MonitorFreeDiskSize start")
8395 targetArguments := struct {
8396 Argzone string
8397 Argid types.ID `json:"id"`
8398 Argcondition *iaas.MonitorCondition `json:"condition"`
8399 }{
8400 Argzone: zone,
8401 Argid: id,
8402 Argcondition: condition,
8403 }
8404 if d, err := json.Marshal(targetArguments); err == nil {
8405 log.Printf("[TRACE] \targs: %s\n", string(d))
8406 }
8407
8408 defer func() {
8409 log.Println("[TRACE] NFSAPI.MonitorFreeDiskSize end")
8410 }()
8411
8412 resultFreeDiskSizeActivity, err := t.Internal.MonitorFreeDiskSize(ctx, zone, id, condition)
8413 targetResults := struct {
8414 FreeDiskSizeActivity *iaas.FreeDiskSizeActivity
8415 Error error
8416 }{
8417 FreeDiskSizeActivity: resultFreeDiskSizeActivity,
8418 Error: err,
8419 }
8420 if d, err := json.Marshal(targetResults); err == nil {
8421 log.Printf("[TRACE] \tresults: %s\n", string(d))
8422 }
8423
8424 return resultFreeDiskSizeActivity, err
8425 }
8426
8427 // MonitorInterface is API call with trace log
8428 func (t *NFSTracer) MonitorInterface(ctx context.Context, zone string, id types.ID, condition *iaas.MonitorCondition) (*iaas.InterfaceActivity, error) {
8429 log.Println("[TRACE] NFSAPI.MonitorInterface start")
8430 targetArguments := struct {
8431 Argzone string
8432 Argid types.ID `json:"id"`
8433 Argcondition *iaas.MonitorCondition `json:"condition"`
8434 }{
8435 Argzone: zone,
8436 Argid: id,
8437 Argcondition: condition,
8438 }
8439 if d, err := json.Marshal(targetArguments); err == nil {
8440 log.Printf("[TRACE] \targs: %s\n", string(d))
8441 }
8442
8443 defer func() {
8444 log.Println("[TRACE] NFSAPI.MonitorInterface end")
8445 }()
8446
8447 resultInterfaceActivity, err := t.Internal.MonitorInterface(ctx, zone, id, condition)
8448 targetResults := struct {
8449 InterfaceActivity *iaas.InterfaceActivity
8450 Error error
8451 }{
8452 InterfaceActivity: resultInterfaceActivity,
8453 Error: err,
8454 }
8455 if d, err := json.Marshal(targetResults); err == nil {
8456 log.Printf("[TRACE] \tresults: %s\n", string(d))
8457 }
8458
8459 return resultInterfaceActivity, err
8460 }
8461
8462 /*************************************************
8463 * NoteTracer
8464 *************************************************/
8465
8466 // NoteTracer is for trace NoteOp operations
8467 type NoteTracer struct {
8468 Internal iaas.NoteAPI
8469 }
8470
8471 // NewNoteTracer creates new NoteTracer instance
8472 func NewNoteTracer(in iaas.NoteAPI) iaas.NoteAPI {
8473 return &NoteTracer{
8474 Internal: in,
8475 }
8476 }
8477
8478 // Find is API call with trace log
8479 func (t *NoteTracer) Find(ctx context.Context, conditions *iaas.FindCondition) (*iaas.NoteFindResult, error) {
8480 log.Println("[TRACE] NoteAPI.Find start")
8481 targetArguments := struct {
8482 Argconditions *iaas.FindCondition `json:"conditions"`
8483 }{
8484 Argconditions: conditions,
8485 }
8486 if d, err := json.Marshal(targetArguments); err == nil {
8487 log.Printf("[TRACE] \targs: %s\n", string(d))
8488 }
8489
8490 defer func() {
8491 log.Println("[TRACE] NoteAPI.Find end")
8492 }()
8493
8494 result, err := t.Internal.Find(ctx, conditions)
8495 targetResults := struct {
8496 Result *iaas.NoteFindResult
8497 Error error
8498 }{
8499 Result: result,
8500 Error: err,
8501 }
8502 if d, err := json.Marshal(targetResults); err == nil {
8503 log.Printf("[TRACE] \tresults: %s\n", string(d))
8504 }
8505
8506 return result, err
8507 }
8508
8509 // Create is API call with trace log
8510 func (t *NoteTracer) Create(ctx context.Context, param *iaas.NoteCreateRequest) (*iaas.Note, error) {
8511 log.Println("[TRACE] NoteAPI.Create start")
8512 targetArguments := struct {
8513 Argparam *iaas.NoteCreateRequest `json:"param"`
8514 }{
8515 Argparam: param,
8516 }
8517 if d, err := json.Marshal(targetArguments); err == nil {
8518 log.Printf("[TRACE] \targs: %s\n", string(d))
8519 }
8520
8521 defer func() {
8522 log.Println("[TRACE] NoteAPI.Create end")
8523 }()
8524
8525 resultNote, err := t.Internal.Create(ctx, param)
8526 targetResults := struct {
8527 Note *iaas.Note
8528 Error error
8529 }{
8530 Note: resultNote,
8531 Error: err,
8532 }
8533 if d, err := json.Marshal(targetResults); err == nil {
8534 log.Printf("[TRACE] \tresults: %s\n", string(d))
8535 }
8536
8537 return resultNote, err
8538 }
8539
8540 // Read is API call with trace log
8541 func (t *NoteTracer) Read(ctx context.Context, id types.ID) (*iaas.Note, error) {
8542 log.Println("[TRACE] NoteAPI.Read start")
8543 targetArguments := struct {
8544 Argid types.ID `json:"id"`
8545 }{
8546 Argid: id,
8547 }
8548 if d, err := json.Marshal(targetArguments); err == nil {
8549 log.Printf("[TRACE] \targs: %s\n", string(d))
8550 }
8551
8552 defer func() {
8553 log.Println("[TRACE] NoteAPI.Read end")
8554 }()
8555
8556 resultNote, err := t.Internal.Read(ctx, id)
8557 targetResults := struct {
8558 Note *iaas.Note
8559 Error error
8560 }{
8561 Note: resultNote,
8562 Error: err,
8563 }
8564 if d, err := json.Marshal(targetResults); err == nil {
8565 log.Printf("[TRACE] \tresults: %s\n", string(d))
8566 }
8567
8568 return resultNote, err
8569 }
8570
8571 // Update is API call with trace log
8572 func (t *NoteTracer) Update(ctx context.Context, id types.ID, param *iaas.NoteUpdateRequest) (*iaas.Note, error) {
8573 log.Println("[TRACE] NoteAPI.Update start")
8574 targetArguments := struct {
8575 Argid types.ID `json:"id"`
8576 Argparam *iaas.NoteUpdateRequest `json:"param"`
8577 }{
8578 Argid: id,
8579 Argparam: param,
8580 }
8581 if d, err := json.Marshal(targetArguments); err == nil {
8582 log.Printf("[TRACE] \targs: %s\n", string(d))
8583 }
8584
8585 defer func() {
8586 log.Println("[TRACE] NoteAPI.Update end")
8587 }()
8588
8589 resultNote, err := t.Internal.Update(ctx, id, param)
8590 targetResults := struct {
8591 Note *iaas.Note
8592 Error error
8593 }{
8594 Note: resultNote,
8595 Error: err,
8596 }
8597 if d, err := json.Marshal(targetResults); err == nil {
8598 log.Printf("[TRACE] \tresults: %s\n", string(d))
8599 }
8600
8601 return resultNote, err
8602 }
8603
8604 // Delete is API call with trace log
8605 func (t *NoteTracer) Delete(ctx context.Context, id types.ID) error {
8606 log.Println("[TRACE] NoteAPI.Delete start")
8607 targetArguments := struct {
8608 Argid types.ID `json:"id"`
8609 }{
8610 Argid: id,
8611 }
8612 if d, err := json.Marshal(targetArguments); err == nil {
8613 log.Printf("[TRACE] \targs: %s\n", string(d))
8614 }
8615
8616 defer func() {
8617 log.Println("[TRACE] NoteAPI.Delete end")
8618 }()
8619
8620 err := t.Internal.Delete(ctx, id)
8621 targetResults := struct {
8622 Error error
8623 }{
8624 Error: err,
8625 }
8626 if d, err := json.Marshal(targetResults); err == nil {
8627 log.Printf("[TRACE] \tresults: %s\n", string(d))
8628 }
8629
8630 return err
8631 }
8632
8633 /*************************************************
8634 * PacketFilterTracer
8635 *************************************************/
8636
8637 // PacketFilterTracer is for trace PacketFilterOp operations
8638 type PacketFilterTracer struct {
8639 Internal iaas.PacketFilterAPI
8640 }
8641
8642 // NewPacketFilterTracer creates new PacketFilterTracer instance
8643 func NewPacketFilterTracer(in iaas.PacketFilterAPI) iaas.PacketFilterAPI {
8644 return &PacketFilterTracer{
8645 Internal: in,
8646 }
8647 }
8648
8649 // Find is API call with trace log
8650 func (t *PacketFilterTracer) Find(ctx context.Context, zone string, conditions *iaas.FindCondition) (*iaas.PacketFilterFindResult, error) {
8651 log.Println("[TRACE] PacketFilterAPI.Find start")
8652 targetArguments := struct {
8653 Argzone string
8654 Argconditions *iaas.FindCondition `json:"conditions"`
8655 }{
8656 Argzone: zone,
8657 Argconditions: conditions,
8658 }
8659 if d, err := json.Marshal(targetArguments); err == nil {
8660 log.Printf("[TRACE] \targs: %s\n", string(d))
8661 }
8662
8663 defer func() {
8664 log.Println("[TRACE] PacketFilterAPI.Find end")
8665 }()
8666
8667 result, err := t.Internal.Find(ctx, zone, conditions)
8668 targetResults := struct {
8669 Result *iaas.PacketFilterFindResult
8670 Error error
8671 }{
8672 Result: result,
8673 Error: err,
8674 }
8675 if d, err := json.Marshal(targetResults); err == nil {
8676 log.Printf("[TRACE] \tresults: %s\n", string(d))
8677 }
8678
8679 return result, err
8680 }
8681
8682 // Create is API call with trace log
8683 func (t *PacketFilterTracer) Create(ctx context.Context, zone string, param *iaas.PacketFilterCreateRequest) (*iaas.PacketFilter, error) {
8684 log.Println("[TRACE] PacketFilterAPI.Create start")
8685 targetArguments := struct {
8686 Argzone string
8687 Argparam *iaas.PacketFilterCreateRequest `json:"param"`
8688 }{
8689 Argzone: zone,
8690 Argparam: param,
8691 }
8692 if d, err := json.Marshal(targetArguments); err == nil {
8693 log.Printf("[TRACE] \targs: %s\n", string(d))
8694 }
8695
8696 defer func() {
8697 log.Println("[TRACE] PacketFilterAPI.Create end")
8698 }()
8699
8700 resultPacketFilter, err := t.Internal.Create(ctx, zone, param)
8701 targetResults := struct {
8702 PacketFilter *iaas.PacketFilter
8703 Error error
8704 }{
8705 PacketFilter: resultPacketFilter,
8706 Error: err,
8707 }
8708 if d, err := json.Marshal(targetResults); err == nil {
8709 log.Printf("[TRACE] \tresults: %s\n", string(d))
8710 }
8711
8712 return resultPacketFilter, err
8713 }
8714
8715 // Read is API call with trace log
8716 func (t *PacketFilterTracer) Read(ctx context.Context, zone string, id types.ID) (*iaas.PacketFilter, error) {
8717 log.Println("[TRACE] PacketFilterAPI.Read start")
8718 targetArguments := struct {
8719 Argzone string
8720 Argid types.ID `json:"id"`
8721 }{
8722 Argzone: zone,
8723 Argid: id,
8724 }
8725 if d, err := json.Marshal(targetArguments); err == nil {
8726 log.Printf("[TRACE] \targs: %s\n", string(d))
8727 }
8728
8729 defer func() {
8730 log.Println("[TRACE] PacketFilterAPI.Read end")
8731 }()
8732
8733 resultPacketFilter, err := t.Internal.Read(ctx, zone, id)
8734 targetResults := struct {
8735 PacketFilter *iaas.PacketFilter
8736 Error error
8737 }{
8738 PacketFilter: resultPacketFilter,
8739 Error: err,
8740 }
8741 if d, err := json.Marshal(targetResults); err == nil {
8742 log.Printf("[TRACE] \tresults: %s\n", string(d))
8743 }
8744
8745 return resultPacketFilter, err
8746 }
8747
8748 // Update is API call with trace log
8749 func (t *PacketFilterTracer) Update(ctx context.Context, zone string, id types.ID, updateParam *iaas.PacketFilterUpdateRequest, originalExpressionHash string) (*iaas.PacketFilter, error) {
8750 log.Println("[TRACE] PacketFilterAPI.Update start")
8751 targetArguments := struct {
8752 Argzone string
8753 Argid types.ID `json:"id"`
8754 ArgupdateParam *iaas.PacketFilterUpdateRequest `json:"updateParam"`
8755 ArgoriginalExpressionHash string `json:"originalExpressionHash"`
8756 }{
8757 Argzone: zone,
8758 Argid: id,
8759 ArgupdateParam: updateParam,
8760 ArgoriginalExpressionHash: originalExpressionHash,
8761 }
8762 if d, err := json.Marshal(targetArguments); err == nil {
8763 log.Printf("[TRACE] \targs: %s\n", string(d))
8764 }
8765
8766 defer func() {
8767 log.Println("[TRACE] PacketFilterAPI.Update end")
8768 }()
8769
8770 resultPacketFilter, err := t.Internal.Update(ctx, zone, id, updateParam, originalExpressionHash)
8771 targetResults := struct {
8772 PacketFilter *iaas.PacketFilter
8773 Error error
8774 }{
8775 PacketFilter: resultPacketFilter,
8776 Error: err,
8777 }
8778 if d, err := json.Marshal(targetResults); err == nil {
8779 log.Printf("[TRACE] \tresults: %s\n", string(d))
8780 }
8781
8782 return resultPacketFilter, err
8783 }
8784
8785 // Delete is API call with trace log
8786 func (t *PacketFilterTracer) Delete(ctx context.Context, zone string, id types.ID) error {
8787 log.Println("[TRACE] PacketFilterAPI.Delete start")
8788 targetArguments := struct {
8789 Argzone string
8790 Argid types.ID `json:"id"`
8791 }{
8792 Argzone: zone,
8793 Argid: id,
8794 }
8795 if d, err := json.Marshal(targetArguments); err == nil {
8796 log.Printf("[TRACE] \targs: %s\n", string(d))
8797 }
8798
8799 defer func() {
8800 log.Println("[TRACE] PacketFilterAPI.Delete end")
8801 }()
8802
8803 err := t.Internal.Delete(ctx, zone, id)
8804 targetResults := struct {
8805 Error error
8806 }{
8807 Error: err,
8808 }
8809 if d, err := json.Marshal(targetResults); err == nil {
8810 log.Printf("[TRACE] \tresults: %s\n", string(d))
8811 }
8812
8813 return err
8814 }
8815
8816 /*************************************************
8817 * PrivateHostTracer
8818 *************************************************/
8819
8820 // PrivateHostTracer is for trace PrivateHostOp operations
8821 type PrivateHostTracer struct {
8822 Internal iaas.PrivateHostAPI
8823 }
8824
8825 // NewPrivateHostTracer creates new PrivateHostTracer instance
8826 func NewPrivateHostTracer(in iaas.PrivateHostAPI) iaas.PrivateHostAPI {
8827 return &PrivateHostTracer{
8828 Internal: in,
8829 }
8830 }
8831
8832 // Find is API call with trace log
8833 func (t *PrivateHostTracer) Find(ctx context.Context, zone string, conditions *iaas.FindCondition) (*iaas.PrivateHostFindResult, error) {
8834 log.Println("[TRACE] PrivateHostAPI.Find start")
8835 targetArguments := struct {
8836 Argzone string
8837 Argconditions *iaas.FindCondition `json:"conditions"`
8838 }{
8839 Argzone: zone,
8840 Argconditions: conditions,
8841 }
8842 if d, err := json.Marshal(targetArguments); err == nil {
8843 log.Printf("[TRACE] \targs: %s\n", string(d))
8844 }
8845
8846 defer func() {
8847 log.Println("[TRACE] PrivateHostAPI.Find end")
8848 }()
8849
8850 result, err := t.Internal.Find(ctx, zone, conditions)
8851 targetResults := struct {
8852 Result *iaas.PrivateHostFindResult
8853 Error error
8854 }{
8855 Result: result,
8856 Error: err,
8857 }
8858 if d, err := json.Marshal(targetResults); err == nil {
8859 log.Printf("[TRACE] \tresults: %s\n", string(d))
8860 }
8861
8862 return result, err
8863 }
8864
8865 // Create is API call with trace log
8866 func (t *PrivateHostTracer) Create(ctx context.Context, zone string, param *iaas.PrivateHostCreateRequest) (*iaas.PrivateHost, error) {
8867 log.Println("[TRACE] PrivateHostAPI.Create start")
8868 targetArguments := struct {
8869 Argzone string
8870 Argparam *iaas.PrivateHostCreateRequest `json:"param"`
8871 }{
8872 Argzone: zone,
8873 Argparam: param,
8874 }
8875 if d, err := json.Marshal(targetArguments); err == nil {
8876 log.Printf("[TRACE] \targs: %s\n", string(d))
8877 }
8878
8879 defer func() {
8880 log.Println("[TRACE] PrivateHostAPI.Create end")
8881 }()
8882
8883 resultPrivateHost, err := t.Internal.Create(ctx, zone, param)
8884 targetResults := struct {
8885 PrivateHost *iaas.PrivateHost
8886 Error error
8887 }{
8888 PrivateHost: resultPrivateHost,
8889 Error: err,
8890 }
8891 if d, err := json.Marshal(targetResults); err == nil {
8892 log.Printf("[TRACE] \tresults: %s\n", string(d))
8893 }
8894
8895 return resultPrivateHost, err
8896 }
8897
8898 // Read is API call with trace log
8899 func (t *PrivateHostTracer) Read(ctx context.Context, zone string, id types.ID) (*iaas.PrivateHost, error) {
8900 log.Println("[TRACE] PrivateHostAPI.Read start")
8901 targetArguments := struct {
8902 Argzone string
8903 Argid types.ID `json:"id"`
8904 }{
8905 Argzone: zone,
8906 Argid: id,
8907 }
8908 if d, err := json.Marshal(targetArguments); err == nil {
8909 log.Printf("[TRACE] \targs: %s\n", string(d))
8910 }
8911
8912 defer func() {
8913 log.Println("[TRACE] PrivateHostAPI.Read end")
8914 }()
8915
8916 resultPrivateHost, err := t.Internal.Read(ctx, zone, id)
8917 targetResults := struct {
8918 PrivateHost *iaas.PrivateHost
8919 Error error
8920 }{
8921 PrivateHost: resultPrivateHost,
8922 Error: err,
8923 }
8924 if d, err := json.Marshal(targetResults); err == nil {
8925 log.Printf("[TRACE] \tresults: %s\n", string(d))
8926 }
8927
8928 return resultPrivateHost, err
8929 }
8930
8931 // Update is API call with trace log
8932 func (t *PrivateHostTracer) Update(ctx context.Context, zone string, id types.ID, param *iaas.PrivateHostUpdateRequest) (*iaas.PrivateHost, error) {
8933 log.Println("[TRACE] PrivateHostAPI.Update start")
8934 targetArguments := struct {
8935 Argzone string
8936 Argid types.ID `json:"id"`
8937 Argparam *iaas.PrivateHostUpdateRequest `json:"param"`
8938 }{
8939 Argzone: zone,
8940 Argid: id,
8941 Argparam: param,
8942 }
8943 if d, err := json.Marshal(targetArguments); err == nil {
8944 log.Printf("[TRACE] \targs: %s\n", string(d))
8945 }
8946
8947 defer func() {
8948 log.Println("[TRACE] PrivateHostAPI.Update end")
8949 }()
8950
8951 resultPrivateHost, err := t.Internal.Update(ctx, zone, id, param)
8952 targetResults := struct {
8953 PrivateHost *iaas.PrivateHost
8954 Error error
8955 }{
8956 PrivateHost: resultPrivateHost,
8957 Error: err,
8958 }
8959 if d, err := json.Marshal(targetResults); err == nil {
8960 log.Printf("[TRACE] \tresults: %s\n", string(d))
8961 }
8962
8963 return resultPrivateHost, err
8964 }
8965
8966 // Delete is API call with trace log
8967 func (t *PrivateHostTracer) Delete(ctx context.Context, zone string, id types.ID) error {
8968 log.Println("[TRACE] PrivateHostAPI.Delete start")
8969 targetArguments := struct {
8970 Argzone string
8971 Argid types.ID `json:"id"`
8972 }{
8973 Argzone: zone,
8974 Argid: id,
8975 }
8976 if d, err := json.Marshal(targetArguments); err == nil {
8977 log.Printf("[TRACE] \targs: %s\n", string(d))
8978 }
8979
8980 defer func() {
8981 log.Println("[TRACE] PrivateHostAPI.Delete end")
8982 }()
8983
8984 err := t.Internal.Delete(ctx, zone, id)
8985 targetResults := struct {
8986 Error error
8987 }{
8988 Error: err,
8989 }
8990 if d, err := json.Marshal(targetResults); err == nil {
8991 log.Printf("[TRACE] \tresults: %s\n", string(d))
8992 }
8993
8994 return err
8995 }
8996
8997 /*************************************************
8998 * PrivateHostPlanTracer
8999 *************************************************/
9000
9001 // PrivateHostPlanTracer is for trace PrivateHostPlanOp operations
9002 type PrivateHostPlanTracer struct {
9003 Internal iaas.PrivateHostPlanAPI
9004 }
9005
9006 // NewPrivateHostPlanTracer creates new PrivateHostPlanTracer instance
9007 func NewPrivateHostPlanTracer(in iaas.PrivateHostPlanAPI) iaas.PrivateHostPlanAPI {
9008 return &PrivateHostPlanTracer{
9009 Internal: in,
9010 }
9011 }
9012
9013 // Find is API call with trace log
9014 func (t *PrivateHostPlanTracer) Find(ctx context.Context, zone string, conditions *iaas.FindCondition) (*iaas.PrivateHostPlanFindResult, error) {
9015 log.Println("[TRACE] PrivateHostPlanAPI.Find start")
9016 targetArguments := struct {
9017 Argzone string
9018 Argconditions *iaas.FindCondition `json:"conditions"`
9019 }{
9020 Argzone: zone,
9021 Argconditions: conditions,
9022 }
9023 if d, err := json.Marshal(targetArguments); err == nil {
9024 log.Printf("[TRACE] \targs: %s\n", string(d))
9025 }
9026
9027 defer func() {
9028 log.Println("[TRACE] PrivateHostPlanAPI.Find end")
9029 }()
9030
9031 result, err := t.Internal.Find(ctx, zone, conditions)
9032 targetResults := struct {
9033 Result *iaas.PrivateHostPlanFindResult
9034 Error error
9035 }{
9036 Result: result,
9037 Error: err,
9038 }
9039 if d, err := json.Marshal(targetResults); err == nil {
9040 log.Printf("[TRACE] \tresults: %s\n", string(d))
9041 }
9042
9043 return result, err
9044 }
9045
9046 // Read is API call with trace log
9047 func (t *PrivateHostPlanTracer) Read(ctx context.Context, zone string, id types.ID) (*iaas.PrivateHostPlan, error) {
9048 log.Println("[TRACE] PrivateHostPlanAPI.Read start")
9049 targetArguments := struct {
9050 Argzone string
9051 Argid types.ID `json:"id"`
9052 }{
9053 Argzone: zone,
9054 Argid: id,
9055 }
9056 if d, err := json.Marshal(targetArguments); err == nil {
9057 log.Printf("[TRACE] \targs: %s\n", string(d))
9058 }
9059
9060 defer func() {
9061 log.Println("[TRACE] PrivateHostPlanAPI.Read end")
9062 }()
9063
9064 resultPrivateHostPlan, err := t.Internal.Read(ctx, zone, id)
9065 targetResults := struct {
9066 PrivateHostPlan *iaas.PrivateHostPlan
9067 Error error
9068 }{
9069 PrivateHostPlan: resultPrivateHostPlan,
9070 Error: err,
9071 }
9072 if d, err := json.Marshal(targetResults); err == nil {
9073 log.Printf("[TRACE] \tresults: %s\n", string(d))
9074 }
9075
9076 return resultPrivateHostPlan, err
9077 }
9078
9079 /*************************************************
9080 * ProxyLBTracer
9081 *************************************************/
9082
9083 // ProxyLBTracer is for trace ProxyLBOp operations
9084 type ProxyLBTracer struct {
9085 Internal iaas.ProxyLBAPI
9086 }
9087
9088 // NewProxyLBTracer creates new ProxyLBTracer instance
9089 func NewProxyLBTracer(in iaas.ProxyLBAPI) iaas.ProxyLBAPI {
9090 return &ProxyLBTracer{
9091 Internal: in,
9092 }
9093 }
9094
9095 // Find is API call with trace log
9096 func (t *ProxyLBTracer) Find(ctx context.Context, conditions *iaas.FindCondition) (*iaas.ProxyLBFindResult, error) {
9097 log.Println("[TRACE] ProxyLBAPI.Find start")
9098 targetArguments := struct {
9099 Argconditions *iaas.FindCondition `json:"conditions"`
9100 }{
9101 Argconditions: conditions,
9102 }
9103 if d, err := json.Marshal(targetArguments); err == nil {
9104 log.Printf("[TRACE] \targs: %s\n", string(d))
9105 }
9106
9107 defer func() {
9108 log.Println("[TRACE] ProxyLBAPI.Find end")
9109 }()
9110
9111 result, err := t.Internal.Find(ctx, conditions)
9112 targetResults := struct {
9113 Result *iaas.ProxyLBFindResult
9114 Error error
9115 }{
9116 Result: result,
9117 Error: err,
9118 }
9119 if d, err := json.Marshal(targetResults); err == nil {
9120 log.Printf("[TRACE] \tresults: %s\n", string(d))
9121 }
9122
9123 return result, err
9124 }
9125
9126 // Create is API call with trace log
9127 func (t *ProxyLBTracer) Create(ctx context.Context, param *iaas.ProxyLBCreateRequest) (*iaas.ProxyLB, error) {
9128 log.Println("[TRACE] ProxyLBAPI.Create start")
9129 targetArguments := struct {
9130 Argparam *iaas.ProxyLBCreateRequest `json:"param"`
9131 }{
9132 Argparam: param,
9133 }
9134 if d, err := json.Marshal(targetArguments); err == nil {
9135 log.Printf("[TRACE] \targs: %s\n", string(d))
9136 }
9137
9138 defer func() {
9139 log.Println("[TRACE] ProxyLBAPI.Create end")
9140 }()
9141
9142 resultProxyLB, err := t.Internal.Create(ctx, param)
9143 targetResults := struct {
9144 ProxyLB *iaas.ProxyLB
9145 Error error
9146 }{
9147 ProxyLB: resultProxyLB,
9148 Error: err,
9149 }
9150 if d, err := json.Marshal(targetResults); err == nil {
9151 log.Printf("[TRACE] \tresults: %s\n", string(d))
9152 }
9153
9154 return resultProxyLB, err
9155 }
9156
9157 // Read is API call with trace log
9158 func (t *ProxyLBTracer) Read(ctx context.Context, id types.ID) (*iaas.ProxyLB, error) {
9159 log.Println("[TRACE] ProxyLBAPI.Read start")
9160 targetArguments := struct {
9161 Argid types.ID `json:"id"`
9162 }{
9163 Argid: id,
9164 }
9165 if d, err := json.Marshal(targetArguments); err == nil {
9166 log.Printf("[TRACE] \targs: %s\n", string(d))
9167 }
9168
9169 defer func() {
9170 log.Println("[TRACE] ProxyLBAPI.Read end")
9171 }()
9172
9173 resultProxyLB, err := t.Internal.Read(ctx, id)
9174 targetResults := struct {
9175 ProxyLB *iaas.ProxyLB
9176 Error error
9177 }{
9178 ProxyLB: resultProxyLB,
9179 Error: err,
9180 }
9181 if d, err := json.Marshal(targetResults); err == nil {
9182 log.Printf("[TRACE] \tresults: %s\n", string(d))
9183 }
9184
9185 return resultProxyLB, err
9186 }
9187
9188 // Update is API call with trace log
9189 func (t *ProxyLBTracer) Update(ctx context.Context, id types.ID, param *iaas.ProxyLBUpdateRequest) (*iaas.ProxyLB, error) {
9190 log.Println("[TRACE] ProxyLBAPI.Update start")
9191 targetArguments := struct {
9192 Argid types.ID `json:"id"`
9193 Argparam *iaas.ProxyLBUpdateRequest `json:"param"`
9194 }{
9195 Argid: id,
9196 Argparam: param,
9197 }
9198 if d, err := json.Marshal(targetArguments); err == nil {
9199 log.Printf("[TRACE] \targs: %s\n", string(d))
9200 }
9201
9202 defer func() {
9203 log.Println("[TRACE] ProxyLBAPI.Update end")
9204 }()
9205
9206 resultProxyLB, err := t.Internal.Update(ctx, id, param)
9207 targetResults := struct {
9208 ProxyLB *iaas.ProxyLB
9209 Error error
9210 }{
9211 ProxyLB: resultProxyLB,
9212 Error: err,
9213 }
9214 if d, err := json.Marshal(targetResults); err == nil {
9215 log.Printf("[TRACE] \tresults: %s\n", string(d))
9216 }
9217
9218 return resultProxyLB, err
9219 }
9220
9221 // UpdateSettings is API call with trace log
9222 func (t *ProxyLBTracer) UpdateSettings(ctx context.Context, id types.ID, param *iaas.ProxyLBUpdateSettingsRequest) (*iaas.ProxyLB, error) {
9223 log.Println("[TRACE] ProxyLBAPI.UpdateSettings start")
9224 targetArguments := struct {
9225 Argid types.ID `json:"id"`
9226 Argparam *iaas.ProxyLBUpdateSettingsRequest `json:"param"`
9227 }{
9228 Argid: id,
9229 Argparam: param,
9230 }
9231 if d, err := json.Marshal(targetArguments); err == nil {
9232 log.Printf("[TRACE] \targs: %s\n", string(d))
9233 }
9234
9235 defer func() {
9236 log.Println("[TRACE] ProxyLBAPI.UpdateSettings end")
9237 }()
9238
9239 resultProxyLB, err := t.Internal.UpdateSettings(ctx, id, param)
9240 targetResults := struct {
9241 ProxyLB *iaas.ProxyLB
9242 Error error
9243 }{
9244 ProxyLB: resultProxyLB,
9245 Error: err,
9246 }
9247 if d, err := json.Marshal(targetResults); err == nil {
9248 log.Printf("[TRACE] \tresults: %s\n", string(d))
9249 }
9250
9251 return resultProxyLB, err
9252 }
9253
9254 // Delete is API call with trace log
9255 func (t *ProxyLBTracer) Delete(ctx context.Context, id types.ID) error {
9256 log.Println("[TRACE] ProxyLBAPI.Delete start")
9257 targetArguments := struct {
9258 Argid types.ID `json:"id"`
9259 }{
9260 Argid: id,
9261 }
9262 if d, err := json.Marshal(targetArguments); err == nil {
9263 log.Printf("[TRACE] \targs: %s\n", string(d))
9264 }
9265
9266 defer func() {
9267 log.Println("[TRACE] ProxyLBAPI.Delete end")
9268 }()
9269
9270 err := t.Internal.Delete(ctx, id)
9271 targetResults := struct {
9272 Error error
9273 }{
9274 Error: err,
9275 }
9276 if d, err := json.Marshal(targetResults); err == nil {
9277 log.Printf("[TRACE] \tresults: %s\n", string(d))
9278 }
9279
9280 return err
9281 }
9282
9283 // ChangePlan is API call with trace log
9284 func (t *ProxyLBTracer) ChangePlan(ctx context.Context, id types.ID, param *iaas.ProxyLBChangePlanRequest) (*iaas.ProxyLB, error) {
9285 log.Println("[TRACE] ProxyLBAPI.ChangePlan start")
9286 targetArguments := struct {
9287 Argid types.ID `json:"id"`
9288 Argparam *iaas.ProxyLBChangePlanRequest `json:"param"`
9289 }{
9290 Argid: id,
9291 Argparam: param,
9292 }
9293 if d, err := json.Marshal(targetArguments); err == nil {
9294 log.Printf("[TRACE] \targs: %s\n", string(d))
9295 }
9296
9297 defer func() {
9298 log.Println("[TRACE] ProxyLBAPI.ChangePlan end")
9299 }()
9300
9301 resultProxyLB, err := t.Internal.ChangePlan(ctx, id, param)
9302 targetResults := struct {
9303 ProxyLB *iaas.ProxyLB
9304 Error error
9305 }{
9306 ProxyLB: resultProxyLB,
9307 Error: err,
9308 }
9309 if d, err := json.Marshal(targetResults); err == nil {
9310 log.Printf("[TRACE] \tresults: %s\n", string(d))
9311 }
9312
9313 return resultProxyLB, err
9314 }
9315
9316 // GetCertificates is API call with trace log
9317 func (t *ProxyLBTracer) GetCertificates(ctx context.Context, id types.ID) (*iaas.ProxyLBCertificates, error) {
9318 log.Println("[TRACE] ProxyLBAPI.GetCertificates start")
9319 targetArguments := struct {
9320 Argid types.ID `json:"id"`
9321 }{
9322 Argid: id,
9323 }
9324 if d, err := json.Marshal(targetArguments); err == nil {
9325 log.Printf("[TRACE] \targs: %s\n", string(d))
9326 }
9327
9328 defer func() {
9329 log.Println("[TRACE] ProxyLBAPI.GetCertificates end")
9330 }()
9331
9332 resultProxyLBCertificates, err := t.Internal.GetCertificates(ctx, id)
9333 targetResults := struct {
9334 ProxyLBCertificates *iaas.ProxyLBCertificates
9335 Error error
9336 }{
9337 ProxyLBCertificates: resultProxyLBCertificates,
9338 Error: err,
9339 }
9340 if d, err := json.Marshal(targetResults); err == nil {
9341 log.Printf("[TRACE] \tresults: %s\n", string(d))
9342 }
9343
9344 return resultProxyLBCertificates, err
9345 }
9346
9347 // SetCertificates is API call with trace log
9348 func (t *ProxyLBTracer) SetCertificates(ctx context.Context, id types.ID, param *iaas.ProxyLBSetCertificatesRequest) (*iaas.ProxyLBCertificates, error) {
9349 log.Println("[TRACE] ProxyLBAPI.SetCertificates start")
9350 targetArguments := struct {
9351 Argid types.ID `json:"id"`
9352 Argparam *iaas.ProxyLBSetCertificatesRequest `json:"param"`
9353 }{
9354 Argid: id,
9355 Argparam: param,
9356 }
9357 if d, err := json.Marshal(targetArguments); err == nil {
9358 log.Printf("[TRACE] \targs: %s\n", string(d))
9359 }
9360
9361 defer func() {
9362 log.Println("[TRACE] ProxyLBAPI.SetCertificates end")
9363 }()
9364
9365 resultProxyLBCertificates, err := t.Internal.SetCertificates(ctx, id, param)
9366 targetResults := struct {
9367 ProxyLBCertificates *iaas.ProxyLBCertificates
9368 Error error
9369 }{
9370 ProxyLBCertificates: resultProxyLBCertificates,
9371 Error: err,
9372 }
9373 if d, err := json.Marshal(targetResults); err == nil {
9374 log.Printf("[TRACE] \tresults: %s\n", string(d))
9375 }
9376
9377 return resultProxyLBCertificates, err
9378 }
9379
9380 // DeleteCertificates is API call with trace log
9381 func (t *ProxyLBTracer) DeleteCertificates(ctx context.Context, id types.ID) error {
9382 log.Println("[TRACE] ProxyLBAPI.DeleteCertificates start")
9383 targetArguments := struct {
9384 Argid types.ID `json:"id"`
9385 }{
9386 Argid: id,
9387 }
9388 if d, err := json.Marshal(targetArguments); err == nil {
9389 log.Printf("[TRACE] \targs: %s\n", string(d))
9390 }
9391
9392 defer func() {
9393 log.Println("[TRACE] ProxyLBAPI.DeleteCertificates end")
9394 }()
9395
9396 err := t.Internal.DeleteCertificates(ctx, id)
9397 targetResults := struct {
9398 Error error
9399 }{
9400 Error: err,
9401 }
9402 if d, err := json.Marshal(targetResults); err == nil {
9403 log.Printf("[TRACE] \tresults: %s\n", string(d))
9404 }
9405
9406 return err
9407 }
9408
9409 // RenewLetsEncryptCert is API call with trace log
9410 func (t *ProxyLBTracer) RenewLetsEncryptCert(ctx context.Context, id types.ID) error {
9411 log.Println("[TRACE] ProxyLBAPI.RenewLetsEncryptCert start")
9412 targetArguments := struct {
9413 Argid types.ID `json:"id"`
9414 }{
9415 Argid: id,
9416 }
9417 if d, err := json.Marshal(targetArguments); err == nil {
9418 log.Printf("[TRACE] \targs: %s\n", string(d))
9419 }
9420
9421 defer func() {
9422 log.Println("[TRACE] ProxyLBAPI.RenewLetsEncryptCert end")
9423 }()
9424
9425 err := t.Internal.RenewLetsEncryptCert(ctx, id)
9426 targetResults := struct {
9427 Error error
9428 }{
9429 Error: err,
9430 }
9431 if d, err := json.Marshal(targetResults); err == nil {
9432 log.Printf("[TRACE] \tresults: %s\n", string(d))
9433 }
9434
9435 return err
9436 }
9437
9438 // HealthStatus is API call with trace log
9439 func (t *ProxyLBTracer) HealthStatus(ctx context.Context, id types.ID) (*iaas.ProxyLBHealth, error) {
9440 log.Println("[TRACE] ProxyLBAPI.HealthStatus start")
9441 targetArguments := struct {
9442 Argid types.ID `json:"id"`
9443 }{
9444 Argid: id,
9445 }
9446 if d, err := json.Marshal(targetArguments); err == nil {
9447 log.Printf("[TRACE] \targs: %s\n", string(d))
9448 }
9449
9450 defer func() {
9451 log.Println("[TRACE] ProxyLBAPI.HealthStatus end")
9452 }()
9453
9454 resultProxyLBHealth, err := t.Internal.HealthStatus(ctx, id)
9455 targetResults := struct {
9456 ProxyLBHealth *iaas.ProxyLBHealth
9457 Error error
9458 }{
9459 ProxyLBHealth: resultProxyLBHealth,
9460 Error: err,
9461 }
9462 if d, err := json.Marshal(targetResults); err == nil {
9463 log.Printf("[TRACE] \tresults: %s\n", string(d))
9464 }
9465
9466 return resultProxyLBHealth, err
9467 }
9468
9469 // MonitorConnection is API call with trace log
9470 func (t *ProxyLBTracer) MonitorConnection(ctx context.Context, id types.ID, condition *iaas.MonitorCondition) (*iaas.ConnectionActivity, error) {
9471 log.Println("[TRACE] ProxyLBAPI.MonitorConnection start")
9472 targetArguments := struct {
9473 Argid types.ID `json:"id"`
9474 Argcondition *iaas.MonitorCondition `json:"condition"`
9475 }{
9476 Argid: id,
9477 Argcondition: condition,
9478 }
9479 if d, err := json.Marshal(targetArguments); err == nil {
9480 log.Printf("[TRACE] \targs: %s\n", string(d))
9481 }
9482
9483 defer func() {
9484 log.Println("[TRACE] ProxyLBAPI.MonitorConnection end")
9485 }()
9486
9487 resultConnectionActivity, err := t.Internal.MonitorConnection(ctx, id, condition)
9488 targetResults := struct {
9489 ConnectionActivity *iaas.ConnectionActivity
9490 Error error
9491 }{
9492 ConnectionActivity: resultConnectionActivity,
9493 Error: err,
9494 }
9495 if d, err := json.Marshal(targetResults); err == nil {
9496 log.Printf("[TRACE] \tresults: %s\n", string(d))
9497 }
9498
9499 return resultConnectionActivity, err
9500 }
9501
9502 /*************************************************
9503 * RegionTracer
9504 *************************************************/
9505
9506 // RegionTracer is for trace RegionOp operations
9507 type RegionTracer struct {
9508 Internal iaas.RegionAPI
9509 }
9510
9511 // NewRegionTracer creates new RegionTracer instance
9512 func NewRegionTracer(in iaas.RegionAPI) iaas.RegionAPI {
9513 return &RegionTracer{
9514 Internal: in,
9515 }
9516 }
9517
9518 // Find is API call with trace log
9519 func (t *RegionTracer) Find(ctx context.Context, conditions *iaas.FindCondition) (*iaas.RegionFindResult, error) {
9520 log.Println("[TRACE] RegionAPI.Find start")
9521 targetArguments := struct {
9522 Argconditions *iaas.FindCondition `json:"conditions"`
9523 }{
9524 Argconditions: conditions,
9525 }
9526 if d, err := json.Marshal(targetArguments); err == nil {
9527 log.Printf("[TRACE] \targs: %s\n", string(d))
9528 }
9529
9530 defer func() {
9531 log.Println("[TRACE] RegionAPI.Find end")
9532 }()
9533
9534 result, err := t.Internal.Find(ctx, conditions)
9535 targetResults := struct {
9536 Result *iaas.RegionFindResult
9537 Error error
9538 }{
9539 Result: result,
9540 Error: err,
9541 }
9542 if d, err := json.Marshal(targetResults); err == nil {
9543 log.Printf("[TRACE] \tresults: %s\n", string(d))
9544 }
9545
9546 return result, err
9547 }
9548
9549 // Read is API call with trace log
9550 func (t *RegionTracer) Read(ctx context.Context, id types.ID) (*iaas.Region, error) {
9551 log.Println("[TRACE] RegionAPI.Read start")
9552 targetArguments := struct {
9553 Argid types.ID `json:"id"`
9554 }{
9555 Argid: id,
9556 }
9557 if d, err := json.Marshal(targetArguments); err == nil {
9558 log.Printf("[TRACE] \targs: %s\n", string(d))
9559 }
9560
9561 defer func() {
9562 log.Println("[TRACE] RegionAPI.Read end")
9563 }()
9564
9565 resultRegion, err := t.Internal.Read(ctx, id)
9566 targetResults := struct {
9567 Region *iaas.Region
9568 Error error
9569 }{
9570 Region: resultRegion,
9571 Error: err,
9572 }
9573 if d, err := json.Marshal(targetResults); err == nil {
9574 log.Printf("[TRACE] \tresults: %s\n", string(d))
9575 }
9576
9577 return resultRegion, err
9578 }
9579
9580 /*************************************************
9581 * ServerTracer
9582 *************************************************/
9583
9584 // ServerTracer is for trace ServerOp operations
9585 type ServerTracer struct {
9586 Internal iaas.ServerAPI
9587 }
9588
9589 // NewServerTracer creates new ServerTracer instance
9590 func NewServerTracer(in iaas.ServerAPI) iaas.ServerAPI {
9591 return &ServerTracer{
9592 Internal: in,
9593 }
9594 }
9595
9596 // Find is API call with trace log
9597 func (t *ServerTracer) Find(ctx context.Context, zone string, conditions *iaas.FindCondition) (*iaas.ServerFindResult, error) {
9598 log.Println("[TRACE] ServerAPI.Find start")
9599 targetArguments := struct {
9600 Argzone string
9601 Argconditions *iaas.FindCondition `json:"conditions"`
9602 }{
9603 Argzone: zone,
9604 Argconditions: conditions,
9605 }
9606 if d, err := json.Marshal(targetArguments); err == nil {
9607 log.Printf("[TRACE] \targs: %s\n", string(d))
9608 }
9609
9610 defer func() {
9611 log.Println("[TRACE] ServerAPI.Find end")
9612 }()
9613
9614 result, err := t.Internal.Find(ctx, zone, conditions)
9615 targetResults := struct {
9616 Result *iaas.ServerFindResult
9617 Error error
9618 }{
9619 Result: result,
9620 Error: err,
9621 }
9622 if d, err := json.Marshal(targetResults); err == nil {
9623 log.Printf("[TRACE] \tresults: %s\n", string(d))
9624 }
9625
9626 return result, err
9627 }
9628
9629 // Create is API call with trace log
9630 func (t *ServerTracer) Create(ctx context.Context, zone string, param *iaas.ServerCreateRequest) (*iaas.Server, error) {
9631 log.Println("[TRACE] ServerAPI.Create start")
9632 targetArguments := struct {
9633 Argzone string
9634 Argparam *iaas.ServerCreateRequest `json:"param"`
9635 }{
9636 Argzone: zone,
9637 Argparam: param,
9638 }
9639 if d, err := json.Marshal(targetArguments); err == nil {
9640 log.Printf("[TRACE] \targs: %s\n", string(d))
9641 }
9642
9643 defer func() {
9644 log.Println("[TRACE] ServerAPI.Create end")
9645 }()
9646
9647 resultServer, err := t.Internal.Create(ctx, zone, param)
9648 targetResults := struct {
9649 Server *iaas.Server
9650 Error error
9651 }{
9652 Server: resultServer,
9653 Error: err,
9654 }
9655 if d, err := json.Marshal(targetResults); err == nil {
9656 log.Printf("[TRACE] \tresults: %s\n", string(d))
9657 }
9658
9659 return resultServer, err
9660 }
9661
9662 // Read is API call with trace log
9663 func (t *ServerTracer) Read(ctx context.Context, zone string, id types.ID) (*iaas.Server, error) {
9664 log.Println("[TRACE] ServerAPI.Read start")
9665 targetArguments := struct {
9666 Argzone string
9667 Argid types.ID `json:"id"`
9668 }{
9669 Argzone: zone,
9670 Argid: id,
9671 }
9672 if d, err := json.Marshal(targetArguments); err == nil {
9673 log.Printf("[TRACE] \targs: %s\n", string(d))
9674 }
9675
9676 defer func() {
9677 log.Println("[TRACE] ServerAPI.Read end")
9678 }()
9679
9680 resultServer, err := t.Internal.Read(ctx, zone, id)
9681 targetResults := struct {
9682 Server *iaas.Server
9683 Error error
9684 }{
9685 Server: resultServer,
9686 Error: err,
9687 }
9688 if d, err := json.Marshal(targetResults); err == nil {
9689 log.Printf("[TRACE] \tresults: %s\n", string(d))
9690 }
9691
9692 return resultServer, err
9693 }
9694
9695 // Update is API call with trace log
9696 func (t *ServerTracer) Update(ctx context.Context, zone string, id types.ID, param *iaas.ServerUpdateRequest) (*iaas.Server, error) {
9697 log.Println("[TRACE] ServerAPI.Update start")
9698 targetArguments := struct {
9699 Argzone string
9700 Argid types.ID `json:"id"`
9701 Argparam *iaas.ServerUpdateRequest `json:"param"`
9702 }{
9703 Argzone: zone,
9704 Argid: id,
9705 Argparam: param,
9706 }
9707 if d, err := json.Marshal(targetArguments); err == nil {
9708 log.Printf("[TRACE] \targs: %s\n", string(d))
9709 }
9710
9711 defer func() {
9712 log.Println("[TRACE] ServerAPI.Update end")
9713 }()
9714
9715 resultServer, err := t.Internal.Update(ctx, zone, id, param)
9716 targetResults := struct {
9717 Server *iaas.Server
9718 Error error
9719 }{
9720 Server: resultServer,
9721 Error: err,
9722 }
9723 if d, err := json.Marshal(targetResults); err == nil {
9724 log.Printf("[TRACE] \tresults: %s\n", string(d))
9725 }
9726
9727 return resultServer, err
9728 }
9729
9730 // Delete is API call with trace log
9731 func (t *ServerTracer) Delete(ctx context.Context, zone string, id types.ID) error {
9732 log.Println("[TRACE] ServerAPI.Delete start")
9733 targetArguments := struct {
9734 Argzone string
9735 Argid types.ID `json:"id"`
9736 }{
9737 Argzone: zone,
9738 Argid: id,
9739 }
9740 if d, err := json.Marshal(targetArguments); err == nil {
9741 log.Printf("[TRACE] \targs: %s\n", string(d))
9742 }
9743
9744 defer func() {
9745 log.Println("[TRACE] ServerAPI.Delete end")
9746 }()
9747
9748 err := t.Internal.Delete(ctx, zone, id)
9749 targetResults := struct {
9750 Error error
9751 }{
9752 Error: err,
9753 }
9754 if d, err := json.Marshal(targetResults); err == nil {
9755 log.Printf("[TRACE] \tresults: %s\n", string(d))
9756 }
9757
9758 return err
9759 }
9760
9761 // DeleteWithDisks is API call with trace log
9762 func (t *ServerTracer) DeleteWithDisks(ctx context.Context, zone string, id types.ID, disks *iaas.ServerDeleteWithDisksRequest) error {
9763 log.Println("[TRACE] ServerAPI.DeleteWithDisks start")
9764 targetArguments := struct {
9765 Argzone string
9766 Argid types.ID `json:"id"`
9767 Argdisks *iaas.ServerDeleteWithDisksRequest `json:"disks"`
9768 }{
9769 Argzone: zone,
9770 Argid: id,
9771 Argdisks: disks,
9772 }
9773 if d, err := json.Marshal(targetArguments); err == nil {
9774 log.Printf("[TRACE] \targs: %s\n", string(d))
9775 }
9776
9777 defer func() {
9778 log.Println("[TRACE] ServerAPI.DeleteWithDisks end")
9779 }()
9780
9781 err := t.Internal.DeleteWithDisks(ctx, zone, id, disks)
9782 targetResults := struct {
9783 Error error
9784 }{
9785 Error: err,
9786 }
9787 if d, err := json.Marshal(targetResults); err == nil {
9788 log.Printf("[TRACE] \tresults: %s\n", string(d))
9789 }
9790
9791 return err
9792 }
9793
9794 // ChangePlan is API call with trace log
9795 func (t *ServerTracer) ChangePlan(ctx context.Context, zone string, id types.ID, plan *iaas.ServerChangePlanRequest) (*iaas.Server, error) {
9796 log.Println("[TRACE] ServerAPI.ChangePlan start")
9797 targetArguments := struct {
9798 Argzone string
9799 Argid types.ID `json:"id"`
9800 Argplan *iaas.ServerChangePlanRequest `json:"plan"`
9801 }{
9802 Argzone: zone,
9803 Argid: id,
9804 Argplan: plan,
9805 }
9806 if d, err := json.Marshal(targetArguments); err == nil {
9807 log.Printf("[TRACE] \targs: %s\n", string(d))
9808 }
9809
9810 defer func() {
9811 log.Println("[TRACE] ServerAPI.ChangePlan end")
9812 }()
9813
9814 resultServer, err := t.Internal.ChangePlan(ctx, zone, id, plan)
9815 targetResults := struct {
9816 Server *iaas.Server
9817 Error error
9818 }{
9819 Server: resultServer,
9820 Error: err,
9821 }
9822 if d, err := json.Marshal(targetResults); err == nil {
9823 log.Printf("[TRACE] \tresults: %s\n", string(d))
9824 }
9825
9826 return resultServer, err
9827 }
9828
9829 // InsertCDROM is API call with trace log
9830 func (t *ServerTracer) InsertCDROM(ctx context.Context, zone string, id types.ID, insertParam *iaas.InsertCDROMRequest) error {
9831 log.Println("[TRACE] ServerAPI.InsertCDROM start")
9832 targetArguments := struct {
9833 Argzone string
9834 Argid types.ID `json:"id"`
9835 ArginsertParam *iaas.InsertCDROMRequest `json:"insertParam"`
9836 }{
9837 Argzone: zone,
9838 Argid: id,
9839 ArginsertParam: insertParam,
9840 }
9841 if d, err := json.Marshal(targetArguments); err == nil {
9842 log.Printf("[TRACE] \targs: %s\n", string(d))
9843 }
9844
9845 defer func() {
9846 log.Println("[TRACE] ServerAPI.InsertCDROM end")
9847 }()
9848
9849 err := t.Internal.InsertCDROM(ctx, zone, id, insertParam)
9850 targetResults := struct {
9851 Error error
9852 }{
9853 Error: err,
9854 }
9855 if d, err := json.Marshal(targetResults); err == nil {
9856 log.Printf("[TRACE] \tresults: %s\n", string(d))
9857 }
9858
9859 return err
9860 }
9861
9862 // EjectCDROM is API call with trace log
9863 func (t *ServerTracer) EjectCDROM(ctx context.Context, zone string, id types.ID, ejectParam *iaas.EjectCDROMRequest) error {
9864 log.Println("[TRACE] ServerAPI.EjectCDROM start")
9865 targetArguments := struct {
9866 Argzone string
9867 Argid types.ID `json:"id"`
9868 ArgejectParam *iaas.EjectCDROMRequest `json:"ejectParam"`
9869 }{
9870 Argzone: zone,
9871 Argid: id,
9872 ArgejectParam: ejectParam,
9873 }
9874 if d, err := json.Marshal(targetArguments); err == nil {
9875 log.Printf("[TRACE] \targs: %s\n", string(d))
9876 }
9877
9878 defer func() {
9879 log.Println("[TRACE] ServerAPI.EjectCDROM end")
9880 }()
9881
9882 err := t.Internal.EjectCDROM(ctx, zone, id, ejectParam)
9883 targetResults := struct {
9884 Error error
9885 }{
9886 Error: err,
9887 }
9888 if d, err := json.Marshal(targetResults); err == nil {
9889 log.Printf("[TRACE] \tresults: %s\n", string(d))
9890 }
9891
9892 return err
9893 }
9894
9895 // Boot is API call with trace log
9896 func (t *ServerTracer) Boot(ctx context.Context, zone string, id types.ID) error {
9897 log.Println("[TRACE] ServerAPI.Boot start")
9898 targetArguments := struct {
9899 Argzone string
9900 Argid types.ID `json:"id"`
9901 }{
9902 Argzone: zone,
9903 Argid: id,
9904 }
9905 if d, err := json.Marshal(targetArguments); err == nil {
9906 log.Printf("[TRACE] \targs: %s\n", string(d))
9907 }
9908
9909 defer func() {
9910 log.Println("[TRACE] ServerAPI.Boot end")
9911 }()
9912
9913 err := t.Internal.Boot(ctx, zone, id)
9914 targetResults := struct {
9915 Error error
9916 }{
9917 Error: err,
9918 }
9919 if d, err := json.Marshal(targetResults); err == nil {
9920 log.Printf("[TRACE] \tresults: %s\n", string(d))
9921 }
9922
9923 return err
9924 }
9925
9926 // Shutdown is API call with trace log
9927 func (t *ServerTracer) Shutdown(ctx context.Context, zone string, id types.ID, shutdownOption *iaas.ShutdownOption) error {
9928 log.Println("[TRACE] ServerAPI.Shutdown start")
9929 targetArguments := struct {
9930 Argzone string
9931 Argid types.ID `json:"id"`
9932 ArgshutdownOption *iaas.ShutdownOption `json:"shutdownOption"`
9933 }{
9934 Argzone: zone,
9935 Argid: id,
9936 ArgshutdownOption: shutdownOption,
9937 }
9938 if d, err := json.Marshal(targetArguments); err == nil {
9939 log.Printf("[TRACE] \targs: %s\n", string(d))
9940 }
9941
9942 defer func() {
9943 log.Println("[TRACE] ServerAPI.Shutdown end")
9944 }()
9945
9946 err := t.Internal.Shutdown(ctx, zone, id, shutdownOption)
9947 targetResults := struct {
9948 Error error
9949 }{
9950 Error: err,
9951 }
9952 if d, err := json.Marshal(targetResults); err == nil {
9953 log.Printf("[TRACE] \tresults: %s\n", string(d))
9954 }
9955
9956 return err
9957 }
9958
9959 // Reset is API call with trace log
9960 func (t *ServerTracer) Reset(ctx context.Context, zone string, id types.ID) error {
9961 log.Println("[TRACE] ServerAPI.Reset start")
9962 targetArguments := struct {
9963 Argzone string
9964 Argid types.ID `json:"id"`
9965 }{
9966 Argzone: zone,
9967 Argid: id,
9968 }
9969 if d, err := json.Marshal(targetArguments); err == nil {
9970 log.Printf("[TRACE] \targs: %s\n", string(d))
9971 }
9972
9973 defer func() {
9974 log.Println("[TRACE] ServerAPI.Reset end")
9975 }()
9976
9977 err := t.Internal.Reset(ctx, zone, id)
9978 targetResults := struct {
9979 Error error
9980 }{
9981 Error: err,
9982 }
9983 if d, err := json.Marshal(targetResults); err == nil {
9984 log.Printf("[TRACE] \tresults: %s\n", string(d))
9985 }
9986
9987 return err
9988 }
9989
9990 // BootWithVariables is API call with trace log
9991 func (t *ServerTracer) BootWithVariables(ctx context.Context, zone string, id types.ID, param *iaas.ServerBootVariables) error {
9992 log.Println("[TRACE] ServerAPI.BootWithVariables start")
9993 targetArguments := struct {
9994 Argzone string
9995 Argid types.ID `json:"id"`
9996 Argparam *iaas.ServerBootVariables `json:"param"`
9997 }{
9998 Argzone: zone,
9999 Argid: id,
10000 Argparam: param,
10001 }
10002 if d, err := json.Marshal(targetArguments); err == nil {
10003 log.Printf("[TRACE] \targs: %s\n", string(d))
10004 }
10005
10006 defer func() {
10007 log.Println("[TRACE] ServerAPI.BootWithVariables end")
10008 }()
10009
10010 err := t.Internal.BootWithVariables(ctx, zone, id, param)
10011 targetResults := struct {
10012 Error error
10013 }{
10014 Error: err,
10015 }
10016 if d, err := json.Marshal(targetResults); err == nil {
10017 log.Printf("[TRACE] \tresults: %s\n", string(d))
10018 }
10019
10020 return err
10021 }
10022
10023 // SendKey is API call with trace log
10024 func (t *ServerTracer) SendKey(ctx context.Context, zone string, id types.ID, keyboardParam *iaas.SendKeyRequest) error {
10025 log.Println("[TRACE] ServerAPI.SendKey start")
10026 targetArguments := struct {
10027 Argzone string
10028 Argid types.ID `json:"id"`
10029 ArgkeyboardParam *iaas.SendKeyRequest `json:"keyboardParam"`
10030 }{
10031 Argzone: zone,
10032 Argid: id,
10033 ArgkeyboardParam: keyboardParam,
10034 }
10035 if d, err := json.Marshal(targetArguments); err == nil {
10036 log.Printf("[TRACE] \targs: %s\n", string(d))
10037 }
10038
10039 defer func() {
10040 log.Println("[TRACE] ServerAPI.SendKey end")
10041 }()
10042
10043 err := t.Internal.SendKey(ctx, zone, id, keyboardParam)
10044 targetResults := struct {
10045 Error error
10046 }{
10047 Error: err,
10048 }
10049 if d, err := json.Marshal(targetResults); err == nil {
10050 log.Printf("[TRACE] \tresults: %s\n", string(d))
10051 }
10052
10053 return err
10054 }
10055
10056 // SendNMI is API call with trace log
10057 func (t *ServerTracer) SendNMI(ctx context.Context, zone string, id types.ID) error {
10058 log.Println("[TRACE] ServerAPI.SendNMI start")
10059 targetArguments := struct {
10060 Argzone string
10061 Argid types.ID `json:"id"`
10062 }{
10063 Argzone: zone,
10064 Argid: id,
10065 }
10066 if d, err := json.Marshal(targetArguments); err == nil {
10067 log.Printf("[TRACE] \targs: %s\n", string(d))
10068 }
10069
10070 defer func() {
10071 log.Println("[TRACE] ServerAPI.SendNMI end")
10072 }()
10073
10074 err := t.Internal.SendNMI(ctx, zone, id)
10075 targetResults := struct {
10076 Error error
10077 }{
10078 Error: err,
10079 }
10080 if d, err := json.Marshal(targetResults); err == nil {
10081 log.Printf("[TRACE] \tresults: %s\n", string(d))
10082 }
10083
10084 return err
10085 }
10086
10087 // GetVNCProxy is API call with trace log
10088 func (t *ServerTracer) GetVNCProxy(ctx context.Context, zone string, id types.ID) (*iaas.VNCProxyInfo, error) {
10089 log.Println("[TRACE] ServerAPI.GetVNCProxy start")
10090 targetArguments := struct {
10091 Argzone string
10092 Argid types.ID `json:"id"`
10093 }{
10094 Argzone: zone,
10095 Argid: id,
10096 }
10097 if d, err := json.Marshal(targetArguments); err == nil {
10098 log.Printf("[TRACE] \targs: %s\n", string(d))
10099 }
10100
10101 defer func() {
10102 log.Println("[TRACE] ServerAPI.GetVNCProxy end")
10103 }()
10104
10105 resultVNCProxyInfo, err := t.Internal.GetVNCProxy(ctx, zone, id)
10106 targetResults := struct {
10107 VNCProxyInfo *iaas.VNCProxyInfo
10108 Error error
10109 }{
10110 VNCProxyInfo: resultVNCProxyInfo,
10111 Error: err,
10112 }
10113 if d, err := json.Marshal(targetResults); err == nil {
10114 log.Printf("[TRACE] \tresults: %s\n", string(d))
10115 }
10116
10117 return resultVNCProxyInfo, err
10118 }
10119
10120 // Monitor is API call with trace log
10121 func (t *ServerTracer) Monitor(ctx context.Context, zone string, id types.ID, condition *iaas.MonitorCondition) (*iaas.CPUTimeActivity, error) {
10122 log.Println("[TRACE] ServerAPI.Monitor start")
10123 targetArguments := struct {
10124 Argzone string
10125 Argid types.ID `json:"id"`
10126 Argcondition *iaas.MonitorCondition `json:"condition"`
10127 }{
10128 Argzone: zone,
10129 Argid: id,
10130 Argcondition: condition,
10131 }
10132 if d, err := json.Marshal(targetArguments); err == nil {
10133 log.Printf("[TRACE] \targs: %s\n", string(d))
10134 }
10135
10136 defer func() {
10137 log.Println("[TRACE] ServerAPI.Monitor end")
10138 }()
10139
10140 resultCPUTimeActivity, err := t.Internal.Monitor(ctx, zone, id, condition)
10141 targetResults := struct {
10142 CPUTimeActivity *iaas.CPUTimeActivity
10143 Error error
10144 }{
10145 CPUTimeActivity: resultCPUTimeActivity,
10146 Error: err,
10147 }
10148 if d, err := json.Marshal(targetResults); err == nil {
10149 log.Printf("[TRACE] \tresults: %s\n", string(d))
10150 }
10151
10152 return resultCPUTimeActivity, err
10153 }
10154
10155 // MonitorCPU is API call with trace log
10156 func (t *ServerTracer) MonitorCPU(ctx context.Context, zone string, id types.ID, condition *iaas.MonitorCondition) (*iaas.CPUTimeActivity, error) {
10157 log.Println("[TRACE] ServerAPI.MonitorCPU start")
10158 targetArguments := struct {
10159 Argzone string
10160 Argid types.ID `json:"id"`
10161 Argcondition *iaas.MonitorCondition `json:"condition"`
10162 }{
10163 Argzone: zone,
10164 Argid: id,
10165 Argcondition: condition,
10166 }
10167 if d, err := json.Marshal(targetArguments); err == nil {
10168 log.Printf("[TRACE] \targs: %s\n", string(d))
10169 }
10170
10171 defer func() {
10172 log.Println("[TRACE] ServerAPI.MonitorCPU end")
10173 }()
10174
10175 resultCPUTimeActivity, err := t.Internal.MonitorCPU(ctx, zone, id, condition)
10176 targetResults := struct {
10177 CPUTimeActivity *iaas.CPUTimeActivity
10178 Error error
10179 }{
10180 CPUTimeActivity: resultCPUTimeActivity,
10181 Error: err,
10182 }
10183 if d, err := json.Marshal(targetResults); err == nil {
10184 log.Printf("[TRACE] \tresults: %s\n", string(d))
10185 }
10186
10187 return resultCPUTimeActivity, err
10188 }
10189
10190 /*************************************************
10191 * ServerPlanTracer
10192 *************************************************/
10193
10194 // ServerPlanTracer is for trace ServerPlanOp operations
10195 type ServerPlanTracer struct {
10196 Internal iaas.ServerPlanAPI
10197 }
10198
10199 // NewServerPlanTracer creates new ServerPlanTracer instance
10200 func NewServerPlanTracer(in iaas.ServerPlanAPI) iaas.ServerPlanAPI {
10201 return &ServerPlanTracer{
10202 Internal: in,
10203 }
10204 }
10205
10206 // Find is API call with trace log
10207 func (t *ServerPlanTracer) Find(ctx context.Context, zone string, conditions *iaas.FindCondition) (*iaas.ServerPlanFindResult, error) {
10208 log.Println("[TRACE] ServerPlanAPI.Find start")
10209 targetArguments := struct {
10210 Argzone string
10211 Argconditions *iaas.FindCondition `json:"conditions"`
10212 }{
10213 Argzone: zone,
10214 Argconditions: conditions,
10215 }
10216 if d, err := json.Marshal(targetArguments); err == nil {
10217 log.Printf("[TRACE] \targs: %s\n", string(d))
10218 }
10219
10220 defer func() {
10221 log.Println("[TRACE] ServerPlanAPI.Find end")
10222 }()
10223
10224 result, err := t.Internal.Find(ctx, zone, conditions)
10225 targetResults := struct {
10226 Result *iaas.ServerPlanFindResult
10227 Error error
10228 }{
10229 Result: result,
10230 Error: err,
10231 }
10232 if d, err := json.Marshal(targetResults); err == nil {
10233 log.Printf("[TRACE] \tresults: %s\n", string(d))
10234 }
10235
10236 return result, err
10237 }
10238
10239 // Read is API call with trace log
10240 func (t *ServerPlanTracer) Read(ctx context.Context, zone string, id types.ID) (*iaas.ServerPlan, error) {
10241 log.Println("[TRACE] ServerPlanAPI.Read start")
10242 targetArguments := struct {
10243 Argzone string
10244 Argid types.ID `json:"id"`
10245 }{
10246 Argzone: zone,
10247 Argid: id,
10248 }
10249 if d, err := json.Marshal(targetArguments); err == nil {
10250 log.Printf("[TRACE] \targs: %s\n", string(d))
10251 }
10252
10253 defer func() {
10254 log.Println("[TRACE] ServerPlanAPI.Read end")
10255 }()
10256
10257 resultServerPlan, err := t.Internal.Read(ctx, zone, id)
10258 targetResults := struct {
10259 ServerPlan *iaas.ServerPlan
10260 Error error
10261 }{
10262 ServerPlan: resultServerPlan,
10263 Error: err,
10264 }
10265 if d, err := json.Marshal(targetResults); err == nil {
10266 log.Printf("[TRACE] \tresults: %s\n", string(d))
10267 }
10268
10269 return resultServerPlan, err
10270 }
10271
10272 /*************************************************
10273 * ServiceClassTracer
10274 *************************************************/
10275
10276 // ServiceClassTracer is for trace ServiceClassOp operations
10277 type ServiceClassTracer struct {
10278 Internal iaas.ServiceClassAPI
10279 }
10280
10281 // NewServiceClassTracer creates new ServiceClassTracer instance
10282 func NewServiceClassTracer(in iaas.ServiceClassAPI) iaas.ServiceClassAPI {
10283 return &ServiceClassTracer{
10284 Internal: in,
10285 }
10286 }
10287
10288 // Find is API call with trace log
10289 func (t *ServiceClassTracer) Find(ctx context.Context, zone string, conditions *iaas.FindCondition) (*iaas.ServiceClassFindResult, error) {
10290 log.Println("[TRACE] ServiceClassAPI.Find start")
10291 targetArguments := struct {
10292 Argzone string
10293 Argconditions *iaas.FindCondition `json:"conditions"`
10294 }{
10295 Argzone: zone,
10296 Argconditions: conditions,
10297 }
10298 if d, err := json.Marshal(targetArguments); err == nil {
10299 log.Printf("[TRACE] \targs: %s\n", string(d))
10300 }
10301
10302 defer func() {
10303 log.Println("[TRACE] ServiceClassAPI.Find end")
10304 }()
10305
10306 result, err := t.Internal.Find(ctx, zone, conditions)
10307 targetResults := struct {
10308 Result *iaas.ServiceClassFindResult
10309 Error error
10310 }{
10311 Result: result,
10312 Error: err,
10313 }
10314 if d, err := json.Marshal(targetResults); err == nil {
10315 log.Printf("[TRACE] \tresults: %s\n", string(d))
10316 }
10317
10318 return result, err
10319 }
10320
10321 /*************************************************
10322 * SIMTracer
10323 *************************************************/
10324
10325 // SIMTracer is for trace SIMOp operations
10326 type SIMTracer struct {
10327 Internal iaas.SIMAPI
10328 }
10329
10330 // NewSIMTracer creates new SIMTracer instance
10331 func NewSIMTracer(in iaas.SIMAPI) iaas.SIMAPI {
10332 return &SIMTracer{
10333 Internal: in,
10334 }
10335 }
10336
10337 // Find is API call with trace log
10338 func (t *SIMTracer) Find(ctx context.Context, conditions *iaas.FindCondition) (*iaas.SIMFindResult, error) {
10339 log.Println("[TRACE] SIMAPI.Find start")
10340 targetArguments := struct {
10341 Argconditions *iaas.FindCondition `json:"conditions"`
10342 }{
10343 Argconditions: conditions,
10344 }
10345 if d, err := json.Marshal(targetArguments); err == nil {
10346 log.Printf("[TRACE] \targs: %s\n", string(d))
10347 }
10348
10349 defer func() {
10350 log.Println("[TRACE] SIMAPI.Find end")
10351 }()
10352
10353 result, err := t.Internal.Find(ctx, conditions)
10354 targetResults := struct {
10355 Result *iaas.SIMFindResult
10356 Error error
10357 }{
10358 Result: result,
10359 Error: err,
10360 }
10361 if d, err := json.Marshal(targetResults); err == nil {
10362 log.Printf("[TRACE] \tresults: %s\n", string(d))
10363 }
10364
10365 return result, err
10366 }
10367
10368 // Create is API call with trace log
10369 func (t *SIMTracer) Create(ctx context.Context, param *iaas.SIMCreateRequest) (*iaas.SIM, error) {
10370 log.Println("[TRACE] SIMAPI.Create start")
10371 targetArguments := struct {
10372 Argparam *iaas.SIMCreateRequest `json:"param"`
10373 }{
10374 Argparam: param,
10375 }
10376 if d, err := json.Marshal(targetArguments); err == nil {
10377 log.Printf("[TRACE] \targs: %s\n", string(d))
10378 }
10379
10380 defer func() {
10381 log.Println("[TRACE] SIMAPI.Create end")
10382 }()
10383
10384 resultSIM, err := t.Internal.Create(ctx, param)
10385 targetResults := struct {
10386 SIM *iaas.SIM
10387 Error error
10388 }{
10389 SIM: resultSIM,
10390 Error: err,
10391 }
10392 if d, err := json.Marshal(targetResults); err == nil {
10393 log.Printf("[TRACE] \tresults: %s\n", string(d))
10394 }
10395
10396 return resultSIM, err
10397 }
10398
10399 // Read is API call with trace log
10400 func (t *SIMTracer) Read(ctx context.Context, id types.ID) (*iaas.SIM, error) {
10401 log.Println("[TRACE] SIMAPI.Read start")
10402 targetArguments := struct {
10403 Argid types.ID `json:"id"`
10404 }{
10405 Argid: id,
10406 }
10407 if d, err := json.Marshal(targetArguments); err == nil {
10408 log.Printf("[TRACE] \targs: %s\n", string(d))
10409 }
10410
10411 defer func() {
10412 log.Println("[TRACE] SIMAPI.Read end")
10413 }()
10414
10415 resultSIM, err := t.Internal.Read(ctx, id)
10416 targetResults := struct {
10417 SIM *iaas.SIM
10418 Error error
10419 }{
10420 SIM: resultSIM,
10421 Error: err,
10422 }
10423 if d, err := json.Marshal(targetResults); err == nil {
10424 log.Printf("[TRACE] \tresults: %s\n", string(d))
10425 }
10426
10427 return resultSIM, err
10428 }
10429
10430 // Update is API call with trace log
10431 func (t *SIMTracer) Update(ctx context.Context, id types.ID, param *iaas.SIMUpdateRequest) (*iaas.SIM, error) {
10432 log.Println("[TRACE] SIMAPI.Update start")
10433 targetArguments := struct {
10434 Argid types.ID `json:"id"`
10435 Argparam *iaas.SIMUpdateRequest `json:"param"`
10436 }{
10437 Argid: id,
10438 Argparam: param,
10439 }
10440 if d, err := json.Marshal(targetArguments); err == nil {
10441 log.Printf("[TRACE] \targs: %s\n", string(d))
10442 }
10443
10444 defer func() {
10445 log.Println("[TRACE] SIMAPI.Update end")
10446 }()
10447
10448 resultSIM, err := t.Internal.Update(ctx, id, param)
10449 targetResults := struct {
10450 SIM *iaas.SIM
10451 Error error
10452 }{
10453 SIM: resultSIM,
10454 Error: err,
10455 }
10456 if d, err := json.Marshal(targetResults); err == nil {
10457 log.Printf("[TRACE] \tresults: %s\n", string(d))
10458 }
10459
10460 return resultSIM, err
10461 }
10462
10463 // Delete is API call with trace log
10464 func (t *SIMTracer) Delete(ctx context.Context, id types.ID) error {
10465 log.Println("[TRACE] SIMAPI.Delete start")
10466 targetArguments := struct {
10467 Argid types.ID `json:"id"`
10468 }{
10469 Argid: id,
10470 }
10471 if d, err := json.Marshal(targetArguments); err == nil {
10472 log.Printf("[TRACE] \targs: %s\n", string(d))
10473 }
10474
10475 defer func() {
10476 log.Println("[TRACE] SIMAPI.Delete end")
10477 }()
10478
10479 err := t.Internal.Delete(ctx, id)
10480 targetResults := struct {
10481 Error error
10482 }{
10483 Error: err,
10484 }
10485 if d, err := json.Marshal(targetResults); err == nil {
10486 log.Printf("[TRACE] \tresults: %s\n", string(d))
10487 }
10488
10489 return err
10490 }
10491
10492 // Activate is API call with trace log
10493 func (t *SIMTracer) Activate(ctx context.Context, id types.ID) error {
10494 log.Println("[TRACE] SIMAPI.Activate start")
10495 targetArguments := struct {
10496 Argid types.ID `json:"id"`
10497 }{
10498 Argid: id,
10499 }
10500 if d, err := json.Marshal(targetArguments); err == nil {
10501 log.Printf("[TRACE] \targs: %s\n", string(d))
10502 }
10503
10504 defer func() {
10505 log.Println("[TRACE] SIMAPI.Activate end")
10506 }()
10507
10508 err := t.Internal.Activate(ctx, id)
10509 targetResults := struct {
10510 Error error
10511 }{
10512 Error: err,
10513 }
10514 if d, err := json.Marshal(targetResults); err == nil {
10515 log.Printf("[TRACE] \tresults: %s\n", string(d))
10516 }
10517
10518 return err
10519 }
10520
10521 // Deactivate is API call with trace log
10522 func (t *SIMTracer) Deactivate(ctx context.Context, id types.ID) error {
10523 log.Println("[TRACE] SIMAPI.Deactivate start")
10524 targetArguments := struct {
10525 Argid types.ID `json:"id"`
10526 }{
10527 Argid: id,
10528 }
10529 if d, err := json.Marshal(targetArguments); err == nil {
10530 log.Printf("[TRACE] \targs: %s\n", string(d))
10531 }
10532
10533 defer func() {
10534 log.Println("[TRACE] SIMAPI.Deactivate end")
10535 }()
10536
10537 err := t.Internal.Deactivate(ctx, id)
10538 targetResults := struct {
10539 Error error
10540 }{
10541 Error: err,
10542 }
10543 if d, err := json.Marshal(targetResults); err == nil {
10544 log.Printf("[TRACE] \tresults: %s\n", string(d))
10545 }
10546
10547 return err
10548 }
10549
10550 // AssignIP is API call with trace log
10551 func (t *SIMTracer) AssignIP(ctx context.Context, id types.ID, param *iaas.SIMAssignIPRequest) error {
10552 log.Println("[TRACE] SIMAPI.AssignIP start")
10553 targetArguments := struct {
10554 Argid types.ID `json:"id"`
10555 Argparam *iaas.SIMAssignIPRequest `json:"param"`
10556 }{
10557 Argid: id,
10558 Argparam: param,
10559 }
10560 if d, err := json.Marshal(targetArguments); err == nil {
10561 log.Printf("[TRACE] \targs: %s\n", string(d))
10562 }
10563
10564 defer func() {
10565 log.Println("[TRACE] SIMAPI.AssignIP end")
10566 }()
10567
10568 err := t.Internal.AssignIP(ctx, id, param)
10569 targetResults := struct {
10570 Error error
10571 }{
10572 Error: err,
10573 }
10574 if d, err := json.Marshal(targetResults); err == nil {
10575 log.Printf("[TRACE] \tresults: %s\n", string(d))
10576 }
10577
10578 return err
10579 }
10580
10581 // ClearIP is API call with trace log
10582 func (t *SIMTracer) ClearIP(ctx context.Context, id types.ID) error {
10583 log.Println("[TRACE] SIMAPI.ClearIP start")
10584 targetArguments := struct {
10585 Argid types.ID `json:"id"`
10586 }{
10587 Argid: id,
10588 }
10589 if d, err := json.Marshal(targetArguments); err == nil {
10590 log.Printf("[TRACE] \targs: %s\n", string(d))
10591 }
10592
10593 defer func() {
10594 log.Println("[TRACE] SIMAPI.ClearIP end")
10595 }()
10596
10597 err := t.Internal.ClearIP(ctx, id)
10598 targetResults := struct {
10599 Error error
10600 }{
10601 Error: err,
10602 }
10603 if d, err := json.Marshal(targetResults); err == nil {
10604 log.Printf("[TRACE] \tresults: %s\n", string(d))
10605 }
10606
10607 return err
10608 }
10609
10610 // IMEILock is API call with trace log
10611 func (t *SIMTracer) IMEILock(ctx context.Context, id types.ID, param *iaas.SIMIMEILockRequest) error {
10612 log.Println("[TRACE] SIMAPI.IMEILock start")
10613 targetArguments := struct {
10614 Argid types.ID `json:"id"`
10615 Argparam *iaas.SIMIMEILockRequest `json:"param"`
10616 }{
10617 Argid: id,
10618 Argparam: param,
10619 }
10620 if d, err := json.Marshal(targetArguments); err == nil {
10621 log.Printf("[TRACE] \targs: %s\n", string(d))
10622 }
10623
10624 defer func() {
10625 log.Println("[TRACE] SIMAPI.IMEILock end")
10626 }()
10627
10628 err := t.Internal.IMEILock(ctx, id, param)
10629 targetResults := struct {
10630 Error error
10631 }{
10632 Error: err,
10633 }
10634 if d, err := json.Marshal(targetResults); err == nil {
10635 log.Printf("[TRACE] \tresults: %s\n", string(d))
10636 }
10637
10638 return err
10639 }
10640
10641 // IMEIUnlock is API call with trace log
10642 func (t *SIMTracer) IMEIUnlock(ctx context.Context, id types.ID) error {
10643 log.Println("[TRACE] SIMAPI.IMEIUnlock start")
10644 targetArguments := struct {
10645 Argid types.ID `json:"id"`
10646 }{
10647 Argid: id,
10648 }
10649 if d, err := json.Marshal(targetArguments); err == nil {
10650 log.Printf("[TRACE] \targs: %s\n", string(d))
10651 }
10652
10653 defer func() {
10654 log.Println("[TRACE] SIMAPI.IMEIUnlock end")
10655 }()
10656
10657 err := t.Internal.IMEIUnlock(ctx, id)
10658 targetResults := struct {
10659 Error error
10660 }{
10661 Error: err,
10662 }
10663 if d, err := json.Marshal(targetResults); err == nil {
10664 log.Printf("[TRACE] \tresults: %s\n", string(d))
10665 }
10666
10667 return err
10668 }
10669
10670 // Logs is API call with trace log
10671 func (t *SIMTracer) Logs(ctx context.Context, id types.ID) (*iaas.SIMLogsResult, error) {
10672 log.Println("[TRACE] SIMAPI.Logs start")
10673 targetArguments := struct {
10674 Argid types.ID `json:"id"`
10675 }{
10676 Argid: id,
10677 }
10678 if d, err := json.Marshal(targetArguments); err == nil {
10679 log.Printf("[TRACE] \targs: %s\n", string(d))
10680 }
10681
10682 defer func() {
10683 log.Println("[TRACE] SIMAPI.Logs end")
10684 }()
10685
10686 result, err := t.Internal.Logs(ctx, id)
10687 targetResults := struct {
10688 Result *iaas.SIMLogsResult
10689 Error error
10690 }{
10691 Result: result,
10692 Error: err,
10693 }
10694 if d, err := json.Marshal(targetResults); err == nil {
10695 log.Printf("[TRACE] \tresults: %s\n", string(d))
10696 }
10697
10698 return result, err
10699 }
10700
10701 // GetNetworkOperator is API call with trace log
10702 func (t *SIMTracer) GetNetworkOperator(ctx context.Context, id types.ID) ([]*iaas.SIMNetworkOperatorConfig, error) {
10703 log.Println("[TRACE] SIMAPI.GetNetworkOperator start")
10704 targetArguments := struct {
10705 Argid types.ID `json:"id"`
10706 }{
10707 Argid: id,
10708 }
10709 if d, err := json.Marshal(targetArguments); err == nil {
10710 log.Printf("[TRACE] \targs: %s\n", string(d))
10711 }
10712
10713 defer func() {
10714 log.Println("[TRACE] SIMAPI.GetNetworkOperator end")
10715 }()
10716
10717 resultConfigs, err := t.Internal.GetNetworkOperator(ctx, id)
10718 targetResults := struct {
10719 Configs []*iaas.SIMNetworkOperatorConfig
10720 Error error
10721 }{
10722 Configs: resultConfigs,
10723 Error: err,
10724 }
10725 if d, err := json.Marshal(targetResults); err == nil {
10726 log.Printf("[TRACE] \tresults: %s\n", string(d))
10727 }
10728
10729 return resultConfigs, err
10730 }
10731
10732 // SetNetworkOperator is API call with trace log
10733 func (t *SIMTracer) SetNetworkOperator(ctx context.Context, id types.ID, configs []*iaas.SIMNetworkOperatorConfig) error {
10734 log.Println("[TRACE] SIMAPI.SetNetworkOperator start")
10735 targetArguments := struct {
10736 Argid types.ID `json:"id"`
10737 Argconfigs []*iaas.SIMNetworkOperatorConfig `json:"configs"`
10738 }{
10739 Argid: id,
10740 Argconfigs: configs,
10741 }
10742 if d, err := json.Marshal(targetArguments); err == nil {
10743 log.Printf("[TRACE] \targs: %s\n", string(d))
10744 }
10745
10746 defer func() {
10747 log.Println("[TRACE] SIMAPI.SetNetworkOperator end")
10748 }()
10749
10750 err := t.Internal.SetNetworkOperator(ctx, id, configs)
10751 targetResults := struct {
10752 Error error
10753 }{
10754 Error: err,
10755 }
10756 if d, err := json.Marshal(targetResults); err == nil {
10757 log.Printf("[TRACE] \tresults: %s\n", string(d))
10758 }
10759
10760 return err
10761 }
10762
10763 // MonitorSIM is API call with trace log
10764 func (t *SIMTracer) MonitorSIM(ctx context.Context, id types.ID, condition *iaas.MonitorCondition) (*iaas.LinkActivity, error) {
10765 log.Println("[TRACE] SIMAPI.MonitorSIM start")
10766 targetArguments := struct {
10767 Argid types.ID `json:"id"`
10768 Argcondition *iaas.MonitorCondition `json:"condition"`
10769 }{
10770 Argid: id,
10771 Argcondition: condition,
10772 }
10773 if d, err := json.Marshal(targetArguments); err == nil {
10774 log.Printf("[TRACE] \targs: %s\n", string(d))
10775 }
10776
10777 defer func() {
10778 log.Println("[TRACE] SIMAPI.MonitorSIM end")
10779 }()
10780
10781 resultLinkActivity, err := t.Internal.MonitorSIM(ctx, id, condition)
10782 targetResults := struct {
10783 LinkActivity *iaas.LinkActivity
10784 Error error
10785 }{
10786 LinkActivity: resultLinkActivity,
10787 Error: err,
10788 }
10789 if d, err := json.Marshal(targetResults); err == nil {
10790 log.Printf("[TRACE] \tresults: %s\n", string(d))
10791 }
10792
10793 return resultLinkActivity, err
10794 }
10795
10796 // Status is API call with trace log
10797 func (t *SIMTracer) Status(ctx context.Context, id types.ID) (*iaas.SIMInfo, error) {
10798 log.Println("[TRACE] SIMAPI.Status start")
10799 targetArguments := struct {
10800 Argid types.ID `json:"id"`
10801 }{
10802 Argid: id,
10803 }
10804 if d, err := json.Marshal(targetArguments); err == nil {
10805 log.Printf("[TRACE] \targs: %s\n", string(d))
10806 }
10807
10808 defer func() {
10809 log.Println("[TRACE] SIMAPI.Status end")
10810 }()
10811
10812 resultSIM, err := t.Internal.Status(ctx, id)
10813 targetResults := struct {
10814 SIM *iaas.SIMInfo
10815 Error error
10816 }{
10817 SIM: resultSIM,
10818 Error: err,
10819 }
10820 if d, err := json.Marshal(targetResults); err == nil {
10821 log.Printf("[TRACE] \tresults: %s\n", string(d))
10822 }
10823
10824 return resultSIM, err
10825 }
10826
10827 /*************************************************
10828 * SimpleMonitorTracer
10829 *************************************************/
10830
10831 // SimpleMonitorTracer is for trace SimpleMonitorOp operations
10832 type SimpleMonitorTracer struct {
10833 Internal iaas.SimpleMonitorAPI
10834 }
10835
10836 // NewSimpleMonitorTracer creates new SimpleMonitorTracer instance
10837 func NewSimpleMonitorTracer(in iaas.SimpleMonitorAPI) iaas.SimpleMonitorAPI {
10838 return &SimpleMonitorTracer{
10839 Internal: in,
10840 }
10841 }
10842
10843 // Find is API call with trace log
10844 func (t *SimpleMonitorTracer) Find(ctx context.Context, conditions *iaas.FindCondition) (*iaas.SimpleMonitorFindResult, error) {
10845 log.Println("[TRACE] SimpleMonitorAPI.Find start")
10846 targetArguments := struct {
10847 Argconditions *iaas.FindCondition `json:"conditions"`
10848 }{
10849 Argconditions: conditions,
10850 }
10851 if d, err := json.Marshal(targetArguments); err == nil {
10852 log.Printf("[TRACE] \targs: %s\n", string(d))
10853 }
10854
10855 defer func() {
10856 log.Println("[TRACE] SimpleMonitorAPI.Find end")
10857 }()
10858
10859 result, err := t.Internal.Find(ctx, conditions)
10860 targetResults := struct {
10861 Result *iaas.SimpleMonitorFindResult
10862 Error error
10863 }{
10864 Result: result,
10865 Error: err,
10866 }
10867 if d, err := json.Marshal(targetResults); err == nil {
10868 log.Printf("[TRACE] \tresults: %s\n", string(d))
10869 }
10870
10871 return result, err
10872 }
10873
10874 // Create is API call with trace log
10875 func (t *SimpleMonitorTracer) Create(ctx context.Context, param *iaas.SimpleMonitorCreateRequest) (*iaas.SimpleMonitor, error) {
10876 log.Println("[TRACE] SimpleMonitorAPI.Create start")
10877 targetArguments := struct {
10878 Argparam *iaas.SimpleMonitorCreateRequest `json:"param"`
10879 }{
10880 Argparam: param,
10881 }
10882 if d, err := json.Marshal(targetArguments); err == nil {
10883 log.Printf("[TRACE] \targs: %s\n", string(d))
10884 }
10885
10886 defer func() {
10887 log.Println("[TRACE] SimpleMonitorAPI.Create end")
10888 }()
10889
10890 resultSimpleMonitor, err := t.Internal.Create(ctx, param)
10891 targetResults := struct {
10892 SimpleMonitor *iaas.SimpleMonitor
10893 Error error
10894 }{
10895 SimpleMonitor: resultSimpleMonitor,
10896 Error: err,
10897 }
10898 if d, err := json.Marshal(targetResults); err == nil {
10899 log.Printf("[TRACE] \tresults: %s\n", string(d))
10900 }
10901
10902 return resultSimpleMonitor, err
10903 }
10904
10905 // Read is API call with trace log
10906 func (t *SimpleMonitorTracer) Read(ctx context.Context, id types.ID) (*iaas.SimpleMonitor, error) {
10907 log.Println("[TRACE] SimpleMonitorAPI.Read start")
10908 targetArguments := struct {
10909 Argid types.ID `json:"id"`
10910 }{
10911 Argid: id,
10912 }
10913 if d, err := json.Marshal(targetArguments); err == nil {
10914 log.Printf("[TRACE] \targs: %s\n", string(d))
10915 }
10916
10917 defer func() {
10918 log.Println("[TRACE] SimpleMonitorAPI.Read end")
10919 }()
10920
10921 resultSimpleMonitor, err := t.Internal.Read(ctx, id)
10922 targetResults := struct {
10923 SimpleMonitor *iaas.SimpleMonitor
10924 Error error
10925 }{
10926 SimpleMonitor: resultSimpleMonitor,
10927 Error: err,
10928 }
10929 if d, err := json.Marshal(targetResults); err == nil {
10930 log.Printf("[TRACE] \tresults: %s\n", string(d))
10931 }
10932
10933 return resultSimpleMonitor, err
10934 }
10935
10936 // Update is API call with trace log
10937 func (t *SimpleMonitorTracer) Update(ctx context.Context, id types.ID, param *iaas.SimpleMonitorUpdateRequest) (*iaas.SimpleMonitor, error) {
10938 log.Println("[TRACE] SimpleMonitorAPI.Update start")
10939 targetArguments := struct {
10940 Argid types.ID `json:"id"`
10941 Argparam *iaas.SimpleMonitorUpdateRequest `json:"param"`
10942 }{
10943 Argid: id,
10944 Argparam: param,
10945 }
10946 if d, err := json.Marshal(targetArguments); err == nil {
10947 log.Printf("[TRACE] \targs: %s\n", string(d))
10948 }
10949
10950 defer func() {
10951 log.Println("[TRACE] SimpleMonitorAPI.Update end")
10952 }()
10953
10954 resultSimpleMonitor, err := t.Internal.Update(ctx, id, param)
10955 targetResults := struct {
10956 SimpleMonitor *iaas.SimpleMonitor
10957 Error error
10958 }{
10959 SimpleMonitor: resultSimpleMonitor,
10960 Error: err,
10961 }
10962 if d, err := json.Marshal(targetResults); err == nil {
10963 log.Printf("[TRACE] \tresults: %s\n", string(d))
10964 }
10965
10966 return resultSimpleMonitor, err
10967 }
10968
10969 // UpdateSettings is API call with trace log
10970 func (t *SimpleMonitorTracer) UpdateSettings(ctx context.Context, id types.ID, param *iaas.SimpleMonitorUpdateSettingsRequest) (*iaas.SimpleMonitor, error) {
10971 log.Println("[TRACE] SimpleMonitorAPI.UpdateSettings start")
10972 targetArguments := struct {
10973 Argid types.ID `json:"id"`
10974 Argparam *iaas.SimpleMonitorUpdateSettingsRequest `json:"param"`
10975 }{
10976 Argid: id,
10977 Argparam: param,
10978 }
10979 if d, err := json.Marshal(targetArguments); err == nil {
10980 log.Printf("[TRACE] \targs: %s\n", string(d))
10981 }
10982
10983 defer func() {
10984 log.Println("[TRACE] SimpleMonitorAPI.UpdateSettings end")
10985 }()
10986
10987 resultSimpleMonitor, err := t.Internal.UpdateSettings(ctx, id, param)
10988 targetResults := struct {
10989 SimpleMonitor *iaas.SimpleMonitor
10990 Error error
10991 }{
10992 SimpleMonitor: resultSimpleMonitor,
10993 Error: err,
10994 }
10995 if d, err := json.Marshal(targetResults); err == nil {
10996 log.Printf("[TRACE] \tresults: %s\n", string(d))
10997 }
10998
10999 return resultSimpleMonitor, err
11000 }
11001
11002 // Delete is API call with trace log
11003 func (t *SimpleMonitorTracer) Delete(ctx context.Context, id types.ID) error {
11004 log.Println("[TRACE] SimpleMonitorAPI.Delete start")
11005 targetArguments := struct {
11006 Argid types.ID `json:"id"`
11007 }{
11008 Argid: id,
11009 }
11010 if d, err := json.Marshal(targetArguments); err == nil {
11011 log.Printf("[TRACE] \targs: %s\n", string(d))
11012 }
11013
11014 defer func() {
11015 log.Println("[TRACE] SimpleMonitorAPI.Delete end")
11016 }()
11017
11018 err := t.Internal.Delete(ctx, id)
11019 targetResults := struct {
11020 Error error
11021 }{
11022 Error: err,
11023 }
11024 if d, err := json.Marshal(targetResults); err == nil {
11025 log.Printf("[TRACE] \tresults: %s\n", string(d))
11026 }
11027
11028 return err
11029 }
11030
11031 // MonitorResponseTime is API call with trace log
11032 func (t *SimpleMonitorTracer) MonitorResponseTime(ctx context.Context, id types.ID, condition *iaas.MonitorCondition) (*iaas.ResponseTimeSecActivity, error) {
11033 log.Println("[TRACE] SimpleMonitorAPI.MonitorResponseTime start")
11034 targetArguments := struct {
11035 Argid types.ID `json:"id"`
11036 Argcondition *iaas.MonitorCondition `json:"condition"`
11037 }{
11038 Argid: id,
11039 Argcondition: condition,
11040 }
11041 if d, err := json.Marshal(targetArguments); err == nil {
11042 log.Printf("[TRACE] \targs: %s\n", string(d))
11043 }
11044
11045 defer func() {
11046 log.Println("[TRACE] SimpleMonitorAPI.MonitorResponseTime end")
11047 }()
11048
11049 resultResponseTimeSecActivity, err := t.Internal.MonitorResponseTime(ctx, id, condition)
11050 targetResults := struct {
11051 ResponseTimeSecActivity *iaas.ResponseTimeSecActivity
11052 Error error
11053 }{
11054 ResponseTimeSecActivity: resultResponseTimeSecActivity,
11055 Error: err,
11056 }
11057 if d, err := json.Marshal(targetResults); err == nil {
11058 log.Printf("[TRACE] \tresults: %s\n", string(d))
11059 }
11060
11061 return resultResponseTimeSecActivity, err
11062 }
11063
11064 // HealthStatus is API call with trace log
11065 func (t *SimpleMonitorTracer) HealthStatus(ctx context.Context, id types.ID) (*iaas.SimpleMonitorHealthStatus, error) {
11066 log.Println("[TRACE] SimpleMonitorAPI.HealthStatus start")
11067 targetArguments := struct {
11068 Argid types.ID `json:"id"`
11069 }{
11070 Argid: id,
11071 }
11072 if d, err := json.Marshal(targetArguments); err == nil {
11073 log.Printf("[TRACE] \targs: %s\n", string(d))
11074 }
11075
11076 defer func() {
11077 log.Println("[TRACE] SimpleMonitorAPI.HealthStatus end")
11078 }()
11079
11080 resultSimpleMonitorHealthStatus, err := t.Internal.HealthStatus(ctx, id)
11081 targetResults := struct {
11082 SimpleMonitorHealthStatus *iaas.SimpleMonitorHealthStatus
11083 Error error
11084 }{
11085 SimpleMonitorHealthStatus: resultSimpleMonitorHealthStatus,
11086 Error: err,
11087 }
11088 if d, err := json.Marshal(targetResults); err == nil {
11089 log.Printf("[TRACE] \tresults: %s\n", string(d))
11090 }
11091
11092 return resultSimpleMonitorHealthStatus, err
11093 }
11094
11095 /*************************************************
11096 * SimpleNotificationDestinationTracer
11097 *************************************************/
11098
11099 // SimpleNotificationDestinationTracer is for trace SimpleNotificationDestinationOp operations
11100 type SimpleNotificationDestinationTracer struct {
11101 Internal iaas.SimpleNotificationDestinationAPI
11102 }
11103
11104 // NewSimpleNotificationDestinationTracer creates new SimpleNotificationDestinationTracer instance
11105 func NewSimpleNotificationDestinationTracer(in iaas.SimpleNotificationDestinationAPI) iaas.SimpleNotificationDestinationAPI {
11106 return &SimpleNotificationDestinationTracer{
11107 Internal: in,
11108 }
11109 }
11110
11111 // Find is API call with trace log
11112 func (t *SimpleNotificationDestinationTracer) Find(ctx context.Context, conditions *iaas.FindCondition) (*iaas.SimpleNotificationDestinationFindResult, error) {
11113 log.Println("[TRACE] SimpleNotificationDestinationAPI.Find start")
11114 targetArguments := struct {
11115 Argconditions *iaas.FindCondition `json:"conditions"`
11116 }{
11117 Argconditions: conditions,
11118 }
11119 if d, err := json.Marshal(targetArguments); err == nil {
11120 log.Printf("[TRACE] \targs: %s\n", string(d))
11121 }
11122
11123 defer func() {
11124 log.Println("[TRACE] SimpleNotificationDestinationAPI.Find end")
11125 }()
11126
11127 result, err := t.Internal.Find(ctx, conditions)
11128 targetResults := struct {
11129 Result *iaas.SimpleNotificationDestinationFindResult
11130 Error error
11131 }{
11132 Result: result,
11133 Error: err,
11134 }
11135 if d, err := json.Marshal(targetResults); err == nil {
11136 log.Printf("[TRACE] \tresults: %s\n", string(d))
11137 }
11138
11139 return result, err
11140 }
11141
11142 // Create is API call with trace log
11143 func (t *SimpleNotificationDestinationTracer) Create(ctx context.Context, param *iaas.SimpleNotificationDestinationCreateRequest) (*iaas.SimpleNotificationDestination, error) {
11144 log.Println("[TRACE] SimpleNotificationDestinationAPI.Create start")
11145 targetArguments := struct {
11146 Argparam *iaas.SimpleNotificationDestinationCreateRequest `json:"param"`
11147 }{
11148 Argparam: param,
11149 }
11150 if d, err := json.Marshal(targetArguments); err == nil {
11151 log.Printf("[TRACE] \targs: %s\n", string(d))
11152 }
11153
11154 defer func() {
11155 log.Println("[TRACE] SimpleNotificationDestinationAPI.Create end")
11156 }()
11157
11158 resultSimpleNotificationDestination, err := t.Internal.Create(ctx, param)
11159 targetResults := struct {
11160 SimpleNotificationDestination *iaas.SimpleNotificationDestination
11161 Error error
11162 }{
11163 SimpleNotificationDestination: resultSimpleNotificationDestination,
11164 Error: err,
11165 }
11166 if d, err := json.Marshal(targetResults); err == nil {
11167 log.Printf("[TRACE] \tresults: %s\n", string(d))
11168 }
11169
11170 return resultSimpleNotificationDestination, err
11171 }
11172
11173 // Read is API call with trace log
11174 func (t *SimpleNotificationDestinationTracer) Read(ctx context.Context, id types.ID) (*iaas.SimpleNotificationDestination, error) {
11175 log.Println("[TRACE] SimpleNotificationDestinationAPI.Read start")
11176 targetArguments := struct {
11177 Argid types.ID `json:"id"`
11178 }{
11179 Argid: id,
11180 }
11181 if d, err := json.Marshal(targetArguments); err == nil {
11182 log.Printf("[TRACE] \targs: %s\n", string(d))
11183 }
11184
11185 defer func() {
11186 log.Println("[TRACE] SimpleNotificationDestinationAPI.Read end")
11187 }()
11188
11189 resultSimpleNotificationDestination, err := t.Internal.Read(ctx, id)
11190 targetResults := struct {
11191 SimpleNotificationDestination *iaas.SimpleNotificationDestination
11192 Error error
11193 }{
11194 SimpleNotificationDestination: resultSimpleNotificationDestination,
11195 Error: err,
11196 }
11197 if d, err := json.Marshal(targetResults); err == nil {
11198 log.Printf("[TRACE] \tresults: %s\n", string(d))
11199 }
11200
11201 return resultSimpleNotificationDestination, err
11202 }
11203
11204 // Update is API call with trace log
11205 func (t *SimpleNotificationDestinationTracer) Update(ctx context.Context, id types.ID, param *iaas.SimpleNotificationDestinationUpdateRequest) (*iaas.SimpleNotificationDestination, error) {
11206 log.Println("[TRACE] SimpleNotificationDestinationAPI.Update start")
11207 targetArguments := struct {
11208 Argid types.ID `json:"id"`
11209 Argparam *iaas.SimpleNotificationDestinationUpdateRequest `json:"param"`
11210 }{
11211 Argid: id,
11212 Argparam: param,
11213 }
11214 if d, err := json.Marshal(targetArguments); err == nil {
11215 log.Printf("[TRACE] \targs: %s\n", string(d))
11216 }
11217
11218 defer func() {
11219 log.Println("[TRACE] SimpleNotificationDestinationAPI.Update end")
11220 }()
11221
11222 resultSimpleNotificationDestination, err := t.Internal.Update(ctx, id, param)
11223 targetResults := struct {
11224 SimpleNotificationDestination *iaas.SimpleNotificationDestination
11225 Error error
11226 }{
11227 SimpleNotificationDestination: resultSimpleNotificationDestination,
11228 Error: err,
11229 }
11230 if d, err := json.Marshal(targetResults); err == nil {
11231 log.Printf("[TRACE] \tresults: %s\n", string(d))
11232 }
11233
11234 return resultSimpleNotificationDestination, err
11235 }
11236
11237 // UpdateSettings is API call with trace log
11238 func (t *SimpleNotificationDestinationTracer) UpdateSettings(ctx context.Context, id types.ID, param *iaas.SimpleNotificationDestinationUpdateSettingsRequest) (*iaas.SimpleNotificationDestination, error) {
11239 log.Println("[TRACE] SimpleNotificationDestinationAPI.UpdateSettings start")
11240 targetArguments := struct {
11241 Argid types.ID `json:"id"`
11242 Argparam *iaas.SimpleNotificationDestinationUpdateSettingsRequest `json:"param"`
11243 }{
11244 Argid: id,
11245 Argparam: param,
11246 }
11247 if d, err := json.Marshal(targetArguments); err == nil {
11248 log.Printf("[TRACE] \targs: %s\n", string(d))
11249 }
11250
11251 defer func() {
11252 log.Println("[TRACE] SimpleNotificationDestinationAPI.UpdateSettings end")
11253 }()
11254
11255 resultSimpleNotificationDestination, err := t.Internal.UpdateSettings(ctx, id, param)
11256 targetResults := struct {
11257 SimpleNotificationDestination *iaas.SimpleNotificationDestination
11258 Error error
11259 }{
11260 SimpleNotificationDestination: resultSimpleNotificationDestination,
11261 Error: err,
11262 }
11263 if d, err := json.Marshal(targetResults); err == nil {
11264 log.Printf("[TRACE] \tresults: %s\n", string(d))
11265 }
11266
11267 return resultSimpleNotificationDestination, err
11268 }
11269
11270 // Delete is API call with trace log
11271 func (t *SimpleNotificationDestinationTracer) Delete(ctx context.Context, id types.ID) error {
11272 log.Println("[TRACE] SimpleNotificationDestinationAPI.Delete start")
11273 targetArguments := struct {
11274 Argid types.ID `json:"id"`
11275 }{
11276 Argid: id,
11277 }
11278 if d, err := json.Marshal(targetArguments); err == nil {
11279 log.Printf("[TRACE] \targs: %s\n", string(d))
11280 }
11281
11282 defer func() {
11283 log.Println("[TRACE] SimpleNotificationDestinationAPI.Delete end")
11284 }()
11285
11286 err := t.Internal.Delete(ctx, id)
11287 targetResults := struct {
11288 Error error
11289 }{
11290 Error: err,
11291 }
11292 if d, err := json.Marshal(targetResults); err == nil {
11293 log.Printf("[TRACE] \tresults: %s\n", string(d))
11294 }
11295
11296 return err
11297 }
11298
11299 // Status is API call with trace log
11300 func (t *SimpleNotificationDestinationTracer) Status(ctx context.Context, id types.ID) (*iaas.SimpleNotificationDestinationStatus, error) {
11301 log.Println("[TRACE] SimpleNotificationDestinationAPI.Status start")
11302 targetArguments := struct {
11303 Argid types.ID `json:"id"`
11304 }{
11305 Argid: id,
11306 }
11307 if d, err := json.Marshal(targetArguments); err == nil {
11308 log.Printf("[TRACE] \targs: %s\n", string(d))
11309 }
11310
11311 defer func() {
11312 log.Println("[TRACE] SimpleNotificationDestinationAPI.Status end")
11313 }()
11314
11315 resultSimpleNotificationDestinationStatus, err := t.Internal.Status(ctx, id)
11316 targetResults := struct {
11317 SimpleNotificationDestinationStatus *iaas.SimpleNotificationDestinationStatus
11318 Error error
11319 }{
11320 SimpleNotificationDestinationStatus: resultSimpleNotificationDestinationStatus,
11321 Error: err,
11322 }
11323 if d, err := json.Marshal(targetResults); err == nil {
11324 log.Printf("[TRACE] \tresults: %s\n", string(d))
11325 }
11326
11327 return resultSimpleNotificationDestinationStatus, err
11328 }
11329
11330 /*************************************************
11331 * SimpleNotificationGroupTracer
11332 *************************************************/
11333
11334 // SimpleNotificationGroupTracer is for trace SimpleNotificationGroupOp operations
11335 type SimpleNotificationGroupTracer struct {
11336 Internal iaas.SimpleNotificationGroupAPI
11337 }
11338
11339 // NewSimpleNotificationGroupTracer creates new SimpleNotificationGroupTracer instance
11340 func NewSimpleNotificationGroupTracer(in iaas.SimpleNotificationGroupAPI) iaas.SimpleNotificationGroupAPI {
11341 return &SimpleNotificationGroupTracer{
11342 Internal: in,
11343 }
11344 }
11345
11346 // Find is API call with trace log
11347 func (t *SimpleNotificationGroupTracer) Find(ctx context.Context, conditions *iaas.FindCondition) (*iaas.SimpleNotificationGroupFindResult, error) {
11348 log.Println("[TRACE] SimpleNotificationGroupAPI.Find start")
11349 targetArguments := struct {
11350 Argconditions *iaas.FindCondition `json:"conditions"`
11351 }{
11352 Argconditions: conditions,
11353 }
11354 if d, err := json.Marshal(targetArguments); err == nil {
11355 log.Printf("[TRACE] \targs: %s\n", string(d))
11356 }
11357
11358 defer func() {
11359 log.Println("[TRACE] SimpleNotificationGroupAPI.Find end")
11360 }()
11361
11362 result, err := t.Internal.Find(ctx, conditions)
11363 targetResults := struct {
11364 Result *iaas.SimpleNotificationGroupFindResult
11365 Error error
11366 }{
11367 Result: result,
11368 Error: err,
11369 }
11370 if d, err := json.Marshal(targetResults); err == nil {
11371 log.Printf("[TRACE] \tresults: %s\n", string(d))
11372 }
11373
11374 return result, err
11375 }
11376
11377 // Create is API call with trace log
11378 func (t *SimpleNotificationGroupTracer) Create(ctx context.Context, param *iaas.SimpleNotificationGroupCreateRequest) (*iaas.SimpleNotificationGroup, error) {
11379 log.Println("[TRACE] SimpleNotificationGroupAPI.Create start")
11380 targetArguments := struct {
11381 Argparam *iaas.SimpleNotificationGroupCreateRequest `json:"param"`
11382 }{
11383 Argparam: param,
11384 }
11385 if d, err := json.Marshal(targetArguments); err == nil {
11386 log.Printf("[TRACE] \targs: %s\n", string(d))
11387 }
11388
11389 defer func() {
11390 log.Println("[TRACE] SimpleNotificationGroupAPI.Create end")
11391 }()
11392
11393 resultSimpleNotificationGroup, err := t.Internal.Create(ctx, param)
11394 targetResults := struct {
11395 SimpleNotificationGroup *iaas.SimpleNotificationGroup
11396 Error error
11397 }{
11398 SimpleNotificationGroup: resultSimpleNotificationGroup,
11399 Error: err,
11400 }
11401 if d, err := json.Marshal(targetResults); err == nil {
11402 log.Printf("[TRACE] \tresults: %s\n", string(d))
11403 }
11404
11405 return resultSimpleNotificationGroup, err
11406 }
11407
11408 // Read is API call with trace log
11409 func (t *SimpleNotificationGroupTracer) Read(ctx context.Context, id types.ID) (*iaas.SimpleNotificationGroup, error) {
11410 log.Println("[TRACE] SimpleNotificationGroupAPI.Read start")
11411 targetArguments := struct {
11412 Argid types.ID `json:"id"`
11413 }{
11414 Argid: id,
11415 }
11416 if d, err := json.Marshal(targetArguments); err == nil {
11417 log.Printf("[TRACE] \targs: %s\n", string(d))
11418 }
11419
11420 defer func() {
11421 log.Println("[TRACE] SimpleNotificationGroupAPI.Read end")
11422 }()
11423
11424 resultSimpleNotificationGroup, err := t.Internal.Read(ctx, id)
11425 targetResults := struct {
11426 SimpleNotificationGroup *iaas.SimpleNotificationGroup
11427 Error error
11428 }{
11429 SimpleNotificationGroup: resultSimpleNotificationGroup,
11430 Error: err,
11431 }
11432 if d, err := json.Marshal(targetResults); err == nil {
11433 log.Printf("[TRACE] \tresults: %s\n", string(d))
11434 }
11435
11436 return resultSimpleNotificationGroup, err
11437 }
11438
11439 // Update is API call with trace log
11440 func (t *SimpleNotificationGroupTracer) Update(ctx context.Context, id types.ID, param *iaas.SimpleNotificationGroupUpdateRequest) (*iaas.SimpleNotificationGroup, error) {
11441 log.Println("[TRACE] SimpleNotificationGroupAPI.Update start")
11442 targetArguments := struct {
11443 Argid types.ID `json:"id"`
11444 Argparam *iaas.SimpleNotificationGroupUpdateRequest `json:"param"`
11445 }{
11446 Argid: id,
11447 Argparam: param,
11448 }
11449 if d, err := json.Marshal(targetArguments); err == nil {
11450 log.Printf("[TRACE] \targs: %s\n", string(d))
11451 }
11452
11453 defer func() {
11454 log.Println("[TRACE] SimpleNotificationGroupAPI.Update end")
11455 }()
11456
11457 resultSimpleNotificationGroup, err := t.Internal.Update(ctx, id, param)
11458 targetResults := struct {
11459 SimpleNotificationGroup *iaas.SimpleNotificationGroup
11460 Error error
11461 }{
11462 SimpleNotificationGroup: resultSimpleNotificationGroup,
11463 Error: err,
11464 }
11465 if d, err := json.Marshal(targetResults); err == nil {
11466 log.Printf("[TRACE] \tresults: %s\n", string(d))
11467 }
11468
11469 return resultSimpleNotificationGroup, err
11470 }
11471
11472 // UpdateSettings is API call with trace log
11473 func (t *SimpleNotificationGroupTracer) UpdateSettings(ctx context.Context, id types.ID, param *iaas.SimpleNotificationGroupUpdateSettingsRequest) (*iaas.SimpleNotificationGroup, error) {
11474 log.Println("[TRACE] SimpleNotificationGroupAPI.UpdateSettings start")
11475 targetArguments := struct {
11476 Argid types.ID `json:"id"`
11477 Argparam *iaas.SimpleNotificationGroupUpdateSettingsRequest `json:"param"`
11478 }{
11479 Argid: id,
11480 Argparam: param,
11481 }
11482 if d, err := json.Marshal(targetArguments); err == nil {
11483 log.Printf("[TRACE] \targs: %s\n", string(d))
11484 }
11485
11486 defer func() {
11487 log.Println("[TRACE] SimpleNotificationGroupAPI.UpdateSettings end")
11488 }()
11489
11490 resultSimpleNotificationGroup, err := t.Internal.UpdateSettings(ctx, id, param)
11491 targetResults := struct {
11492 SimpleNotificationGroup *iaas.SimpleNotificationGroup
11493 Error error
11494 }{
11495 SimpleNotificationGroup: resultSimpleNotificationGroup,
11496 Error: err,
11497 }
11498 if d, err := json.Marshal(targetResults); err == nil {
11499 log.Printf("[TRACE] \tresults: %s\n", string(d))
11500 }
11501
11502 return resultSimpleNotificationGroup, err
11503 }
11504
11505 // Delete is API call with trace log
11506 func (t *SimpleNotificationGroupTracer) Delete(ctx context.Context, id types.ID) error {
11507 log.Println("[TRACE] SimpleNotificationGroupAPI.Delete start")
11508 targetArguments := struct {
11509 Argid types.ID `json:"id"`
11510 }{
11511 Argid: id,
11512 }
11513 if d, err := json.Marshal(targetArguments); err == nil {
11514 log.Printf("[TRACE] \targs: %s\n", string(d))
11515 }
11516
11517 defer func() {
11518 log.Println("[TRACE] SimpleNotificationGroupAPI.Delete end")
11519 }()
11520
11521 err := t.Internal.Delete(ctx, id)
11522 targetResults := struct {
11523 Error error
11524 }{
11525 Error: err,
11526 }
11527 if d, err := json.Marshal(targetResults); err == nil {
11528 log.Printf("[TRACE] \tresults: %s\n", string(d))
11529 }
11530
11531 return err
11532 }
11533
11534 // PostMessage is API call with trace log
11535 func (t *SimpleNotificationGroupTracer) PostMessage(ctx context.Context, id types.ID, message string) error {
11536 log.Println("[TRACE] SimpleNotificationGroupAPI.PostMessage start")
11537 targetArguments := struct {
11538 Argid types.ID `json:"id"`
11539 Argmessage string `json:"message"`
11540 }{
11541 Argid: id,
11542 Argmessage: message,
11543 }
11544 if d, err := json.Marshal(targetArguments); err == nil {
11545 log.Printf("[TRACE] \targs: %s\n", string(d))
11546 }
11547
11548 defer func() {
11549 log.Println("[TRACE] SimpleNotificationGroupAPI.PostMessage end")
11550 }()
11551
11552 err := t.Internal.PostMessage(ctx, id, message)
11553 targetResults := struct {
11554 Error error
11555 }{
11556 Error: err,
11557 }
11558 if d, err := json.Marshal(targetResults); err == nil {
11559 log.Printf("[TRACE] \tresults: %s\n", string(d))
11560 }
11561
11562 return err
11563 }
11564
11565 // History is API call with trace log
11566 func (t *SimpleNotificationGroupTracer) History(ctx context.Context) (*iaas.SimpleNotificationHistories, error) {
11567 log.Println("[TRACE] SimpleNotificationGroupAPI.History start")
11568 targetArguments := struct {
11569 }{}
11570 if d, err := json.Marshal(targetArguments); err == nil {
11571 log.Printf("[TRACE] \targs: %s\n", string(d))
11572 }
11573
11574 defer func() {
11575 log.Println("[TRACE] SimpleNotificationGroupAPI.History end")
11576 }()
11577
11578 resultSimpleNotificationHistories, err := t.Internal.History(ctx)
11579 targetResults := struct {
11580 SimpleNotificationHistories *iaas.SimpleNotificationHistories
11581 Error error
11582 }{
11583 SimpleNotificationHistories: resultSimpleNotificationHistories,
11584 Error: err,
11585 }
11586 if d, err := json.Marshal(targetResults); err == nil {
11587 log.Printf("[TRACE] \tresults: %s\n", string(d))
11588 }
11589
11590 return resultSimpleNotificationHistories, err
11591 }
11592
11593 /*************************************************
11594 * SSHKeyTracer
11595 *************************************************/
11596
11597 // SSHKeyTracer is for trace SSHKeyOp operations
11598 type SSHKeyTracer struct {
11599 Internal iaas.SSHKeyAPI
11600 }
11601
11602 // NewSSHKeyTracer creates new SSHKeyTracer instance
11603 func NewSSHKeyTracer(in iaas.SSHKeyAPI) iaas.SSHKeyAPI {
11604 return &SSHKeyTracer{
11605 Internal: in,
11606 }
11607 }
11608
11609 // Find is API call with trace log
11610 func (t *SSHKeyTracer) Find(ctx context.Context, conditions *iaas.FindCondition) (*iaas.SSHKeyFindResult, error) {
11611 log.Println("[TRACE] SSHKeyAPI.Find start")
11612 targetArguments := struct {
11613 Argconditions *iaas.FindCondition `json:"conditions"`
11614 }{
11615 Argconditions: conditions,
11616 }
11617 if d, err := json.Marshal(targetArguments); err == nil {
11618 log.Printf("[TRACE] \targs: %s\n", string(d))
11619 }
11620
11621 defer func() {
11622 log.Println("[TRACE] SSHKeyAPI.Find end")
11623 }()
11624
11625 result, err := t.Internal.Find(ctx, conditions)
11626 targetResults := struct {
11627 Result *iaas.SSHKeyFindResult
11628 Error error
11629 }{
11630 Result: result,
11631 Error: err,
11632 }
11633 if d, err := json.Marshal(targetResults); err == nil {
11634 log.Printf("[TRACE] \tresults: %s\n", string(d))
11635 }
11636
11637 return result, err
11638 }
11639
11640 // Create is API call with trace log
11641 func (t *SSHKeyTracer) Create(ctx context.Context, param *iaas.SSHKeyCreateRequest) (*iaas.SSHKey, error) {
11642 log.Println("[TRACE] SSHKeyAPI.Create start")
11643 targetArguments := struct {
11644 Argparam *iaas.SSHKeyCreateRequest `json:"param"`
11645 }{
11646 Argparam: param,
11647 }
11648 if d, err := json.Marshal(targetArguments); err == nil {
11649 log.Printf("[TRACE] \targs: %s\n", string(d))
11650 }
11651
11652 defer func() {
11653 log.Println("[TRACE] SSHKeyAPI.Create end")
11654 }()
11655
11656 resultSSHKey, err := t.Internal.Create(ctx, param)
11657 targetResults := struct {
11658 SSHKey *iaas.SSHKey
11659 Error error
11660 }{
11661 SSHKey: resultSSHKey,
11662 Error: err,
11663 }
11664 if d, err := json.Marshal(targetResults); err == nil {
11665 log.Printf("[TRACE] \tresults: %s\n", string(d))
11666 }
11667
11668 return resultSSHKey, err
11669 }
11670
11671 // Read is API call with trace log
11672 func (t *SSHKeyTracer) Read(ctx context.Context, id types.ID) (*iaas.SSHKey, error) {
11673 log.Println("[TRACE] SSHKeyAPI.Read start")
11674 targetArguments := struct {
11675 Argid types.ID `json:"id"`
11676 }{
11677 Argid: id,
11678 }
11679 if d, err := json.Marshal(targetArguments); err == nil {
11680 log.Printf("[TRACE] \targs: %s\n", string(d))
11681 }
11682
11683 defer func() {
11684 log.Println("[TRACE] SSHKeyAPI.Read end")
11685 }()
11686
11687 resultSSHKey, err := t.Internal.Read(ctx, id)
11688 targetResults := struct {
11689 SSHKey *iaas.SSHKey
11690 Error error
11691 }{
11692 SSHKey: resultSSHKey,
11693 Error: err,
11694 }
11695 if d, err := json.Marshal(targetResults); err == nil {
11696 log.Printf("[TRACE] \tresults: %s\n", string(d))
11697 }
11698
11699 return resultSSHKey, err
11700 }
11701
11702 // Update is API call with trace log
11703 func (t *SSHKeyTracer) Update(ctx context.Context, id types.ID, param *iaas.SSHKeyUpdateRequest) (*iaas.SSHKey, error) {
11704 log.Println("[TRACE] SSHKeyAPI.Update start")
11705 targetArguments := struct {
11706 Argid types.ID `json:"id"`
11707 Argparam *iaas.SSHKeyUpdateRequest `json:"param"`
11708 }{
11709 Argid: id,
11710 Argparam: param,
11711 }
11712 if d, err := json.Marshal(targetArguments); err == nil {
11713 log.Printf("[TRACE] \targs: %s\n", string(d))
11714 }
11715
11716 defer func() {
11717 log.Println("[TRACE] SSHKeyAPI.Update end")
11718 }()
11719
11720 resultSSHKey, err := t.Internal.Update(ctx, id, param)
11721 targetResults := struct {
11722 SSHKey *iaas.SSHKey
11723 Error error
11724 }{
11725 SSHKey: resultSSHKey,
11726 Error: err,
11727 }
11728 if d, err := json.Marshal(targetResults); err == nil {
11729 log.Printf("[TRACE] \tresults: %s\n", string(d))
11730 }
11731
11732 return resultSSHKey, err
11733 }
11734
11735 // Delete is API call with trace log
11736 func (t *SSHKeyTracer) Delete(ctx context.Context, id types.ID) error {
11737 log.Println("[TRACE] SSHKeyAPI.Delete start")
11738 targetArguments := struct {
11739 Argid types.ID `json:"id"`
11740 }{
11741 Argid: id,
11742 }
11743 if d, err := json.Marshal(targetArguments); err == nil {
11744 log.Printf("[TRACE] \targs: %s\n", string(d))
11745 }
11746
11747 defer func() {
11748 log.Println("[TRACE] SSHKeyAPI.Delete end")
11749 }()
11750
11751 err := t.Internal.Delete(ctx, id)
11752 targetResults := struct {
11753 Error error
11754 }{
11755 Error: err,
11756 }
11757 if d, err := json.Marshal(targetResults); err == nil {
11758 log.Printf("[TRACE] \tresults: %s\n", string(d))
11759 }
11760
11761 return err
11762 }
11763
11764 /*************************************************
11765 * SubnetTracer
11766 *************************************************/
11767
11768 // SubnetTracer is for trace SubnetOp operations
11769 type SubnetTracer struct {
11770 Internal iaas.SubnetAPI
11771 }
11772
11773 // NewSubnetTracer creates new SubnetTracer instance
11774 func NewSubnetTracer(in iaas.SubnetAPI) iaas.SubnetAPI {
11775 return &SubnetTracer{
11776 Internal: in,
11777 }
11778 }
11779
11780 // Find is API call with trace log
11781 func (t *SubnetTracer) Find(ctx context.Context, zone string, conditions *iaas.FindCondition) (*iaas.SubnetFindResult, error) {
11782 log.Println("[TRACE] SubnetAPI.Find start")
11783 targetArguments := struct {
11784 Argzone string
11785 Argconditions *iaas.FindCondition `json:"conditions"`
11786 }{
11787 Argzone: zone,
11788 Argconditions: conditions,
11789 }
11790 if d, err := json.Marshal(targetArguments); err == nil {
11791 log.Printf("[TRACE] \targs: %s\n", string(d))
11792 }
11793
11794 defer func() {
11795 log.Println("[TRACE] SubnetAPI.Find end")
11796 }()
11797
11798 result, err := t.Internal.Find(ctx, zone, conditions)
11799 targetResults := struct {
11800 Result *iaas.SubnetFindResult
11801 Error error
11802 }{
11803 Result: result,
11804 Error: err,
11805 }
11806 if d, err := json.Marshal(targetResults); err == nil {
11807 log.Printf("[TRACE] \tresults: %s\n", string(d))
11808 }
11809
11810 return result, err
11811 }
11812
11813 // Read is API call with trace log
11814 func (t *SubnetTracer) Read(ctx context.Context, zone string, id types.ID) (*iaas.Subnet, error) {
11815 log.Println("[TRACE] SubnetAPI.Read start")
11816 targetArguments := struct {
11817 Argzone string
11818 Argid types.ID `json:"id"`
11819 }{
11820 Argzone: zone,
11821 Argid: id,
11822 }
11823 if d, err := json.Marshal(targetArguments); err == nil {
11824 log.Printf("[TRACE] \targs: %s\n", string(d))
11825 }
11826
11827 defer func() {
11828 log.Println("[TRACE] SubnetAPI.Read end")
11829 }()
11830
11831 resultSubnet, err := t.Internal.Read(ctx, zone, id)
11832 targetResults := struct {
11833 Subnet *iaas.Subnet
11834 Error error
11835 }{
11836 Subnet: resultSubnet,
11837 Error: err,
11838 }
11839 if d, err := json.Marshal(targetResults); err == nil {
11840 log.Printf("[TRACE] \tresults: %s\n", string(d))
11841 }
11842
11843 return resultSubnet, err
11844 }
11845
11846 /*************************************************
11847 * SwitchTracer
11848 *************************************************/
11849
11850 // SwitchTracer is for trace SwitchOp operations
11851 type SwitchTracer struct {
11852 Internal iaas.SwitchAPI
11853 }
11854
11855 // NewSwitchTracer creates new SwitchTracer instance
11856 func NewSwitchTracer(in iaas.SwitchAPI) iaas.SwitchAPI {
11857 return &SwitchTracer{
11858 Internal: in,
11859 }
11860 }
11861
11862 // Find is API call with trace log
11863 func (t *SwitchTracer) Find(ctx context.Context, zone string, conditions *iaas.FindCondition) (*iaas.SwitchFindResult, error) {
11864 log.Println("[TRACE] SwitchAPI.Find start")
11865 targetArguments := struct {
11866 Argzone string
11867 Argconditions *iaas.FindCondition `json:"conditions"`
11868 }{
11869 Argzone: zone,
11870 Argconditions: conditions,
11871 }
11872 if d, err := json.Marshal(targetArguments); err == nil {
11873 log.Printf("[TRACE] \targs: %s\n", string(d))
11874 }
11875
11876 defer func() {
11877 log.Println("[TRACE] SwitchAPI.Find end")
11878 }()
11879
11880 result, err := t.Internal.Find(ctx, zone, conditions)
11881 targetResults := struct {
11882 Result *iaas.SwitchFindResult
11883 Error error
11884 }{
11885 Result: result,
11886 Error: err,
11887 }
11888 if d, err := json.Marshal(targetResults); err == nil {
11889 log.Printf("[TRACE] \tresults: %s\n", string(d))
11890 }
11891
11892 return result, err
11893 }
11894
11895 // Create is API call with trace log
11896 func (t *SwitchTracer) Create(ctx context.Context, zone string, param *iaas.SwitchCreateRequest) (*iaas.Switch, error) {
11897 log.Println("[TRACE] SwitchAPI.Create start")
11898 targetArguments := struct {
11899 Argzone string
11900 Argparam *iaas.SwitchCreateRequest `json:"param"`
11901 }{
11902 Argzone: zone,
11903 Argparam: param,
11904 }
11905 if d, err := json.Marshal(targetArguments); err == nil {
11906 log.Printf("[TRACE] \targs: %s\n", string(d))
11907 }
11908
11909 defer func() {
11910 log.Println("[TRACE] SwitchAPI.Create end")
11911 }()
11912
11913 resultSwitch, err := t.Internal.Create(ctx, zone, param)
11914 targetResults := struct {
11915 Switch *iaas.Switch
11916 Error error
11917 }{
11918 Switch: resultSwitch,
11919 Error: err,
11920 }
11921 if d, err := json.Marshal(targetResults); err == nil {
11922 log.Printf("[TRACE] \tresults: %s\n", string(d))
11923 }
11924
11925 return resultSwitch, err
11926 }
11927
11928 // Read is API call with trace log
11929 func (t *SwitchTracer) Read(ctx context.Context, zone string, id types.ID) (*iaas.Switch, error) {
11930 log.Println("[TRACE] SwitchAPI.Read start")
11931 targetArguments := struct {
11932 Argzone string
11933 Argid types.ID `json:"id"`
11934 }{
11935 Argzone: zone,
11936 Argid: id,
11937 }
11938 if d, err := json.Marshal(targetArguments); err == nil {
11939 log.Printf("[TRACE] \targs: %s\n", string(d))
11940 }
11941
11942 defer func() {
11943 log.Println("[TRACE] SwitchAPI.Read end")
11944 }()
11945
11946 resultSwitch, err := t.Internal.Read(ctx, zone, id)
11947 targetResults := struct {
11948 Switch *iaas.Switch
11949 Error error
11950 }{
11951 Switch: resultSwitch,
11952 Error: err,
11953 }
11954 if d, err := json.Marshal(targetResults); err == nil {
11955 log.Printf("[TRACE] \tresults: %s\n", string(d))
11956 }
11957
11958 return resultSwitch, err
11959 }
11960
11961 // Update is API call with trace log
11962 func (t *SwitchTracer) Update(ctx context.Context, zone string, id types.ID, param *iaas.SwitchUpdateRequest) (*iaas.Switch, error) {
11963 log.Println("[TRACE] SwitchAPI.Update start")
11964 targetArguments := struct {
11965 Argzone string
11966 Argid types.ID `json:"id"`
11967 Argparam *iaas.SwitchUpdateRequest `json:"param"`
11968 }{
11969 Argzone: zone,
11970 Argid: id,
11971 Argparam: param,
11972 }
11973 if d, err := json.Marshal(targetArguments); err == nil {
11974 log.Printf("[TRACE] \targs: %s\n", string(d))
11975 }
11976
11977 defer func() {
11978 log.Println("[TRACE] SwitchAPI.Update end")
11979 }()
11980
11981 resultSwitch, err := t.Internal.Update(ctx, zone, id, param)
11982 targetResults := struct {
11983 Switch *iaas.Switch
11984 Error error
11985 }{
11986 Switch: resultSwitch,
11987 Error: err,
11988 }
11989 if d, err := json.Marshal(targetResults); err == nil {
11990 log.Printf("[TRACE] \tresults: %s\n", string(d))
11991 }
11992
11993 return resultSwitch, err
11994 }
11995
11996 // Delete is API call with trace log
11997 func (t *SwitchTracer) Delete(ctx context.Context, zone string, id types.ID) error {
11998 log.Println("[TRACE] SwitchAPI.Delete start")
11999 targetArguments := struct {
12000 Argzone string
12001 Argid types.ID `json:"id"`
12002 }{
12003 Argzone: zone,
12004 Argid: id,
12005 }
12006 if d, err := json.Marshal(targetArguments); err == nil {
12007 log.Printf("[TRACE] \targs: %s\n", string(d))
12008 }
12009
12010 defer func() {
12011 log.Println("[TRACE] SwitchAPI.Delete end")
12012 }()
12013
12014 err := t.Internal.Delete(ctx, zone, id)
12015 targetResults := struct {
12016 Error error
12017 }{
12018 Error: err,
12019 }
12020 if d, err := json.Marshal(targetResults); err == nil {
12021 log.Printf("[TRACE] \tresults: %s\n", string(d))
12022 }
12023
12024 return err
12025 }
12026
12027 // ConnectToBridge is API call with trace log
12028 func (t *SwitchTracer) ConnectToBridge(ctx context.Context, zone string, id types.ID, bridgeID types.ID) error {
12029 log.Println("[TRACE] SwitchAPI.ConnectToBridge start")
12030 targetArguments := struct {
12031 Argzone string
12032 Argid types.ID `json:"id"`
12033 ArgbridgeID types.ID `json:"bridgeID"`
12034 }{
12035 Argzone: zone,
12036 Argid: id,
12037 ArgbridgeID: bridgeID,
12038 }
12039 if d, err := json.Marshal(targetArguments); err == nil {
12040 log.Printf("[TRACE] \targs: %s\n", string(d))
12041 }
12042
12043 defer func() {
12044 log.Println("[TRACE] SwitchAPI.ConnectToBridge end")
12045 }()
12046
12047 err := t.Internal.ConnectToBridge(ctx, zone, id, bridgeID)
12048 targetResults := struct {
12049 Error error
12050 }{
12051 Error: err,
12052 }
12053 if d, err := json.Marshal(targetResults); err == nil {
12054 log.Printf("[TRACE] \tresults: %s\n", string(d))
12055 }
12056
12057 return err
12058 }
12059
12060 // DisconnectFromBridge is API call with trace log
12061 func (t *SwitchTracer) DisconnectFromBridge(ctx context.Context, zone string, id types.ID) error {
12062 log.Println("[TRACE] SwitchAPI.DisconnectFromBridge start")
12063 targetArguments := struct {
12064 Argzone string
12065 Argid types.ID `json:"id"`
12066 }{
12067 Argzone: zone,
12068 Argid: id,
12069 }
12070 if d, err := json.Marshal(targetArguments); err == nil {
12071 log.Printf("[TRACE] \targs: %s\n", string(d))
12072 }
12073
12074 defer func() {
12075 log.Println("[TRACE] SwitchAPI.DisconnectFromBridge end")
12076 }()
12077
12078 err := t.Internal.DisconnectFromBridge(ctx, zone, id)
12079 targetResults := struct {
12080 Error error
12081 }{
12082 Error: err,
12083 }
12084 if d, err := json.Marshal(targetResults); err == nil {
12085 log.Printf("[TRACE] \tresults: %s\n", string(d))
12086 }
12087
12088 return err
12089 }
12090
12091 // GetServers is API call with trace log
12092 func (t *SwitchTracer) GetServers(ctx context.Context, zone string, id types.ID) (*iaas.SwitchGetServersResult, error) {
12093 log.Println("[TRACE] SwitchAPI.GetServers start")
12094 targetArguments := struct {
12095 Argzone string
12096 Argid types.ID `json:"id"`
12097 }{
12098 Argzone: zone,
12099 Argid: id,
12100 }
12101 if d, err := json.Marshal(targetArguments); err == nil {
12102 log.Printf("[TRACE] \targs: %s\n", string(d))
12103 }
12104
12105 defer func() {
12106 log.Println("[TRACE] SwitchAPI.GetServers end")
12107 }()
12108
12109 result, err := t.Internal.GetServers(ctx, zone, id)
12110 targetResults := struct {
12111 Result *iaas.SwitchGetServersResult
12112 Error error
12113 }{
12114 Result: result,
12115 Error: err,
12116 }
12117 if d, err := json.Marshal(targetResults); err == nil {
12118 log.Printf("[TRACE] \tresults: %s\n", string(d))
12119 }
12120
12121 return result, err
12122 }
12123
12124 /*************************************************
12125 * VPCRouterTracer
12126 *************************************************/
12127
12128 // VPCRouterTracer is for trace VPCRouterOp operations
12129 type VPCRouterTracer struct {
12130 Internal iaas.VPCRouterAPI
12131 }
12132
12133 // NewVPCRouterTracer creates new VPCRouterTracer instance
12134 func NewVPCRouterTracer(in iaas.VPCRouterAPI) iaas.VPCRouterAPI {
12135 return &VPCRouterTracer{
12136 Internal: in,
12137 }
12138 }
12139
12140 // Find is API call with trace log
12141 func (t *VPCRouterTracer) Find(ctx context.Context, zone string, conditions *iaas.FindCondition) (*iaas.VPCRouterFindResult, error) {
12142 log.Println("[TRACE] VPCRouterAPI.Find start")
12143 targetArguments := struct {
12144 Argzone string
12145 Argconditions *iaas.FindCondition `json:"conditions"`
12146 }{
12147 Argzone: zone,
12148 Argconditions: conditions,
12149 }
12150 if d, err := json.Marshal(targetArguments); err == nil {
12151 log.Printf("[TRACE] \targs: %s\n", string(d))
12152 }
12153
12154 defer func() {
12155 log.Println("[TRACE] VPCRouterAPI.Find end")
12156 }()
12157
12158 result, err := t.Internal.Find(ctx, zone, conditions)
12159 targetResults := struct {
12160 Result *iaas.VPCRouterFindResult
12161 Error error
12162 }{
12163 Result: result,
12164 Error: err,
12165 }
12166 if d, err := json.Marshal(targetResults); err == nil {
12167 log.Printf("[TRACE] \tresults: %s\n", string(d))
12168 }
12169
12170 return result, err
12171 }
12172
12173 // Create is API call with trace log
12174 func (t *VPCRouterTracer) Create(ctx context.Context, zone string, param *iaas.VPCRouterCreateRequest) (*iaas.VPCRouter, error) {
12175 log.Println("[TRACE] VPCRouterAPI.Create start")
12176 targetArguments := struct {
12177 Argzone string
12178 Argparam *iaas.VPCRouterCreateRequest `json:"param"`
12179 }{
12180 Argzone: zone,
12181 Argparam: param,
12182 }
12183 if d, err := json.Marshal(targetArguments); err == nil {
12184 log.Printf("[TRACE] \targs: %s\n", string(d))
12185 }
12186
12187 defer func() {
12188 log.Println("[TRACE] VPCRouterAPI.Create end")
12189 }()
12190
12191 resultVPCRouter, err := t.Internal.Create(ctx, zone, param)
12192 targetResults := struct {
12193 VPCRouter *iaas.VPCRouter
12194 Error error
12195 }{
12196 VPCRouter: resultVPCRouter,
12197 Error: err,
12198 }
12199 if d, err := json.Marshal(targetResults); err == nil {
12200 log.Printf("[TRACE] \tresults: %s\n", string(d))
12201 }
12202
12203 return resultVPCRouter, err
12204 }
12205
12206 // Read is API call with trace log
12207 func (t *VPCRouterTracer) Read(ctx context.Context, zone string, id types.ID) (*iaas.VPCRouter, error) {
12208 log.Println("[TRACE] VPCRouterAPI.Read start")
12209 targetArguments := struct {
12210 Argzone string
12211 Argid types.ID `json:"id"`
12212 }{
12213 Argzone: zone,
12214 Argid: id,
12215 }
12216 if d, err := json.Marshal(targetArguments); err == nil {
12217 log.Printf("[TRACE] \targs: %s\n", string(d))
12218 }
12219
12220 defer func() {
12221 log.Println("[TRACE] VPCRouterAPI.Read end")
12222 }()
12223
12224 resultVPCRouter, err := t.Internal.Read(ctx, zone, id)
12225 targetResults := struct {
12226 VPCRouter *iaas.VPCRouter
12227 Error error
12228 }{
12229 VPCRouter: resultVPCRouter,
12230 Error: err,
12231 }
12232 if d, err := json.Marshal(targetResults); err == nil {
12233 log.Printf("[TRACE] \tresults: %s\n", string(d))
12234 }
12235
12236 return resultVPCRouter, err
12237 }
12238
12239 // Update is API call with trace log
12240 func (t *VPCRouterTracer) Update(ctx context.Context, zone string, id types.ID, param *iaas.VPCRouterUpdateRequest) (*iaas.VPCRouter, error) {
12241 log.Println("[TRACE] VPCRouterAPI.Update start")
12242 targetArguments := struct {
12243 Argzone string
12244 Argid types.ID `json:"id"`
12245 Argparam *iaas.VPCRouterUpdateRequest `json:"param"`
12246 }{
12247 Argzone: zone,
12248 Argid: id,
12249 Argparam: param,
12250 }
12251 if d, err := json.Marshal(targetArguments); err == nil {
12252 log.Printf("[TRACE] \targs: %s\n", string(d))
12253 }
12254
12255 defer func() {
12256 log.Println("[TRACE] VPCRouterAPI.Update end")
12257 }()
12258
12259 resultVPCRouter, err := t.Internal.Update(ctx, zone, id, param)
12260 targetResults := struct {
12261 VPCRouter *iaas.VPCRouter
12262 Error error
12263 }{
12264 VPCRouter: resultVPCRouter,
12265 Error: err,
12266 }
12267 if d, err := json.Marshal(targetResults); err == nil {
12268 log.Printf("[TRACE] \tresults: %s\n", string(d))
12269 }
12270
12271 return resultVPCRouter, err
12272 }
12273
12274 // UpdateSettings is API call with trace log
12275 func (t *VPCRouterTracer) UpdateSettings(ctx context.Context, zone string, id types.ID, param *iaas.VPCRouterUpdateSettingsRequest) (*iaas.VPCRouter, error) {
12276 log.Println("[TRACE] VPCRouterAPI.UpdateSettings start")
12277 targetArguments := struct {
12278 Argzone string
12279 Argid types.ID `json:"id"`
12280 Argparam *iaas.VPCRouterUpdateSettingsRequest `json:"param"`
12281 }{
12282 Argzone: zone,
12283 Argid: id,
12284 Argparam: param,
12285 }
12286 if d, err := json.Marshal(targetArguments); err == nil {
12287 log.Printf("[TRACE] \targs: %s\n", string(d))
12288 }
12289
12290 defer func() {
12291 log.Println("[TRACE] VPCRouterAPI.UpdateSettings end")
12292 }()
12293
12294 resultVPCRouter, err := t.Internal.UpdateSettings(ctx, zone, id, param)
12295 targetResults := struct {
12296 VPCRouter *iaas.VPCRouter
12297 Error error
12298 }{
12299 VPCRouter: resultVPCRouter,
12300 Error: err,
12301 }
12302 if d, err := json.Marshal(targetResults); err == nil {
12303 log.Printf("[TRACE] \tresults: %s\n", string(d))
12304 }
12305
12306 return resultVPCRouter, err
12307 }
12308
12309 // Delete is API call with trace log
12310 func (t *VPCRouterTracer) Delete(ctx context.Context, zone string, id types.ID) error {
12311 log.Println("[TRACE] VPCRouterAPI.Delete start")
12312 targetArguments := struct {
12313 Argzone string
12314 Argid types.ID `json:"id"`
12315 }{
12316 Argzone: zone,
12317 Argid: id,
12318 }
12319 if d, err := json.Marshal(targetArguments); err == nil {
12320 log.Printf("[TRACE] \targs: %s\n", string(d))
12321 }
12322
12323 defer func() {
12324 log.Println("[TRACE] VPCRouterAPI.Delete end")
12325 }()
12326
12327 err := t.Internal.Delete(ctx, zone, id)
12328 targetResults := struct {
12329 Error error
12330 }{
12331 Error: err,
12332 }
12333 if d, err := json.Marshal(targetResults); err == nil {
12334 log.Printf("[TRACE] \tresults: %s\n", string(d))
12335 }
12336
12337 return err
12338 }
12339
12340 // Config is API call with trace log
12341 func (t *VPCRouterTracer) Config(ctx context.Context, zone string, id types.ID) error {
12342 log.Println("[TRACE] VPCRouterAPI.Config start")
12343 targetArguments := struct {
12344 Argzone string
12345 Argid types.ID `json:"id"`
12346 }{
12347 Argzone: zone,
12348 Argid: id,
12349 }
12350 if d, err := json.Marshal(targetArguments); err == nil {
12351 log.Printf("[TRACE] \targs: %s\n", string(d))
12352 }
12353
12354 defer func() {
12355 log.Println("[TRACE] VPCRouterAPI.Config end")
12356 }()
12357
12358 err := t.Internal.Config(ctx, zone, id)
12359 targetResults := struct {
12360 Error error
12361 }{
12362 Error: err,
12363 }
12364 if d, err := json.Marshal(targetResults); err == nil {
12365 log.Printf("[TRACE] \tresults: %s\n", string(d))
12366 }
12367
12368 return err
12369 }
12370
12371 // Boot is API call with trace log
12372 func (t *VPCRouterTracer) Boot(ctx context.Context, zone string, id types.ID) error {
12373 log.Println("[TRACE] VPCRouterAPI.Boot start")
12374 targetArguments := struct {
12375 Argzone string
12376 Argid types.ID `json:"id"`
12377 }{
12378 Argzone: zone,
12379 Argid: id,
12380 }
12381 if d, err := json.Marshal(targetArguments); err == nil {
12382 log.Printf("[TRACE] \targs: %s\n", string(d))
12383 }
12384
12385 defer func() {
12386 log.Println("[TRACE] VPCRouterAPI.Boot end")
12387 }()
12388
12389 err := t.Internal.Boot(ctx, zone, id)
12390 targetResults := struct {
12391 Error error
12392 }{
12393 Error: err,
12394 }
12395 if d, err := json.Marshal(targetResults); err == nil {
12396 log.Printf("[TRACE] \tresults: %s\n", string(d))
12397 }
12398
12399 return err
12400 }
12401
12402 // Shutdown is API call with trace log
12403 func (t *VPCRouterTracer) Shutdown(ctx context.Context, zone string, id types.ID, shutdownOption *iaas.ShutdownOption) error {
12404 log.Println("[TRACE] VPCRouterAPI.Shutdown start")
12405 targetArguments := struct {
12406 Argzone string
12407 Argid types.ID `json:"id"`
12408 ArgshutdownOption *iaas.ShutdownOption `json:"shutdownOption"`
12409 }{
12410 Argzone: zone,
12411 Argid: id,
12412 ArgshutdownOption: shutdownOption,
12413 }
12414 if d, err := json.Marshal(targetArguments); err == nil {
12415 log.Printf("[TRACE] \targs: %s\n", string(d))
12416 }
12417
12418 defer func() {
12419 log.Println("[TRACE] VPCRouterAPI.Shutdown end")
12420 }()
12421
12422 err := t.Internal.Shutdown(ctx, zone, id, shutdownOption)
12423 targetResults := struct {
12424 Error error
12425 }{
12426 Error: err,
12427 }
12428 if d, err := json.Marshal(targetResults); err == nil {
12429 log.Printf("[TRACE] \tresults: %s\n", string(d))
12430 }
12431
12432 return err
12433 }
12434
12435 // Reset is API call with trace log
12436 func (t *VPCRouterTracer) Reset(ctx context.Context, zone string, id types.ID) error {
12437 log.Println("[TRACE] VPCRouterAPI.Reset start")
12438 targetArguments := struct {
12439 Argzone string
12440 Argid types.ID `json:"id"`
12441 }{
12442 Argzone: zone,
12443 Argid: id,
12444 }
12445 if d, err := json.Marshal(targetArguments); err == nil {
12446 log.Printf("[TRACE] \targs: %s\n", string(d))
12447 }
12448
12449 defer func() {
12450 log.Println("[TRACE] VPCRouterAPI.Reset end")
12451 }()
12452
12453 err := t.Internal.Reset(ctx, zone, id)
12454 targetResults := struct {
12455 Error error
12456 }{
12457 Error: err,
12458 }
12459 if d, err := json.Marshal(targetResults); err == nil {
12460 log.Printf("[TRACE] \tresults: %s\n", string(d))
12461 }
12462
12463 return err
12464 }
12465
12466 // ConnectToSwitch is API call with trace log
12467 func (t *VPCRouterTracer) ConnectToSwitch(ctx context.Context, zone string, id types.ID, nicIndex int, switchID types.ID) error {
12468 log.Println("[TRACE] VPCRouterAPI.ConnectToSwitch start")
12469 targetArguments := struct {
12470 Argzone string
12471 Argid types.ID `json:"id"`
12472 ArgnicIndex int `json:"nicIndex"`
12473 ArgswitchID types.ID `json:"switchID"`
12474 }{
12475 Argzone: zone,
12476 Argid: id,
12477 ArgnicIndex: nicIndex,
12478 ArgswitchID: switchID,
12479 }
12480 if d, err := json.Marshal(targetArguments); err == nil {
12481 log.Printf("[TRACE] \targs: %s\n", string(d))
12482 }
12483
12484 defer func() {
12485 log.Println("[TRACE] VPCRouterAPI.ConnectToSwitch end")
12486 }()
12487
12488 err := t.Internal.ConnectToSwitch(ctx, zone, id, nicIndex, switchID)
12489 targetResults := struct {
12490 Error error
12491 }{
12492 Error: err,
12493 }
12494 if d, err := json.Marshal(targetResults); err == nil {
12495 log.Printf("[TRACE] \tresults: %s\n", string(d))
12496 }
12497
12498 return err
12499 }
12500
12501 // DisconnectFromSwitch is API call with trace log
12502 func (t *VPCRouterTracer) DisconnectFromSwitch(ctx context.Context, zone string, id types.ID, nicIndex int) error {
12503 log.Println("[TRACE] VPCRouterAPI.DisconnectFromSwitch start")
12504 targetArguments := struct {
12505 Argzone string
12506 Argid types.ID `json:"id"`
12507 ArgnicIndex int `json:"nicIndex"`
12508 }{
12509 Argzone: zone,
12510 Argid: id,
12511 ArgnicIndex: nicIndex,
12512 }
12513 if d, err := json.Marshal(targetArguments); err == nil {
12514 log.Printf("[TRACE] \targs: %s\n", string(d))
12515 }
12516
12517 defer func() {
12518 log.Println("[TRACE] VPCRouterAPI.DisconnectFromSwitch end")
12519 }()
12520
12521 err := t.Internal.DisconnectFromSwitch(ctx, zone, id, nicIndex)
12522 targetResults := struct {
12523 Error error
12524 }{
12525 Error: err,
12526 }
12527 if d, err := json.Marshal(targetResults); err == nil {
12528 log.Printf("[TRACE] \tresults: %s\n", string(d))
12529 }
12530
12531 return err
12532 }
12533
12534 // MonitorCPU is API call with trace log
12535 func (t *VPCRouterTracer) MonitorCPU(ctx context.Context, zone string, id types.ID, condition *iaas.MonitorCondition) (*iaas.CPUTimeActivity, error) {
12536 log.Println("[TRACE] VPCRouterAPI.MonitorCPU start")
12537 targetArguments := struct {
12538 Argzone string
12539 Argid types.ID `json:"id"`
12540 Argcondition *iaas.MonitorCondition `json:"condition"`
12541 }{
12542 Argzone: zone,
12543 Argid: id,
12544 Argcondition: condition,
12545 }
12546 if d, err := json.Marshal(targetArguments); err == nil {
12547 log.Printf("[TRACE] \targs: %s\n", string(d))
12548 }
12549
12550 defer func() {
12551 log.Println("[TRACE] VPCRouterAPI.MonitorCPU end")
12552 }()
12553
12554 resultCPUTimeActivity, err := t.Internal.MonitorCPU(ctx, zone, id, condition)
12555 targetResults := struct {
12556 CPUTimeActivity *iaas.CPUTimeActivity
12557 Error error
12558 }{
12559 CPUTimeActivity: resultCPUTimeActivity,
12560 Error: err,
12561 }
12562 if d, err := json.Marshal(targetResults); err == nil {
12563 log.Printf("[TRACE] \tresults: %s\n", string(d))
12564 }
12565
12566 return resultCPUTimeActivity, err
12567 }
12568
12569 // MonitorInterface is API call with trace log
12570 func (t *VPCRouterTracer) MonitorInterface(ctx context.Context, zone string, id types.ID, index int, condition *iaas.MonitorCondition) (*iaas.InterfaceActivity, error) {
12571 log.Println("[TRACE] VPCRouterAPI.MonitorInterface start")
12572 targetArguments := struct {
12573 Argzone string
12574 Argid types.ID `json:"id"`
12575 Argindex int `json:"index"`
12576 Argcondition *iaas.MonitorCondition `json:"condition"`
12577 }{
12578 Argzone: zone,
12579 Argid: id,
12580 Argindex: index,
12581 Argcondition: condition,
12582 }
12583 if d, err := json.Marshal(targetArguments); err == nil {
12584 log.Printf("[TRACE] \targs: %s\n", string(d))
12585 }
12586
12587 defer func() {
12588 log.Println("[TRACE] VPCRouterAPI.MonitorInterface end")
12589 }()
12590
12591 resultInterfaceActivity, err := t.Internal.MonitorInterface(ctx, zone, id, index, condition)
12592 targetResults := struct {
12593 InterfaceActivity *iaas.InterfaceActivity
12594 Error error
12595 }{
12596 InterfaceActivity: resultInterfaceActivity,
12597 Error: err,
12598 }
12599 if d, err := json.Marshal(targetResults); err == nil {
12600 log.Printf("[TRACE] \tresults: %s\n", string(d))
12601 }
12602
12603 return resultInterfaceActivity, err
12604 }
12605
12606 // Status is API call with trace log
12607 func (t *VPCRouterTracer) Status(ctx context.Context, zone string, id types.ID) (*iaas.VPCRouterStatus, error) {
12608 log.Println("[TRACE] VPCRouterAPI.Status start")
12609 targetArguments := struct {
12610 Argzone string
12611 Argid types.ID `json:"id"`
12612 }{
12613 Argzone: zone,
12614 Argid: id,
12615 }
12616 if d, err := json.Marshal(targetArguments); err == nil {
12617 log.Printf("[TRACE] \targs: %s\n", string(d))
12618 }
12619
12620 defer func() {
12621 log.Println("[TRACE] VPCRouterAPI.Status end")
12622 }()
12623
12624 resultVPCRouterStatus, err := t.Internal.Status(ctx, zone, id)
12625 targetResults := struct {
12626 VPCRouterStatus *iaas.VPCRouterStatus
12627 Error error
12628 }{
12629 VPCRouterStatus: resultVPCRouterStatus,
12630 Error: err,
12631 }
12632 if d, err := json.Marshal(targetResults); err == nil {
12633 log.Printf("[TRACE] \tresults: %s\n", string(d))
12634 }
12635
12636 return resultVPCRouterStatus, err
12637 }
12638
12639 // Logs is API call with trace log
12640 func (t *VPCRouterTracer) Logs(ctx context.Context, zone string, id types.ID) (*iaas.VPCRouterLog, error) {
12641 log.Println("[TRACE] VPCRouterAPI.Logs start")
12642 targetArguments := struct {
12643 Argzone string
12644 Argid types.ID `json:"id"`
12645 }{
12646 Argzone: zone,
12647 Argid: id,
12648 }
12649 if d, err := json.Marshal(targetArguments); err == nil {
12650 log.Printf("[TRACE] \targs: %s\n", string(d))
12651 }
12652
12653 defer func() {
12654 log.Println("[TRACE] VPCRouterAPI.Logs end")
12655 }()
12656
12657 resultVPCRouterLog, err := t.Internal.Logs(ctx, zone, id)
12658 targetResults := struct {
12659 VPCRouterLog *iaas.VPCRouterLog
12660 Error error
12661 }{
12662 VPCRouterLog: resultVPCRouterLog,
12663 Error: err,
12664 }
12665 if d, err := json.Marshal(targetResults); err == nil {
12666 log.Printf("[TRACE] \tresults: %s\n", string(d))
12667 }
12668
12669 return resultVPCRouterLog, err
12670 }
12671
12672 // Ping is API call with trace log
12673 func (t *VPCRouterTracer) Ping(ctx context.Context, zone string, id types.ID, destination string) (*iaas.VPCRouterPingResults, error) {
12674 log.Println("[TRACE] VPCRouterAPI.Ping start")
12675 targetArguments := struct {
12676 Argzone string
12677 Argid types.ID `json:"id"`
12678 Argdestination string `json:"destination"`
12679 }{
12680 Argzone: zone,
12681 Argid: id,
12682 Argdestination: destination,
12683 }
12684 if d, err := json.Marshal(targetArguments); err == nil {
12685 log.Printf("[TRACE] \targs: %s\n", string(d))
12686 }
12687
12688 defer func() {
12689 log.Println("[TRACE] VPCRouterAPI.Ping end")
12690 }()
12691
12692 resultVPCRouterPingResults, err := t.Internal.Ping(ctx, zone, id, destination)
12693 targetResults := struct {
12694 VPCRouterPingResults *iaas.VPCRouterPingResults
12695 Error error
12696 }{
12697 VPCRouterPingResults: resultVPCRouterPingResults,
12698 Error: err,
12699 }
12700 if d, err := json.Marshal(targetResults); err == nil {
12701 log.Printf("[TRACE] \tresults: %s\n", string(d))
12702 }
12703
12704 return resultVPCRouterPingResults, err
12705 }
12706
12707 /*************************************************
12708 * ZoneTracer
12709 *************************************************/
12710
12711 // ZoneTracer is for trace ZoneOp operations
12712 type ZoneTracer struct {
12713 Internal iaas.ZoneAPI
12714 }
12715
12716 // NewZoneTracer creates new ZoneTracer instance
12717 func NewZoneTracer(in iaas.ZoneAPI) iaas.ZoneAPI {
12718 return &ZoneTracer{
12719 Internal: in,
12720 }
12721 }
12722
12723 // Find is API call with trace log
12724 func (t *ZoneTracer) Find(ctx context.Context, conditions *iaas.FindCondition) (*iaas.ZoneFindResult, error) {
12725 log.Println("[TRACE] ZoneAPI.Find start")
12726 targetArguments := struct {
12727 Argconditions *iaas.FindCondition `json:"conditions"`
12728 }{
12729 Argconditions: conditions,
12730 }
12731 if d, err := json.Marshal(targetArguments); err == nil {
12732 log.Printf("[TRACE] \targs: %s\n", string(d))
12733 }
12734
12735 defer func() {
12736 log.Println("[TRACE] ZoneAPI.Find end")
12737 }()
12738
12739 result, err := t.Internal.Find(ctx, conditions)
12740 targetResults := struct {
12741 Result *iaas.ZoneFindResult
12742 Error error
12743 }{
12744 Result: result,
12745 Error: err,
12746 }
12747 if d, err := json.Marshal(targetResults); err == nil {
12748 log.Printf("[TRACE] \tresults: %s\n", string(d))
12749 }
12750
12751 return result, err
12752 }
12753
12754 // Read is API call with trace log
12755 func (t *ZoneTracer) Read(ctx context.Context, id types.ID) (*iaas.Zone, error) {
12756 log.Println("[TRACE] ZoneAPI.Read start")
12757 targetArguments := struct {
12758 Argid types.ID `json:"id"`
12759 }{
12760 Argid: id,
12761 }
12762 if d, err := json.Marshal(targetArguments); err == nil {
12763 log.Printf("[TRACE] \targs: %s\n", string(d))
12764 }
12765
12766 defer func() {
12767 log.Println("[TRACE] ZoneAPI.Read end")
12768 }()
12769
12770 resultZone, err := t.Internal.Read(ctx, id)
12771 targetResults := struct {
12772 Zone *iaas.Zone
12773 Error error
12774 }{
12775 Zone: resultZone,
12776 Error: err,
12777 }
12778 if d, err := json.Marshal(targetResults); err == nil {
12779 log.Printf("[TRACE] \tresults: %s\n", string(d))
12780 }
12781
12782 return resultZone, err
12783 }
12784