func (bc *bmpClient) CreateBaremetals(createBaremetalsInfo CreateBaremetalsInfo, dryRun bool) (CreateBaremetalsResponse, error) {
requestBody, err := json.Marshal(createBaremetalsInfo)
if err != nil {
errorMessage := fmt.Sprintf("bmp: failed to encode Json File, error message '%s'", err.Error())
return CreateBaremetalsResponse{}, errors.New(errorMessage)
}
path := "baremetals"
if dryRun {
path = "baremetals/dryrun"
}
responseBytes, errorCode, err := bc.httpClient.DoRawHttpRequest(path, "POST", bytes.NewBuffer(requestBody))
if err != nil {
errorMessage := fmt.Sprintf("bmp: could not calls /baremetals on BMP server, error message %s", err.Error())
return CreateBaremetalsResponse{}, errors.New(errorMessage)
}
if slcommon.IsHttpErrorCode(errorCode) {
errorMessage := fmt.Sprintf("bmp: could not call /baremetals on BMP server, HTTP error code: %d", errorCode)
return CreateBaremetalsResponse{}, errors.New(errorMessage)
}
response := CreateBaremetalsResponse{}
err = json.Unmarshal(responseBytes, &response)
if err != nil {
errorMessage := fmt.Sprintf("bmp: failed to decode JSON response, err message '%s'", err.Error())
return CreateBaremetalsResponse{}, errors.New(errorMessage)
}
return response, nil
}
func (slssks *softLayer_Security_Ssh_Key_Service) CreateObject(template datatypes.SoftLayer_Security_Ssh_Key) (datatypes.SoftLayer_Security_Ssh_Key, error) {
parameters := datatypes.SoftLayer_Shh_Key_Parameters{
Parameters: []datatypes.SoftLayer_Security_Ssh_Key{
template,
},
}
requestBody, err := json.Marshal(parameters)
if err != nil {
return datatypes.SoftLayer_Security_Ssh_Key{}, err
}
data, errorCode, err := slssks.client.GetHttpClient().DoRawHttpRequest(fmt.Sprintf("%s/createObject", slssks.GetName()), "POST", bytes.NewBuffer(requestBody))
if err != nil {
return datatypes.SoftLayer_Security_Ssh_Key{}, err
}
if common.IsHttpErrorCode(errorCode) {
errorMessage := fmt.Sprintf("softlayer-go: could not SoftLayer_Security_Ssh_Key#createObject, HTTP error code: '%d'", errorCode)
return datatypes.SoftLayer_Security_Ssh_Key{}, errors.New(errorMessage)
}
err = slssks.client.GetHttpClient().CheckForHttpResponseErrors(data)
if err != nil {
return datatypes.SoftLayer_Security_Ssh_Key{}, err
}
softLayer_Ssh_Key := datatypes.SoftLayer_Security_Ssh_Key{}
err = json.Unmarshal(data, &softLayer_Ssh_Key)
if err != nil {
return datatypes.SoftLayer_Security_Ssh_Key{}, err
}
return softLayer_Ssh_Key, nil
}
func (slns *softLayer_Network_Storage_Service) AttachNetworkStorageToHardware(hardware datatypes.SoftLayer_Hardware, volumeId int) (bool, error) {
parameters := datatypes.SoftLayer_Hardware_Parameters{
Parameters: []datatypes.SoftLayer_Hardware{
hardware,
},
}
requestBody, err := json.Marshal(parameters)
if err != nil {
return false, err
}
resp, errorCode, err := slns.client.GetHttpClient().DoRawHttpRequest(fmt.Sprintf("%s/%d/allowAccessFromHardware.json", slns.GetName(), volumeId), "PUT", bytes.NewBuffer(requestBody))
if err != nil {
return false, err
}
if common.IsHttpErrorCode(errorCode) {
errorMessage := fmt.Sprintf("softlayer-go: could not SoftLayer_Network_Storage#attachNetworkStorageToHardware, HTTP error code: '%d'", errorCode)
return false, errors.New(errorMessage)
}
allowable, err := strconv.ParseBool(string(resp[:]))
if err != nil {
return false, nil
}
return allowable, nil
}
func (slns *softLayer_Network_Storage_Service) HasAllowedHardware(volumeId int, vmId int) (bool, error) {
filter := string(`{"allowedVirtualGuests":{"id":{"operation":"` + strconv.Itoa(vmId) + `"}}}`)
response, errorCode, err := slns.client.GetHttpClient().DoRawHttpRequestWithObjectFilterAndObjectMask(fmt.Sprintf("%s/%d/getAllowedHardware.json", slns.GetName(), volumeId), []string{"id"}, fmt.Sprintf(string(filter)), "GET", new(bytes.Buffer))
if err != nil {
return false, errors.New(fmt.Sprintf("Cannot check authentication for volume %d in vm %d", volumeId, vmId))
}
if common.IsHttpErrorCode(errorCode) {
errorMessage := fmt.Sprintf("softlayer-go: could not SoftLayer_Network_Storage#hasAllowedHardware, HTTP error code: '%d'", errorCode)
return false, errors.New(errorMessage)
}
hardware := []datatypes.SoftLayer_Hardware{}
err = json.Unmarshal(response, &hardware)
if err != nil {
return false, errors.New(fmt.Sprintf("Failed to unmarshal response of checking authentication for volume %d in vm %d", volumeId, vmId))
}
if len(hardware) > 0 {
return true, nil
}
return false, nil
}
func (slbicr *softLayer_Billing_Item_Cancellation_Request_Service) CreateObject(request datatypes.SoftLayer_Billing_Item_Cancellation_Request) (datatypes.SoftLayer_Billing_Item_Cancellation_Request, error) {
parameters := datatypes.SoftLayer_Billing_Item_Cancellation_Request_Parameters{
Parameters: []datatypes.SoftLayer_Billing_Item_Cancellation_Request{
request,
},
}
requestBody, err := json.Marshal(parameters)
if err != nil {
return datatypes.SoftLayer_Billing_Item_Cancellation_Request{}, err
}
responseBytes, errorCode, err := slbicr.client.GetHttpClient().DoRawHttpRequest(fmt.Sprintf("%s/createObject.json", slbicr.GetName()), "POST", bytes.NewBuffer(requestBody))
if err != nil {
return datatypes.SoftLayer_Billing_Item_Cancellation_Request{}, err
}
if common.IsHttpErrorCode(errorCode) {
errorMessage := fmt.Sprintf("softlayer-go: could not SoftLayer_Billing_Item_Cancellation_Request#createObject TTP error code: '%d'", errorCode)
return datatypes.SoftLayer_Billing_Item_Cancellation_Request{}, errors.New(errorMessage)
}
result := datatypes.SoftLayer_Billing_Item_Cancellation_Request{}
err = json.Unmarshal(responseBytes, &result)
if err != nil {
return datatypes.SoftLayer_Billing_Item_Cancellation_Request{}, err
}
return result, nil
}
func (slssks *softLayer_Security_Ssh_Key_Service) GetObject(sshKeyId int) (datatypes.SoftLayer_Security_Ssh_Key, error) {
objectMask := []string{
"createDate",
"fingerprint",
"id",
"key",
"label",
"modifyDate",
"notes",
}
response, errorCode, err := slssks.client.GetHttpClient().DoRawHttpRequestWithObjectMask(fmt.Sprintf("%s/%d/getObject.json", slssks.GetName(), sshKeyId), objectMask, "GET", new(bytes.Buffer))
if err != nil {
return datatypes.SoftLayer_Security_Ssh_Key{}, err
}
if common.IsHttpErrorCode(errorCode) {
errorMessage := fmt.Sprintf("softlayer-go: could not SoftLayer_Security_Ssh_Key#getObject, HTTP error code: '%d'", errorCode)
return datatypes.SoftLayer_Security_Ssh_Key{}, errors.New(errorMessage)
}
sshKey := datatypes.SoftLayer_Security_Ssh_Key{}
err = json.Unmarshal(response, &sshKey)
if err != nil {
return datatypes.SoftLayer_Security_Ssh_Key{}, err
}
return sshKey, nil
}
func (slvgbdtg *softLayer_Virtual_Guest_Block_Device_Template_Group_Service) SetAvailableLocations(id int, locations []datatypes.SoftLayer_Location) (bool, error) {
parameters := datatypes.SoftLayer_Virtual_Guest_Block_Device_Template_Group_LocationsInitParameters{
Parameters: datatypes.SoftLayer_Virtual_Guest_Block_Device_Template_Group_LocationsInitParameter{
Locations: locations,
},
}
requestBody, err := json.Marshal(parameters)
if err != nil {
return false, err
}
response, errorCode, err := slvgbdtg.client.GetHttpClient().DoRawHttpRequest(fmt.Sprintf("%s/%d/setAvailableLocations.json", slvgbdtg.GetName(), id), "POST", bytes.NewBuffer(requestBody))
if err != nil {
return false, err
}
if common.IsHttpErrorCode(errorCode) {
errorMessage := fmt.Sprintf("softlayer-go: could not SoftLayer_Virtual_Guest_Block_Device_Template_Group#setAvailableLocations, HTTP error code: '%d'", errorCode)
return false, errors.New(errorMessage)
}
if res := string(response[:]); res != "true" {
return false, errors.New(fmt.Sprintf("Failed to set available locations access to VGDBTG with ID: %d", id))
}
return true, nil
}
func (slas *softLayer_Account_Service) GetBlockDeviceTemplateGroupsWithFilter(filters string) ([]datatypes.SoftLayer_Virtual_Guest_Block_Device_Template_Group, error) {
isJson, err := common.ValidateJson(filters)
if !isJson || err != nil {
errorMessage := fmt.Sprintf("softlayer-go: filters string %s is not a valid Json formatted string, error message '%s'", filters, err.Error())
return []datatypes.SoftLayer_Virtual_Guest_Block_Device_Template_Group{}, errors.New(errorMessage)
}
path := fmt.Sprintf("%s/%s", slas.GetName(), "getBlockDeviceTemplateGroups.json")
responseBytes, errorCode, err := slas.client.GetHttpClient().DoRawHttpRequestWithObjectFilter(path, filters, "GET", &bytes.Buffer{})
if err != nil {
errorMessage := fmt.Sprintf("softlayer-go: could not SoftLayer_Account#getBlockDeviceTemplateGroups, error message '%s'", err.Error())
return []datatypes.SoftLayer_Virtual_Guest_Block_Device_Template_Group{}, errors.New(errorMessage)
}
if common.IsHttpErrorCode(errorCode) {
errorMessage := fmt.Sprintf("softlayer-go: could not SoftLayer_Account#getBlockDeviceTemplateGroups, HTTP error code: '%d'", errorCode)
return []datatypes.SoftLayer_Virtual_Guest_Block_Device_Template_Group{}, errors.New(errorMessage)
}
vgbdtGroups := []datatypes.SoftLayer_Virtual_Guest_Block_Device_Template_Group{}
err = json.Unmarshal(responseBytes, &vgbdtGroups)
if err != nil {
errorMessage := fmt.Sprintf("softlayer-go: failed to decode JSON response, err message '%s'", err.Error())
err := errors.New(errorMessage)
return []datatypes.SoftLayer_Virtual_Guest_Block_Device_Template_Group{}, err
}
return vgbdtGroups, nil
}
func (slpp *softLayer_Product_Package_Service) GetPackagesByType(packageType string) ([]datatypes.Softlayer_Product_Package, error) {
objectMasks := []string{
"id",
"name",
"description",
"isActive",
"type.keyName",
}
filterObject := string(`{"type":{"keyName":{"operation":"` + packageType + `"}}}`)
response, errorCode, err := slpp.client.GetHttpClient().DoRawHttpRequestWithObjectFilterAndObjectMask(fmt.Sprintf("%s/getAllObjects.json", slpp.GetName()), objectMasks, filterObject, "GET", new(bytes.Buffer))
if err != nil {
return []datatypes.Softlayer_Product_Package{}, err
}
if common.IsHttpErrorCode(errorCode) {
errorMessage := fmt.Sprintf("softlayer-go: could not SoftLayer_Product_Package#getPackagesByType, HTTP error code: '%d'", errorCode)
return []datatypes.Softlayer_Product_Package{}, errors.New(errorMessage)
}
productPackages := []*datatypes.Softlayer_Product_Package{}
err = json.Unmarshal(response, &productPackages)
if err != nil {
return []datatypes.Softlayer_Product_Package{}, err
}
// Remove packages designated as OUTLET
// See method "#get_packages_of_type" in SoftLayer Python client for details: https://github.com/softlayer/softlayer-python/blob/master/SoftLayer/managers/ordering.py
nonOutletPackages := slpp.filterProducts(productPackages, func(productPackage *datatypes.Softlayer_Product_Package) bool {
return !strings.Contains(productPackage.Description, OUTLET_PACKAGE) && !strings.Contains(productPackage.Name, OUTLET_PACKAGE)
})
return nonOutletPackages, nil
}
func (sldds *softLayer_Dns_Domain_Service) GetObject(dnsId int) (datatypes.SoftLayer_Dns_Domain, error) {
objectMask := []string{
"id",
"name",
"serial",
"updateDate",
"account",
"managedResourceFlag",
"resourceRecordCount",
"resourceRecords",
"secondary",
}
response, errorCode, err := sldds.client.GetHttpClient().DoRawHttpRequestWithObjectMask(fmt.Sprintf("%s/%d/getObject.json", sldds.GetName(), dnsId), objectMask, "GET", new(bytes.Buffer))
if err != nil {
return datatypes.SoftLayer_Dns_Domain{}, err
}
if common.IsHttpErrorCode(errorCode) {
errorMessage := fmt.Sprintf("softlayer-go: could not SoftLayer_Dns_Domain#getObject, HTTP error code: '%d'", errorCode)
return datatypes.SoftLayer_Dns_Domain{}, errors.New(errorMessage)
}
dns_domain := datatypes.SoftLayer_Dns_Domain{}
err = json.Unmarshal(response, &dns_domain)
if err != nil {
return datatypes.SoftLayer_Dns_Domain{}, err
}
return dns_domain, nil
}
func (slpo *softLayer_Product_Order_Service) PlaceContainerOrderVirtualGuestUpgrade(order datatypes.SoftLayer_Container_Product_Order_Virtual_Guest_Upgrade) (datatypes.SoftLayer_Container_Product_Order_Receipt, error) {
parameters := datatypes.SoftLayer_Container_Product_Order_Virtual_Guest_Upgrade_Parameters{
Parameters: []datatypes.SoftLayer_Container_Product_Order_Virtual_Guest_Upgrade{
order,
},
}
requestBody, err := json.Marshal(parameters)
if err != nil {
return datatypes.SoftLayer_Container_Product_Order_Receipt{}, err
}
responseBytes, errorCode, err := slpo.client.GetHttpClient().DoRawHttpRequest(fmt.Sprintf("%s/placeOrder.json", slpo.GetName()), "POST", bytes.NewBuffer(requestBody))
if err != nil {
return datatypes.SoftLayer_Container_Product_Order_Receipt{}, err
}
if common.IsHttpErrorCode(errorCode) {
errorMessage := fmt.Sprintf("softlayer-go: could not SoftLayer_Product_Order#placeOrder, HTTP error code: '%d'", errorCode)
return datatypes.SoftLayer_Container_Product_Order_Receipt{}, errors.New(errorMessage)
}
receipt := datatypes.SoftLayer_Container_Product_Order_Receipt{}
err = json.Unmarshal(responseBytes, &receipt)
if err != nil {
return datatypes.SoftLayer_Container_Product_Order_Receipt{}, err
}
return receipt, nil
}
func (slvgbdtg *softLayer_Virtual_Guest_Block_Device_Template_Group_Service) DenySharingAccess(id int, accountId int) (bool, error) {
parameters := datatypes.SoftLayer_Virtual_Guest_Block_Device_Template_GroupInitParameters{
Parameters: datatypes.SoftLayer_Virtual_Guest_Block_Device_Template_GroupInitParameter{
AccountId: accountId,
},
}
requestBody, err := json.Marshal(parameters)
if err != nil {
return false, err
}
response, errorCode, err := slvgbdtg.client.GetHttpClient().DoRawHttpRequest(fmt.Sprintf("%s/%d/denySharingAccess.json", slvgbdtg.GetName(), id), "POST", bytes.NewBuffer(requestBody))
if err != nil {
return false, err
}
if common.IsHttpErrorCode(errorCode) {
errorMessage := fmt.Sprintf("softlayer-go: could not SoftLayer_Virtual_Guest_Block_Device_Template_Group#denySharingAccess, HTTP error code: '%d'", errorCode)
return false, errors.New(errorMessage)
}
if res := string(response[:]); res != "true" {
return false, errors.New(fmt.Sprintf("Failed to permit sharing access to VGDBTG with ID: %d to account ID: %d", id, accountId))
}
return true, nil
}
func (slvgbdtg *softLayer_Virtual_Guest_Block_Device_Template_Group_Service) CopyToExternalSource(configuration datatypes.SoftLayer_Container_Virtual_Guest_Block_Device_Template_Configuration) (bool, error) {
parameters := datatypes.SoftLayer_Container_Virtual_Guest_Block_Device_Template_Configuration_Parameters{
Parameters: []datatypes.SoftLayer_Container_Virtual_Guest_Block_Device_Template_Configuration{configuration},
}
requestBody, err := json.Marshal(parameters)
if err != nil {
return false, err
}
response, errorCode, err := slvgbdtg.client.GetHttpClient().DoRawHttpRequest(fmt.Sprintf("%s/copyToExternalSource.json", slvgbdtg.GetName()), "POST", bytes.NewBuffer(requestBody))
if err != nil {
return false, err
}
if common.IsHttpErrorCode(errorCode) {
errorMessage := fmt.Sprintf("softlayer-go: could not SoftLayer_Virtual_Guest_Block_Device_Template_Group#copyToExternalSource, HTTP error code: '%d'", errorCode)
return false, errors.New(errorMessage)
}
if res := string(response[:]); res != "true" {
return false, errors.New(fmt.Sprintf("Failed to create virtual guest block device template group, got '%s' as response from the API.", res))
}
return true, nil
}
func (slvgbdtg *softLayer_Virtual_Guest_Block_Device_Template_Group_Service) CreateFromExternalSource(configuration datatypes.SoftLayer_Container_Virtual_Guest_Block_Device_Template_Configuration) (datatypes.SoftLayer_Virtual_Guest_Block_Device_Template_Group, error) {
parameters := datatypes.SoftLayer_Container_Virtual_Guest_Block_Device_Template_Configuration_Parameters{
Parameters: []datatypes.SoftLayer_Container_Virtual_Guest_Block_Device_Template_Configuration{configuration},
}
requestBody, err := json.Marshal(parameters)
if err != nil {
return datatypes.SoftLayer_Virtual_Guest_Block_Device_Template_Group{}, err
}
response, errorCode, err := slvgbdtg.client.GetHttpClient().DoRawHttpRequest(fmt.Sprintf("%s/createFromExternalSource.json", slvgbdtg.GetName()), "POST", bytes.NewBuffer(requestBody))
if err != nil {
return datatypes.SoftLayer_Virtual_Guest_Block_Device_Template_Group{}, err
}
if common.IsHttpErrorCode(errorCode) {
errorMessage := fmt.Sprintf("softlayer-go: could not SoftLayer_Virtual_Guest_Block_Device_Template_Group#createFromExternalSource, HTTP error code: '%d'", errorCode)
return datatypes.SoftLayer_Virtual_Guest_Block_Device_Template_Group{}, errors.New(errorMessage)
}
vgbdtGroup := datatypes.SoftLayer_Virtual_Guest_Block_Device_Template_Group{}
err = json.Unmarshal(response, &vgbdtGroup)
if err != nil {
return datatypes.SoftLayer_Virtual_Guest_Block_Device_Template_Group{}, err
}
return vgbdtGroup, err
}
func (slvgbdtg *softLayer_Virtual_Guest_Block_Device_Template_Group_Service) CreatePublicArchiveTransaction(id int, groupName string, summary string, note string, locations []datatypes.SoftLayer_Location) (int, error) {
groupName = url.QueryEscape(groupName)
summary = url.QueryEscape(summary)
note = url.QueryEscape(note)
parameters := datatypes.SoftLayer_Virtual_Guest_Block_Device_Template_GroupInitParameters2{
Parameters: []interface{}{groupName, summary, note, locations},
}
requestBody, err := json.Marshal(parameters)
if err != nil {
return 0, err
}
response, errorCode, err := slvgbdtg.client.GetHttpClient().DoRawHttpRequest(fmt.Sprintf("%s/%d/createPublicArchiveTransaction.json", slvgbdtg.GetName(), id), "POST", bytes.NewBuffer(requestBody))
if err != nil {
return 0, err
}
if common.IsHttpErrorCode(errorCode) {
errorMessage := fmt.Sprintf("softlayer-go: could not SoftLayer_Virtual_Guest_Block_Device_Template_Group#createPublicArchiveTransaction, HTTP error code: '%d'", errorCode)
return 0, errors.New(errorMessage)
}
transactionId, err := strconv.Atoi(string(response[:]))
if err != nil {
return 0, errors.New(fmt.Sprintf("Failed to createPublicArchiveTransaction for ID: %d, error: %s", id, string(response[:])))
}
return transactionId, nil
}
func (slhs *softLayer_Hardware_Service) AllowAccessToNetworkStorage(id int, storage datatypes.SoftLayer_Network_Storage) (bool, error) {
parameters := datatypes.SoftLayer_Hardware_NetworkStorage_Parameters{
Parameters: storage,
}
requestBody, err := json.Marshal(parameters)
if err != nil {
return false, err
}
response, errorCode, err := slhs.client.GetHttpClient().DoRawHttpRequest(fmt.Sprintf("%s/%d/allowAccessToNetworkStorage.json", slhs.GetName(), id), "POST", bytes.NewBuffer(requestBody))
if err != nil {
return false, err
}
if common.IsHttpErrorCode(errorCode) {
errorMessage := fmt.Sprintf("softlayer-go: could not SoftLayer_Hardware#allowAccessToNetworkStorage, HTTP error code: '%d'", errorCode)
return false, errors.New(errorMessage)
}
if res := string(response[:]); res != "true" {
return false, errors.New(fmt.Sprintf("Failed to allowAccessToNetworkStorage with id '%d', got '%s' as response from the API.", id, res))
}
return true, nil
}
func (slvgs *softLayer_Virtual_Guest_Service) DetachDiskImage(instanceId int, imageId int) (datatypes.SoftLayer_Provisioning_Version1_Transaction, error) {
parameters := datatypes.SoftLayer_Virtual_GuestInit_ImageId_Parameters{
Parameters: datatypes.ImageId_Parameter{
ImageId: imageId,
},
}
requestBody, err := json.Marshal(parameters)
if err != nil {
return datatypes.SoftLayer_Provisioning_Version1_Transaction{}, err
}
response, errorCode, err := slvgs.client.GetHttpClient().DoRawHttpRequest(fmt.Sprintf("%s/%d/detachDiskImage.json", slvgs.GetName(), instanceId), "POST", bytes.NewBuffer(requestBody))
if err != nil {
return datatypes.SoftLayer_Provisioning_Version1_Transaction{}, err
}
if common.IsHttpErrorCode(errorCode) {
errorMessage := fmt.Sprintf("softlayer-go: could not SoftLayer_Virtual_Guest#detachDiskImage, HTTP error code: '%d'", errorCode)
return datatypes.SoftLayer_Provisioning_Version1_Transaction{}, errors.New(errorMessage)
}
transaction := datatypes.SoftLayer_Provisioning_Version1_Transaction{}
err = json.Unmarshal(response, &transaction)
if err != nil {
return datatypes.SoftLayer_Provisioning_Version1_Transaction{}, err
}
return transaction, nil
}
func (slvgs *softLayer_Virtual_Guest_Service) ReloadOperatingSystem(instanceId int, template datatypes.Image_Template_Config) error {
parameter := [2]interface{}{"FORCE", template}
parameters := map[string]interface{}{
"parameters": parameter,
}
requestBody, err := json.Marshal(parameters)
if err != nil {
return err
}
response, errorCode, err := slvgs.client.GetHttpClient().DoRawHttpRequest(fmt.Sprintf("%s/%d/reloadOperatingSystem.json", slvgs.GetName(), instanceId), "POST", bytes.NewBuffer(requestBody))
if err != nil {
return err
}
if common.IsHttpErrorCode(errorCode) {
errorMessage := fmt.Sprintf("softlayer-go: could not SoftLayer_Virtual_Guest#reloadOperatingSystem, HTTP error code: '%d'", errorCode)
return errors.New(errorMessage)
}
if res := string(response[:]); res != `"1"` {
return errors.New(fmt.Sprintf("Failed to reload OS on instance with id '%d', got '%s' as response from the API.", instanceId, res))
}
return nil
}
func (sldr *SoftLayer_Dns_Domain_ResourceRecord_Service) EditObject(recordId int, template datatypes.SoftLayer_Dns_Domain_ResourceRecord) (bool, error) {
parameters := datatypes.SoftLayer_Dns_Domain_ResourceRecord_Parameters{
Parameters: []datatypes.SoftLayer_Dns_Domain_ResourceRecord{
template,
},
}
requestBody, err := json.Marshal(parameters)
if err != nil {
return false, err
}
response, errorCode, err := sldr.client.GetHttpClient().DoRawHttpRequest(fmt.Sprintf("%s/%d/editObject.json", sldr.getNameByType(template.Type), recordId), "POST", bytes.NewBuffer(requestBody))
if res := string(response[:]); res != "true" {
return false, errors.New(fmt.Sprintf("Failed to edit DNS Domain Record with id: %d, got '%s' as response from the API.", recordId, res))
}
if common.IsHttpErrorCode(errorCode) {
errorMessage := fmt.Sprintf("softlayer-go: could not SoftLayer_Dns_Domain_ResourceRecord#editObject, HTTP error code: '%d'", errorCode)
return false, errors.New(errorMessage)
}
return true, err
}
func (slvgs *softLayer_Virtual_Guest_Service) SetMetadata(instanceId int, metadata string) (bool, error) {
dataBytes := []byte(metadata)
base64EncodedMetadata := base64.StdEncoding.EncodeToString(dataBytes)
parameters := datatypes.SoftLayer_SetUserMetadata_Parameters{
Parameters: []datatypes.UserMetadataArray{
[]datatypes.UserMetadata{datatypes.UserMetadata(base64EncodedMetadata)},
},
}
requestBody, err := json.Marshal(parameters)
if err != nil {
return false, err
}
response, errorCode, err := slvgs.client.GetHttpClient().DoRawHttpRequest(fmt.Sprintf("%s/%d/setUserMetadata.json", slvgs.GetName(), instanceId), "POST", bytes.NewBuffer(requestBody))
if err != nil {
return false, err
}
if res := string(response[:]); res != "true" {
return false, errors.New(fmt.Sprintf("Failed to setUserMetadata for instance with id '%d', got '%s' as response from the API.", instanceId, res))
}
if common.IsHttpErrorCode(errorCode) {
errorMessage := fmt.Sprintf("softlayer-go: could not SoftLayer_Virtual_Guest#setUserMetadata, HTTP error code: '%d'", errorCode)
return false, errors.New(errorMessage)
}
return true, err
}
func (slvgs *softLayer_Virtual_Guest_Service) SetTags(instanceId int, tags []string) (bool, error) {
var tagStringBuffer bytes.Buffer
for i, tag := range tags {
tagStringBuffer.WriteString(tag)
if i != len(tags)-1 {
tagStringBuffer.WriteString(", ")
}
}
setTagsParameters := datatypes.SoftLayer_Virtual_Guest_SetTags_Parameters{
Parameters: []string{tagStringBuffer.String()},
}
requestBody, err := json.Marshal(setTagsParameters)
if err != nil {
return false, err
}
response, errorCode, err := slvgs.client.GetHttpClient().DoRawHttpRequest(fmt.Sprintf("%s/%d/setTags.json", slvgs.GetName(), instanceId), "POST", bytes.NewBuffer(requestBody))
if err != nil {
return false, err
}
if common.IsHttpErrorCode(errorCode) {
errorMessage := fmt.Sprintf("softlayer-go: could not SoftLayer_Virtual_Guest#setTags, HTTP error code: '%d'", errorCode)
return false, errors.New(errorMessage)
}
if res := string(response[:]); res != "true" {
return false, errors.New(fmt.Sprintf("Failed to setTags for instance with id '%d', got '%s' as response from the API.", instanceId, res))
}
return true, nil
}
func (slvgs *softLayer_Virtual_Guest_Service) CreateArchiveTransaction(instanceId int, groupName string, blockDevices []datatypes.SoftLayer_Virtual_Guest_Block_Device, note string) (datatypes.SoftLayer_Provisioning_Version1_Transaction, error) {
groupName = url.QueryEscape(groupName)
note = url.QueryEscape(note)
parameters := datatypes.SoftLayer_Virtual_GuestInitParameters{
Parameters: []interface{}{groupName, blockDevices, note},
}
requestBody, err := json.Marshal(parameters)
if err != nil {
return datatypes.SoftLayer_Provisioning_Version1_Transaction{}, err
}
response, errorCode, err := slvgs.client.GetHttpClient().DoRawHttpRequest(fmt.Sprintf("%s/%d/createArchiveTransaction.json", slvgs.GetName(), instanceId), "POST", bytes.NewBuffer(requestBody))
if err != nil {
return datatypes.SoftLayer_Provisioning_Version1_Transaction{}, err
}
if common.IsHttpErrorCode(errorCode) {
errorMessage := fmt.Sprintf("softlayer-go: could not SoftLayer_Virtual_Guest#createArchiveTransaction, HTTP error code: '%d'", errorCode)
return datatypes.SoftLayer_Provisioning_Version1_Transaction{}, errors.New(errorMessage)
}
transaction := datatypes.SoftLayer_Provisioning_Version1_Transaction{}
err = json.Unmarshal(response, &transaction)
if err != nil {
return datatypes.SoftLayer_Provisioning_Version1_Transaction{}, err
}
return transaction, nil
}
func (slvgs *softLayer_Virtual_Guest_Service) EditObject(instanceId int, template datatypes.SoftLayer_Virtual_Guest) (bool, error) {
parameters := datatypes.SoftLayer_Virtual_Guest_Parameters{
Parameters: []datatypes.SoftLayer_Virtual_Guest{template},
}
requestBody, err := json.Marshal(parameters)
if err != nil {
return false, err
}
response, errorCode, err := slvgs.client.GetHttpClient().DoRawHttpRequest(fmt.Sprintf("%s/%d/editObject.json", slvgs.GetName(), instanceId), "POST", bytes.NewBuffer(requestBody))
if err != nil {
return false, err
}
if res := string(response[:]); res != "true" {
return false, errors.New(fmt.Sprintf("Failed to edit virtual guest with id: %d, got '%s' as response from the API.", instanceId, res))
}
if common.IsHttpErrorCode(errorCode) {
errorMessage := fmt.Sprintf("softlayer-go: could not SoftLayer_Virtual_Guest#editObject, HTTP error code: '%d'", errorCode)
return false, errors.New(errorMessage)
}
return true, err
}
func (sldr *SoftLayer_Dns_Domain_ResourceRecord_Service) CreateObject(template datatypes.SoftLayer_Dns_Domain_ResourceRecord_Template) (datatypes.SoftLayer_Dns_Domain_ResourceRecord, error) {
parameters := datatypes.SoftLayer_Dns_Domain_ResourceRecord_Template_Parameters{
Parameters: []datatypes.SoftLayer_Dns_Domain_ResourceRecord_Template{
template,
},
}
requestBody, err := json.Marshal(parameters)
if err != nil {
return datatypes.SoftLayer_Dns_Domain_ResourceRecord{}, err
}
response, errorCode, err := sldr.client.GetHttpClient().DoRawHttpRequest(fmt.Sprintf("%s/createObject", sldr.getNameByType(template.Type)), "POST", bytes.NewBuffer(requestBody))
if err != nil {
return datatypes.SoftLayer_Dns_Domain_ResourceRecord{}, err
}
if common.IsHttpErrorCode(errorCode) {
errorMessage := fmt.Sprintf("softlayer-go: could not SoftLayer_Dns_Domain_ResourceRecord#createObject, HTTP error code: '%d'", errorCode)
return datatypes.SoftLayer_Dns_Domain_ResourceRecord{}, errors.New(errorMessage)
}
err = sldr.client.GetHttpClient().CheckForHttpResponseErrors(response)
if err != nil {
return datatypes.SoftLayer_Dns_Domain_ResourceRecord{}, err
}
dns_record := datatypes.SoftLayer_Dns_Domain_ResourceRecord{}
err = json.Unmarshal(response, &dns_record)
if err != nil {
return datatypes.SoftLayer_Dns_Domain_ResourceRecord{}, err
}
return dns_record, nil
}
func (slhs *softLayer_Hardware_Service) CreateObject(template datatypes.SoftLayer_Hardware_Template) (datatypes.SoftLayer_Hardware, error) {
parameters := datatypes.SoftLayer_Hardware_Template_Parameters{
Parameters: []datatypes.SoftLayer_Hardware_Template{
template,
},
}
requestBody, err := json.Marshal(parameters)
if err != nil {
return datatypes.SoftLayer_Hardware{}, err
}
response, errorCode, err := slhs.client.GetHttpClient().DoRawHttpRequest(fmt.Sprintf("%s.json", slhs.GetName()), "POST", bytes.NewBuffer(requestBody))
if err != nil {
return datatypes.SoftLayer_Hardware{}, err
}
if common.IsHttpErrorCode(errorCode) {
errorMessage := fmt.Sprintf("softlayer-go: could not SoftLayer_Hardware#createObject, HTTP error code: '%d'", errorCode)
return datatypes.SoftLayer_Hardware{}, errors.New(errorMessage)
}
err = slhs.client.GetHttpClient().CheckForHttpResponseErrors(response)
if err != nil {
return datatypes.SoftLayer_Hardware{}, err
}
hardware := datatypes.SoftLayer_Hardware{}
err = json.Unmarshal(response, &hardware)
if err != nil {
return datatypes.SoftLayer_Hardware{}, err
}
return hardware, nil
}
func (slas *softLayer_Account_Service) GetIscsiNetworkStorageWithFilter(filter string) ([]datatypes.SoftLayer_Network_Storage, error) {
path := fmt.Sprintf("%s/%s", slas.GetName(), "getIscsiNetworkStorage.json")
objectMasks := []string{
"username",
"accountId",
"capacityGb",
"id",
"billingItem.id",
"billingItem.orderItem.order.id",
}
responseBytes, errorCode, err := slas.client.GetHttpClient().DoRawHttpRequestWithObjectFilterAndObjectMask(path, objectMasks, filter, "GET", &bytes.Buffer{})
if err != nil {
errorMessage := fmt.Sprintf("softlayer-go: could not SoftLayer_Account#getIscsiNetworkStorage, error message '%s'", err.Error())
return []datatypes.SoftLayer_Network_Storage{}, errors.New(errorMessage)
}
if common.IsHttpErrorCode(errorCode) {
errorMessage := fmt.Sprintf("softlayer-go: could not SoftLayer_Account#getIscsiNetworkStorage, HTTP error code: '%d'", errorCode)
return []datatypes.SoftLayer_Network_Storage{}, errors.New(errorMessage)
}
networkStorage := []datatypes.SoftLayer_Network_Storage{}
err = json.Unmarshal(responseBytes, &networkStorage)
if err != nil {
errorMessage := fmt.Sprintf("softlayer-go: failed to decode JSON response, err message '%s'", err.Error())
err := errors.New(errorMessage)
return []datatypes.SoftLayer_Network_Storage{}, err
}
return networkStorage, nil
}
func (slpp *softLayer_Product_Package_Service) GetItems(packageId int) ([]datatypes.SoftLayer_Product_Item, error) {
objectMasks := []string{
"id",
"capacity",
"description",
"prices.id",
"prices.categories.id",
"prices.categories.name",
}
response, errorCode, err := slpp.client.GetHttpClient().DoRawHttpRequestWithObjectMask(fmt.Sprintf("%s/%d/getItems.json", slpp.GetName(), packageId), objectMasks, "GET", new(bytes.Buffer))
if err != nil {
return []datatypes.SoftLayer_Product_Item{}, err
}
if common.IsHttpErrorCode(errorCode) {
errorMessage := fmt.Sprintf("softlayer-go: could not SoftLayer_Product_Package#getItems, HTTP error code: '%d'", errorCode)
return []datatypes.SoftLayer_Product_Item{}, errors.New(errorMessage)
}
productItems := []datatypes.SoftLayer_Product_Item{}
err = json.Unmarshal(response, &productItems)
if err != nil {
return []datatypes.SoftLayer_Product_Item{}, err
}
return productItems, nil
}
func (slvgbdtg *softLayer_Virtual_Guest_Block_Device_Template_Group_Service) GetGlobalIdentifier(id int) (string, error) {
response, errorCode, err := slvgbdtg.client.GetHttpClient().DoRawHttpRequest(fmt.Sprintf("%s/%d/getGlobalIdentifier.json", slvgbdtg.GetName(), id), "GET", new(bytes.Buffer))
if common.IsHttpErrorCode(errorCode) {
errorMessage := fmt.Sprintf("softlayer-go: could not SoftLayer_Virtual_Guest_Block_Device_Template_Group#getGlobalIdentifier, HTTP error code: '%d'", errorCode)
return "", errors.New(errorMessage)
}
return string(strings.TrimSpace(string(response))), err
}
func (slhs *softLayer_Hardware_Service) GetAttachedNetworkStorages(id int, nasType string) ([]datatypes.SoftLayer_Network_Storage, error) {
nasTypeParameters := datatypes.SoftLayer_Hardware_String_Parameters{
Parameters: []string{nasType},
}
requestBody, err := json.Marshal(nasTypeParameters)
if err != nil {
return []datatypes.SoftLayer_Network_Storage{}, err
}
objectMask := []string{
"accountId",
"capacityGb",
"createDate",
"guestId",
"hardwareId",
"hostId",
"id",
"fullyQualifiedDomainName",
"nasType",
"notes",
"Password",
"serviceProviderId",
"upgradableFlag",
"username",
"billingItem.id",
"billingItem.orderItem.order.id",
"lunId",
"serviceResourceBackendIpAddress",
}
response, errorCode, err := slhs.client.GetHttpClient().DoRawHttpRequestWithObjectMask(fmt.Sprintf("%s/%d/getAttachedNetworkStorages.json", slhs.GetName(), id), objectMask, "POST", bytes.NewBuffer(requestBody))
if err != nil {
return []datatypes.SoftLayer_Network_Storage{}, err
}
if common.IsHttpErrorCode(errorCode) {
errorMessage := fmt.Sprintf("softlayer-go: could not SoftLayer_Hardware#getAttachedNetworkStorages, HTTP error code: '%d'", errorCode)
return []datatypes.SoftLayer_Network_Storage{}, errors.New(errorMessage)
}
err = slhs.client.GetHttpClient().CheckForHttpResponseErrors(response)
if err != nil {
return []datatypes.SoftLayer_Network_Storage{}, err
}
storageList := []datatypes.SoftLayer_Network_Storage{}
err = json.Unmarshal(response, &storageList)
if err != nil {
return []datatypes.SoftLayer_Network_Storage{}, err
}
return storageList, nil
}
func (slhs *softLayer_Hardware_Service) GetPrimaryBackendIpAddress(id int) (string, error) {
response, errorCode, err := slhs.client.GetHttpClient().DoRawHttpRequest(fmt.Sprintf("%s/%d/getPrimaryBackendIpAddress.json", slhs.GetName(), id), "GET", new(bytes.Buffer))
if err != nil {
return "", err
}
if common.IsHttpErrorCode(errorCode) {
errorMessage := fmt.Sprintf("softlayer-go: could not SoftLayer_Hardware#getPrimaryBackendIpAddress, HTTP error code: '%d'", errorCode)
return "", errors.New(errorMessage)
}
return string(response[:]), nil
}