class SecuredCloudRestClient

Class SecuredCloudRestClient provides a collection of methods that issue requests to the Secured Cloud RESTful External API.

@author

Alan Vella, Secured Cloud

Public Class Methods

assignPublicIpToVM(sc_connection, vmResource, ipFromReserved, privateIpMapping) click to toggle source

Assigns a public IP to a VM. ipFromReserved: a new IP will be assigned if set to nil privateIpMapping: Private ip mappings are only supported for nodes

with custom network configurations. Should this field be set for 
nodes with a different network configuration, a 405 �Method not 
allowed� error will be returned.
# File lib/secured_cloud_api_client.rb, line 307
def self.assignPublicIpToVM(sc_connection, vmResource, ipFromReserved, privateIpMapping)
  
  #validation
  validate_sc_connection(sc_connection)
  validate_resource("Virtual Machine Resource", vmResource)
  if (ipFromReserved != nil) then
    raise ArgumentError, 'ipFromReserved needs to be a valid string' unless ipFromReserved.respond_to?(:to_str)  
  end
  if (privateIpMapping != nil) then
    raise ArgumentError, 'privateIpMapping needs to be a valid string' unless privateIpMapping.respond_to?(:to_str)  
  end
  
  ipFromReserved = (ipFromReserved == nil) ? 'null' : '"' + ipFromReserved + '"'
  privateIpMapping = (privateIpMapping == nil) ? 'null' : '"' + privateIpMapping + '"'    
  jsonBody = '{"ipFromReserved":' + ipFromReserved + ',"privateIpMapping":' + privateIpMapping + '}'
  
  response = HttpClient.sendPOSTRequest( sc_connection, sc_connection.getUrl() + vmResource + "/publicip", jsonBody)
  
  if (response.code == "202") then
    responseBodyAsObject = JSON.parse(response.body)
    responseBodyAsObject.each do |item|
    return "202", item[1]
    end
  else
    return response.code, response['X-Application-Error-Reference'], response['X-Application-Error-Description']
  end
  
end
createVM(sc_connection, orgResource, nodeResource, name, description, storageGB, memoryMB, vCPUCount, powerStatus, imageResource, osTemplateResource, osPassword) click to toggle source

Starts a Create VM transaction. Returns the response code as well as the task resource if the transaction is triggered successfully.

# File lib/secured_cloud_api_client.rb, line 110
def self.createVM(sc_connection, orgResource, nodeResource, name, description, storageGB, memoryMB, vCPUCount, powerStatus, imageResource, osTemplateResource, osPassword)
  
  #validation
  validate_sc_connection(sc_connection)
  validate_resource("Organization Resource", orgResource)
  validate_resource("Node Resource", nodeResource)

  createVMPostBody = createVMJSONBody(name, description, storageGB, memoryMB, vCPUCount, powerStatus, imageResource, osTemplateResource, osPassword)
  response = HttpClient.sendPOSTRequest( sc_connection, sc_connection.getUrl() + orgResource + nodeResource + "/virtualmachine", createVMPostBody)
  
  if (response.code == "202") then
    responseBodyAsObject = JSON.parse(response.body)
    responseBodyAsObject.each do |item|
      return "202", item[1]
    end
  else
    return response.code, response['X-Application-Error-Reference'], response['X-Application-Error-Description']
  end
  
end
deleteVM(sc_connection, vmResource, releaseIPs) click to toggle source

Starts a Delete VM transaction. Returns the response code as well as the task resource if the transaction is triggered successfully.

# File lib/secured_cloud_api_client.rb, line 342
def self.deleteVM(sc_connection, vmResource, releaseIPs)
  
  #validation
  validate_sc_connection(sc_connection)
  validate_resource("Virtual Machine Resource", vmResource)
  
  params = []
  
  if ((releaseIPs != nil) && (releaseIPs)) then
    params.push(["released","true"])
  else
    params.push(["released","false"])
  end
  
  response = HttpClient.sendDELETERequest( sc_connection, sc_connection.getUrl() + vmResource, params)
  
  if (response.code == "202") then
    responseBodyAsObject = JSON.parse(response.body)
    
    responseBodyAsObject.each do |item|
      return "202", item[1]
    end
  else
    return response.code, response['X-Application-Error-Reference'], response['X-Application-Error-Description']
  end
  
end
getNodesAvailable(sc_connection, orgResource) click to toggle source

Returns a list of available nodes for a given organization.

# File lib/secured_cloud_api_client.rb, line 41
def self.getNodesAvailable(sc_connection, orgResource)
  
  #validation
  validate_sc_connection(sc_connection)
  validate_resource("Organization Resource", orgResource)
  
  response = HttpClient.sendGETRequest( sc_connection, sc_connection.getUrl() + orgResource + "/node" )
  nodesAvailable = []
  responseBodyAsObject = JSON.parse(response.body)
  responseBodyAsObject.each do |item|
    nodesAvailable.push(item["resourceURL"])
  end
  
  return nodesAvailable
end
getOsTemplateDetails(sc_connection, osTemplateResource) click to toggle source

Returns the details of an OS template

# File lib/secured_cloud_api_client.rb, line 79
def self.getOsTemplateDetails(sc_connection, osTemplateResource)
  
  #validation
  validate_sc_connection(sc_connection)
  validate_resource("OS Template", osTemplateResource)    

  osResponse = HttpClient.sendGETRequest( sc_connection, sc_connection.getUrl() + osTemplateResource )
  responseBodyAsObject = JSON.parse(osResponse.body)
  osName = osVersion = minimumStorageSpace = defaultAdministratorUsername = diskExpandable = ""
  
  responseBodyAsObject.each do |item|
    if item[0] == "name" then
    osName = item[1]
    elsif item[0] == "version" then
    osVersion = item[1]
    elsif item[0] == "minimumStorageSpace" then
    minimumStorageSpace = item[1]
    elsif item[0] == "defaultAdministratorUsername" then
    defaultAdministratorUsername = item[1]
    elsif item[0] == "diskExpandable" then
    diskExpandable = item[1]
    end       
  end    
  
  return OsTemplate.new(osName, osVersion, minimumStorageSpace, defaultAdministratorUsername, diskExpandable)   
end
getOsTemplatesAvailable(sc_connection, orgResource, nodeResource) click to toggle source

Returns a list of available OS templates for a given organization and node.

# File lib/secured_cloud_api_client.rb, line 59
def self.getOsTemplatesAvailable(sc_connection, orgResource, nodeResource)
  
  #validation
  validate_sc_connection(sc_connection)
  validate_resource("Organization Resource", orgResource)
  validate_resource("Node Resource", nodeResource)

  response = HttpClient.sendGETRequest( sc_connection, sc_connection.getUrl() + orgResource + nodeResource + "/ostemplate")
  osTemplatesAvailable = []
  responseBodyAsObject = JSON.parse(response.body)
  
  responseBodyAsObject.each do |item|
    osTemplatesAvailable.push(item["resourceURL"])
  end
  
  return osTemplatesAvailable
end
getTaskStatus(sc_connection, taskResource) click to toggle source

Returns the status of a task.

# File lib/secured_cloud_api_client.rb, line 422
def self.getTaskStatus(sc_connection, taskResource)
  
  #validation
  raise ArgumentError, 'SecuredCloudConnection needs to be initialized' unless sc_connection != nil
  raise ArgumentError, 'Task Resource needs to be initialized' unless taskResource != nil
  raise ArgumentError, 'Task Resource needs to be a valid string' unless taskResource.respond_to?(:to_s)

  response = HttpClient.sendGETRequest( sc_connection, sc_connection.getUrl() + taskResource )
  responseBodyAsObject = JSON.parse(response.body)
  percentageComplete, requestStateEnum, result, errorCode, errorMessage, latestTaskDescription, processDescription, createdTimestamp, lastUpdatedTimeStamp = ""
  
  responseBodyAsObject.each do |item|
    if item[0] == "percentageComplete" then
      percentageComplete = item[1]
    elsif item[0] == "requestStateEnum" then
      requestStateEnum = item[1]
    elsif item[0] == "result" then
      result = item[1]
    elsif item[0] == "errorCode" then
      errorCode = item[1]
    elsif item[0] == "errorMessage" then
      errorMessage = item[1]
    elsif item[0] == "latestTaskDescription" then
      latestTaskDescription = item[1]
    elsif item[0] == "processDescription" then
      processDescription = item[1]
    elsif item[0] == "createdTimestamp" then
      createdTimestamp = item[1]
    elsif item[0] == "lastUpdatedTimeStamp" then
      lastUpdatedTimeStamp = item[1]
    end 
  end   
  
  return TaskStatus.new(percentageComplete, requestStateEnum, result, errorCode, errorMessage, latestTaskDescription, processDescription, createdTimestamp, lastUpdatedTimeStamp)
end
getVMDetails(sc_connection, vmResource) click to toggle source

Gets the details of a VM

# File lib/secured_cloud_api_client.rb, line 132
def self.getVMDetails(sc_connection, vmResource)
  
  #validation
  validate_sc_connection(sc_connection)
  validate_resource("Virtual Machine Resource", vmResource)
  
  response = HttpClient.sendGETRequest( sc_connection, sc_connection.getUrl() + vmResource )
  responseBodyAsObject = JSON.parse(response.body)
  name, description, storageGB, storageType, memoryMB, vCPUs, powerStatus, nodeResource, organizationResource,
  operatingSystemTemplate, imageResource, disks, macAddress, deducedPrivateIps, ipMappings = ""
  
  responseBodyAsObject.each do |item|
    if item[0] == "name" then
      name = item[1]
    elsif item[0] == "description" then
      description = item[1]
    elsif item[0] == "storageGB" then
    storageGB = item[1]
    elsif item[0] == "storageType" then
      storageType = item[1]
    elsif item[0] == "memoryMB" then
      memoryMB = item[1]
    elsif item[0] == "vCPUs" then
      vCPUs = item[1]
    elsif item[0] == "powerStatus" then
      powerStatus = item[1]
    elsif item[0] == "nodeResource" then
      nodeResource = item[1]["resourceURL"]
    elsif item[0] == "organizationResource" then
      organizationResource = item[1]["resourceURL"]
    elsif item[0] == "operatingSystemTemplate" && !item[1].nil? then
      operatingSystemTemplate = item[1]["resourceURL"]
    elsif item[0] == "imageResource" then
      imageResource = item[1]
    elsif item[0] == "disks" then
      diskArray = item[1]
      disks = []
      diskArray.each do |disk|
        disks.push(disk["resourceURL"])          
      end
    elsif item[0] == "macAddress" then
      macAddress = item[1]
    elsif item[0] == "deducedPrivateIps" then
      deducedPrivateIps = item[1]        
    elsif item[0] == "ipMappings" then
      ipMappingsArray = item[1]
      ipMappings = []
      ipMappingsArray.each do |ipMapping|
        ipMappingToPush = IpMapping.new(ipMapping["privateIp"], ipMapping["publicIps"])
        ipMappings.push(ipMappingToPush)          
      end
    end 
  end 
            
  return VirtualMachine.new(name, description, storageGB, storageType, memoryMB, vCPUs, powerStatus, nodeResource, organizationResource,
    operatingSystemTemplate, imageResource, disks, macAddress, deducedPrivateIps, ipMappings)
end
getVMPrivateIPs(sc_connection, vmResource) click to toggle source

Returns all private IPs on a VM

# File lib/secured_cloud_api_client.rb, line 211
def self.getVMPrivateIPs(sc_connection, vmResource)

  #validation
  validate_sc_connection(sc_connection)
  validate_resource("Virtual Machine Resource", vmResource)

  response = HttpClient.sendGETRequest( sc_connection, sc_connection.getUrl() + vmResource + "/privateip")
  privateIps = []
  responseBodyAsObject = JSON.parse(response.body)
  responseBodyAsObject.each do |item|
    privateIps.push(item["resourceURL"])
  end
  
  return privateIps
  
end
getVMPrivateIpDetails(sc_connection, privateIpResource) click to toggle source

Returns the details of a VM private IP

# File lib/secured_cloud_api_client.rb, line 268
def self.getVMPrivateIpDetails(sc_connection, privateIpResource)
  
  #validation
  validate_sc_connection(sc_connection)
  validate_resource("Private IP Resource", privateIpResource)
  
  response = HttpClient.sendGETRequest( sc_connection, sc_connection.getUrl() + privateIpResource )
  responseBodyAsObject = JSON.parse(response.body)
  ipAddress, assignedTo, publicIpMappings, nodeResource, organizationResource = ""
  
  responseBodyAsObject.each do |item|
    if item[0] == "ipAddress" then
      ipAddress = item[1]
    elsif item[0] == "assignedTo" then
      vmResourceArray = item[1]
      assignedTo = []
      vmResourceArray.each do |vmResource|
        assignedTo.push(vmResource["resourceURL"])          
      end
    elsif item[0] == "publicIpMappings" then
      publicIpMappings = item[1]
    elsif item[0] == "nodeResource" then
      nodeResource = item[1]["resourceURL"]
    elsif item[0] == "organizationResource" then
      organizationResource = item[1]["resourceURL"]
    end
  end
  
  return VmPrivateIp.new(ipAddress, assignedTo, publicIpMappings, nodeResource, organizationResource)

end
getVMPublicIPs(sc_connection, vmResource) click to toggle source

Returns all public IPs on a VM

# File lib/secured_cloud_api_client.rb, line 192
def self.getVMPublicIPs(sc_connection, vmResource)

  #validation
  validate_sc_connection(sc_connection)
  validate_resource("Virtual Machine Resource", vmResource)

  response = HttpClient.sendGETRequest( sc_connection, sc_connection.getUrl() + vmResource + "/publicip")
  publicIps = []
  responseBodyAsObject = JSON.parse(response.body)
  responseBodyAsObject.each do |item|
    publicIps.push(item["resourceURL"])
  end
  return publicIps
  
end
getVMPublicIpDetails(sc_connection, publicIpResource) click to toggle source

Returns the details of a VM public IP

# File lib/secured_cloud_api_client.rb, line 230
def self.getVMPublicIpDetails(sc_connection, publicIpResource)
  
  #validation
  validate_sc_connection(sc_connection)
  validate_resource("Public IP Resource", publicIpResource)
  
  response = HttpClient.sendGETRequest( sc_connection, sc_connection.getUrl() + publicIpResource )
  responseBodyAsObject = JSON.parse(response.body)
  ipAddress, ipType, reserved, assignedTo, privateIpMapping, nodeResource, organizationResource = ""
  
  responseBodyAsObject.each do |item|
    if item[0] == "ipAddress" then
      ipAddress = item[1]
    elsif item[0] == "ipType" then
      ipType = item[1]
    elsif item[0] == "reserved" then
      reserved = item[1]
    elsif item[0] == "assignedTo" then
      vmResourceArray = item[1]
      assignedTo = []
      vmResourceArray.each do |vmResource|
        assignedTo.push(vmResource["resourceURL"])          
      end
    elsif item[0] == "privateIpMapping" then
      privateIpMapping = item[1]
    elsif item[0] == "nodeResource" then
      nodeResource = item[1]["resourceURL"]
    elsif item[0] == "organizationResource" then
      organizationResource = item[1]["resourceURL"]
    end
  end 
  
  return VmPublicIp.new(ipAddress, ipType, reserved, assignedTo, privateIpMapping, nodeResource, organizationResource)

end
powerVM(sc_connection, vmResource, powerState) click to toggle source

Starts a Power On/Off transaction. Returns the response code as well as the task resource if the transaction is triggered successfully.

# File lib/secured_cloud_api_client.rb, line 374
def self.powerVM(sc_connection, vmResource, powerState)
  
  #validation
  validate_sc_connection(sc_connection)
  validate_resource("Virtual Machine Resource", vmResource)
  raise ArgumentError, 'powerState needs to be initialized' unless powerState != nil
  raise ArgumentError, 'powerState needs to be a valid string' unless powerState.respond_to?(:to_str)
  
  params = []
  params.push(["powerState", powerState]) 
  response = HttpClient.sendPUTRequest( sc_connection, sc_connection.getUrl() + vmResource + "/power", params)
  
  if (response.code == "202") then
    responseBodyAsObject = JSON.parse(response.body)
    responseBodyAsObject.each do |item|
      return "202", item[1]
    end
  else
    return response.code, response['X-Application-Error-Reference'], response['X-Application-Error-Description']
  end
end
rebootVM(sc_connection, vmResource) click to toggle source

Starts a Reboot VM transaction. Returns the response code as well as the task resource if the transaction is triggered successfully.

# File lib/secured_cloud_api_client.rb, line 400
def self.rebootVM(sc_connection, vmResource)
  
  #validation
  validate_sc_connection(sc_connection)
  validate_resource("Virtual Machine Resource", vmResource)
  
  response = HttpClient.sendPUTRequest( sc_connection, sc_connection.getUrl() + vmResource + "/reboot")
  if (response.code == "202") then
    responseBodyAsObject = JSON.parse(response.body)
    responseBodyAsObject.each do |item|
    return "202", item[1]
  end
  else
    return response.code, response['X-Application-Error-Reference'], response['X-Application-Error-Description']
  end
  
end
validate_resource(resourceName, resource) click to toggle source

validation for resource URLs used by all api calls

# File lib/secured_cloud_api_client.rb, line 33
def self.validate_resource(resourceName, resource)
  raise ArgumentError, resourceName.to_s + ' needs to be initialized' unless resource != nil
  raise ArgumentError, resourceName.to_s + ' needs to be a valid string' unless resource.respond_to?(:to_str)
end

Private Class Methods

createVMJSONBody(name, description, storageGB, memoryMB, vCPUCount, powerStatus, imageResource, osTemplateResource, osPassword) click to toggle source
# File lib/secured_cloud_api_client.rb, line 459
def self.createVMJSONBody(name, description, storageGB, memoryMB, vCPUCount, powerStatus, imageResource, osTemplateResource, osPassword)
  
  if (name == nil) then 
    name = 'null' 
  else
    raise ArgumentError, 'Config error: name needs to be a valid string' unless name.respond_to?(:to_str)
    name = '"' + name + '"'
  end
  
  if (description == nil) then 
    description = 'null' 
  else
    raise ArgumentError, 'Config error: description needs to be a valid string' unless description.respond_to?(:to_str)
    description = '"' + description + '"'
  end
  
  storageType = '"SATA"'
  
  if (storageGB == nil) then 
    if ((imageResource != nil) && (imageResource != ""))
      storageGB = 'null'
    else
      raise ArgumentError, 'Config error: storageGB needs to be defined when creating VMs from OS template'
    end      
  else 
    raise ArgumentError, 'Config error: storageGB needs to be a valid number' unless storageGB.is_a? Numeric
  end
  
  if (memoryMB == nil) then 
    memoryMB = 'null' 
  else 
    raise ArgumentError, 'Config error: memoryMB needs to be a valid number' unless memoryMB.is_a? Numeric
  end
  
  if (vCPUCount == nil) then 
    vCPUCount = 'null' 
  else 
    raise ArgumentError, 'Config error: vCPUCount needs to be a valid number' unless vCPUCount.is_a? Numeric
  end
  
  if (powerStatus == nil) then 
    powerStatus = 'null' 
  else
    raise ArgumentError, 'Config error: powerStatus needs to be a valid string' unless powerStatus.respond_to?(:to_str)
    powerStatus = '"' + powerStatus + '"'
  end
  
  if (imageResource == nil) then 
    imageResource = 'null' 
  else
    raise ArgumentError, 'Config error: imageResource needs to be a valid string' unless imageResource.respond_to?(:to_str)
    imageResource = '{"resourceURL":"' + imageResource + '"}'
  end
  
  if (osTemplateResource == nil) then 
    osTemplateResource = 'null' 
  else
    raise ArgumentError, 'Config error: osTemplateResource needs to be a valid string' unless osTemplateResource.respond_to?(:to_str)
    osTemplateResource = '{"resourceURL":"' + osTemplateResource + '"}'
  end
  
  if (osPassword == nil) then 
    osPassword = 'null' 
  else
    raise ArgumentError, 'Config error: osPassword needs to be a valid string' unless osPassword.respond_to?(:to_str)
    osPassword = '"' + osPassword + '"'
  end
  
  return '{"name":' + name + ',"description":' + description + 
    ',"storageGB":' + storageGB.to_s() + ',"memoryMB":' + memoryMB.to_s() +
    ',"vCPUs":' + vCPUCount.to_s() + ',"storageType":' + storageType +
    ',"powerStatus":' + powerStatus + ',"operatingSystemTemplate":' + osTemplateResource + 
    ',"newOperatingSystemAdminPassword":' + osPassword +
    ',"imageResource":' + imageResource + '}'
end
validate_sc_connection(sc_connection) click to toggle source

validation for sc_connection objects used by all api calls

# File lib/secured_cloud_api_client.rb, line 24
def self.validate_sc_connection(sc_connection)
  raise ArgumentError, 'SecuredCloudConnection needs to be initialized' unless sc_connection != nil
  raise ArgumentError, 'SecuredCloudConnection needs to implement getUrl()' unless sc_connection.respond_to?(:getUrl)
  raise ArgumentError, 'SecuredCloudConnection needs to implement getApplicationKey()' unless sc_connection.respond_to?(:getApplicationKey)
  raise ArgumentError, 'SecuredCloudConnection needs to implement getSharedSecret()' unless sc_connection.respond_to?(:getSharedSecret)
end