virtual.go raw
1 /**
2 * Copyright 2016-2024 IBM Corp.
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
5 * the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
6 *
7 * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed
8 * on an "AS IS" BASIS,WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
9 * See the License for the specific language governing permissions and limitations under the License.
10 */
11
12 // AUTOMATICALLY GENERATED CODE - DO NOT MODIFY
13
14 package services
15
16 import (
17 "fmt"
18 "strings"
19
20 "github.com/softlayer/softlayer-go/datatypes"
21 "github.com/softlayer/softlayer-go/session"
22 "github.com/softlayer/softlayer-go/sl"
23 )
24
25 // This data type presents the structure for a dedicated host. The data type contains relational properties to distinguish a dedicated host and associate an account to it.
26 type Virtual_DedicatedHost struct {
27 Session session.SLSession
28 Options sl.Options
29 }
30
31 // GetVirtualDedicatedHostService returns an instance of the Virtual_DedicatedHost SoftLayer service
32 func GetVirtualDedicatedHostService(sess session.SLSession) Virtual_DedicatedHost {
33 return Virtual_DedicatedHost{Session: sess}
34 }
35
36 func (r Virtual_DedicatedHost) Id(id int) Virtual_DedicatedHost {
37 r.Options.Id = &id
38 return r
39 }
40
41 func (r Virtual_DedicatedHost) Mask(mask string) Virtual_DedicatedHost {
42 if !strings.HasPrefix(mask, "mask[") && (strings.Contains(mask, "[") || strings.Contains(mask, ",")) {
43 mask = fmt.Sprintf("mask[%s]", mask)
44 }
45
46 r.Options.Mask = mask
47 return r
48 }
49
50 func (r Virtual_DedicatedHost) Filter(filter string) Virtual_DedicatedHost {
51 r.Options.Filter = filter
52 return r
53 }
54
55 func (r Virtual_DedicatedHost) Limit(limit int) Virtual_DedicatedHost {
56 r.Options.Limit = &limit
57 return r
58 }
59
60 func (r Virtual_DedicatedHost) Offset(offset int) Virtual_DedicatedHost {
61 r.Options.Offset = &offset
62 return r
63 }
64
65 // This method will cancel a dedicated host immediately.
66 func (r Virtual_DedicatedHost) DeleteObject() (resp bool, err error) {
67 err = r.Session.DoRequest("SoftLayer_Virtual_DedicatedHost", "deleteObject", nil, &r.Options, &resp)
68 return
69 }
70
71 // Edit a dedicated host's properties.
72 func (r Virtual_DedicatedHost) EditObject(templateObject *datatypes.Virtual_DedicatedHost) (resp bool, err error) {
73 params := []interface{}{
74 templateObject,
75 }
76 err = r.Session.DoRequest("SoftLayer_Virtual_DedicatedHost", "editObject", params, &r.Options, &resp)
77 return
78 }
79
80 // Retrieve The account that the dedicated host belongs to.
81 func (r Virtual_DedicatedHost) GetAccount() (resp datatypes.Account, err error) {
82 err = r.Session.DoRequest("SoftLayer_Virtual_DedicatedHost", "getAccount", nil, &r.Options, &resp)
83 return
84 }
85
86 // Retrieve The container that represents allocations on the dedicated host.
87 func (r Virtual_DedicatedHost) GetAllocationStatus() (resp datatypes.Container_Virtual_DedicatedHost_AllocationStatus, err error) {
88 err = r.Session.DoRequest("SoftLayer_Virtual_DedicatedHost", "getAllocationStatus", nil, &r.Options, &resp)
89 return
90 }
91
92 // This method will get the available backend routers to order a dedicated host.
93 func (r Virtual_DedicatedHost) GetAvailableRouters(dedicatedHost *datatypes.Virtual_DedicatedHost) (resp []datatypes.Hardware, err error) {
94 params := []interface{}{
95 dedicatedHost,
96 }
97 err = r.Session.DoRequest("SoftLayer_Virtual_DedicatedHost", "getAvailableRouters", params, &r.Options, &resp)
98 return
99 }
100
101 // Retrieve The backend router behind dedicated host's pool of resources.
102 func (r Virtual_DedicatedHost) GetBackendRouter() (resp datatypes.Hardware_Router_Backend, err error) {
103 err = r.Session.DoRequest("SoftLayer_Virtual_DedicatedHost", "getBackendRouter", nil, &r.Options, &resp)
104 return
105 }
106
107 // Retrieve The billing item for the dedicated host.
108 func (r Virtual_DedicatedHost) GetBillingItem() (resp datatypes.Billing_Item_Virtual_DedicatedHost, err error) {
109 err = r.Session.DoRequest("SoftLayer_Virtual_DedicatedHost", "getBillingItem", nil, &r.Options, &resp)
110 return
111 }
112
113 // Retrieve The datacenter that the dedicated host resides in.
114 func (r Virtual_DedicatedHost) GetDatacenter() (resp datatypes.Location, err error) {
115 err = r.Session.DoRequest("SoftLayer_Virtual_DedicatedHost", "getDatacenter", nil, &r.Options, &resp)
116 return
117 }
118
119 // Retrieve The guests associated with the dedicated host.
120 func (r Virtual_DedicatedHost) GetGuests() (resp []datatypes.Virtual_Guest, err error) {
121 err = r.Session.DoRequest("SoftLayer_Virtual_DedicatedHost", "getGuests", nil, &r.Options, &resp)
122 return
123 }
124
125 // Retrieve
126 func (r Virtual_DedicatedHost) GetInternalTagReferences() (resp []datatypes.Tag_Reference, err error) {
127 err = r.Session.DoRequest("SoftLayer_Virtual_DedicatedHost", "getInternalTagReferences", nil, &r.Options, &resp)
128 return
129 }
130
131 // no documentation yet
132 func (r Virtual_DedicatedHost) GetObject() (resp datatypes.Virtual_DedicatedHost, err error) {
133 err = r.Session.DoRequest("SoftLayer_Virtual_DedicatedHost", "getObject", nil, &r.Options, &resp)
134 return
135 }
136
137 // Retrieve The container that represents PCI device allocations on the dedicated host.
138 func (r Virtual_DedicatedHost) GetPciDeviceAllocationStatus() (resp datatypes.Container_Virtual_DedicatedHost_Pci_Device_AllocationStatus, err error) {
139 err = r.Session.DoRequest("SoftLayer_Virtual_DedicatedHost", "getPciDeviceAllocationStatus", nil, &r.Options, &resp)
140 return
141 }
142
143 // Retrieve A collection of SoftLayer_Virtual_Host_PciDevice objects on the host.
144 func (r Virtual_DedicatedHost) GetPciDevices() (resp []datatypes.Virtual_Host_PciDevice, err error) {
145 err = r.Session.DoRequest("SoftLayer_Virtual_DedicatedHost", "getPciDevices", nil, &r.Options, &resp)
146 return
147 }
148
149 // Retrieve
150 func (r Virtual_DedicatedHost) GetTagReferences() (resp []datatypes.Tag_Reference, err error) {
151 err = r.Session.DoRequest("SoftLayer_Virtual_DedicatedHost", "getTagReferences", nil, &r.Options, &resp)
152 return
153 }
154
155 // no documentation yet
156 func (r Virtual_DedicatedHost) SetTags(tags *string) (resp bool, err error) {
157 params := []interface{}{
158 tags,
159 }
160 err = r.Session.DoRequest("SoftLayer_Virtual_DedicatedHost", "setTags", params, &r.Options, &resp)
161 return
162 }
163
164 // The virtual disk image data type presents the structure in which a virtual disk image will be presented.
165 //
166 // Virtual block devices are assigned to disk images.
167 type Virtual_Disk_Image struct {
168 Session session.SLSession
169 Options sl.Options
170 }
171
172 // GetVirtualDiskImageService returns an instance of the Virtual_Disk_Image SoftLayer service
173 func GetVirtualDiskImageService(sess session.SLSession) Virtual_Disk_Image {
174 return Virtual_Disk_Image{Session: sess}
175 }
176
177 func (r Virtual_Disk_Image) Id(id int) Virtual_Disk_Image {
178 r.Options.Id = &id
179 return r
180 }
181
182 func (r Virtual_Disk_Image) Mask(mask string) Virtual_Disk_Image {
183 if !strings.HasPrefix(mask, "mask[") && (strings.Contains(mask, "[") || strings.Contains(mask, ",")) {
184 mask = fmt.Sprintf("mask[%s]", mask)
185 }
186
187 r.Options.Mask = mask
188 return r
189 }
190
191 func (r Virtual_Disk_Image) Filter(filter string) Virtual_Disk_Image {
192 r.Options.Filter = filter
193 return r
194 }
195
196 func (r Virtual_Disk_Image) Limit(limit int) Virtual_Disk_Image {
197 r.Options.Limit = &limit
198 return r
199 }
200
201 func (r Virtual_Disk_Image) Offset(offset int) Virtual_Disk_Image {
202 r.Options.Offset = &offset
203 return r
204 }
205
206 // no documentation yet
207 func (r Virtual_Disk_Image) EditObject(templateObject *datatypes.Virtual_Disk_Image) (resp bool, err error) {
208 params := []interface{}{
209 templateObject,
210 }
211 err = r.Session.DoRequest("SoftLayer_Virtual_Disk_Image", "editObject", params, &r.Options, &resp)
212 return
213 }
214
215 // Returns a collection of boot modes that are supported for primary disks.
216 func (r Virtual_Disk_Image) GetAvailableBootModes() (resp []string, err error) {
217 err = r.Session.DoRequest("SoftLayer_Virtual_Disk_Image", "getAvailableBootModes", nil, &r.Options, &resp)
218 return
219 }
220
221 // Retrieve The billing item for a virtual disk image.
222 func (r Virtual_Disk_Image) GetBillingItem() (resp datatypes.Billing_Item_Virtual_Disk_Image, err error) {
223 err = r.Session.DoRequest("SoftLayer_Virtual_Disk_Image", "getBillingItem", nil, &r.Options, &resp)
224 return
225 }
226
227 // Retrieve The block devices that a disk image is attached to. Block devices connect computing instances to disk images.
228 func (r Virtual_Disk_Image) GetBlockDevices() (resp []datatypes.Virtual_Guest_Block_Device, err error) {
229 err = r.Session.DoRequest("SoftLayer_Virtual_Disk_Image", "getBlockDevices", nil, &r.Options, &resp)
230 return
231 }
232
233 // Retrieve
234 func (r Virtual_Disk_Image) GetBootableVolumeFlag() (resp bool, err error) {
235 err = r.Session.DoRequest("SoftLayer_Virtual_Disk_Image", "getBootableVolumeFlag", nil, &r.Options, &resp)
236 return
237 }
238
239 // Retrieve Check if cloud-init is enabled.
240 func (r Virtual_Disk_Image) GetCloudInitFlag() (resp bool, err error) {
241 err = r.Session.DoRequest("SoftLayer_Virtual_Disk_Image", "getCloudInitFlag", nil, &r.Options, &resp)
242 return
243 }
244
245 // Retrieve
246 func (r Virtual_Disk_Image) GetCoalescedDiskImages() (resp []datatypes.Virtual_Disk_Image, err error) {
247 err = r.Session.DoRequest("SoftLayer_Virtual_Disk_Image", "getCoalescedDiskImages", nil, &r.Options, &resp)
248 return
249 }
250
251 // Retrieve
252 func (r Virtual_Disk_Image) GetCopyOnWriteFlag() (resp bool, err error) {
253 err = r.Session.DoRequest("SoftLayer_Virtual_Disk_Image", "getCopyOnWriteFlag", nil, &r.Options, &resp)
254 return
255 }
256
257 // Retrieve Return disk file extension
258 func (r Virtual_Disk_Image) GetDiskFileExtension() (resp string, err error) {
259 err = r.Session.DoRequest("SoftLayer_Virtual_Disk_Image", "getDiskFileExtension", nil, &r.Options, &resp)
260 return
261 }
262
263 // Retrieve
264 func (r Virtual_Disk_Image) GetDiskImageStorageGroup() (resp datatypes.Configuration_Storage_Group, err error) {
265 err = r.Session.DoRequest("SoftLayer_Virtual_Disk_Image", "getDiskImageStorageGroup", nil, &r.Options, &resp)
266 return
267 }
268
269 // Retrieve Return imported disk type
270 func (r Virtual_Disk_Image) GetImportedDiskType() (resp string, err error) {
271 err = r.Session.DoRequest("SoftLayer_Virtual_Disk_Image", "getImportedDiskType", nil, &r.Options, &resp)
272 return
273 }
274
275 // Retrieve Return if image is encrypted
276 func (r Virtual_Disk_Image) GetIsEncrypted() (resp bool, err error) {
277 err = r.Session.DoRequest("SoftLayer_Virtual_Disk_Image", "getIsEncrypted", nil, &r.Options, &resp)
278 return
279 }
280
281 // Retrieve
282 func (r Virtual_Disk_Image) GetLocalDiskFlag() (resp bool, err error) {
283 err = r.Session.DoRequest("SoftLayer_Virtual_Disk_Image", "getLocalDiskFlag", nil, &r.Options, &resp)
284 return
285 }
286
287 // Retrieve Whether this disk image is meant for storage of custom user data supplied with a Cloud Computing Instance order.
288 func (r Virtual_Disk_Image) GetMetadataFlag() (resp bool, err error) {
289 err = r.Session.DoRequest("SoftLayer_Virtual_Disk_Image", "getMetadataFlag", nil, &r.Options, &resp)
290 return
291 }
292
293 // no documentation yet
294 func (r Virtual_Disk_Image) GetObject() (resp datatypes.Virtual_Disk_Image, err error) {
295 err = r.Session.DoRequest("SoftLayer_Virtual_Disk_Image", "getObject", nil, &r.Options, &resp)
296 return
297 }
298
299 // Retrieves images from the public ISO repository
300 func (r Virtual_Disk_Image) GetPublicIsoImages() (resp []datatypes.Virtual_Disk_Image, err error) {
301 err = r.Session.DoRequest("SoftLayer_Virtual_Disk_Image", "getPublicIsoImages", nil, &r.Options, &resp)
302 return
303 }
304
305 // Retrieve References to the software that resides on a disk image.
306 func (r Virtual_Disk_Image) GetSoftwareReferences() (resp []datatypes.Virtual_Disk_Image_Software, err error) {
307 err = r.Session.DoRequest("SoftLayer_Virtual_Disk_Image", "getSoftwareReferences", nil, &r.Options, &resp)
308 return
309 }
310
311 // Retrieve The original disk image that the current disk image was cloned from.
312 func (r Virtual_Disk_Image) GetSourceDiskImage() (resp datatypes.Virtual_Disk_Image, err error) {
313 err = r.Session.DoRequest("SoftLayer_Virtual_Disk_Image", "getSourceDiskImage", nil, &r.Options, &resp)
314 return
315 }
316
317 // Retrieve Return storage group details for symantec disk
318 func (r Virtual_Disk_Image) GetStorageGroupDetails() (resp datatypes.Container_Image_StorageGroupDetails, err error) {
319 err = r.Session.DoRequest("SoftLayer_Virtual_Disk_Image", "getStorageGroupDetails", nil, &r.Options, &resp)
320 return
321 }
322
323 // Retrieve The storage group for a virtual disk image.
324 func (r Virtual_Disk_Image) GetStorageGroups() (resp []datatypes.Configuration_Storage_Group, err error) {
325 err = r.Session.DoRequest("SoftLayer_Virtual_Disk_Image", "getStorageGroups", nil, &r.Options, &resp)
326 return
327 }
328
329 // Retrieve The storage repository that a disk image resides in.
330 func (r Virtual_Disk_Image) GetStorageRepository() (resp datatypes.Virtual_Storage_Repository, err error) {
331 err = r.Session.DoRequest("SoftLayer_Virtual_Disk_Image", "getStorageRepository", nil, &r.Options, &resp)
332 return
333 }
334
335 // Retrieve The type of storage repository that a disk image resides in.
336 func (r Virtual_Disk_Image) GetStorageRepositoryType() (resp datatypes.Virtual_Storage_Repository_Type, err error) {
337 err = r.Session.DoRequest("SoftLayer_Virtual_Disk_Image", "getStorageRepositoryType", nil, &r.Options, &resp)
338 return
339 }
340
341 // Retrieve Return supported hardware component IDs for symantec disk
342 func (r Virtual_Disk_Image) GetSupportedHardware() (resp string, err error) {
343 err = r.Session.DoRequest("SoftLayer_Virtual_Disk_Image", "getSupportedHardware", nil, &r.Options, &resp)
344 return
345 }
346
347 // Retrieve The template that attaches a disk image to a [[SoftLayer_Virtual_Guest_Block_Device_Template_Group|archive]].
348 func (r Virtual_Disk_Image) GetTemplateBlockDevice() (resp datatypes.Virtual_Guest_Block_Device_Template, err error) {
349 err = r.Session.DoRequest("SoftLayer_Virtual_Disk_Image", "getTemplateBlockDevice", nil, &r.Options, &resp)
350 return
351 }
352
353 // Retrieve A virtual disk image's type.
354 func (r Virtual_Disk_Image) GetType() (resp datatypes.Virtual_Disk_Image_Type, err error) {
355 err = r.Session.DoRequest("SoftLayer_Virtual_Disk_Image", "getType", nil, &r.Options, &resp)
356 return
357 }
358
359 // The virtual guest data type presents the structure in which all virtual guests will be presented. Internally, the structure supports various virtualization platforms with no change to external interaction.
360 //
361 // A guest, also known as a virtual server, represents an allocation of resources on a virtual host.
362 type Virtual_Guest struct {
363 Session session.SLSession
364 Options sl.Options
365 }
366
367 // GetVirtualGuestService returns an instance of the Virtual_Guest SoftLayer service
368 func GetVirtualGuestService(sess session.SLSession) Virtual_Guest {
369 return Virtual_Guest{Session: sess}
370 }
371
372 func (r Virtual_Guest) Id(id int) Virtual_Guest {
373 r.Options.Id = &id
374 return r
375 }
376
377 func (r Virtual_Guest) Mask(mask string) Virtual_Guest {
378 if !strings.HasPrefix(mask, "mask[") && (strings.Contains(mask, "[") || strings.Contains(mask, ",")) {
379 mask = fmt.Sprintf("mask[%s]", mask)
380 }
381
382 r.Options.Mask = mask
383 return r
384 }
385
386 func (r Virtual_Guest) Filter(filter string) Virtual_Guest {
387 r.Options.Filter = filter
388 return r
389 }
390
391 func (r Virtual_Guest) Limit(limit int) Virtual_Guest {
392 r.Options.Limit = &limit
393 return r
394 }
395
396 func (r Virtual_Guest) Offset(offset int) Virtual_Guest {
397 r.Options.Offset = &offset
398 return r
399 }
400
401 // Activate the private network port
402 func (r Virtual_Guest) ActivatePrivatePort() (resp bool, err error) {
403 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "activatePrivatePort", nil, &r.Options, &resp)
404 return
405 }
406
407 // Activate the public network port
408 func (r Virtual_Guest) ActivatePublicPort() (resp bool, err error) {
409 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "activatePublicPort", nil, &r.Options, &resp)
410 return
411 }
412
413 // This method is used to allow access to a SoftLayer_Network_Storage volume that supports host- or network-level access control.
414 func (r Virtual_Guest) AllowAccessToNetworkStorage(networkStorageTemplateObject *datatypes.Network_Storage) (resp bool, err error) {
415 params := []interface{}{
416 networkStorageTemplateObject,
417 }
418 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "allowAccessToNetworkStorage", params, &r.Options, &resp)
419 return
420 }
421
422 // This method is used to allow access to multiple SoftLayer_Network_Storage volumes that support host- or network-level access control.
423 func (r Virtual_Guest) AllowAccessToNetworkStorageList(networkStorageTemplateObjects []datatypes.Network_Storage) (resp bool, err error) {
424 params := []interface{}{
425 networkStorageTemplateObjects,
426 }
427 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "allowAccessToNetworkStorageList", params, &r.Options, &resp)
428 return
429 }
430
431 // Creates a transaction to attach a guest's disk image. If the disk image is already attached it will be ignored.
432 //
433 // WARNING: SoftLayer_Virtual_Guest::checkHostDiskAvailability should be called before this method. If the SoftLayer_Virtual_Guest::checkHostDiskAvailability method is not called before this method, the guest migration will happen automatically.
434 func (r Virtual_Guest) AttachDiskImage(imageId *int) (resp datatypes.Provisioning_Version1_Transaction, err error) {
435 params := []interface{}{
436 imageId,
437 }
438 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "attachDiskImage", params, &r.Options, &resp)
439 return
440 }
441
442 // Reopens the public and/or private ports to reverse the changes made when the server was isolated for a destructive action.
443 func (r Virtual_Guest) CancelIsolationForDestructiveAction() (err error) {
444 var resp datatypes.Void
445 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "cancelIsolationForDestructiveAction", nil, &r.Options, &resp)
446 return
447 }
448
449 // Captures a Flex Image of the hard disk on the virtual machine, based on the capture template parameter. Returns the image template group containing the disk image.
450 func (r Virtual_Guest) CaptureImage(captureTemplate *datatypes.Container_Disk_Image_Capture_Template) (resp datatypes.Virtual_Guest_Block_Device_Template_Group, err error) {
451 params := []interface{}{
452 captureTemplate,
453 }
454 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "captureImage", params, &r.Options, &resp)
455 return
456 }
457
458 // Checks the associated host for available disk space to determine if guest migration is necessary. This method is only used with local disks. If this method returns false, calling attachDiskImage($imageId) will automatically migrate the destination guest to a new host before attaching the portable volume.
459 func (r Virtual_Guest) CheckHostDiskAvailability(diskCapacity *int) (resp bool, err error) {
460 params := []interface{}{
461 diskCapacity,
462 }
463 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "checkHostDiskAvailability", params, &r.Options, &resp)
464 return
465 }
466
467 // Creates a transaction to configure the guest's metadata disk. If the guest has user data associated with it, the transaction will create a small virtual drive and write the metadata to a file on the drive; if the drive already exists, the metadata will be rewritten. If the guest has no user data associated with it, the transaction will remove the virtual drive if it exists.
468 //
469 // WARNING: The transaction created by this service will shut down the guest while the metadata disk is configured. The guest will be turned back on once this process is complete.
470 func (r Virtual_Guest) ConfigureMetadataDisk() (resp datatypes.Provisioning_Version1_Transaction, err error) {
471 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "configureMetadataDisk", nil, &r.Options, &resp)
472 return
473 }
474
475 // Create a transaction to archive a computing instance's block devices
476 func (r Virtual_Guest) CreateArchiveTemplate(groupName *string, blockDevices []datatypes.Virtual_Guest_Block_Device, note *string) (resp datatypes.Virtual_Guest_Block_Device_Template_Group, err error) {
477 params := []interface{}{
478 groupName,
479 blockDevices,
480 note,
481 }
482 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "createArchiveTemplate", params, &r.Options, &resp)
483 return
484 }
485
486 // Create a transaction to archive a computing instance's block devices
487 // Deprecated: This function has been marked as deprecated.
488 func (r Virtual_Guest) CreateArchiveTransaction(groupName *string, blockDevices []datatypes.Virtual_Guest_Block_Device, note *string) (resp datatypes.Provisioning_Version1_Transaction, err error) {
489 params := []interface{}{
490 groupName,
491 blockDevices,
492 note,
493 }
494 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "createArchiveTransaction", params, &r.Options, &resp)
495 return
496 }
497
498 // createObject() enables the creation of computing instances on an account. This method is a simplified alternative to interacting with the ordering system directly.
499 //
500 // In order to create a computing instance, a template object must be sent in with a few required values.
501 //
502 // When this method returns an order will have been placed for a computing instance of the specified configuration.
503 //
504 // To determine when the instance is available you can poll the instance via [[SoftLayer_Virtual_Guest/getObject]], with an object mask requesting the `provisionDate` relational property. When `provisionDate` is not `null`, the instance will be ready.
505 //
506 // > **Warning:** Computing instances created via this method will incur charges on your account. For testing input parameters see [[SoftLayer_Virtual_Guest/generateOrderTemplate]].
507 //
508 // ### Required Input [[SoftLayer_Virtual_Guest]]
509 //
510 // - `Hostname` String **Required**
511 // - Hostname for the computing instance.
512 //
513 // - `Domain` String **Required**
514 // - Domain for the computing instance.
515 //
516 // - `startCpus` Integer **Required**
517 // - The number of CPU cores to allocate.
518 // - See [[SoftLayer_Virtual_Guest/getCreateObjectOptions]] for available options.
519 //
520 // - `maxMemory` Integer **Required**
521 // - The amount of memory to allocate in megabytes.
522 // - See [[SoftLayer_Virtual_Guest/getCreateObjectOptions]] for available options.
523 //
524 // - `datacenter.name` *String* **Required**
525 // - Specifies which datacenter the instance is to be provisioned in. Needs to be a nested object.
526 // - Example: `"datacenter": {"name": "dal05"}`
527 // - See [[SoftLayer_Virtual_Guest/getCreateObjectOptions]] for available options.
528 //
529 // - `hourlyBillingFlag` Boolean **Required**
530 // - Specifies the billing type for the instance.
531 // - True for hourly billing, False for monthly billing.
532 //
533 // - `localDiskFlag` Boolean **Required**
534 // - Specifies the disk type for the instance.
535 // - True for local to the instance disks, False for SAN disks.
536 //
537 // - `dedicatedAccountHostOnlyFlag` Boolean
538 // - When true this flag specifies that a compute instance is to run on hosts that only have guests from the same account.
539 // - Default: False
540 //
541 // - `operatingSystemReferenceCode` String **Conditionally required**
542 // - An identifier for the operating system to provision the computing instance with.
543 // - Not required when using a `blockDeviceTemplateGroup.globalIdentifier`, as the template will have its own operating system.
544 // - See [[SoftLayer_Virtual_Guest/getCreateObjectOptions]] for available options.
545 // - **Notice**: Some operating systems are billed based on the number of CPUs the guest has. The price which is used can be determined by calling
546 // [[SoftLayer_Virtual_Guest/generateOrderTemplate]] with your desired device specifications.
547 //
548 // - `blockDeviceTemplateGroup.globalIdentifier` String
549 // - The GUID for the template to be used to provision the computing instance.
550 // - Conflicts with `operatingSystemReferenceCode`
551 // - **Notice**: Some operating systems are billed based on the number of CPUs the guest has. The price which is used can be determined by calling
552 // [[SoftLayer_Virtual_Guest/generateOrderTemplate]] with your desired device specifications.
553 // - A list of public images may be obtained via a request to [[SoftLayer_Virtual_Guest_Block_Device_Template_Group/getPublicImages]]
554 // - A list of private images may be obtained via a request to [[SoftLayer_Account/getPrivateBlockDeviceTemplateGroups]]
555 // - Example: `"blockDeviceTemplateGroup": { globalIdentifier": "07beadaa-1e11-476e-a188-3f7795feb9fb"`
556 //
557 // - `networkComponents.maxSpeed` Integer
558 // - Specifies the connection speed for the instance's network components.
559 // - The `networkComponents` property is an array with a single [[SoftLayer_Virtual_Guest_Network_Component]] structure.
560 // The `maxSpeed` property must be set to specify the network uplink speed, in megabits per second, of the computing instance.
561 // - See [[SoftLayer_Virtual_Guest/getCreateObjectOptions]] for available options.
562 // - Default: 10
563 // - Example: `"networkComponents": [{"maxSpeed": 1000}]`
564 //
565 // - `privateNetworkOnlyFlag` Boolean
566 // - When true this flag specifies that a compute instance is to only have access to the private network.
567 // - Default: False
568 //
569 // - `primaryNetworkComponent.networkVlan.id` Integer
570 // - Specifies the network vlan which is to be used for the frontend interface of the computing instance.
571 // - The `primaryNetworkComponent` property is a [[SoftLayer_Virtual_Guest_Network_Component]] structure with the `networkVlan` property populated with a i
572 // [[SoftLayer_Network_Vlan]] structure. The `id` property must be set to specify the frontend network vlan of the computing instance.
573 // - *NOTE* This is the VLAN `id`, NOT the vlan number.
574 // - Example: `"primaryNetworkComponent":{"networkVlan": {"id": 1234567}}`
575 //
576 // - `backendNetworkComponent.networkVlan.id` Integer
577 // - Specifies the network vlan which is to be used for the backend interface of the computing instance.
578 // - The `backendNetworkComponent` property is a [[SoftLayer_Virtual_Guest_Network_Component]] structure with the `networkVlan` property populated with a
579 // [[SoftLayer_Network_Vlan]] structure. The `id` property must be set to specify the backend network vlan of the computing instance.
580 // - *NOTE* This is the VLAN `id`, NOT the vlan number.
581 // - Example: `"backendNetworkComponent":{"networkVlan": {"id": 1234567}}`
582 //
583 // - `primaryNetworkComponent.securityGroupBindings` [[SoftLayer_Virtual_Network_SecurityGroup_NetworkComponentBinding]][]
584 // - Specifies the security groups to be attached to this VSI's frontend network adapter
585 // - The `primaryNetworkComponent` property is a [[SoftLayer_Virtual_Guest_Network_Component]] structure with the `securityGroupBindings` property populated
586 // with an array of [[SoftLayer_Virtual_Network_SecurityGroup_NetworkComponentBinding]] structures. The `securityGroup` property in each must be set to
587 // specify the security group to be attached to the primary frontend network component.
588 // - Example:
589 // ```
590 // "primaryNetworkComponent": {
591 // "securityGroupBindings": [
592 // {"securityGroup":{"id": 5555555}},
593 // {"securityGroup":{"id": 1112223}},
594 // ]
595 // }
596 // ```
597 //
598 // - `primaryBackendNetworkComponent.securityGroupBindings` [[SoftLayer_Virtual_Network_SecurityGroup_NetworkComponentBinding]][]
599 // - Specifies the security groups to be attached to this VSI's backend network adapter
600 // - The `primaryNetworkComponent` property is a [[SoftLayer_Virtual_Guest_Network_Component]] structure with the `securityGroupBindings` property populated
601 // with an array of [[SoftLayer_Virtual_Network_SecurityGroup_NetworkComponentBinding]] structures. The `securityGroup` property in each must be set to
602 // specify the security group to be attached to the primary frontend network component.
603 // - Example:
604 // ```
605 // "primaryBackendNetworkComponent": {
606 // "securityGroupBindings": [
607 // {"securityGroup":{"id": 33322211}},
608 // {"securityGroup":{"id": 77777222}},
609 // ]
610 // }
611 // ```
612 //
613 // - `blockDevices` [[SoftLayer_Virtual_Guest_Block_Device]][]
614 // - Block device and disk image settings for the computing instance
615 // - The `blockDevices` property is an array of [[SoftLayer_Virtual_Guest_Block_Device]] structures. Each block device must specify the `device` property
616 // along with the `diskImage` property, which is a [[SoftLayer_Virtual_Disk_Image]] structure with the `capacity` property set. The `device` number `'1'`
617 // is reserved for the SWAP disk attached to the computing instance.
618 // - Default: The smallest available capacity for the primary disk will be used. If an image template is specified the disk capacity will be be provided by the template.
619 // - Example:
620 // ```
621 // "blockDevices":[{"device": "0", "diskImage": {"capacity": 100}}],
622 // "localDiskFlag": true
623 // ```
624 // - See [[SoftLayer_Virtual_Guest/getCreateObjectOptions]] for available options.
625 //
626 // - `userData.value` String
627 // - Arbitrary data to be made available to the computing instance.
628 // - The `userData` property is an array with a single [[SoftLayer_Virtual_Guest_Attribute]] structure with the `value` property set to an arbitrary value.
629 // This value can be retrieved via the [[SoftLayer_Resource_Metadata/getUserMetadata]] method from a request originating from the computing instance.
630 // This is primarily useful for providing data to software that may be on the instance and configured to execute upon first boot.
631 // - Example: `"userData":[{"value": "testData"}]`
632 //
633 // - `sshKeys` [[SoftLayer_Security_Ssh_Key]][]
634 // - The `sshKeys` property is an array of [[SoftLayer_Security_Ssh_Key]] structures with the `id` property set to the value of an existing SSH key.
635 // - To create a new SSH key, call [[SoftLayer_Security_Ssh_Key/createObject|createObject]].
636 // - To obtain a list of existing SSH keys, call [[SoftLayer_Account/getSshKeys]]
637 // - Example: `"sshKeys":[{"id": 1234567}]`
638 //
639 // - `postInstallScriptUri` String
640 // - Specifies the uri location of the script to be downloaded and run after installation is complete. Only scripts from HTTPS servers are executed on startup.
641 //
642 // REST Example:
643 // ```
644 //
645 // curl -X POST -d '{
646 // "parameters":[
647 // {
648 // "hostname": "host1",
649 // "domain": "example.com",
650 // "startCpus": 1,
651 // "maxMemory": 1024,
652 // "hourlyBillingFlag": true,
653 // "localDiskFlag": true,
654 // "operatingSystemReferenceCode": "UBUNTU_LATEST"
655 // }
656 // }' https://api.softlayer.com/rest/v3.1/SoftLayer_Virtual_Guest/createObject.json
657 //
658 // HTTP/1.1 201 Created
659 // Location: https://api.softlayer.com/rest/v3.1/SoftLayer_Virtual_Guest/1301396/getObject
660 //
661 // {
662 // "accountId": 232298,
663 // "createDate": "2012-11-30T16:28:17-06:00",
664 // "dedicatedAccountHostOnlyFlag": false,
665 // "domain": "example.com",
666 // "hostname": "host1",
667 // "id": 1301396,
668 // "lastPowerStateId": null,
669 // "lastVerifiedDate": null,
670 // "maxCpu": 1,
671 // "maxCpuUnits": "CORE",
672 // "maxMemory": 1024,
673 // "metricPollDate": null,
674 // "modifyDate": null,
675 // "privateNetworkOnlyFlag": false,
676 // "startCpus": 1,
677 // "statusId": 1001,
678 // "globalIdentifier": "2d203774-0ee1-49f5-9599-6ef67358dd31"
679 // }
680 //
681 // ```
682 func (r Virtual_Guest) CreateObject(templateObject *datatypes.Virtual_Guest) (resp datatypes.Virtual_Guest, err error) {
683 params := []interface{}{
684 templateObject,
685 }
686 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "createObject", params, &r.Options, &resp)
687 return
688 }
689
690 // createObjects() enables the creation of multiple computing instances on an account in a single call. This
691 // method is a simplified alternative to interacting with the ordering system directly.
692 //
693 // In order to create a computing instance a set of template objects must be sent in with a few required
694 // values.
695 //
696 // <b>Warning:</b> Computing instances created via this method will incur charges on your account.
697 //
698 // See [[SoftLayer_Virtual_Guest/createObject|createObject]] for specifics on the requirements of each template object.
699 //
700 // <h1>Example</h1>
701 //
702 // <http title="Request">curl -X POST -d '{
703 // "parameters":[
704 // [
705 // {
706 // "hostname": "host1",
707 // "domain": "example.com",
708 // "startCpus": 1,
709 // "maxMemory": 1024,
710 // "hourlyBillingFlag": true,
711 // "localDiskFlag": true,
712 // "operatingSystemReferenceCode": "UBUNTU_LATEST"
713 // },
714 // {
715 // "hostname": "host2",
716 // "domain": "example.com",
717 // "startCpus": 1,
718 // "maxMemory": 1024,
719 // "hourlyBillingFlag": true,
720 // "localDiskFlag": true,
721 // "operatingSystemReferenceCode": "UBUNTU_LATEST"
722 // }
723 // ]
724 // ]
725 // }' https://api.softlayer.com/rest/v3/SoftLayer_Virtual_Guest/createObjects.json
726 //
727 // </http>
728 // <http title="Response">HTTP/1.1 200 OK
729 //
730 // [
731 //
732 // {
733 // "accountId": 232298,
734 // "createDate": "2012-11-30T23:56:48-06:00",
735 // "dedicatedAccountHostOnlyFlag": false,
736 // "domain": "softlayer.com",
737 // "hostname": "ubuntu1",
738 // "id": 1301456,
739 // "lastPowerStateId": null,
740 // "lastVerifiedDate": null,
741 // "maxCpu": 1,
742 // "maxCpuUnits": "CORE",
743 // "maxMemory": 1024,
744 // "metricPollDate": null,
745 // "modifyDate": null,
746 // "privateNetworkOnlyFlag": false,
747 // "startCpus": 1,
748 // "statusId": 1001,
749 // "globalIdentifier": "fed4c822-48c0-45d0-85e2-90476aa0c542"
750 // },
751 // {
752 // "accountId": 232298,
753 // "createDate": "2012-11-30T23:56:49-06:00",
754 // "dedicatedAccountHostOnlyFlag": false,
755 // "domain": "softlayer.com",
756 // "hostname": "ubuntu2",
757 // "id": 1301457,
758 // "lastPowerStateId": null,
759 // "lastVerifiedDate": null,
760 // "maxCpu": 1,
761 // "maxCpuUnits": "CORE",
762 // "maxMemory": 1024,
763 // "metricPollDate": null,
764 // "modifyDate": null,
765 // "privateNetworkOnlyFlag": false,
766 // "startCpus": 1,
767 // "statusId": 1001,
768 // "globalIdentifier": "bed4c686-9562-4ade-9049-dc4d5b6b200c"
769 // }
770 //
771 // ]
772 // </http>
773 func (r Virtual_Guest) CreateObjects(templateObjects []datatypes.Virtual_Guest) (resp []datatypes.Virtual_Guest, err error) {
774 params := []interface{}{
775 templateObjects,
776 }
777 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "createObjects", params, &r.Options, &resp)
778 return
779 }
780
781 // no documentation yet
782 func (r Virtual_Guest) CreatePostSoftwareInstallTransaction(data *string, returnBoolean *bool) (resp bool, err error) {
783 params := []interface{}{
784 data,
785 returnBoolean,
786 }
787 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "createPostSoftwareInstallTransaction", params, &r.Options, &resp)
788 return
789 }
790
791 // This method will cancel a computing instance effective immediately. For instances billed hourly, the charges will stop immediately after the method returns.
792 func (r Virtual_Guest) DeleteObject() (resp bool, err error) {
793 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "deleteObject", nil, &r.Options, &resp)
794 return
795 }
796
797 // no documentation yet
798 func (r Virtual_Guest) DeleteTag(tagName *string) (resp bool, err error) {
799 params := []interface{}{
800 tagName,
801 }
802 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "deleteTag", params, &r.Options, &resp)
803 return
804 }
805
806 // no documentation yet
807 func (r Virtual_Guest) DeleteTransientWebhook() (err error) {
808 var resp datatypes.Void
809 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "deleteTransientWebhook", nil, &r.Options, &resp)
810 return
811 }
812
813 // Creates a transaction to detach a guest's disk image. If the disk image is already detached it will be ignored.
814 //
815 // WARNING: The transaction created by this service will shut down the guest while the disk image is attached. The guest will be turned back on once this process is complete.
816 func (r Virtual_Guest) DetachDiskImage(imageId *int) (resp datatypes.Provisioning_Version1_Transaction, err error) {
817 params := []interface{}{
818 imageId,
819 }
820 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "detachDiskImage", params, &r.Options, &resp)
821 return
822 }
823
824 // Edit a computing instance's properties
825 func (r Virtual_Guest) EditObject(templateObject *datatypes.Virtual_Guest) (resp bool, err error) {
826 params := []interface{}{
827 templateObject,
828 }
829 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "editObject", params, &r.Options, &resp)
830 return
831 }
832
833 // Reboot a guest into the Idera Bare Metal Restore image.
834 func (r Virtual_Guest) ExecuteIderaBareMetalRestore() (resp bool, err error) {
835 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "executeIderaBareMetalRestore", nil, &r.Options, &resp)
836 return
837 }
838
839 // Reboot a guest into the R1Soft Bare Metal Restore image.
840 func (r Virtual_Guest) ExecuteR1SoftBareMetalRestore() (resp bool, err error) {
841 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "executeR1SoftBareMetalRestore", nil, &r.Options, &resp)
842 return
843 }
844
845 // Download and run remote script from uri on virtual guests.
846 func (r Virtual_Guest) ExecuteRemoteScript(uri *string) (err error) {
847 var resp datatypes.Void
848 params := []interface{}{
849 uri,
850 }
851 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "executeRemoteScript", params, &r.Options, &resp)
852 return
853 }
854
855 // Reboot a Linux guest into the Xen rescue image.
856 func (r Virtual_Guest) ExecuteRescueLayer() (resp bool, err error) {
857 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "executeRescueLayer", nil, &r.Options, &resp)
858 return
859 }
860
861 // Find VSIs by hostname.
862 func (r Virtual_Guest) FindByHostname(hostname *string) (resp []datatypes.Virtual_Guest, err error) {
863 params := []interface{}{
864 hostname,
865 }
866 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "findByHostname", params, &r.Options, &resp)
867 return
868 }
869
870 // Find CCI by only its primary public or private IP address. IP addresses within secondary subnets tied to the CCI will not return the CCI. If no CCI is found, no errors are generated and no data is returned.
871 func (r Virtual_Guest) FindByIpAddress(ipAddress *string) (resp datatypes.Virtual_Guest, err error) {
872 params := []interface{}{
873 ipAddress,
874 }
875 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "findByIpAddress", params, &r.Options, &resp)
876 return
877 }
878
879 // Obtain an [[SoftLayer_Container_Product_Order_Virtual_Guest (type)|order container]] that can be sent to [[SoftLayer_Product_Order/verifyOrder|verifyOrder]] or [[SoftLayer_Product_Order/placeOrder|placeOrder]].
880 //
881 // This is primarily useful when there is a necessity to confirm the price which will be charged for an order.
882 //
883 // See [[SoftLayer_Virtual_Guest/createObject|createObject]] for specifics on the requirements of the template object parameter.
884 func (r Virtual_Guest) GenerateOrderTemplate(templateObject *datatypes.Virtual_Guest) (resp datatypes.Container_Product_Order, err error) {
885 params := []interface{}{
886 templateObject,
887 }
888 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "generateOrderTemplate", params, &r.Options, &resp)
889 return
890 }
891
892 // Retrieve The account that a virtual guest belongs to.
893 func (r Virtual_Guest) GetAccount() (resp datatypes.Account, err error) {
894 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "getAccount", nil, &r.Options, &resp)
895 return
896 }
897
898 // Retrieve
899 func (r Virtual_Guest) GetAccountOwnedPoolFlag() (resp bool, err error) {
900 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "getAccountOwnedPoolFlag", nil, &r.Options, &resp)
901 return
902 }
903
904 // Retrieve A virtual guest's currently active network monitoring incidents.
905 func (r Virtual_Guest) GetActiveNetworkMonitorIncident() (resp []datatypes.Network_Monitor_Version1_Incident, err error) {
906 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "getActiveNetworkMonitorIncident", nil, &r.Options, &resp)
907 return
908 }
909
910 // Retrieve
911 func (r Virtual_Guest) GetActiveTickets() (resp []datatypes.Ticket, err error) {
912 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "getActiveTickets", nil, &r.Options, &resp)
913 return
914 }
915
916 // Retrieve A transaction that is still be performed on a cloud server.
917 func (r Virtual_Guest) GetActiveTransaction() (resp datatypes.Provisioning_Version1_Transaction, err error) {
918 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "getActiveTransaction", nil, &r.Options, &resp)
919 return
920 }
921
922 // Retrieve Any active transaction(s) that are currently running for the server (example: os reload).
923 func (r Virtual_Guest) GetActiveTransactions() (resp []datatypes.Provisioning_Version1_Transaction, err error) {
924 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "getActiveTransactions", nil, &r.Options, &resp)
925 return
926 }
927
928 // Return a collection of SoftLayer_Item_Price objects for an OS reload
929 func (r Virtual_Guest) GetAdditionalRequiredPricesForOsReload(config *datatypes.Container_Hardware_Server_Configuration) (resp []datatypes.Product_Item_Price, err error) {
930 params := []interface{}{
931 config,
932 }
933 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "getAdditionalRequiredPricesForOsReload", params, &r.Options, &resp)
934 return
935 }
936
937 // Retrieve The SoftLayer_Network_Storage_Allowed_Host information to connect this Virtual Guest to Network Storage volumes that require access control lists.
938 func (r Virtual_Guest) GetAllowedHost() (resp datatypes.Network_Storage_Allowed_Host, err error) {
939 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "getAllowedHost", nil, &r.Options, &resp)
940 return
941 }
942
943 // Retrieve The SoftLayer_Network_Storage objects that this SoftLayer_Virtual_Guest has access to.
944 func (r Virtual_Guest) GetAllowedNetworkStorage() (resp []datatypes.Network_Storage, err error) {
945 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "getAllowedNetworkStorage", nil, &r.Options, &resp)
946 return
947 }
948
949 // Retrieve The SoftLayer_Network_Storage objects whose Replica that this SoftLayer_Virtual_Guest has access to.
950 func (r Virtual_Guest) GetAllowedNetworkStorageReplicas() (resp []datatypes.Network_Storage, err error) {
951 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "getAllowedNetworkStorageReplicas", nil, &r.Options, &resp)
952 return
953 }
954
955 // Retrieve A antivirus / spyware software component object.
956 func (r Virtual_Guest) GetAntivirusSpywareSoftwareComponent() (resp datatypes.Software_Component, err error) {
957 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "getAntivirusSpywareSoftwareComponent", nil, &r.Options, &resp)
958 return
959 }
960
961 // Retrieve
962 func (r Virtual_Guest) GetApplicationDeliveryController() (resp datatypes.Network_Application_Delivery_Controller, err error) {
963 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "getApplicationDeliveryController", nil, &r.Options, &resp)
964 return
965 }
966
967 // This method is retrieve a list of SoftLayer_Network_Storage volumes that are authorized access to this SoftLayer_Virtual_Guest.
968 func (r Virtual_Guest) GetAttachedNetworkStorages(nasType *string) (resp []datatypes.Network_Storage, err error) {
969 params := []interface{}{
970 nasType,
971 }
972 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "getAttachedNetworkStorages", params, &r.Options, &resp)
973 return
974 }
975
976 // Retrieve
977 func (r Virtual_Guest) GetAttributes() (resp []datatypes.Virtual_Guest_Attribute, err error) {
978 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "getAttributes", nil, &r.Options, &resp)
979 return
980 }
981
982 // no documentation yet
983 func (r Virtual_Guest) GetAvailableBlockDevicePositions() (resp []string, err error) {
984 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "getAvailableBlockDevicePositions", nil, &r.Options, &resp)
985 return
986 }
987
988 // Retrieve An object that stores the maximum level for the monitoring query types and response types.
989 func (r Virtual_Guest) GetAvailableMonitoring() (resp []datatypes.Network_Monitor_Version1_Query_Host_Stratum, err error) {
990 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "getAvailableMonitoring", nil, &r.Options, &resp)
991 return
992 }
993
994 // This method retrieves a list of SoftLayer_Network_Storage volumes that can be authorized to this SoftLayer_Virtual_Guest.
995 func (r Virtual_Guest) GetAvailableNetworkStorages(nasType *string) (resp []datatypes.Network_Storage, err error) {
996 params := []interface{}{
997 nasType,
998 }
999 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "getAvailableNetworkStorages", params, &r.Options, &resp)
1000 return
1001 }
1002
1003 // Retrieve The average daily private bandwidth usage for the current billing cycle.
1004 func (r Virtual_Guest) GetAverageDailyPrivateBandwidthUsage() (resp datatypes.Float64, err error) {
1005 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "getAverageDailyPrivateBandwidthUsage", nil, &r.Options, &resp)
1006 return
1007 }
1008
1009 // Retrieve The average daily public bandwidth usage for the current billing cycle.
1010 func (r Virtual_Guest) GetAverageDailyPublicBandwidthUsage() (resp datatypes.Float64, err error) {
1011 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "getAverageDailyPublicBandwidthUsage", nil, &r.Options, &resp)
1012 return
1013 }
1014
1015 // Retrieve A guests's backend network components.
1016 func (r Virtual_Guest) GetBackendNetworkComponents() (resp []datatypes.Virtual_Guest_Network_Component, err error) {
1017 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "getBackendNetworkComponents", nil, &r.Options, &resp)
1018 return
1019 }
1020
1021 // Retrieve A guest's backend or private router.
1022 func (r Virtual_Guest) GetBackendRouters() (resp []datatypes.Hardware, err error) {
1023 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "getBackendRouters", nil, &r.Options, &resp)
1024 return
1025 }
1026
1027 // Retrieve A computing instance's allotted bandwidth (measured in GB).
1028 func (r Virtual_Guest) GetBandwidthAllocation() (resp datatypes.Float64, err error) {
1029 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "getBandwidthAllocation", nil, &r.Options, &resp)
1030 return
1031 }
1032
1033 // Retrieve A computing instance's allotted detail record. Allotment details link bandwidth allocation with allotments.
1034 func (r Virtual_Guest) GetBandwidthAllotmentDetail() (resp datatypes.Network_Bandwidth_Version1_Allotment_Detail, err error) {
1035 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "getBandwidthAllotmentDetail", nil, &r.Options, &resp)
1036 return
1037 }
1038
1039 // Use this method when needing the metric data for bandwidth for a single guest. It will gather the correct input parameters based on the date ranges
1040 func (r Virtual_Guest) GetBandwidthDataByDate(startDateTime *datatypes.Time, endDateTime *datatypes.Time, networkType *string) (resp []datatypes.Metric_Tracking_Object_Data, err error) {
1041 params := []interface{}{
1042 startDateTime,
1043 endDateTime,
1044 networkType,
1045 }
1046 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "getBandwidthDataByDate", params, &r.Options, &resp)
1047 return
1048 }
1049
1050 // Retrieve a collection of bandwidth data from an individual public or private network tracking object. Data is ideal if you with to employ your own traffic storage and graphing systems.
1051 func (r Virtual_Guest) GetBandwidthForDateRange(startDate *datatypes.Time, endDate *datatypes.Time) (resp []datatypes.Metric_Tracking_Object_Data, err error) {
1052 params := []interface{}{
1053 startDate,
1054 endDate,
1055 }
1056 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "getBandwidthForDateRange", params, &r.Options, &resp)
1057 return
1058 }
1059
1060 // Returns the total amount of bandwidth used during the time specified for a computing instance.
1061 func (r Virtual_Guest) GetBandwidthTotal(startDateTime *datatypes.Time, endDateTime *datatypes.Time, direction *string, side *string) (resp uint, err error) {
1062 params := []interface{}{
1063 startDateTime,
1064 endDateTime,
1065 direction,
1066 side,
1067 }
1068 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "getBandwidthTotal", params, &r.Options, &resp)
1069 return
1070 }
1071
1072 // Retrieve The raw bandwidth usage data for the current billing cycle. One object will be returned for each network this server is attached to.
1073 func (r Virtual_Guest) GetBillingCycleBandwidthUsage() (resp []datatypes.Network_Bandwidth_Usage, err error) {
1074 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "getBillingCycleBandwidthUsage", nil, &r.Options, &resp)
1075 return
1076 }
1077
1078 // Retrieve The raw private bandwidth usage data for the current billing cycle.
1079 func (r Virtual_Guest) GetBillingCyclePrivateBandwidthUsage() (resp datatypes.Network_Bandwidth_Usage, err error) {
1080 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "getBillingCyclePrivateBandwidthUsage", nil, &r.Options, &resp)
1081 return
1082 }
1083
1084 // Retrieve The raw public bandwidth usage data for the current billing cycle.
1085 func (r Virtual_Guest) GetBillingCyclePublicBandwidthUsage() (resp datatypes.Network_Bandwidth_Usage, err error) {
1086 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "getBillingCyclePublicBandwidthUsage", nil, &r.Options, &resp)
1087 return
1088 }
1089
1090 // Retrieve The billing item for a CloudLayer Compute Instance.
1091 func (r Virtual_Guest) GetBillingItem() (resp datatypes.Billing_Item_Virtual_Guest, err error) {
1092 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "getBillingItem", nil, &r.Options, &resp)
1093 return
1094 }
1095
1096 // Retrieve Determines whether the instance is ineligible for cancellation because it is disconnected.
1097 func (r Virtual_Guest) GetBlockCancelBecauseDisconnectedFlag() (resp bool, err error) {
1098 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "getBlockCancelBecauseDisconnectedFlag", nil, &r.Options, &resp)
1099 return
1100 }
1101
1102 // Retrieve The global identifier for the image template that was used to provision or reload a guest.
1103 func (r Virtual_Guest) GetBlockDeviceTemplateGroup() (resp datatypes.Virtual_Guest_Block_Device_Template_Group, err error) {
1104 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "getBlockDeviceTemplateGroup", nil, &r.Options, &resp)
1105 return
1106 }
1107
1108 // Retrieve A computing instance's block devices. Block devices link [[SoftLayer_Virtual_Disk_Image|disk images]] to computing instances.
1109 func (r Virtual_Guest) GetBlockDevices() (resp []datatypes.Virtual_Guest_Block_Device, err error) {
1110 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "getBlockDevices", nil, &r.Options, &resp)
1111 return
1112 }
1113
1114 // Retrieves the boot mode of the VSI.
1115 func (r Virtual_Guest) GetBootMode() (resp string, err error) {
1116 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "getBootMode", nil, &r.Options, &resp)
1117 return
1118 }
1119
1120 // no documentation yet
1121 func (r Virtual_Guest) GetBootOrder() (resp string, err error) {
1122 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "getBootOrder", nil, &r.Options, &resp)
1123 return
1124 }
1125
1126 // Retrieve A virtual guest's browser access logs.
1127 func (r Virtual_Guest) GetBrowserConsoleAccessLogs() (resp []datatypes.Virtual_BrowserConsoleAccessLog, err error) {
1128 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "getBrowserConsoleAccessLogs", nil, &r.Options, &resp)
1129 return
1130 }
1131
1132 // Gets the console access logs for a computing instance
1133 func (r Virtual_Guest) GetConsoleAccessLog() (resp []datatypes.Network_Logging_Syslog, err error) {
1134 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "getConsoleAccessLog", nil, &r.Options, &resp)
1135 return
1136 }
1137
1138 // Retrieve A container for a guest's console data
1139 func (r Virtual_Guest) GetConsoleData() (resp datatypes.Container_Virtual_ConsoleData, err error) {
1140 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "getConsoleData", nil, &r.Options, &resp)
1141 return
1142 }
1143
1144 // Retrieve [DEPRECATED] A flag indicating a computing instance's console IP address is assigned.
1145 func (r Virtual_Guest) GetConsoleIpAddressFlag() (resp bool, err error) {
1146 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "getConsoleIpAddressFlag", nil, &r.Options, &resp)
1147 return
1148 }
1149
1150 // Retrieve [DEPRECATED] A record containing information about a computing instance's console IP and port number.
1151 func (r Virtual_Guest) GetConsoleIpAddressRecord() (resp datatypes.Virtual_Guest_Network_Component_IpAddress, err error) {
1152 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "getConsoleIpAddressRecord", nil, &r.Options, &resp)
1153 return
1154 }
1155
1156 // Retrieve A continuous data protection software component object.
1157 func (r Virtual_Guest) GetContinuousDataProtectionSoftwareComponent() (resp datatypes.Software_Component, err error) {
1158 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "getContinuousDataProtectionSoftwareComponent", nil, &r.Options, &resp)
1159 return
1160 }
1161
1162 // Retrieve A guest's control panel.
1163 func (r Virtual_Guest) GetControlPanel() (resp datatypes.Software_Component, err error) {
1164 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "getControlPanel", nil, &r.Options, &resp)
1165 return
1166 }
1167
1168 // If the virtual server currently has an operating system that has a core capacity restriction, return the associated core-restricted operating system item price. Some operating systems (e.g., Red Hat Enterprise Linux) may be billed by the number of processor cores, so therefore require that a certain number of cores be present on the server.
1169 func (r Virtual_Guest) GetCoreRestrictedOperatingSystemPrice() (resp datatypes.Product_Item_Price, err error) {
1170 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "getCoreRestrictedOperatingSystemPrice", nil, &r.Options, &resp)
1171 return
1172 }
1173
1174 // Use this method when needing the metric data for a single guest's CPUs. It will gather the correct input parameters based on the date ranges
1175 func (r Virtual_Guest) GetCpuMetricDataByDate(startDateTime *datatypes.Time, endDateTime *datatypes.Time, cpuIndexes []int) (resp []datatypes.Metric_Tracking_Object_Data, err error) {
1176 params := []interface{}{
1177 startDateTime,
1178 endDateTime,
1179 cpuIndexes,
1180 }
1181 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "getCpuMetricDataByDate", params, &r.Options, &resp)
1182 return
1183 }
1184
1185 // There are many options that may be provided while ordering a computing instance, this method can be used to determine what these options are.
1186 //
1187 // Detailed information on the return value can be found on the data type page for [[SoftLayer_Container_Virtual_Guest_Configuration (type)]].
1188 func (r Virtual_Guest) GetCreateObjectOptions() (resp datatypes.Container_Virtual_Guest_Configuration, err error) {
1189 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "getCreateObjectOptions", nil, &r.Options, &resp)
1190 return
1191 }
1192
1193 // Retrieve An object that provides commonly used bandwidth summary components for the current billing cycle.
1194 func (r Virtual_Guest) GetCurrentBandwidthSummary() (resp datatypes.Metric_Tracking_Object_Bandwidth_Summary, err error) {
1195 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "getCurrentBandwidthSummary", nil, &r.Options, &resp)
1196 return
1197 }
1198
1199 // Get the billing detail for this instance for the current billing period. This does not include bandwidth usage.
1200 func (r Virtual_Guest) GetCurrentBillingDetail() (resp []datatypes.Billing_Item, err error) {
1201 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "getCurrentBillingDetail", nil, &r.Options, &resp)
1202 return
1203 }
1204
1205 // Get the total bill amount in US Dollars ($) for this instance in the current billing period. This includes all bandwidth used up to the point this method is called on the instance.
1206 func (r Virtual_Guest) GetCurrentBillingTotal() (resp datatypes.Float64, err error) {
1207 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "getCurrentBillingTotal", nil, &r.Options, &resp)
1208 return
1209 }
1210
1211 // Retrieve The datacenter that a virtual guest resides in.
1212 func (r Virtual_Guest) GetDatacenter() (resp datatypes.Location, err error) {
1213 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "getDatacenter", nil, &r.Options, &resp)
1214 return
1215 }
1216
1217 // Retrieve The dedicated host associated with this guest.
1218 func (r Virtual_Guest) GetDedicatedHost() (resp datatypes.Virtual_DedicatedHost, err error) {
1219 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "getDedicatedHost", nil, &r.Options, &resp)
1220 return
1221 }
1222
1223 // Retrieve The device status of this virtual guest.
1224 func (r Virtual_Guest) GetDeviceStatus() (resp datatypes.Device_Status, err error) {
1225 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "getDeviceStatus", nil, &r.Options, &resp)
1226 return
1227 }
1228
1229 // Return a drive retention SoftLayer_Item_Price object for a guest.
1230 func (r Virtual_Guest) GetDriveRetentionItemPrice() (resp datatypes.Product_Item_Price, err error) {
1231 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "getDriveRetentionItemPrice", nil, &r.Options, &resp)
1232 return
1233 }
1234
1235 // Retrieve A guest's associated EVault network storage service account.
1236 func (r Virtual_Guest) GetEvaultNetworkStorage() (resp []datatypes.Network_Storage, err error) {
1237 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "getEvaultNetworkStorage", nil, &r.Options, &resp)
1238 return
1239 }
1240
1241 // Get the subnets associated with this CloudLayer computing instance that are protectable by a network component firewall.
1242 func (r Virtual_Guest) GetFirewallProtectableSubnets() (resp []datatypes.Network_Subnet, err error) {
1243 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "getFirewallProtectableSubnets", nil, &r.Options, &resp)
1244 return
1245 }
1246
1247 // Retrieve A computing instance's hardware firewall services.
1248 func (r Virtual_Guest) GetFirewallServiceComponent() (resp datatypes.Network_Component_Firewall, err error) {
1249 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "getFirewallServiceComponent", nil, &r.Options, &resp)
1250 return
1251 }
1252
1253 // no documentation yet
1254 func (r Virtual_Guest) GetFirstAvailableBlockDevicePosition() (resp string, err error) {
1255 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "getFirstAvailableBlockDevicePosition", nil, &r.Options, &resp)
1256 return
1257 }
1258
1259 // Retrieve A guest's frontend network components.
1260 func (r Virtual_Guest) GetFrontendNetworkComponents() (resp []datatypes.Virtual_Guest_Network_Component, err error) {
1261 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "getFrontendNetworkComponents", nil, &r.Options, &resp)
1262 return
1263 }
1264
1265 // Retrieve A guest's frontend or public router.
1266 func (r Virtual_Guest) GetFrontendRouters() (resp datatypes.Hardware, err error) {
1267 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "getFrontendRouters", nil, &r.Options, &resp)
1268 return
1269 }
1270
1271 // Retrieve A guest's universally unique identifier.
1272 func (r Virtual_Guest) GetGlobalIdentifier() (resp string, err error) {
1273 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "getGlobalIdentifier", nil, &r.Options, &resp)
1274 return
1275 }
1276
1277 // Retrieve The number of GPUs attached to the guest.
1278 func (r Virtual_Guest) GetGpuCount() (resp int, err error) {
1279 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "getGpuCount", nil, &r.Options, &resp)
1280 return
1281 }
1282
1283 // Retrieve The name of the GPU type attached to the guest.
1284 func (r Virtual_Guest) GetGpuType() (resp string, err error) {
1285 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "getGpuType", nil, &r.Options, &resp)
1286 return
1287 }
1288
1289 // Retrieve
1290 func (r Virtual_Guest) GetGuestBootParameter() (resp datatypes.Virtual_Guest_Boot_Parameter, err error) {
1291 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "getGuestBootParameter", nil, &r.Options, &resp)
1292 return
1293 }
1294
1295 // Retrieve The object's function.
1296 func (r Virtual_Guest) GetHardwareFunctionDescription() (resp string, err error) {
1297 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "getHardwareFunctionDescription", nil, &r.Options, &resp)
1298 return
1299 }
1300
1301 // Retrieve The virtual host on which a virtual guest resides (available only on private clouds).
1302 func (r Virtual_Guest) GetHost() (resp datatypes.Virtual_Host, err error) {
1303 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "getHost", nil, &r.Options, &resp)
1304 return
1305 }
1306
1307 // Retrieve A host IPS software component object.
1308 func (r Virtual_Guest) GetHostIpsSoftwareComponent() (resp datatypes.Software_Component, err error) {
1309 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "getHostIpsSoftwareComponent", nil, &r.Options, &resp)
1310 return
1311 }
1312
1313 // Retrieve A guest's hourly billing status.
1314 func (r Virtual_Guest) GetHourlyBillingFlag() (resp bool, err error) {
1315 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "getHourlyBillingFlag", nil, &r.Options, &resp)
1316 return
1317 }
1318
1319 // Retrieve The total private inbound bandwidth for this computing instance for the current billing cycle.
1320 func (r Virtual_Guest) GetInboundPrivateBandwidthUsage() (resp datatypes.Float64, err error) {
1321 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "getInboundPrivateBandwidthUsage", nil, &r.Options, &resp)
1322 return
1323 }
1324
1325 // Retrieve The total public inbound bandwidth for this computing instance for the current billing cycle.
1326 func (r Virtual_Guest) GetInboundPublicBandwidthUsage() (resp datatypes.Float64, err error) {
1327 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "getInboundPublicBandwidthUsage", nil, &r.Options, &resp)
1328 return
1329 }
1330
1331 // Retrieve
1332 func (r Virtual_Guest) GetInternalTagReferences() (resp []datatypes.Tag_Reference, err error) {
1333 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "getInternalTagReferences", nil, &r.Options, &resp)
1334 return
1335 }
1336
1337 // no documentation yet
1338 func (r Virtual_Guest) GetIsoBootImage() (resp datatypes.Virtual_Disk_Image, err error) {
1339 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "getIsoBootImage", nil, &r.Options, &resp)
1340 return
1341 }
1342
1343 // Return a collection of SoftLayer_Item_Price objects from a collection of SoftLayer_Software_Description
1344 func (r Virtual_Guest) GetItemPricesFromSoftwareDescriptions(softwareDescriptions []datatypes.Software_Description, includeTranslationsFlag *bool, returnAllPricesFlag *bool) (resp []datatypes.Product_Item, err error) {
1345 params := []interface{}{
1346 softwareDescriptions,
1347 includeTranslationsFlag,
1348 returnAllPricesFlag,
1349 }
1350 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "getItemPricesFromSoftwareDescriptions", params, &r.Options, &resp)
1351 return
1352 }
1353
1354 // Retrieve The last known power state of a virtual guest in the event the guest is turned off outside of IMS or has gone offline.
1355 func (r Virtual_Guest) GetLastKnownPowerState() (resp datatypes.Virtual_Guest_Power_State, err error) {
1356 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "getLastKnownPowerState", nil, &r.Options, &resp)
1357 return
1358 }
1359
1360 // Retrieve The last transaction that a cloud server's operating system was loaded.
1361 func (r Virtual_Guest) GetLastOperatingSystemReload() (resp datatypes.Provisioning_Version1_Transaction, err error) {
1362 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "getLastOperatingSystemReload", nil, &r.Options, &resp)
1363 return
1364 }
1365
1366 // Retrieve The last transaction a cloud server had performed.
1367 func (r Virtual_Guest) GetLastTransaction() (resp datatypes.Provisioning_Version1_Transaction, err error) {
1368 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "getLastTransaction", nil, &r.Options, &resp)
1369 return
1370 }
1371
1372 // Retrieve A virtual guest's latest network monitoring incident.
1373 func (r Virtual_Guest) GetLatestNetworkMonitorIncident() (resp datatypes.Network_Monitor_Version1_Incident, err error) {
1374 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "getLatestNetworkMonitorIncident", nil, &r.Options, &resp)
1375 return
1376 }
1377
1378 // Retrieve A flag indicating that the virtual guest has at least one disk which is local to the host it runs on. This does not include a SWAP device.
1379 func (r Virtual_Guest) GetLocalDiskFlag() (resp bool, err error) {
1380 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "getLocalDiskFlag", nil, &r.Options, &resp)
1381 return
1382 }
1383
1384 // Retrieve Where guest is located within SoftLayer's location hierarchy.
1385 func (r Virtual_Guest) GetLocation() (resp datatypes.Location, err error) {
1386 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "getLocation", nil, &r.Options, &resp)
1387 return
1388 }
1389
1390 // Retrieve A flag indicating that the virtual guest is a managed resource.
1391 func (r Virtual_Guest) GetManagedResourceFlag() (resp bool, err error) {
1392 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "getManagedResourceFlag", nil, &r.Options, &resp)
1393 return
1394 }
1395
1396 // Use this method when needing the metric data for memory for a single computing instance.
1397 func (r Virtual_Guest) GetMemoryMetricDataByDate(startDateTime *datatypes.Time, endDateTime *datatypes.Time) (resp []datatypes.Metric_Tracking_Object_Data, err error) {
1398 params := []interface{}{
1399 startDateTime,
1400 endDateTime,
1401 }
1402 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "getMemoryMetricDataByDate", params, &r.Options, &resp)
1403 return
1404 }
1405
1406 // Retrieve A guest's metric tracking object.
1407 func (r Virtual_Guest) GetMetricTrackingObject() (resp datatypes.Metric_Tracking_Object, err error) {
1408 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "getMetricTrackingObject", nil, &r.Options, &resp)
1409 return
1410 }
1411
1412 // Retrieve The metric tracking object id for this guest.
1413 func (r Virtual_Guest) GetMetricTrackingObjectId() (resp int, err error) {
1414 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "getMetricTrackingObjectId", nil, &r.Options, &resp)
1415 return
1416 }
1417
1418 // Retrieve
1419 func (r Virtual_Guest) GetMonitoringRobot() (resp datatypes.Monitoring_Robot, err error) {
1420 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "getMonitoringRobot", nil, &r.Options, &resp)
1421 return
1422 }
1423
1424 // Retrieve A virtual guest's network monitoring services.
1425 func (r Virtual_Guest) GetMonitoringServiceComponent() (resp datatypes.Network_Monitor_Version1_Query_Host_Stratum, err error) {
1426 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "getMonitoringServiceComponent", nil, &r.Options, &resp)
1427 return
1428 }
1429
1430 // Retrieve
1431 func (r Virtual_Guest) GetMonitoringServiceEligibilityFlag() (resp bool, err error) {
1432 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "getMonitoringServiceEligibilityFlag", nil, &r.Options, &resp)
1433 return
1434 }
1435
1436 // Retrieve The monitoring notification objects for this guest. Each object links this guest instance to a user account that will be notified if monitoring on this guest object fails
1437 func (r Virtual_Guest) GetMonitoringUserNotification() (resp []datatypes.User_Customer_Notification_Virtual_Guest, err error) {
1438 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "getMonitoringUserNotification", nil, &r.Options, &resp)
1439 return
1440 }
1441
1442 // Get the IP addresses associated with this CloudLayer computing instance that are protectable by a network component firewall. Note, this may not return all values for IPv6 subnets for this CloudLayer computing instance. Please use getFirewallProtectableSubnets to get all protectable subnets.
1443 func (r Virtual_Guest) GetNetworkComponentFirewallProtectableIpAddresses() (resp []datatypes.Network_Subnet_IpAddress, err error) {
1444 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "getNetworkComponentFirewallProtectableIpAddresses", nil, &r.Options, &resp)
1445 return
1446 }
1447
1448 // Retrieve A guests's network components.
1449 func (r Virtual_Guest) GetNetworkComponents() (resp []datatypes.Virtual_Guest_Network_Component, err error) {
1450 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "getNetworkComponents", nil, &r.Options, &resp)
1451 return
1452 }
1453
1454 // Retrieve All of a virtual guest's network monitoring incidents.
1455 func (r Virtual_Guest) GetNetworkMonitorIncidents() (resp []datatypes.Network_Monitor_Version1_Incident, err error) {
1456 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "getNetworkMonitorIncidents", nil, &r.Options, &resp)
1457 return
1458 }
1459
1460 // Retrieve A guests's network monitors.
1461 func (r Virtual_Guest) GetNetworkMonitors() (resp []datatypes.Network_Monitor_Version1_Query_Host, err error) {
1462 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "getNetworkMonitors", nil, &r.Options, &resp)
1463 return
1464 }
1465
1466 // Retrieve A guest's associated network storage accounts.
1467 func (r Virtual_Guest) GetNetworkStorage() (resp []datatypes.Network_Storage, err error) {
1468 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "getNetworkStorage", nil, &r.Options, &resp)
1469 return
1470 }
1471
1472 // Retrieve The network Vlans that a guest's network components are associated with.
1473 func (r Virtual_Guest) GetNetworkVlans() (resp []datatypes.Network_Vlan, err error) {
1474 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "getNetworkVlans", nil, &r.Options, &resp)
1475 return
1476 }
1477
1478 // no documentation yet
1479 func (r Virtual_Guest) GetObject() (resp datatypes.Virtual_Guest, err error) {
1480 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "getObject", nil, &r.Options, &resp)
1481 return
1482 }
1483
1484 // Retrieve An open ticket requesting cancellation of this server, if one exists.
1485 func (r Virtual_Guest) GetOpenCancellationTicket() (resp datatypes.Ticket, err error) {
1486 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "getOpenCancellationTicket", nil, &r.Options, &resp)
1487 return
1488 }
1489
1490 // Retrieve A guest's operating system.
1491 func (r Virtual_Guest) GetOperatingSystem() (resp datatypes.Software_Component_OperatingSystem, err error) {
1492 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "getOperatingSystem", nil, &r.Options, &resp)
1493 return
1494 }
1495
1496 // Retrieve A guest's operating system software description.
1497 func (r Virtual_Guest) GetOperatingSystemReferenceCode() (resp string, err error) {
1498 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "getOperatingSystemReferenceCode", nil, &r.Options, &resp)
1499 return
1500 }
1501
1502 // Obtain an order container that is ready to be sent to the [[SoftLayer_Product_Order#placeOrder|SoftLayer_Product_Order::placeOrder]] method. This container will include all services that the selected computing instance has. If desired you may remove prices which were returned.
1503 func (r Virtual_Guest) GetOrderTemplate(billingType *string, orderPrices []datatypes.Product_Item_Price) (resp datatypes.Container_Product_Order, err error) {
1504 params := []interface{}{
1505 billingType,
1506 orderPrices,
1507 }
1508 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "getOrderTemplate", params, &r.Options, &resp)
1509 return
1510 }
1511
1512 // Retrieve The original package id provided with the order for a Cloud Computing Instance.
1513 func (r Virtual_Guest) GetOrderedPackageId() (resp string, err error) {
1514 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "getOrderedPackageId", nil, &r.Options, &resp)
1515 return
1516 }
1517
1518 // Retrieve The total private outbound bandwidth for this computing instance for the current billing cycle.
1519 func (r Virtual_Guest) GetOutboundPrivateBandwidthUsage() (resp datatypes.Float64, err error) {
1520 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "getOutboundPrivateBandwidthUsage", nil, &r.Options, &resp)
1521 return
1522 }
1523
1524 // Retrieve The total public outbound bandwidth for this computing instance for the current billing cycle.
1525 func (r Virtual_Guest) GetOutboundPublicBandwidthUsage() (resp datatypes.Float64, err error) {
1526 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "getOutboundPublicBandwidthUsage", nil, &r.Options, &resp)
1527 return
1528 }
1529
1530 // Retrieve Whether the bandwidth usage for this computing instance for the current billing cycle exceeds the allocation.
1531 func (r Virtual_Guest) GetOverBandwidthAllocationFlag() (resp int, err error) {
1532 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "getOverBandwidthAllocationFlag", nil, &r.Options, &resp)
1533 return
1534 }
1535
1536 // Returns a list of all the pending maintenance actions affecting this guest.
1537 func (r Virtual_Guest) GetPendingMaintenanceActions() (resp []datatypes.Container_Virtual_Guest_PendingMaintenanceAction, err error) {
1538 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "getPendingMaintenanceActions", nil, &r.Options, &resp)
1539 return
1540 }
1541
1542 // Retrieve When true this virtual guest must be migrated using SoftLayer_Virtual_Guest::migrate.
1543 func (r Virtual_Guest) GetPendingMigrationFlag() (resp bool, err error) {
1544 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "getPendingMigrationFlag", nil, &r.Options, &resp)
1545 return
1546 }
1547
1548 // Retrieve The placement group that a virtual guest belongs to.
1549 func (r Virtual_Guest) GetPlacementGroup() (resp datatypes.Virtual_PlacementGroup, err error) {
1550 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "getPlacementGroup", nil, &r.Options, &resp)
1551 return
1552 }
1553
1554 // Retrieve The current power state of a virtual guest.
1555 func (r Virtual_Guest) GetPowerState() (resp datatypes.Virtual_Guest_Power_State, err error) {
1556 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "getPowerState", nil, &r.Options, &resp)
1557 return
1558 }
1559
1560 // Retrieve A guest's primary private IP address.
1561 func (r Virtual_Guest) GetPrimaryBackendIpAddress() (resp string, err error) {
1562 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "getPrimaryBackendIpAddress", nil, &r.Options, &resp)
1563 return
1564 }
1565
1566 // Retrieve A guest's primary backend network component.
1567 func (r Virtual_Guest) GetPrimaryBackendNetworkComponent() (resp datatypes.Virtual_Guest_Network_Component, err error) {
1568 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "getPrimaryBackendNetworkComponent", nil, &r.Options, &resp)
1569 return
1570 }
1571
1572 // Retrieve The guest's primary public IP address.
1573 func (r Virtual_Guest) GetPrimaryIpAddress() (resp string, err error) {
1574 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "getPrimaryIpAddress", nil, &r.Options, &resp)
1575 return
1576 }
1577
1578 // Retrieve A guest's primary public network component.
1579 func (r Virtual_Guest) GetPrimaryNetworkComponent() (resp datatypes.Virtual_Guest_Network_Component, err error) {
1580 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "getPrimaryNetworkComponent", nil, &r.Options, &resp)
1581 return
1582 }
1583
1584 // Retrieve Whether the computing instance only has access to the private network.
1585 func (r Virtual_Guest) GetPrivateNetworkOnlyFlag() (resp bool, err error) {
1586 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "getPrivateNetworkOnlyFlag", nil, &r.Options, &resp)
1587 return
1588 }
1589
1590 // Retrieve Whether the bandwidth usage for this computing instance for the current billing cycle is projected to exceed the allocation.
1591 func (r Virtual_Guest) GetProjectedOverBandwidthAllocationFlag() (resp int, err error) {
1592 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "getProjectedOverBandwidthAllocationFlag", nil, &r.Options, &resp)
1593 return
1594 }
1595
1596 // Retrieve The projected public outbound bandwidth for this computing instance for the current billing cycle.
1597 func (r Virtual_Guest) GetProjectedPublicBandwidthUsage() (resp datatypes.Float64, err error) {
1598 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "getProjectedPublicBandwidthUsage", nil, &r.Options, &resp)
1599 return
1600 }
1601
1602 // no documentation yet
1603 func (r Virtual_Guest) GetProvisionDate() (resp datatypes.Time, err error) {
1604 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "getProvisionDate", nil, &r.Options, &resp)
1605 return
1606 }
1607
1608 // Retrieve Recent events that impact this computing instance.
1609 func (r Virtual_Guest) GetRecentEvents() (resp []datatypes.Notification_Occurrence_Event, err error) {
1610 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "getRecentEvents", nil, &r.Options, &resp)
1611 return
1612 }
1613
1614 // Recent metric data for a guest
1615 func (r Virtual_Guest) GetRecentMetricData(time *uint) (resp []datatypes.Metric_Tracking_Object, err error) {
1616 params := []interface{}{
1617 time,
1618 }
1619 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "getRecentMetricData", params, &r.Options, &resp)
1620 return
1621 }
1622
1623 // Retrieve The regional group this guest is in.
1624 func (r Virtual_Guest) GetRegionalGroup() (resp datatypes.Location_Group_Regional, err error) {
1625 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "getRegionalGroup", nil, &r.Options, &resp)
1626 return
1627 }
1628
1629 // Retrieve
1630 func (r Virtual_Guest) GetRegionalInternetRegistry() (resp datatypes.Network_Regional_Internet_Registry, err error) {
1631 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "getRegionalInternetRegistry", nil, &r.Options, &resp)
1632 return
1633 }
1634
1635 // Retrieve The reserved capacity group the guest is associated with.
1636 func (r Virtual_Guest) GetReservedCapacityGroup() (resp datatypes.Virtual_ReservedCapacityGroup, err error) {
1637 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "getReservedCapacityGroup", nil, &r.Options, &resp)
1638 return
1639 }
1640
1641 // Retrieve Flag to indicate whether or not a guest is part of a reserved capacity group.
1642 func (r Virtual_Guest) GetReservedCapacityGroupFlag() (resp bool, err error) {
1643 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "getReservedCapacityGroupFlag", nil, &r.Options, &resp)
1644 return
1645 }
1646
1647 // Retrieve The reserved capacity group instance the guest is associated with.
1648 func (r Virtual_Guest) GetReservedCapacityGroupInstance() (resp datatypes.Virtual_ReservedCapacityGroup_Instance, err error) {
1649 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "getReservedCapacityGroupInstance", nil, &r.Options, &resp)
1650 return
1651 }
1652
1653 // Retrieve the reverse domain records associated with this server.
1654 func (r Virtual_Guest) GetReverseDomainRecords() (resp []datatypes.Dns_Domain, err error) {
1655 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "getReverseDomainRecords", nil, &r.Options, &resp)
1656 return
1657 }
1658
1659 // Retrieve A guest's vulnerability scan requests.
1660 func (r Virtual_Guest) GetSecurityScanRequests() (resp []datatypes.Network_Security_Scanner_Request, err error) {
1661 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "getSecurityScanRequests", nil, &r.Options, &resp)
1662 return
1663 }
1664
1665 // Retrieve The server room that a guest is located at. There may be more than one server room for every data center.
1666 func (r Virtual_Guest) GetServerRoom() (resp datatypes.Location, err error) {
1667 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "getServerRoom", nil, &r.Options, &resp)
1668 return
1669 }
1670
1671 // Retrieve A guest's installed software.
1672 func (r Virtual_Guest) GetSoftwareComponents() (resp []datatypes.Software_Component, err error) {
1673 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "getSoftwareComponents", nil, &r.Options, &resp)
1674 return
1675 }
1676
1677 // Retrieve SSH keys to be installed on the server during provisioning or an OS reload.
1678 func (r Virtual_Guest) GetSshKeys() (resp []datatypes.Security_Ssh_Key, err error) {
1679 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "getSshKeys", nil, &r.Options, &resp)
1680 return
1681 }
1682
1683 // Retrieve A computing instance's status.
1684 func (r Virtual_Guest) GetStatus() (resp datatypes.Virtual_Guest_Status, err error) {
1685 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "getStatus", nil, &r.Options, &resp)
1686 return
1687 }
1688
1689 // Retrieve
1690 func (r Virtual_Guest) GetTagReferences() (resp []datatypes.Tag_Reference, err error) {
1691 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "getTagReferences", nil, &r.Options, &resp)
1692 return
1693 }
1694
1695 // Retrieve Whether or not a computing instance is a Transient Instance.
1696 func (r Virtual_Guest) GetTransientGuestFlag() (resp bool, err error) {
1697 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "getTransientGuestFlag", nil, &r.Options, &resp)
1698 return
1699 }
1700
1701 // Retrieve The endpoint used to notify customers their transient guest is terminating.
1702 func (r Virtual_Guest) GetTransientWebhookURI() (resp datatypes.Virtual_Guest_Attribute, err error) {
1703 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "getTransientWebhookURI", nil, &r.Options, &resp)
1704 return
1705 }
1706
1707 // Retrieve The type of this virtual guest.
1708 func (r Virtual_Guest) GetType() (resp datatypes.Virtual_Guest_Type, err error) {
1709 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "getType", nil, &r.Options, &resp)
1710 return
1711 }
1712
1713 // Retrieves a list of all upgrades available to a virtual server. Upgradeable items include, but are not limited to, number of cores, amount of RAM, storage configuration, and network port speed.
1714 //
1715 // This method exclude downgrade item prices by default. You can set the "includeDowngradeItemPrices" parameter to true so that it can include downgrade item prices.
1716 func (r Virtual_Guest) GetUpgradeItemPrices(includeDowngradeItemPrices *bool) (resp []datatypes.Product_Item_Price, err error) {
1717 params := []interface{}{
1718 includeDowngradeItemPrices,
1719 }
1720 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "getUpgradeItemPrices", params, &r.Options, &resp)
1721 return
1722 }
1723
1724 // Retrieve A computing instance's associated upgrade request object if any.
1725 func (r Virtual_Guest) GetUpgradeRequest() (resp datatypes.Product_Upgrade_Request, err error) {
1726 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "getUpgradeRequest", nil, &r.Options, &resp)
1727 return
1728 }
1729
1730 // Retrieve A base64 encoded string containing custom user data for a Cloud Computing Instance order.
1731 func (r Virtual_Guest) GetUserData() (resp []datatypes.Virtual_Guest_Attribute, err error) {
1732 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "getUserData", nil, &r.Options, &resp)
1733 return
1734 }
1735
1736 // Retrieve A list of users that have access to this computing instance.
1737 func (r Virtual_Guest) GetUsers() (resp []datatypes.User_Customer, err error) {
1738 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "getUsers", nil, &r.Options, &resp)
1739 return
1740 }
1741
1742 // This method will return the list of block device template groups that are valid to the host. For instance, it will validate that the template groups returned are compatible with the size and number of disks on the host.
1743 func (r Virtual_Guest) GetValidBlockDeviceTemplateGroups(visibility *string) (resp []datatypes.Virtual_Guest_Block_Device_Template_Group, err error) {
1744 params := []interface{}{
1745 visibility,
1746 }
1747 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "getValidBlockDeviceTemplateGroups", params, &r.Options, &resp)
1748 return
1749 }
1750
1751 // Retrieve The name of the bandwidth allotment that a hardware belongs too.
1752 func (r Virtual_Guest) GetVirtualRack() (resp datatypes.Network_Bandwidth_Version1_Allotment, err error) {
1753 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "getVirtualRack", nil, &r.Options, &resp)
1754 return
1755 }
1756
1757 // Retrieve The id of the bandwidth allotment that a computing instance belongs too.
1758 func (r Virtual_Guest) GetVirtualRackId() (resp int, err error) {
1759 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "getVirtualRackId", nil, &r.Options, &resp)
1760 return
1761 }
1762
1763 // Retrieve The name of the bandwidth allotment that a computing instance belongs too.
1764 func (r Virtual_Guest) GetVirtualRackName() (resp string, err error) {
1765 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "getVirtualRackName", nil, &r.Options, &resp)
1766 return
1767 }
1768
1769 // Issues a ping command and returns the success (true) or failure (false) of the ping command.
1770 func (r Virtual_Guest) IsBackendPingable() (resp bool, err error) {
1771 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "isBackendPingable", nil, &r.Options, &resp)
1772 return
1773 }
1774
1775 // Determines if the virtual guest was provisioned from a cloud-init enabled image.
1776 func (r Virtual_Guest) IsCloudInit() (resp bool, err error) {
1777 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "isCloudInit", nil, &r.Options, &resp)
1778 return
1779 }
1780
1781 // Issues a ping command and returns the success (true) or failure (false) of the ping command.
1782 func (r Virtual_Guest) IsPingable() (resp bool, err error) {
1783 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "isPingable", nil, &r.Options, &resp)
1784 return
1785 }
1786
1787 // Closes the public or private ports to isolate the instance before a destructive action.
1788 func (r Virtual_Guest) IsolateInstanceForDestructiveAction() (err error) {
1789 var resp datatypes.Void
1790 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "isolateInstanceForDestructiveAction", nil, &r.Options, &resp)
1791 return
1792 }
1793
1794 // Creates a transaction to migrate a virtual guest to a new host. NOTE: Will only migrate if SoftLayer_Virtual_Guest property pendingMigrationFlag = true
1795 func (r Virtual_Guest) Migrate() (resp datatypes.Provisioning_Version1_Transaction, err error) {
1796 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "migrate", nil, &r.Options, &resp)
1797 return
1798 }
1799
1800 // Create a transaction to migrate an instance from one dedicated host to another dedicated host
1801 func (r Virtual_Guest) MigrateDedicatedHost(destinationHostId *int) (err error) {
1802 var resp datatypes.Void
1803 params := []interface{}{
1804 destinationHostId,
1805 }
1806 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "migrateDedicatedHost", params, &r.Options, &resp)
1807 return
1808 }
1809
1810 // no documentation yet
1811 func (r Virtual_Guest) MountIsoImage(diskImageId *int) (resp datatypes.Provisioning_Version1_Transaction, err error) {
1812 params := []interface{}{
1813 diskImageId,
1814 }
1815 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "mountIsoImage", params, &r.Options, &resp)
1816 return
1817 }
1818
1819 // Pause a virtual guest. This can only be called when the specified VM is in the Running state.
1820 func (r Virtual_Guest) Pause() (resp bool, err error) {
1821 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "pause", nil, &r.Options, &resp)
1822 return
1823 }
1824
1825 // Power cycle a virtual guest
1826 func (r Virtual_Guest) PowerCycle() (resp bool, err error) {
1827 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "powerCycle", nil, &r.Options, &resp)
1828 return
1829 }
1830
1831 // Power off a virtual guest
1832 func (r Virtual_Guest) PowerOff() (resp bool, err error) {
1833 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "powerOff", nil, &r.Options, &resp)
1834 return
1835 }
1836
1837 // Power off a virtual guest
1838 func (r Virtual_Guest) PowerOffSoft() (resp bool, err error) {
1839 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "powerOffSoft", nil, &r.Options, &resp)
1840 return
1841 }
1842
1843 // Power on a virtual guest
1844 func (r Virtual_Guest) PowerOn() (resp bool, err error) {
1845 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "powerOn", nil, &r.Options, &resp)
1846 return
1847 }
1848
1849 // Power cycle a virtual guest
1850 func (r Virtual_Guest) RebootDefault() (resp bool, err error) {
1851 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "rebootDefault", nil, &r.Options, &resp)
1852 return
1853 }
1854
1855 // Power cycle a guest.
1856 func (r Virtual_Guest) RebootHard() (resp bool, err error) {
1857 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "rebootHard", nil, &r.Options, &resp)
1858 return
1859 }
1860
1861 // Attempt to complete a soft reboot of a guest by shutting down the operating system.
1862 func (r Virtual_Guest) RebootSoft() (resp bool, err error) {
1863 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "rebootSoft", nil, &r.Options, &resp)
1864 return
1865 }
1866
1867 // no documentation yet
1868 // Deprecated: This function has been marked as deprecated.
1869 func (r Virtual_Guest) ReconfigureConsole() (err error) {
1870 var resp datatypes.Void
1871 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "reconfigureConsole", nil, &r.Options, &resp)
1872 return
1873 }
1874
1875 // Create a transaction to perform an OS reload
1876 func (r Virtual_Guest) ReloadCurrentOperatingSystemConfiguration() (resp datatypes.Provisioning_Version1_Transaction, err error) {
1877 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "reloadCurrentOperatingSystemConfiguration", nil, &r.Options, &resp)
1878 return
1879 }
1880
1881 // Reloads current operating system configuration.
1882 //
1883 // This service has a confirmation protocol for proceeding with the reload. To proceed with the reload without confirmation, simply pass in 'FORCE' as the token parameter. To proceed with the reload with confirmation, simply call the service with no parameter. A token string will be returned by this service. The token will remain active for 10 minutes. Use this token as the parameter to confirm that a reload is to be performed for the server.
1884 //
1885 // As a precaution, we strongly recommend backing up all data before reloading the operating system. The reload will format the primary disk and will reconfigure the computing instance to the current specifications on record.
1886 //
1887 // If reloading from an image template, we recommend first getting the list of valid private block device template groups, by calling the getOperatingSystemReloadImages method.
1888 func (r Virtual_Guest) ReloadOperatingSystem(token *string, config *datatypes.Container_Hardware_Server_Configuration) (resp string, err error) {
1889 params := []interface{}{
1890 token,
1891 config,
1892 }
1893 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "reloadOperatingSystem", params, &r.Options, &resp)
1894 return
1895 }
1896
1897 // This method is used to remove access to a SoftLayer_Network_Storage volume that supports host- or network-level access control.
1898 func (r Virtual_Guest) RemoveAccessToNetworkStorage(networkStorageTemplateObject *datatypes.Network_Storage) (resp bool, err error) {
1899 params := []interface{}{
1900 networkStorageTemplateObject,
1901 }
1902 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "removeAccessToNetworkStorage", params, &r.Options, &resp)
1903 return
1904 }
1905
1906 // This method is used to allow access to multiple SoftLayer_Network_Storage volumes that support host- or network-level access control.
1907 func (r Virtual_Guest) RemoveAccessToNetworkStorageList(networkStorageTemplateObjects []datatypes.Network_Storage) (resp bool, err error) {
1908 params := []interface{}{
1909 networkStorageTemplateObjects,
1910 }
1911 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "removeAccessToNetworkStorageList", params, &r.Options, &resp)
1912 return
1913 }
1914
1915 // no documentation yet
1916 func (r Virtual_Guest) RemoveTags(tags *string) (resp bool, err error) {
1917 params := []interface{}{
1918 tags,
1919 }
1920 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "removeTags", params, &r.Options, &resp)
1921 return
1922 }
1923
1924 // Resume a virtual guest, this can only be called when a VSI is in Suspended state.
1925 func (r Virtual_Guest) Resume() (resp bool, err error) {
1926 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "resume", nil, &r.Options, &resp)
1927 return
1928 }
1929
1930 // no documentation yet
1931 func (r Virtual_Guest) SendTestReclaimScheduledAlert() (err error) {
1932 var resp datatypes.Void
1933 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "sendTestReclaimScheduledAlert", nil, &r.Options, &resp)
1934 return
1935 }
1936
1937 // Sets the private network interface speed to the new speed. Speed values can only be 0 (Disconnect), 10, 100, or 1000. The new speed must be equal to or less than the max speed of the interface.
1938 //
1939 // It will take less than a minute to update the port speed.
1940 func (r Virtual_Guest) SetPrivateNetworkInterfaceSpeed(newSpeed *int) (resp bool, err error) {
1941 params := []interface{}{
1942 newSpeed,
1943 }
1944 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "setPrivateNetworkInterfaceSpeed", params, &r.Options, &resp)
1945 return
1946 }
1947
1948 // Sets the public network interface speed to the new speed. Speed values can only be 0 (Disconnect), 10, 100, or 1000. The new speed must be equal to or less than the max speed of the interface.
1949 //
1950 // It will take less than a minute to update the port speed.
1951 func (r Virtual_Guest) SetPublicNetworkInterfaceSpeed(newSpeed *int) (resp bool, err error) {
1952 params := []interface{}{
1953 newSpeed,
1954 }
1955 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "setPublicNetworkInterfaceSpeed", params, &r.Options, &resp)
1956 return
1957 }
1958
1959 // no documentation yet
1960 func (r Virtual_Guest) SetTags(tags *string) (resp bool, err error) {
1961 params := []interface{}{
1962 tags,
1963 }
1964 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "setTags", params, &r.Options, &resp)
1965 return
1966 }
1967
1968 // no documentation yet
1969 func (r Virtual_Guest) SetTransientWebhook(uri *string, secret *string) (err error) {
1970 var resp datatypes.Void
1971 params := []interface{}{
1972 uri,
1973 secret,
1974 }
1975 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "setTransientWebhook", params, &r.Options, &resp)
1976 return
1977 }
1978
1979 // Sets the data that will be written to the configuration drive.
1980 func (r Virtual_Guest) SetUserMetadata(metadata []string) (resp bool, err error) {
1981 params := []interface{}{
1982 metadata,
1983 }
1984 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "setUserMetadata", params, &r.Options, &resp)
1985 return
1986 }
1987
1988 // Shuts down the private network port
1989 func (r Virtual_Guest) ShutdownPrivatePort() (resp bool, err error) {
1990 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "shutdownPrivatePort", nil, &r.Options, &resp)
1991 return
1992 }
1993
1994 // Shuts down the public network port
1995 func (r Virtual_Guest) ShutdownPublicPort() (resp bool, err error) {
1996 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "shutdownPublicPort", nil, &r.Options, &resp)
1997 return
1998 }
1999
2000 // no documentation yet
2001 func (r Virtual_Guest) UnmountIsoImage() (resp datatypes.Provisioning_Version1_Transaction, err error) {
2002 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "unmountIsoImage", nil, &r.Options, &resp)
2003 return
2004 }
2005
2006 // Validate an image template for OS Reload
2007 func (r Virtual_Guest) ValidateImageTemplate(imageTemplateId *int) (resp bool, err error) {
2008 params := []interface{}{
2009 imageTemplateId,
2010 }
2011 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "validateImageTemplate", params, &r.Options, &resp)
2012 return
2013 }
2014
2015 // Verify that a virtual server can go through the operating system reload process. It may be useful to call this method before attempting to actually reload the operating system just to verify that the reload will go smoothly. If the server configuration is not setup correctly or there is some other issue, an exception will be thrown indicating the error. If there were no issues, this will just return true.
2016 func (r Virtual_Guest) VerifyReloadOperatingSystem(config *datatypes.Container_Hardware_Server_Configuration) (resp bool, err error) {
2017 params := []interface{}{
2018 config,
2019 }
2020 err = r.Session.DoRequest("SoftLayer_Virtual_Guest", "verifyReloadOperatingSystem", params, &r.Options, &resp)
2021 return
2022 }
2023
2024 // The virtual block device template group data type presents the structure in which a group of archived image templates will be presented. The structure consists of a parent template group which contain multiple child template group objects. Each child template group object represents the image template in a particular location. Unless editing/deleting a specific child template group object, it is best to use the parent object.
2025 //
2026 // A virtual block device template group, also known as an image template group, represents an image of a virtual guest instance.
2027 type Virtual_Guest_Block_Device_Template_Group struct {
2028 Session session.SLSession
2029 Options sl.Options
2030 }
2031
2032 // GetVirtualGuestBlockDeviceTemplateGroupService returns an instance of the Virtual_Guest_Block_Device_Template_Group SoftLayer service
2033 func GetVirtualGuestBlockDeviceTemplateGroupService(sess session.SLSession) Virtual_Guest_Block_Device_Template_Group {
2034 return Virtual_Guest_Block_Device_Template_Group{Session: sess}
2035 }
2036
2037 func (r Virtual_Guest_Block_Device_Template_Group) Id(id int) Virtual_Guest_Block_Device_Template_Group {
2038 r.Options.Id = &id
2039 return r
2040 }
2041
2042 func (r Virtual_Guest_Block_Device_Template_Group) Mask(mask string) Virtual_Guest_Block_Device_Template_Group {
2043 if !strings.HasPrefix(mask, "mask[") && (strings.Contains(mask, "[") || strings.Contains(mask, ",")) {
2044 mask = fmt.Sprintf("mask[%s]", mask)
2045 }
2046
2047 r.Options.Mask = mask
2048 return r
2049 }
2050
2051 func (r Virtual_Guest_Block_Device_Template_Group) Filter(filter string) Virtual_Guest_Block_Device_Template_Group {
2052 r.Options.Filter = filter
2053 return r
2054 }
2055
2056 func (r Virtual_Guest_Block_Device_Template_Group) Limit(limit int) Virtual_Guest_Block_Device_Template_Group {
2057 r.Options.Limit = &limit
2058 return r
2059 }
2060
2061 func (r Virtual_Guest_Block_Device_Template_Group) Offset(offset int) Virtual_Guest_Block_Device_Template_Group {
2062 r.Options.Offset = &offset
2063 return r
2064 }
2065
2066 // This method allows you to mark this image template as customer managed software license (BYOL)
2067 func (r Virtual_Guest_Block_Device_Template_Group) AddByolAttribute() (resp bool, err error) {
2068 err = r.Session.DoRequest("SoftLayer_Virtual_Guest_Block_Device_Template_Group", "addByolAttribute", nil, &r.Options, &resp)
2069 return
2070 }
2071
2072 // This method allows you to mark this image template as cloud init
2073 func (r Virtual_Guest_Block_Device_Template_Group) AddCloudInitAttribute() (resp bool, err error) {
2074 err = r.Session.DoRequest("SoftLayer_Virtual_Guest_Block_Device_Template_Group", "addCloudInitAttribute", nil, &r.Options, &resp)
2075 return
2076 }
2077
2078 // This method will create transaction(s) to add available locations to an archive image template.
2079 func (r Virtual_Guest_Block_Device_Template_Group) AddLocations(locations []datatypes.Location) (resp bool, err error) {
2080 params := []interface{}{
2081 locations,
2082 }
2083 err = r.Session.DoRequest("SoftLayer_Virtual_Guest_Block_Device_Template_Group", "addLocations", params, &r.Options, &resp)
2084 return
2085 }
2086
2087 // This method allows you to mark this image's supported boot modes as 'HVM' or 'PV'.
2088 func (r Virtual_Guest_Block_Device_Template_Group) AddSupportedBootMode(bootMode *string) (resp bool, err error) {
2089 params := []interface{}{
2090 bootMode,
2091 }
2092 err = r.Session.DoRequest("SoftLayer_Virtual_Guest_Block_Device_Template_Group", "addSupportedBootMode", params, &r.Options, &resp)
2093 return
2094 }
2095
2096 // Create a transaction to export/copy a template to an external source.
2097 func (r Virtual_Guest_Block_Device_Template_Group) CopyToExternalSource(configuration *datatypes.Container_Virtual_Guest_Block_Device_Template_Configuration) (resp bool, err error) {
2098 params := []interface{}{
2099 configuration,
2100 }
2101 err = r.Session.DoRequest("SoftLayer_Virtual_Guest_Block_Device_Template_Group", "copyToExternalSource", params, &r.Options, &resp)
2102 return
2103 }
2104
2105 // Create a transaction to export/copy a template to an ICOS.
2106 func (r Virtual_Guest_Block_Device_Template_Group) CopyToIcos(configuration *datatypes.Container_Virtual_Guest_Block_Device_Template_Configuration) (resp bool, err error) {
2107 params := []interface{}{
2108 configuration,
2109 }
2110 err = r.Session.DoRequest("SoftLayer_Virtual_Guest_Block_Device_Template_Group", "copyToIcos", params, &r.Options, &resp)
2111 return
2112 }
2113
2114 // Create a transaction to import a disk image from an external source and create a standard image template.
2115 func (r Virtual_Guest_Block_Device_Template_Group) CreateFromExternalSource(configuration *datatypes.Container_Virtual_Guest_Block_Device_Template_Configuration) (resp datatypes.Virtual_Guest_Block_Device_Template_Group, err error) {
2116 params := []interface{}{
2117 configuration,
2118 }
2119 err = r.Session.DoRequest("SoftLayer_Virtual_Guest_Block_Device_Template_Group", "createFromExternalSource", params, &r.Options, &resp)
2120 return
2121 }
2122
2123 // Create a process to import a disk image from ICOS and create a standard
2124 func (r Virtual_Guest_Block_Device_Template_Group) CreateFromIcos(configuration *datatypes.Container_Virtual_Guest_Block_Device_Template_Configuration) (resp datatypes.Virtual_Guest_Block_Device_Template_Group, err error) {
2125 params := []interface{}{
2126 configuration,
2127 }
2128 err = r.Session.DoRequest("SoftLayer_Virtual_Guest_Block_Device_Template_Group", "createFromIcos", params, &r.Options, &resp)
2129 return
2130 }
2131
2132 // Create a transaction to copy archived block devices into public repository
2133 func (r Virtual_Guest_Block_Device_Template_Group) CreatePublicArchiveTransaction(groupName *string, summary *string, note *string, locations []datatypes.Location) (resp int, err error) {
2134 params := []interface{}{
2135 groupName,
2136 summary,
2137 note,
2138 locations,
2139 }
2140 err = r.Session.DoRequest("SoftLayer_Virtual_Guest_Block_Device_Template_Group", "createPublicArchiveTransaction", params, &r.Options, &resp)
2141 return
2142 }
2143
2144 // This method allows you to remove BYOL attribute for a given image template.
2145 func (r Virtual_Guest_Block_Device_Template_Group) DeleteByolAttribute() (resp bool, err error) {
2146 err = r.Session.DoRequest("SoftLayer_Virtual_Guest_Block_Device_Template_Group", "deleteByolAttribute", nil, &r.Options, &resp)
2147 return
2148 }
2149
2150 // This method allows you to remove cloud init attribute for a given image template.
2151 func (r Virtual_Guest_Block_Device_Template_Group) DeleteCloudInitAttribute() (resp bool, err error) {
2152 err = r.Session.DoRequest("SoftLayer_Virtual_Guest_Block_Device_Template_Group", "deleteCloudInitAttribute", nil, &r.Options, &resp)
2153 return
2154 }
2155
2156 // Deleting a block device template group is different from the deletion of other objects. A block device template group can contain several gigabytes of data in its disk images. This may take some time to delete and requires a transaction to be created. This method creates a transaction that will delete all resources associated with the block device template group.
2157 func (r Virtual_Guest_Block_Device_Template_Group) DeleteObject() (resp datatypes.Provisioning_Version1_Transaction, err error) {
2158 err = r.Session.DoRequest("SoftLayer_Virtual_Guest_Block_Device_Template_Group", "deleteObject", nil, &r.Options, &resp)
2159 return
2160 }
2161
2162 // This method will deny another SoftLayer customer account's previously given access to provision CloudLayer Computing Instances from an image template group. Template access should only be removed from the parent template group object, not the child.
2163 func (r Virtual_Guest_Block_Device_Template_Group) DenySharingAccess(accountId *int) (resp bool, err error) {
2164 params := []interface{}{
2165 accountId,
2166 }
2167 err = r.Session.DoRequest("SoftLayer_Virtual_Guest_Block_Device_Template_Group", "denySharingAccess", params, &r.Options, &resp)
2168 return
2169 }
2170
2171 // Edit an image template group's associated name and note. All other properties in the SoftLayer_Virtual_Guest_Block_Device_Template_Group data type are read-only.
2172 func (r Virtual_Guest_Block_Device_Template_Group) EditObject(templateObject *datatypes.Virtual_Guest_Block_Device_Template_Group) (resp bool, err error) {
2173 params := []interface{}{
2174 templateObject,
2175 }
2176 err = r.Session.DoRequest("SoftLayer_Virtual_Guest_Block_Device_Template_Group", "editObject", params, &r.Options, &resp)
2177 return
2178 }
2179
2180 // Find block device template groups containing a GC enabled cloudinit image for the current active user. A sorted collection of groups is returned. The Caller can optionally specify data center or region names to retrieve GC images from only those locations.
2181 func (r Virtual_Guest_Block_Device_Template_Group) FindGcImagesByCurrentUser(dataCenters []string, regions []string) (resp []datatypes.Virtual_Guest_Block_Device_Template_Group, err error) {
2182 params := []interface{}{
2183 dataCenters,
2184 regions,
2185 }
2186 err = r.Session.DoRequest("SoftLayer_Virtual_Guest_Block_Device_Template_Group", "findGcImagesByCurrentUser", params, &r.Options, &resp)
2187 return
2188 }
2189
2190 // Retrieve A block device template group's [[SoftLayer_Account|account]].
2191 func (r Virtual_Guest_Block_Device_Template_Group) GetAccount() (resp datatypes.Account, err error) {
2192 err = r.Session.DoRequest("SoftLayer_Virtual_Guest_Block_Device_Template_Group", "getAccount", nil, &r.Options, &resp)
2193 return
2194 }
2195
2196 // Retrieve
2197 func (r Virtual_Guest_Block_Device_Template_Group) GetAccountContacts() (resp []datatypes.Account_Contact, err error) {
2198 err = r.Session.DoRequest("SoftLayer_Virtual_Guest_Block_Device_Template_Group", "getAccountContacts", nil, &r.Options, &resp)
2199 return
2200 }
2201
2202 // Retrieve The accounts which may have read-only access to an image template group. Will only be populated for parent template group objects.
2203 func (r Virtual_Guest_Block_Device_Template_Group) GetAccountReferences() (resp []datatypes.Virtual_Guest_Block_Device_Template_Group_Accounts, err error) {
2204 err = r.Session.DoRequest("SoftLayer_Virtual_Guest_Block_Device_Template_Group", "getAccountReferences", nil, &r.Options, &resp)
2205 return
2206 }
2207
2208 // Get all available compatible platform names that can be added to a template group.
2209 func (r Virtual_Guest_Block_Device_Template_Group) GetAllAvailableCompatiblePlatformNames() (resp []string, err error) {
2210 err = r.Session.DoRequest("SoftLayer_Virtual_Guest_Block_Device_Template_Group", "getAllAvailableCompatiblePlatformNames", nil, &r.Options, &resp)
2211 return
2212 }
2213
2214 // Retrieve The block devices that are part of an image template group
2215 func (r Virtual_Guest_Block_Device_Template_Group) GetBlockDevices() (resp []datatypes.Virtual_Guest_Block_Device_Template, err error) {
2216 err = r.Session.DoRequest("SoftLayer_Virtual_Guest_Block_Device_Template_Group", "getBlockDevices", nil, &r.Options, &resp)
2217 return
2218 }
2219
2220 // Retrieve The total disk space of all images in a image template group.
2221 func (r Virtual_Guest_Block_Device_Template_Group) GetBlockDevicesDiskSpaceTotal() (resp datatypes.Float64, err error) {
2222 err = r.Session.DoRequest("SoftLayer_Virtual_Guest_Block_Device_Template_Group", "getBlockDevicesDiskSpaceTotal", nil, &r.Options, &resp)
2223 return
2224 }
2225
2226 // This method returns the boot mode, if any, set on a given image template.
2227 func (r Virtual_Guest_Block_Device_Template_Group) GetBootMode() (resp string, err error) {
2228 err = r.Session.DoRequest("SoftLayer_Virtual_Guest_Block_Device_Template_Group", "getBootMode", nil, &r.Options, &resp)
2229 return
2230 }
2231
2232 // Retrieve A flag indicating that customer is providing the software licenses.
2233 func (r Virtual_Guest_Block_Device_Template_Group) GetByolFlag() (resp bool, err error) {
2234 err = r.Session.DoRequest("SoftLayer_Virtual_Guest_Block_Device_Template_Group", "getByolFlag", nil, &r.Options, &resp)
2235 return
2236 }
2237
2238 // Retrieve The image template groups that are clones of an image template group.
2239 func (r Virtual_Guest_Block_Device_Template_Group) GetChildren() (resp []datatypes.Virtual_Guest_Block_Device_Template_Group, err error) {
2240 err = r.Session.DoRequest("SoftLayer_Virtual_Guest_Block_Device_Template_Group", "getChildren", nil, &r.Options, &resp)
2241 return
2242 }
2243
2244 // Get compatible platform names currently set on the template group.
2245 func (r Virtual_Guest_Block_Device_Template_Group) GetCurrentCompatiblePlatformNames() (resp []string, err error) {
2246 err = r.Session.DoRequest("SoftLayer_Virtual_Guest_Block_Device_Template_Group", "getCurrentCompatiblePlatformNames", nil, &r.Options, &resp)
2247 return
2248 }
2249
2250 // Retrieve The location containing this image template group. Will only be populated for child template group objects.
2251 func (r Virtual_Guest_Block_Device_Template_Group) GetDatacenter() (resp datatypes.Location, err error) {
2252 err = r.Session.DoRequest("SoftLayer_Virtual_Guest_Block_Device_Template_Group", "getDatacenter", nil, &r.Options, &resp)
2253 return
2254 }
2255
2256 // Retrieve A collection of locations containing a copy of this image template group. Will only be populated for parent template group objects.
2257 func (r Virtual_Guest_Block_Device_Template_Group) GetDatacenters() (resp []datatypes.Location, err error) {
2258 err = r.Session.DoRequest("SoftLayer_Virtual_Guest_Block_Device_Template_Group", "getDatacenters", nil, &r.Options, &resp)
2259 return
2260 }
2261
2262 // This method returns the default boot mode set by the software description
2263 func (r Virtual_Guest_Block_Device_Template_Group) GetDefaultBootMode() (resp string, err error) {
2264 err = r.Session.DoRequest("SoftLayer_Virtual_Guest_Block_Device_Template_Group", "getDefaultBootMode", nil, &r.Options, &resp)
2265 return
2266 }
2267
2268 // This method returns an array of encryption values, or empty array if none are found
2269 func (r Virtual_Guest_Block_Device_Template_Group) GetEncryptionAttributes() (resp []string, err error) {
2270 err = r.Session.DoRequest("SoftLayer_Virtual_Guest_Block_Device_Template_Group", "getEncryptionAttributes", nil, &r.Options, &resp)
2271 return
2272 }
2273
2274 // Retrieve The first clone of the image template group
2275 func (r Virtual_Guest_Block_Device_Template_Group) GetFirstChild() (resp datatypes.Virtual_Guest_Block_Device_Template_Group, err error) {
2276 err = r.Session.DoRequest("SoftLayer_Virtual_Guest_Block_Device_Template_Group", "getFirstChild", nil, &r.Options, &resp)
2277 return
2278 }
2279
2280 // Retrieve A flag indicating if this is a flex image.
2281 func (r Virtual_Guest_Block_Device_Template_Group) GetFlexImageFlag() (resp bool, err error) {
2282 err = r.Session.DoRequest("SoftLayer_Virtual_Guest_Block_Device_Template_Group", "getFlexImageFlag", nil, &r.Options, &resp)
2283 return
2284 }
2285
2286 // Retrieve An image template's universally unique identifier.
2287 func (r Virtual_Guest_Block_Device_Template_Group) GetGlobalIdentifier() (resp string, err error) {
2288 err = r.Session.DoRequest("SoftLayer_Virtual_Guest_Block_Device_Template_Group", "getGlobalIdentifier", nil, &r.Options, &resp)
2289 return
2290 }
2291
2292 // Retrieve The virtual disk image type of this template. Value will be populated on parent and child, but only supports object filtering on the parent.
2293 func (r Virtual_Guest_Block_Device_Template_Group) GetImageType() (resp datatypes.Virtual_Disk_Image_Type, err error) {
2294 err = r.Session.DoRequest("SoftLayer_Virtual_Guest_Block_Device_Template_Group", "getImageType", nil, &r.Options, &resp)
2295 return
2296 }
2297
2298 // Retrieve The virtual disk image type keyname (e.g. SYSTEM, DISK_CAPTURE, ISO, etc) of this template. Value will be populated on parent and child, but only supports object filtering on the parent.
2299 func (r Virtual_Guest_Block_Device_Template_Group) GetImageTypeKeyName() (resp string, err error) {
2300 err = r.Session.DoRequest("SoftLayer_Virtual_Guest_Block_Device_Template_Group", "getImageTypeKeyName", nil, &r.Options, &resp)
2301 return
2302 }
2303
2304 // Retrieve A flag indicating if this is a next generation image.
2305 func (r Virtual_Guest_Block_Device_Template_Group) GetNextGenFlag() (resp bool, err error) {
2306 err = r.Session.DoRequest("SoftLayer_Virtual_Guest_Block_Device_Template_Group", "getNextGenFlag", nil, &r.Options, &resp)
2307 return
2308 }
2309
2310 // no documentation yet
2311 func (r Virtual_Guest_Block_Device_Template_Group) GetObject() (resp datatypes.Virtual_Guest_Block_Device_Template_Group, err error) {
2312 err = r.Session.DoRequest("SoftLayer_Virtual_Guest_Block_Device_Template_Group", "getObject", nil, &r.Options, &resp)
2313 return
2314 }
2315
2316 // Retrieve The image template group that another image template group was cloned from.
2317 func (r Virtual_Guest_Block_Device_Template_Group) GetParent() (resp datatypes.Virtual_Guest_Block_Device_Template_Group, err error) {
2318 err = r.Session.DoRequest("SoftLayer_Virtual_Guest_Block_Device_Template_Group", "getParent", nil, &r.Options, &resp)
2319 return
2320 }
2321
2322 // This method gets all public customer owned image templates that the user is allowed to see.
2323 func (r Virtual_Guest_Block_Device_Template_Group) GetPublicCustomerOwnedImages() (resp []datatypes.Virtual_Guest_Block_Device_Template_Group, err error) {
2324 err = r.Session.DoRequest("SoftLayer_Virtual_Guest_Block_Device_Template_Group", "getPublicCustomerOwnedImages", nil, &r.Options, &resp)
2325 return
2326 }
2327
2328 // This method gets all public image templates that the user is allowed to see.
2329 func (r Virtual_Guest_Block_Device_Template_Group) GetPublicImages() (resp []datatypes.Virtual_Guest_Block_Device_Template_Group, err error) {
2330 err = r.Session.DoRequest("SoftLayer_Virtual_Guest_Block_Device_Template_Group", "getPublicImages", nil, &r.Options, &resp)
2331 return
2332 }
2333
2334 // Retrieve
2335 func (r Virtual_Guest_Block_Device_Template_Group) GetRegion() (resp datatypes.Network_Service_Resource, err error) {
2336 err = r.Session.DoRequest("SoftLayer_Virtual_Guest_Block_Device_Template_Group", "getRegion", nil, &r.Options, &resp)
2337 return
2338 }
2339
2340 // Retrieve
2341 func (r Virtual_Guest_Block_Device_Template_Group) GetRegions() (resp []datatypes.Network_Service_Resource, err error) {
2342 err = r.Session.DoRequest("SoftLayer_Virtual_Guest_Block_Device_Template_Group", "getRegions", nil, &r.Options, &resp)
2343 return
2344 }
2345
2346 // Retrieve The ssh keys to be implemented on the server when provisioned or reloaded from an image template group.
2347 func (r Virtual_Guest_Block_Device_Template_Group) GetSshKeys() (resp []datatypes.Security_Ssh_Key, err error) {
2348 err = r.Session.DoRequest("SoftLayer_Virtual_Guest_Block_Device_Template_Group", "getSshKeys", nil, &r.Options, &resp)
2349 return
2350 }
2351
2352 // Retrieve A template group's status.
2353 func (r Virtual_Guest_Block_Device_Template_Group) GetStatus() (resp datatypes.Virtual_Guest_Block_Device_Template_Group_Status, err error) {
2354 err = r.Session.DoRequest("SoftLayer_Virtual_Guest_Block_Device_Template_Group", "getStatus", nil, &r.Options, &resp)
2355 return
2356 }
2357
2358 // Returns the image storage locations.
2359 func (r Virtual_Guest_Block_Device_Template_Group) GetStorageLocations() (resp []datatypes.Location, err error) {
2360 err = r.Session.DoRequest("SoftLayer_Virtual_Guest_Block_Device_Template_Group", "getStorageLocations", nil, &r.Options, &resp)
2361 return
2362 }
2363
2364 // Retrieve The storage repository that an image template group resides on.
2365 func (r Virtual_Guest_Block_Device_Template_Group) GetStorageRepository() (resp datatypes.Virtual_Storage_Repository, err error) {
2366 err = r.Session.DoRequest("SoftLayer_Virtual_Guest_Block_Device_Template_Group", "getStorageRepository", nil, &r.Options, &resp)
2367 return
2368 }
2369
2370 // This method indicates which boot modes are supported by the image.
2371 func (r Virtual_Guest_Block_Device_Template_Group) GetSupportedBootModes() (resp []string, err error) {
2372 err = r.Session.DoRequest("SoftLayer_Virtual_Guest_Block_Device_Template_Group", "getSupportedBootModes", nil, &r.Options, &resp)
2373 return
2374 }
2375
2376 // Retrieve The tags associated with this image template group.
2377 func (r Virtual_Guest_Block_Device_Template_Group) GetTagReferences() (resp []datatypes.Tag_Reference, err error) {
2378 err = r.Session.DoRequest("SoftLayer_Virtual_Guest_Block_Device_Template_Group", "getTagReferences", nil, &r.Options, &resp)
2379 return
2380 }
2381
2382 // This method allows you to grab the first data center that the image(s) reside on so we can pull it from there.
2383 func (r Virtual_Guest_Block_Device_Template_Group) GetTemplateDataCenterName() (resp string, err error) {
2384 err = r.Session.DoRequest("SoftLayer_Virtual_Guest_Block_Device_Template_Group", "getTemplateDataCenterName", nil, &r.Options, &resp)
2385 return
2386 }
2387
2388 // Retrieve A transaction that is being performed on a image template group.
2389 func (r Virtual_Guest_Block_Device_Template_Group) GetTransaction() (resp datatypes.Provisioning_Version1_Transaction, err error) {
2390 err = r.Session.DoRequest("SoftLayer_Virtual_Guest_Block_Device_Template_Group", "getTransaction", nil, &r.Options, &resp)
2391 return
2392 }
2393
2394 // Returns an array of SoftLayer_Software_Description that are supported for VHD imports.
2395 func (r Virtual_Guest_Block_Device_Template_Group) GetVhdImportSoftwareDescriptions() (resp []datatypes.Software_Description, err error) {
2396 err = r.Session.DoRequest("SoftLayer_Virtual_Guest_Block_Device_Template_Group", "getVhdImportSoftwareDescriptions", nil, &r.Options, &resp)
2397 return
2398 }
2399
2400 // This method indicates whether or not this image is a customer supplied license image.
2401 func (r Virtual_Guest_Block_Device_Template_Group) IsByol() (resp bool, err error) {
2402 err = r.Session.DoRequest("SoftLayer_Virtual_Guest_Block_Device_Template_Group", "isByol", nil, &r.Options, &resp)
2403 return
2404 }
2405
2406 // This method indicates whether or not this image uses an operating system capable of using a customer supplied license image.
2407 func (r Virtual_Guest_Block_Device_Template_Group) IsByolCapableOperatingSystem() (resp bool, err error) {
2408 err = r.Session.DoRequest("SoftLayer_Virtual_Guest_Block_Device_Template_Group", "isByolCapableOperatingSystem", nil, &r.Options, &resp)
2409 return
2410 }
2411
2412 // This method indicates whether or not this image uses an operating system that requires using a customer supplied license image
2413 func (r Virtual_Guest_Block_Device_Template_Group) IsByolOnlyOperatingSystem() (resp bool, err error) {
2414 err = r.Session.DoRequest("SoftLayer_Virtual_Guest_Block_Device_Template_Group", "isByolOnlyOperatingSystem", nil, &r.Options, &resp)
2415 return
2416 }
2417
2418 // This method indicates whether or not this image is a cloud-init image.
2419 func (r Virtual_Guest_Block_Device_Template_Group) IsCloudInit() (resp bool, err error) {
2420 err = r.Session.DoRequest("SoftLayer_Virtual_Guest_Block_Device_Template_Group", "isCloudInit", nil, &r.Options, &resp)
2421 return
2422 }
2423
2424 // This method indicates whether or not this image uses an operating system that requires cloud init
2425 func (r Virtual_Guest_Block_Device_Template_Group) IsCloudInitOnlyOperatingSystem() (resp bool, err error) {
2426 err = r.Session.DoRequest("SoftLayer_Virtual_Guest_Block_Device_Template_Group", "isCloudInitOnlyOperatingSystem", nil, &r.Options, &resp)
2427 return
2428 }
2429
2430 // This method indicates whether this image template contains an encrypted disk image.
2431 func (r Virtual_Guest_Block_Device_Template_Group) IsEncrypted() (resp bool, err error) {
2432 err = r.Session.DoRequest("SoftLayer_Virtual_Guest_Block_Device_Template_Group", "isEncrypted", nil, &r.Options, &resp)
2433 return
2434 }
2435
2436 // This method will permit another SoftLayer customer account access to provision CloudLayer Computing Instances from an image template group. Template access should only be given to the parent template group object, not the child.
2437 func (r Virtual_Guest_Block_Device_Template_Group) PermitSharingAccess(accountId *int) (resp bool, err error) {
2438 params := []interface{}{
2439 accountId,
2440 }
2441 err = r.Session.DoRequest("SoftLayer_Virtual_Guest_Block_Device_Template_Group", "permitSharingAccess", params, &r.Options, &resp)
2442 return
2443 }
2444
2445 // Removes compatible platforms on the template group.
2446 func (r Virtual_Guest_Block_Device_Template_Group) RemoveCompatiblePlatforms(platformNames []string) (resp bool, err error) {
2447 params := []interface{}{
2448 platformNames,
2449 }
2450 err = r.Session.DoRequest("SoftLayer_Virtual_Guest_Block_Device_Template_Group", "removeCompatiblePlatforms", params, &r.Options, &resp)
2451 return
2452 }
2453
2454 // This method will create transaction(s) to remove available locations from an archive image template.
2455 func (r Virtual_Guest_Block_Device_Template_Group) RemoveLocations(locations []datatypes.Location) (resp bool, err error) {
2456 params := []interface{}{
2457 locations,
2458 }
2459 err = r.Session.DoRequest("SoftLayer_Virtual_Guest_Block_Device_Template_Group", "removeLocations", params, &r.Options, &resp)
2460 return
2461 }
2462
2463 // This method allows you to remove a supported boot mode attribute for a given image template.
2464 func (r Virtual_Guest_Block_Device_Template_Group) RemoveSupportedBootMode(bootMode *string) (resp bool, err error) {
2465 params := []interface{}{
2466 bootMode,
2467 }
2468 err = r.Session.DoRequest("SoftLayer_Virtual_Guest_Block_Device_Template_Group", "removeSupportedBootMode", params, &r.Options, &resp)
2469 return
2470 }
2471
2472 // Create transaction(s) to set the archived block device available locations
2473 func (r Virtual_Guest_Block_Device_Template_Group) SetAvailableLocations(locations []datatypes.Location) (resp bool, err error) {
2474 params := []interface{}{
2475 locations,
2476 }
2477 err = r.Session.DoRequest("SoftLayer_Virtual_Guest_Block_Device_Template_Group", "setAvailableLocations", params, &r.Options, &resp)
2478 return
2479 }
2480
2481 // This method allows you to specify the boot mode for a given image template.
2482 func (r Virtual_Guest_Block_Device_Template_Group) SetBootMode(newBootMode *string) (resp bool, err error) {
2483 params := []interface{}{
2484 newBootMode,
2485 }
2486 err = r.Session.DoRequest("SoftLayer_Virtual_Guest_Block_Device_Template_Group", "setBootMode", params, &r.Options, &resp)
2487 return
2488 }
2489
2490 // Sets compatible platforms on the template group.
2491 func (r Virtual_Guest_Block_Device_Template_Group) SetCompatiblePlatforms(platformNames []string) (resp bool, err error) {
2492 params := []interface{}{
2493 platformNames,
2494 }
2495 err = r.Session.DoRequest("SoftLayer_Virtual_Guest_Block_Device_Template_Group", "setCompatiblePlatforms", params, &r.Options, &resp)
2496 return
2497 }
2498
2499 // Set the tags for this template group.
2500 func (r Virtual_Guest_Block_Device_Template_Group) SetTags(tags *string) (resp bool, err error) {
2501 params := []interface{}{
2502 tags,
2503 }
2504 err = r.Session.DoRequest("SoftLayer_Virtual_Guest_Block_Device_Template_Group", "setTags", params, &r.Options, &resp)
2505 return
2506 }
2507
2508 // no documentation yet
2509 type Virtual_Guest_Boot_Parameter struct {
2510 Session session.SLSession
2511 Options sl.Options
2512 }
2513
2514 // GetVirtualGuestBootParameterService returns an instance of the Virtual_Guest_Boot_Parameter SoftLayer service
2515 func GetVirtualGuestBootParameterService(sess session.SLSession) Virtual_Guest_Boot_Parameter {
2516 return Virtual_Guest_Boot_Parameter{Session: sess}
2517 }
2518
2519 func (r Virtual_Guest_Boot_Parameter) Id(id int) Virtual_Guest_Boot_Parameter {
2520 r.Options.Id = &id
2521 return r
2522 }
2523
2524 func (r Virtual_Guest_Boot_Parameter) Mask(mask string) Virtual_Guest_Boot_Parameter {
2525 if !strings.HasPrefix(mask, "mask[") && (strings.Contains(mask, "[") || strings.Contains(mask, ",")) {
2526 mask = fmt.Sprintf("mask[%s]", mask)
2527 }
2528
2529 r.Options.Mask = mask
2530 return r
2531 }
2532
2533 func (r Virtual_Guest_Boot_Parameter) Filter(filter string) Virtual_Guest_Boot_Parameter {
2534 r.Options.Filter = filter
2535 return r
2536 }
2537
2538 func (r Virtual_Guest_Boot_Parameter) Limit(limit int) Virtual_Guest_Boot_Parameter {
2539 r.Options.Limit = &limit
2540 return r
2541 }
2542
2543 func (r Virtual_Guest_Boot_Parameter) Offset(offset int) Virtual_Guest_Boot_Parameter {
2544 r.Options.Offset = &offset
2545 return r
2546 }
2547
2548 // no documentation yet
2549 func (r Virtual_Guest_Boot_Parameter) CreateObject(templateObject *datatypes.Virtual_Guest_Boot_Parameter) (resp bool, err error) {
2550 params := []interface{}{
2551 templateObject,
2552 }
2553 err = r.Session.DoRequest("SoftLayer_Virtual_Guest_Boot_Parameter", "createObject", params, &r.Options, &resp)
2554 return
2555 }
2556
2557 // no documentation yet
2558 func (r Virtual_Guest_Boot_Parameter) DeleteObject() (resp bool, err error) {
2559 err = r.Session.DoRequest("SoftLayer_Virtual_Guest_Boot_Parameter", "deleteObject", nil, &r.Options, &resp)
2560 return
2561 }
2562
2563 // no documentation yet
2564 func (r Virtual_Guest_Boot_Parameter) EditObject(templateObject *datatypes.Virtual_Guest_Boot_Parameter) (resp bool, err error) {
2565 params := []interface{}{
2566 templateObject,
2567 }
2568 err = r.Session.DoRequest("SoftLayer_Virtual_Guest_Boot_Parameter", "editObject", params, &r.Options, &resp)
2569 return
2570 }
2571
2572 // Retrieve
2573 func (r Virtual_Guest_Boot_Parameter) GetGuest() (resp datatypes.Virtual_Guest, err error) {
2574 err = r.Session.DoRequest("SoftLayer_Virtual_Guest_Boot_Parameter", "getGuest", nil, &r.Options, &resp)
2575 return
2576 }
2577
2578 // Retrieve
2579 func (r Virtual_Guest_Boot_Parameter) GetGuestBootParameterType() (resp datatypes.Virtual_Guest_Boot_Parameter_Type, err error) {
2580 err = r.Session.DoRequest("SoftLayer_Virtual_Guest_Boot_Parameter", "getGuestBootParameterType", nil, &r.Options, &resp)
2581 return
2582 }
2583
2584 // no documentation yet
2585 func (r Virtual_Guest_Boot_Parameter) GetObject() (resp datatypes.Virtual_Guest_Boot_Parameter, err error) {
2586 err = r.Session.DoRequest("SoftLayer_Virtual_Guest_Boot_Parameter", "getObject", nil, &r.Options, &resp)
2587 return
2588 }
2589
2590 // Describes a virtual guest boot parameter. In this the word class is used in the context of arguments sent to cloud computing instances such as single user mode and boot into bash.
2591 type Virtual_Guest_Boot_Parameter_Type struct {
2592 Session session.SLSession
2593 Options sl.Options
2594 }
2595
2596 // GetVirtualGuestBootParameterTypeService returns an instance of the Virtual_Guest_Boot_Parameter_Type SoftLayer service
2597 func GetVirtualGuestBootParameterTypeService(sess session.SLSession) Virtual_Guest_Boot_Parameter_Type {
2598 return Virtual_Guest_Boot_Parameter_Type{Session: sess}
2599 }
2600
2601 func (r Virtual_Guest_Boot_Parameter_Type) Id(id int) Virtual_Guest_Boot_Parameter_Type {
2602 r.Options.Id = &id
2603 return r
2604 }
2605
2606 func (r Virtual_Guest_Boot_Parameter_Type) Mask(mask string) Virtual_Guest_Boot_Parameter_Type {
2607 if !strings.HasPrefix(mask, "mask[") && (strings.Contains(mask, "[") || strings.Contains(mask, ",")) {
2608 mask = fmt.Sprintf("mask[%s]", mask)
2609 }
2610
2611 r.Options.Mask = mask
2612 return r
2613 }
2614
2615 func (r Virtual_Guest_Boot_Parameter_Type) Filter(filter string) Virtual_Guest_Boot_Parameter_Type {
2616 r.Options.Filter = filter
2617 return r
2618 }
2619
2620 func (r Virtual_Guest_Boot_Parameter_Type) Limit(limit int) Virtual_Guest_Boot_Parameter_Type {
2621 r.Options.Limit = &limit
2622 return r
2623 }
2624
2625 func (r Virtual_Guest_Boot_Parameter_Type) Offset(offset int) Virtual_Guest_Boot_Parameter_Type {
2626 r.Options.Offset = &offset
2627 return r
2628 }
2629
2630 // no documentation yet
2631 func (r Virtual_Guest_Boot_Parameter_Type) GetAllObjects() (resp []datatypes.Virtual_Guest_Boot_Parameter_Type, err error) {
2632 err = r.Session.DoRequest("SoftLayer_Virtual_Guest_Boot_Parameter_Type", "getAllObjects", nil, &r.Options, &resp)
2633 return
2634 }
2635
2636 // no documentation yet
2637 func (r Virtual_Guest_Boot_Parameter_Type) GetObject() (resp datatypes.Virtual_Guest_Boot_Parameter_Type, err error) {
2638 err = r.Session.DoRequest("SoftLayer_Virtual_Guest_Boot_Parameter_Type", "getObject", nil, &r.Options, &resp)
2639 return
2640 }
2641
2642 // The virtual guest network component data type presents the structure in which all computing instance network components are presented. Internally, the structure supports various virtualization platforms with no change to external interaction.
2643 //
2644 // A guest, also known as a virtual server, represents an allocation of resources on a virtual host.
2645 type Virtual_Guest_Network_Component struct {
2646 Session session.SLSession
2647 Options sl.Options
2648 }
2649
2650 // GetVirtualGuestNetworkComponentService returns an instance of the Virtual_Guest_Network_Component SoftLayer service
2651 func GetVirtualGuestNetworkComponentService(sess session.SLSession) Virtual_Guest_Network_Component {
2652 return Virtual_Guest_Network_Component{Session: sess}
2653 }
2654
2655 func (r Virtual_Guest_Network_Component) Id(id int) Virtual_Guest_Network_Component {
2656 r.Options.Id = &id
2657 return r
2658 }
2659
2660 func (r Virtual_Guest_Network_Component) Mask(mask string) Virtual_Guest_Network_Component {
2661 if !strings.HasPrefix(mask, "mask[") && (strings.Contains(mask, "[") || strings.Contains(mask, ",")) {
2662 mask = fmt.Sprintf("mask[%s]", mask)
2663 }
2664
2665 r.Options.Mask = mask
2666 return r
2667 }
2668
2669 func (r Virtual_Guest_Network_Component) Filter(filter string) Virtual_Guest_Network_Component {
2670 r.Options.Filter = filter
2671 return r
2672 }
2673
2674 func (r Virtual_Guest_Network_Component) Limit(limit int) Virtual_Guest_Network_Component {
2675 r.Options.Limit = &limit
2676 return r
2677 }
2678
2679 func (r Virtual_Guest_Network_Component) Offset(offset int) Virtual_Guest_Network_Component {
2680 r.Options.Offset = &offset
2681 return r
2682 }
2683
2684 // Completely restrict all incoming and outgoing bandwidth traffic to a network component
2685 func (r Virtual_Guest_Network_Component) Disable() (resp bool, err error) {
2686 err = r.Session.DoRequest("SoftLayer_Virtual_Guest_Network_Component", "disable", nil, &r.Options, &resp)
2687 return
2688 }
2689
2690 // Allow incoming and outgoing bandwidth traffic to a network component
2691 func (r Virtual_Guest_Network_Component) Enable() (resp bool, err error) {
2692 err = r.Session.DoRequest("SoftLayer_Virtual_Guest_Network_Component", "enable", nil, &r.Options, &resp)
2693 return
2694 }
2695
2696 // Retrieve The computing instance that this network component exists on.
2697 func (r Virtual_Guest_Network_Component) GetGuest() (resp datatypes.Virtual_Guest, err error) {
2698 err = r.Session.DoRequest("SoftLayer_Virtual_Guest_Network_Component", "getGuest", nil, &r.Options, &resp)
2699 return
2700 }
2701
2702 // Retrieve
2703 func (r Virtual_Guest_Network_Component) GetHighAvailabilityFirewallFlag() (resp bool, err error) {
2704 err = r.Session.DoRequest("SoftLayer_Virtual_Guest_Network_Component", "getHighAvailabilityFirewallFlag", nil, &r.Options, &resp)
2705 return
2706 }
2707
2708 // Retrieve
2709 func (r Virtual_Guest_Network_Component) GetIcpBinding() (resp datatypes.Virtual_Guest_Network_Component_IcpBinding, err error) {
2710 err = r.Session.DoRequest("SoftLayer_Virtual_Guest_Network_Component", "getIcpBinding", nil, &r.Options, &resp)
2711 return
2712 }
2713
2714 // Retrieve The records of all IP addresses bound to a computing instance's network component.
2715 func (r Virtual_Guest_Network_Component) GetIpAddressBindings() (resp []datatypes.Virtual_Guest_Network_Component_IpAddress, err error) {
2716 err = r.Session.DoRequest("SoftLayer_Virtual_Guest_Network_Component", "getIpAddressBindings", nil, &r.Options, &resp)
2717 return
2718 }
2719
2720 // Retrieve The upstream network component firewall.
2721 func (r Virtual_Guest_Network_Component) GetNetworkComponentFirewall() (resp datatypes.Network_Component_Firewall, err error) {
2722 err = r.Session.DoRequest("SoftLayer_Virtual_Guest_Network_Component", "getNetworkComponentFirewall", nil, &r.Options, &resp)
2723 return
2724 }
2725
2726 // Retrieve The VLAN that a computing instance network component's subnet is associated with.
2727 func (r Virtual_Guest_Network_Component) GetNetworkVlan() (resp datatypes.Network_Vlan, err error) {
2728 err = r.Session.DoRequest("SoftLayer_Virtual_Guest_Network_Component", "getNetworkVlan", nil, &r.Options, &resp)
2729 return
2730 }
2731
2732 // no documentation yet
2733 func (r Virtual_Guest_Network_Component) GetObject() (resp datatypes.Virtual_Guest_Network_Component, err error) {
2734 err = r.Session.DoRequest("SoftLayer_Virtual_Guest_Network_Component", "getObject", nil, &r.Options, &resp)
2735 return
2736 }
2737
2738 // Retrieve A computing instance network component's primary IP address.
2739 func (r Virtual_Guest_Network_Component) GetPrimaryIpAddress() (resp string, err error) {
2740 err = r.Session.DoRequest("SoftLayer_Virtual_Guest_Network_Component", "getPrimaryIpAddress", nil, &r.Options, &resp)
2741 return
2742 }
2743
2744 // Retrieve
2745 func (r Virtual_Guest_Network_Component) GetPrimaryIpAddressRecord() (resp datatypes.Network_Subnet_IpAddress, err error) {
2746 err = r.Session.DoRequest("SoftLayer_Virtual_Guest_Network_Component", "getPrimaryIpAddressRecord", nil, &r.Options, &resp)
2747 return
2748 }
2749
2750 // Retrieve A network component's subnet for its primary IP address
2751 func (r Virtual_Guest_Network_Component) GetPrimarySubnet() (resp datatypes.Network_Subnet, err error) {
2752 err = r.Session.DoRequest("SoftLayer_Virtual_Guest_Network_Component", "getPrimarySubnet", nil, &r.Options, &resp)
2753 return
2754 }
2755
2756 // Retrieve A network component's primary IPv6 IP address record.
2757 func (r Virtual_Guest_Network_Component) GetPrimaryVersion6IpAddressRecord() (resp datatypes.Network_Subnet_IpAddress, err error) {
2758 err = r.Session.DoRequest("SoftLayer_Virtual_Guest_Network_Component", "getPrimaryVersion6IpAddressRecord", nil, &r.Options, &resp)
2759 return
2760 }
2761
2762 // Retrieve A network component's routers.
2763 func (r Virtual_Guest_Network_Component) GetRouter() (resp datatypes.Hardware_Router, err error) {
2764 err = r.Session.DoRequest("SoftLayer_Virtual_Guest_Network_Component", "getRouter", nil, &r.Options, &resp)
2765 return
2766 }
2767
2768 // Retrieve The bindings associating security groups to this network component
2769 func (r Virtual_Guest_Network_Component) GetSecurityGroupBindings() (resp []datatypes.Virtual_Network_SecurityGroup_NetworkComponentBinding, err error) {
2770 err = r.Session.DoRequest("SoftLayer_Virtual_Guest_Network_Component", "getSecurityGroupBindings", nil, &r.Options, &resp)
2771 return
2772 }
2773
2774 // Retrieve A network component's subnets. A subnet is a group of IP addresses
2775 func (r Virtual_Guest_Network_Component) GetSubnets() (resp []datatypes.Network_Subnet, err error) {
2776 err = r.Session.DoRequest("SoftLayer_Virtual_Guest_Network_Component", "getSubnets", nil, &r.Options, &resp)
2777 return
2778 }
2779
2780 // Issues a ping command and returns the success (true) or failure (false) of the ping command.
2781 func (r Virtual_Guest_Network_Component) IsPingable() (resp bool, err error) {
2782 err = r.Session.DoRequest("SoftLayer_Virtual_Guest_Network_Component", "isPingable", nil, &r.Options, &resp)
2783 return
2784 }
2785
2786 // no documentation yet
2787 func (r Virtual_Guest_Network_Component) SecurityGroupsReady() (resp bool, err error) {
2788 err = r.Session.DoRequest("SoftLayer_Virtual_Guest_Network_Component", "securityGroupsReady", nil, &r.Options, &resp)
2789 return
2790 }
2791
2792 // The virtual host represents the platform on which virtual guests reside. At times a virtual host has no allocations on the physical server, however with many modern platforms it is a virtual machine with small CPU and Memory allocations that runs in the Control Domain.
2793 type Virtual_Host struct {
2794 Session session.SLSession
2795 Options sl.Options
2796 }
2797
2798 // GetVirtualHostService returns an instance of the Virtual_Host SoftLayer service
2799 func GetVirtualHostService(sess session.SLSession) Virtual_Host {
2800 return Virtual_Host{Session: sess}
2801 }
2802
2803 func (r Virtual_Host) Id(id int) Virtual_Host {
2804 r.Options.Id = &id
2805 return r
2806 }
2807
2808 func (r Virtual_Host) Mask(mask string) Virtual_Host {
2809 if !strings.HasPrefix(mask, "mask[") && (strings.Contains(mask, "[") || strings.Contains(mask, ",")) {
2810 mask = fmt.Sprintf("mask[%s]", mask)
2811 }
2812
2813 r.Options.Mask = mask
2814 return r
2815 }
2816
2817 func (r Virtual_Host) Filter(filter string) Virtual_Host {
2818 r.Options.Filter = filter
2819 return r
2820 }
2821
2822 func (r Virtual_Host) Limit(limit int) Virtual_Host {
2823 r.Options.Limit = &limit
2824 return r
2825 }
2826
2827 func (r Virtual_Host) Offset(offset int) Virtual_Host {
2828 r.Options.Offset = &offset
2829 return r
2830 }
2831
2832 // Retrieve The account which a virtual host belongs to.
2833 func (r Virtual_Host) GetAccount() (resp datatypes.Account, err error) {
2834 err = r.Session.DoRequest("SoftLayer_Virtual_Host", "getAccount", nil, &r.Options, &resp)
2835 return
2836 }
2837
2838 // Retrieve The hardware record which a virtual host resides on.
2839 func (r Virtual_Host) GetHardware() (resp datatypes.Hardware_Server, err error) {
2840 err = r.Session.DoRequest("SoftLayer_Virtual_Host", "getHardware", nil, &r.Options, &resp)
2841 return
2842 }
2843
2844 // no documentation yet
2845 func (r Virtual_Host) GetObject() (resp datatypes.Virtual_Host, err error) {
2846 err = r.Session.DoRequest("SoftLayer_Virtual_Host", "getObject", nil, &r.Options, &resp)
2847 return
2848 }
2849
2850 // Retrieve
2851 func (r Virtual_Host) GetPciDevices() (resp []datatypes.Virtual_Host_PciDevice, err error) {
2852 err = r.Session.DoRequest("SoftLayer_Virtual_Host", "getPciDevices", nil, &r.Options, &resp)
2853 return
2854 }
2855
2856 // This data type presents the structure for a virtual guest placement group. The data type contains relational properties to the virtual guest placement group rule class.
2857 type Virtual_PlacementGroup struct {
2858 Session session.SLSession
2859 Options sl.Options
2860 }
2861
2862 // GetVirtualPlacementGroupService returns an instance of the Virtual_PlacementGroup SoftLayer service
2863 func GetVirtualPlacementGroupService(sess session.SLSession) Virtual_PlacementGroup {
2864 return Virtual_PlacementGroup{Session: sess}
2865 }
2866
2867 func (r Virtual_PlacementGroup) Id(id int) Virtual_PlacementGroup {
2868 r.Options.Id = &id
2869 return r
2870 }
2871
2872 func (r Virtual_PlacementGroup) Mask(mask string) Virtual_PlacementGroup {
2873 if !strings.HasPrefix(mask, "mask[") && (strings.Contains(mask, "[") || strings.Contains(mask, ",")) {
2874 mask = fmt.Sprintf("mask[%s]", mask)
2875 }
2876
2877 r.Options.Mask = mask
2878 return r
2879 }
2880
2881 func (r Virtual_PlacementGroup) Filter(filter string) Virtual_PlacementGroup {
2882 r.Options.Filter = filter
2883 return r
2884 }
2885
2886 func (r Virtual_PlacementGroup) Limit(limit int) Virtual_PlacementGroup {
2887 r.Options.Limit = &limit
2888 return r
2889 }
2890
2891 func (r Virtual_PlacementGroup) Offset(offset int) Virtual_PlacementGroup {
2892 r.Options.Offset = &offset
2893 return r
2894 }
2895
2896 // Add a placement group to your account for use during VSI provisioning.
2897 func (r Virtual_PlacementGroup) CreateObject(templateObject *datatypes.Virtual_PlacementGroup) (resp datatypes.Virtual_PlacementGroup, err error) {
2898 params := []interface{}{
2899 templateObject,
2900 }
2901 err = r.Session.DoRequest("SoftLayer_Virtual_PlacementGroup", "createObject", params, &r.Options, &resp)
2902 return
2903 }
2904
2905 // Delete a placement group from your account.
2906 func (r Virtual_PlacementGroup) DeleteObject() (resp bool, err error) {
2907 err = r.Session.DoRequest("SoftLayer_Virtual_PlacementGroup", "deleteObject", nil, &r.Options, &resp)
2908 return
2909 }
2910
2911 // Update a placement group.
2912 func (r Virtual_PlacementGroup) EditObject(templateObject *datatypes.Virtual_PlacementGroup) (resp bool, err error) {
2913 params := []interface{}{
2914 templateObject,
2915 }
2916 err = r.Session.DoRequest("SoftLayer_Virtual_PlacementGroup", "editObject", params, &r.Options, &resp)
2917 return
2918 }
2919
2920 // Retrieve The account that the placement group is implemented on.
2921 func (r Virtual_PlacementGroup) GetAccount() (resp datatypes.Account, err error) {
2922 err = r.Session.DoRequest("SoftLayer_Virtual_PlacementGroup", "getAccount", nil, &r.Options, &resp)
2923 return
2924 }
2925
2926 // Returns all routers available for use with placement groups. If a datacenter location ID is provided, this method will further restrict the list of routers to ones contained within that datacenter.
2927 func (r Virtual_PlacementGroup) GetAvailableRouters(datacenterId *int) (resp []datatypes.Hardware, err error) {
2928 params := []interface{}{
2929 datacenterId,
2930 }
2931 err = r.Session.DoRequest("SoftLayer_Virtual_PlacementGroup", "getAvailableRouters", params, &r.Options, &resp)
2932 return
2933 }
2934
2935 // Retrieve The router the placement group is implemented on.
2936 func (r Virtual_PlacementGroup) GetBackendRouter() (resp datatypes.Hardware_Router_Backend, err error) {
2937 err = r.Session.DoRequest("SoftLayer_Virtual_PlacementGroup", "getBackendRouter", nil, &r.Options, &resp)
2938 return
2939 }
2940
2941 // Retrieve The virtual guests that are members of the placement group.
2942 func (r Virtual_PlacementGroup) GetGuests() (resp []datatypes.Virtual_Guest, err error) {
2943 err = r.Session.DoRequest("SoftLayer_Virtual_PlacementGroup", "getGuests", nil, &r.Options, &resp)
2944 return
2945 }
2946
2947 // no documentation yet
2948 func (r Virtual_PlacementGroup) GetObject() (resp datatypes.Virtual_PlacementGroup, err error) {
2949 err = r.Session.DoRequest("SoftLayer_Virtual_PlacementGroup", "getObject", nil, &r.Options, &resp)
2950 return
2951 }
2952
2953 // Retrieve The placement rule that the placement group is implementing.
2954 func (r Virtual_PlacementGroup) GetRule() (resp datatypes.Virtual_PlacementGroup_Rule, err error) {
2955 err = r.Session.DoRequest("SoftLayer_Virtual_PlacementGroup", "getRule", nil, &r.Options, &resp)
2956 return
2957 }
2958
2959 // This data type presents the structure of a virtual guest placement group rule.
2960 type Virtual_PlacementGroup_Rule struct {
2961 Session session.SLSession
2962 Options sl.Options
2963 }
2964
2965 // GetVirtualPlacementGroupRuleService returns an instance of the Virtual_PlacementGroup_Rule SoftLayer service
2966 func GetVirtualPlacementGroupRuleService(sess session.SLSession) Virtual_PlacementGroup_Rule {
2967 return Virtual_PlacementGroup_Rule{Session: sess}
2968 }
2969
2970 func (r Virtual_PlacementGroup_Rule) Id(id int) Virtual_PlacementGroup_Rule {
2971 r.Options.Id = &id
2972 return r
2973 }
2974
2975 func (r Virtual_PlacementGroup_Rule) Mask(mask string) Virtual_PlacementGroup_Rule {
2976 if !strings.HasPrefix(mask, "mask[") && (strings.Contains(mask, "[") || strings.Contains(mask, ",")) {
2977 mask = fmt.Sprintf("mask[%s]", mask)
2978 }
2979
2980 r.Options.Mask = mask
2981 return r
2982 }
2983
2984 func (r Virtual_PlacementGroup_Rule) Filter(filter string) Virtual_PlacementGroup_Rule {
2985 r.Options.Filter = filter
2986 return r
2987 }
2988
2989 func (r Virtual_PlacementGroup_Rule) Limit(limit int) Virtual_PlacementGroup_Rule {
2990 r.Options.Limit = &limit
2991 return r
2992 }
2993
2994 func (r Virtual_PlacementGroup_Rule) Offset(offset int) Virtual_PlacementGroup_Rule {
2995 r.Options.Offset = &offset
2996 return r
2997 }
2998
2999 // Get all placement group rules.
3000 func (r Virtual_PlacementGroup_Rule) GetAllObjects() (resp []datatypes.Virtual_PlacementGroup_Rule, err error) {
3001 err = r.Session.DoRequest("SoftLayer_Virtual_PlacementGroup_Rule", "getAllObjects", nil, &r.Options, &resp)
3002 return
3003 }
3004
3005 // no documentation yet
3006 func (r Virtual_PlacementGroup_Rule) GetObject() (resp datatypes.Virtual_PlacementGroup_Rule, err error) {
3007 err = r.Session.DoRequest("SoftLayer_Virtual_PlacementGroup_Rule", "getObject", nil, &r.Options, &resp)
3008 return
3009 }
3010
3011 // This data type presents the structure for a virtual reserved capacity group.
3012 type Virtual_ReservedCapacityGroup struct {
3013 Session session.SLSession
3014 Options sl.Options
3015 }
3016
3017 // GetVirtualReservedCapacityGroupService returns an instance of the Virtual_ReservedCapacityGroup SoftLayer service
3018 func GetVirtualReservedCapacityGroupService(sess session.SLSession) Virtual_ReservedCapacityGroup {
3019 return Virtual_ReservedCapacityGroup{Session: sess}
3020 }
3021
3022 func (r Virtual_ReservedCapacityGroup) Id(id int) Virtual_ReservedCapacityGroup {
3023 r.Options.Id = &id
3024 return r
3025 }
3026
3027 func (r Virtual_ReservedCapacityGroup) Mask(mask string) Virtual_ReservedCapacityGroup {
3028 if !strings.HasPrefix(mask, "mask[") && (strings.Contains(mask, "[") || strings.Contains(mask, ",")) {
3029 mask = fmt.Sprintf("mask[%s]", mask)
3030 }
3031
3032 r.Options.Mask = mask
3033 return r
3034 }
3035
3036 func (r Virtual_ReservedCapacityGroup) Filter(filter string) Virtual_ReservedCapacityGroup {
3037 r.Options.Filter = filter
3038 return r
3039 }
3040
3041 func (r Virtual_ReservedCapacityGroup) Limit(limit int) Virtual_ReservedCapacityGroup {
3042 r.Options.Limit = &limit
3043 return r
3044 }
3045
3046 func (r Virtual_ReservedCapacityGroup) Offset(offset int) Virtual_ReservedCapacityGroup {
3047 r.Options.Offset = &offset
3048 return r
3049 }
3050
3051 // Update a reserved capacity group.
3052 func (r Virtual_ReservedCapacityGroup) EditObject(templateObject *datatypes.Virtual_ReservedCapacityGroup) (resp bool, err error) {
3053 params := []interface{}{
3054 templateObject,
3055 }
3056 err = r.Session.DoRequest("SoftLayer_Virtual_ReservedCapacityGroup", "editObject", params, &r.Options, &resp)
3057 return
3058 }
3059
3060 // Retrieve The account that the reserved capacity group is implemented on.
3061 func (r Virtual_ReservedCapacityGroup) GetAccount() (resp datatypes.Account, err error) {
3062 err = r.Session.DoRequest("SoftLayer_Virtual_ReservedCapacityGroup", "getAccount", nil, &r.Options, &resp)
3063 return
3064 }
3065
3066 // Retrieve The instances available for guest provisions on this reserved capacity group.
3067 func (r Virtual_ReservedCapacityGroup) GetAvailableInstances() (resp []datatypes.Virtual_ReservedCapacityGroup_Instance, err error) {
3068 err = r.Session.DoRequest("SoftLayer_Virtual_ReservedCapacityGroup", "getAvailableInstances", nil, &r.Options, &resp)
3069 return
3070 }
3071
3072 // Retrieve The router the reserved capacity group is implemented on.
3073 func (r Virtual_ReservedCapacityGroup) GetBackendRouter() (resp datatypes.Hardware_Router_Backend, err error) {
3074 err = r.Session.DoRequest("SoftLayer_Virtual_ReservedCapacityGroup", "getBackendRouter", nil, &r.Options, &resp)
3075 return
3076 }
3077
3078 // Retrieve The guest instances that are members of this reserved capacity group.
3079 func (r Virtual_ReservedCapacityGroup) GetInstances() (resp []datatypes.Virtual_ReservedCapacityGroup_Instance, err error) {
3080 err = r.Session.DoRequest("SoftLayer_Virtual_ReservedCapacityGroup", "getInstances", nil, &r.Options, &resp)
3081 return
3082 }
3083
3084 // Retrieve The number of instances that are members of this reserved capacity group.
3085 func (r Virtual_ReservedCapacityGroup) GetInstancesCount() (resp uint, err error) {
3086 err = r.Session.DoRequest("SoftLayer_Virtual_ReservedCapacityGroup", "getInstancesCount", nil, &r.Options, &resp)
3087 return
3088 }
3089
3090 // no documentation yet
3091 func (r Virtual_ReservedCapacityGroup) GetObject() (resp datatypes.Virtual_ReservedCapacityGroup, err error) {
3092 err = r.Session.DoRequest("SoftLayer_Virtual_ReservedCapacityGroup", "getObject", nil, &r.Options, &resp)
3093 return
3094 }
3095
3096 // Retrieve The instances already occupied by a guest on this reserved capacity group.
3097 func (r Virtual_ReservedCapacityGroup) GetOccupiedInstances() (resp []datatypes.Virtual_ReservedCapacityGroup_Instance, err error) {
3098 err = r.Session.DoRequest("SoftLayer_Virtual_ReservedCapacityGroup", "getOccupiedInstances", nil, &r.Options, &resp)
3099 return
3100 }
3101
3102 // This data type presents the structure for a virtual reserved capacity group instance.
3103 type Virtual_ReservedCapacityGroup_Instance struct {
3104 Session session.SLSession
3105 Options sl.Options
3106 }
3107
3108 // GetVirtualReservedCapacityGroupInstanceService returns an instance of the Virtual_ReservedCapacityGroup_Instance SoftLayer service
3109 func GetVirtualReservedCapacityGroupInstanceService(sess session.SLSession) Virtual_ReservedCapacityGroup_Instance {
3110 return Virtual_ReservedCapacityGroup_Instance{Session: sess}
3111 }
3112
3113 func (r Virtual_ReservedCapacityGroup_Instance) Id(id int) Virtual_ReservedCapacityGroup_Instance {
3114 r.Options.Id = &id
3115 return r
3116 }
3117
3118 func (r Virtual_ReservedCapacityGroup_Instance) Mask(mask string) Virtual_ReservedCapacityGroup_Instance {
3119 if !strings.HasPrefix(mask, "mask[") && (strings.Contains(mask, "[") || strings.Contains(mask, ",")) {
3120 mask = fmt.Sprintf("mask[%s]", mask)
3121 }
3122
3123 r.Options.Mask = mask
3124 return r
3125 }
3126
3127 func (r Virtual_ReservedCapacityGroup_Instance) Filter(filter string) Virtual_ReservedCapacityGroup_Instance {
3128 r.Options.Filter = filter
3129 return r
3130 }
3131
3132 func (r Virtual_ReservedCapacityGroup_Instance) Limit(limit int) Virtual_ReservedCapacityGroup_Instance {
3133 r.Options.Limit = &limit
3134 return r
3135 }
3136
3137 func (r Virtual_ReservedCapacityGroup_Instance) Offset(offset int) Virtual_ReservedCapacityGroup_Instance {
3138 r.Options.Offset = &offset
3139 return r
3140 }
3141
3142 // Retrieve Flag to indecate whether or not the reserved instance is available or not.
3143 func (r Virtual_ReservedCapacityGroup_Instance) GetAvailableFlag() (resp bool, err error) {
3144 err = r.Session.DoRequest("SoftLayer_Virtual_ReservedCapacityGroup_Instance", "getAvailableFlag", nil, &r.Options, &resp)
3145 return
3146 }
3147
3148 // Retrieve The billing item for the reserved capacity group instance.
3149 func (r Virtual_ReservedCapacityGroup_Instance) GetBillingItem() (resp datatypes.Billing_Item, err error) {
3150 err = r.Session.DoRequest("SoftLayer_Virtual_ReservedCapacityGroup_Instance", "getBillingItem", nil, &r.Options, &resp)
3151 return
3152 }
3153
3154 // Retrieve The virtual guest associated with this reserved capacity group instance.
3155 func (r Virtual_ReservedCapacityGroup_Instance) GetGuest() (resp datatypes.Virtual_Guest, err error) {
3156 err = r.Session.DoRequest("SoftLayer_Virtual_ReservedCapacityGroup_Instance", "getGuest", nil, &r.Options, &resp)
3157 return
3158 }
3159
3160 // no documentation yet
3161 func (r Virtual_ReservedCapacityGroup_Instance) GetObject() (resp datatypes.Virtual_ReservedCapacityGroup_Instance, err error) {
3162 err = r.Session.DoRequest("SoftLayer_Virtual_ReservedCapacityGroup_Instance", "getObject", nil, &r.Options, &resp)
3163 return
3164 }
3165
3166 // Retrieve The reserved instances that are members of this reserved capacity group.
3167 func (r Virtual_ReservedCapacityGroup_Instance) GetReservedCapacityGroup() (resp datatypes.Virtual_ReservedCapacityGroup, err error) {
3168 err = r.Session.DoRequest("SoftLayer_Virtual_ReservedCapacityGroup_Instance", "getReservedCapacityGroup", nil, &r.Options, &resp)
3169 return
3170 }
3171
3172 // The SoftLayer_Virtual_Storage_Repository represents a web based storage system that can be accessed through many types of devices, interfaces, and other resources.
3173 type Virtual_Storage_Repository struct {
3174 Session session.SLSession
3175 Options sl.Options
3176 }
3177
3178 // GetVirtualStorageRepositoryService returns an instance of the Virtual_Storage_Repository SoftLayer service
3179 func GetVirtualStorageRepositoryService(sess session.SLSession) Virtual_Storage_Repository {
3180 return Virtual_Storage_Repository{Session: sess}
3181 }
3182
3183 func (r Virtual_Storage_Repository) Id(id int) Virtual_Storage_Repository {
3184 r.Options.Id = &id
3185 return r
3186 }
3187
3188 func (r Virtual_Storage_Repository) Mask(mask string) Virtual_Storage_Repository {
3189 if !strings.HasPrefix(mask, "mask[") && (strings.Contains(mask, "[") || strings.Contains(mask, ",")) {
3190 mask = fmt.Sprintf("mask[%s]", mask)
3191 }
3192
3193 r.Options.Mask = mask
3194 return r
3195 }
3196
3197 func (r Virtual_Storage_Repository) Filter(filter string) Virtual_Storage_Repository {
3198 r.Options.Filter = filter
3199 return r
3200 }
3201
3202 func (r Virtual_Storage_Repository) Limit(limit int) Virtual_Storage_Repository {
3203 r.Options.Limit = &limit
3204 return r
3205 }
3206
3207 func (r Virtual_Storage_Repository) Offset(offset int) Virtual_Storage_Repository {
3208 r.Options.Offset = &offset
3209 return r
3210 }
3211
3212 // Retrieve The [[SoftLayer_Account|account]] that a storage repository belongs to.
3213 func (r Virtual_Storage_Repository) GetAccount() (resp datatypes.Account, err error) {
3214 err = r.Session.DoRequest("SoftLayer_Virtual_Storage_Repository", "getAccount", nil, &r.Options, &resp)
3215 return
3216 }
3217
3218 // Returns the archive storage disk usage fee rate per gigabyte.
3219 func (r Virtual_Storage_Repository) GetArchiveDiskUsageRatePerGb() (resp datatypes.Float64, err error) {
3220 err = r.Session.DoRequest("SoftLayer_Virtual_Storage_Repository", "getArchiveDiskUsageRatePerGb", nil, &r.Options, &resp)
3221 return
3222 }
3223
3224 // Returns the average disk space usage for a storage repository.
3225 func (r Virtual_Storage_Repository) GetAverageDiskUsageMetricDataFromInfluxByDate(startDateTime *datatypes.Time, endDateTime *datatypes.Time) (resp datatypes.Float64, err error) {
3226 params := []interface{}{
3227 startDateTime,
3228 endDateTime,
3229 }
3230 err = r.Session.DoRequest("SoftLayer_Virtual_Storage_Repository", "getAverageDiskUsageMetricDataFromInfluxByDate", params, &r.Options, &resp)
3231 return
3232 }
3233
3234 // Retrieve The current billing item for a storage repository.
3235 func (r Virtual_Storage_Repository) GetBillingItem() (resp datatypes.Billing_Item, err error) {
3236 err = r.Session.DoRequest("SoftLayer_Virtual_Storage_Repository", "getBillingItem", nil, &r.Options, &resp)
3237 return
3238 }
3239
3240 // Retrieve The datacenter that a virtual storage repository resides in.
3241 func (r Virtual_Storage_Repository) GetDatacenter() (resp datatypes.Location, err error) {
3242 err = r.Session.DoRequest("SoftLayer_Virtual_Storage_Repository", "getDatacenter", nil, &r.Options, &resp)
3243 return
3244 }
3245
3246 // Retrieve The [[SoftLayer_Virtual_Disk_Image|disk images]] that are in a storage repository. Disk images are the virtual hard drives for a virtual guest.
3247 func (r Virtual_Storage_Repository) GetDiskImages() (resp []datatypes.Virtual_Disk_Image, err error) {
3248 err = r.Session.DoRequest("SoftLayer_Virtual_Storage_Repository", "getDiskImages", nil, &r.Options, &resp)
3249 return
3250 }
3251
3252 // Retrieve The computing instances that have disk images in a storage repository.
3253 func (r Virtual_Storage_Repository) GetGuests() (resp []datatypes.Virtual_Guest, err error) {
3254 err = r.Session.DoRequest("SoftLayer_Virtual_Storage_Repository", "getGuests", nil, &r.Options, &resp)
3255 return
3256 }
3257
3258 // Retrieve
3259 func (r Virtual_Storage_Repository) GetMetricTrackingObject() (resp datatypes.Metric_Tracking_Object, err error) {
3260 err = r.Session.DoRequest("SoftLayer_Virtual_Storage_Repository", "getMetricTrackingObject", nil, &r.Options, &resp)
3261 return
3262 }
3263
3264 // no documentation yet
3265 func (r Virtual_Storage_Repository) GetObject() (resp datatypes.Virtual_Storage_Repository, err error) {
3266 err = r.Session.DoRequest("SoftLayer_Virtual_Storage_Repository", "getObject", nil, &r.Options, &resp)
3267 return
3268 }
3269
3270 // Retrieve The current billing item for a public storage repository.
3271 func (r Virtual_Storage_Repository) GetPublicImageBillingItem() (resp datatypes.Billing_Item, err error) {
3272 err = r.Session.DoRequest("SoftLayer_Virtual_Storage_Repository", "getPublicImageBillingItem", nil, &r.Options, &resp)
3273 return
3274 }
3275
3276 // Returns the public image storage disk usage fee rate per gigabyte.
3277 func (r Virtual_Storage_Repository) GetPublicImageDiskUsageRatePerGb() (resp datatypes.Float64, err error) {
3278 err = r.Session.DoRequest("SoftLayer_Virtual_Storage_Repository", "getPublicImageDiskUsageRatePerGb", nil, &r.Options, &resp)
3279 return
3280 }
3281
3282 // Returns the public image storage locations.
3283 func (r Virtual_Storage_Repository) GetStorageLocations() (resp []datatypes.Location, err error) {
3284 err = r.Session.DoRequest("SoftLayer_Virtual_Storage_Repository", "getStorageLocations", nil, &r.Options, &resp)
3285 return
3286 }
3287
3288 // Retrieve A storage repository's [[SoftLayer_Virtual_Storage_Repository_Type|type]].
3289 func (r Virtual_Storage_Repository) GetType() (resp datatypes.Virtual_Storage_Repository_Type, err error) {
3290 err = r.Session.DoRequest("SoftLayer_Virtual_Storage_Repository", "getType", nil, &r.Options, &resp)
3291 return
3292 }
3293