secured_cloud_api_client 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 916195ff166c0e20fa129e31f298034f147678dc
+  data.tar.gz: 0897f1d09d6f64740314bd33dfb90a29d8495a6f
+SHA512:
+  metadata.gz: a2d734f61a03dfcb7966accd27efa0a90ecafcfda80d87f6057d50ede2f7c613c457701ce27c39fec398227b8d3fee6c8658b95fd02bc113a962a3aea01af0a7
+  data.tar.gz: a337d3ae467d0e7362f044633b3c2aae233120b3c9dfb2add5698bee7ead8e2a2563daa5ffd31476c0b3d86b8b5d8776647c2ede88264d47a4af6f4bf90f84be

data/lib/secured_cloud_api_client/http_client.rb

@@ -0,0 +1,151 @@
+require 'net/http'
+require 'openssl'
+require 'base64'
+
+
+##
+# Class HttpClient performs HTTP requests to the Secured Cloud API Server. 
+# Authentication is handled via the supplied application key and shared secret.
+#
+# @author::  Alan Vella
+##
+
+class HttpClient
+
+
+  APP_CONTENT_TYPE = "application/vnd.securedcloud.v7.0+json"
+  AUTH_SCHEME = "SC "
+
+  
+  #Sends an HTTP GET request and returns response.
+  def self.sendGETRequest(authInfo, url)
+  
+    @applicationKey = authInfo.getApplicationKey()
+    @sharedSecret = authInfo.getSharedSecret()
+    
+    @url = URI.parse(url)
+    req = Net::HTTP::Get.new(url)
+    
+    #Populate header with required stuff.
+    req['Accept'] = APP_CONTENT_TYPE  
+    req['Authorization'] = AUTH_SCHEME + createAuthorization("GET", url) 
+    
+    #Execute request.
+    res = Net::HTTP.start(@url.host, @url.port) {|http|http.request(req)} # Net::HTTPResponse object
+
+    #Return response.
+    return res
+  end
+  
+  
+  #Sends an HTTP POST request and returns response.
+  def self.sendPOSTRequest(authInfo, url, body)
+    
+    @applicationKey = authInfo.getApplicationKey()
+    @sharedSecret = authInfo.getSharedSecret()
+    
+    @url = URI.parse(url)
+    req = Net::HTTP::Post.new(url)
+    req.body = body
+    
+    #Populate header with required stuff.
+    req['Accept'] = APP_CONTENT_TYPE
+    req['Content-Type'] = APP_CONTENT_TYPE
+    req['Authorization'] = AUTH_SCHEME + createAuthorization("POST", url)
+    
+    #Execute request.
+    res = Net::HTTP.start(@url.host, @url.port) {|http|http.request(req)} # Net::HTTPResponse object
+
+    #Return response.
+    return res
+  end
+  
+
+  #Sends an HTTP DELETE request and returns response.
+  def self.sendDELETERequest(authInfo, url, params = nil)
+    
+    @applicationKey = authInfo.getApplicationKey()
+    @sharedSecret = authInfo.getSharedSecret()
+    
+    #Add parameters if present
+    if (params != nil) then
+      url += "?"
+      params.each do |param|
+        url += param[0] + "=" + param[1] + "&"
+      end
+      
+      #Remove last ampersand
+      url = url[0...-1]
+    end
+    
+    @url = URI.parse(url)
+    req = Net::HTTP::Delete.new(@url)
+    
+    #Populate header with required stuff.
+    req['Accept'] = APP_CONTENT_TYPE
+    req['Content-Type'] = APP_CONTENT_TYPE
+    req['Authorization'] = AUTH_SCHEME + createAuthorization("DELETE", url)
+    
+    #Execute request.
+    res = Net::HTTP.start(@url.host, @url.port) {|http|http.request(req)} # Net::HTTPResponse object
+
+    #Return response.
+    return res
+    
+  end
+       
+    
+  #Sends an HTTP PUT request and returns response.
+  def self.sendPUTRequest(authInfo, url, params = nil)
+    
+    @applicationKey = authInfo.getApplicationKey()
+    @sharedSecret = authInfo.getSharedSecret()
+    
+    #Add parameters if present
+    if (params != nil) then
+      url += "?"
+      params.each do |param|
+      url += param[0] + "=" + param[1] + "&"
+      end
+      #Remove last ampersand
+      url = url[0...-1]
+    end
+    
+    @url = URI.parse(url)
+    req = Net::HTTP::Put.new(@url)
+    
+    #Populate header with required stuff.
+    req['Accept'] = APP_CONTENT_TYPE
+    req['Content-Type'] = APP_CONTENT_TYPE
+    req['Authorization'] = AUTH_SCHEME + createAuthorization("PUT", url)
+    
+    #Execute request.
+    res = Net::HTTP.start(@url.host, @url.port) {|http|http.request(req)} # Net::HTTPResponse object
+
+    #Return response.
+    return res
+    
+  end
+
+
+  #Removes the servlet name from a given external API URL.
+  def self.removeServletName(url)
+    urlAsArray = url.split("/");
+    newURL = ""
+    for i in 4..(urlAsArray.size() - 1)
+      newURL += "/" + urlAsArray[i]
+    end
+    return newURL
+  end
+
+
+  #Creates authorization header for a given method and URL.
+  def self.createAuthorization(method, url)
+    stringToSign = method + " " + removeServletName(url) + " " + @applicationKey
+    hash = OpenSSL::HMAC.digest('sha256', @sharedSecret, stringToSign)
+    requestSignature = Base64.encode64(hash).gsub(/\s+/, ' ').strip    
+    credentials = @applicationKey + ":" + requestSignature;    
+    encodedCredentials = Base64.encode64(credentials).gsub(/\s+/, ' ').strip
+    return encodedCredentials
+  end
+end

data/lib/secured_cloud_api_client/ip_mapping.rb

@@ -0,0 +1,34 @@
+
+##
+# A mapping between a set of public IPs and a private IP.
+#
+# @author::  Alan Vella
+##
+
+class IpMapping
+
+
+  def initialize(privateIp, publicIps)
+    @privateIp = privateIp
+    @publicIps = publicIps
+  end
+
+    
+  def get_details()
+    s = ""    
+    if (@publicIps == nil) then
+      s = "  Public IPs [ - ] => "
+    else
+      s = "  Public IPs [" + @publicIps.join(", ") + "] => "
+    end    
+    s += "  Private IP [" + @privateIp + "]"
+    return s
+  end
+  
+  
+  def get_public_ips()
+    return @publicIps
+  end
+  
+  
+end

data/lib/secured_cloud_api_client/os_template.rb

@@ -0,0 +1,51 @@
+
+##
+# OS Templates for creating new virtual machines.
+#
+# @author::  Alan Vella
+##
+
+class OsTemplate
+
+
+  def initialize(name, version, minimumStorageSpace, defaultAdministratorUsername, diskExpandable)
+    @name = name
+    @version = version
+    @minimumStorageSpace = minimumStorageSpace
+    @defaultAdministratorUsername = defaultAdministratorUsername
+    @diskExpandable = diskExpandable
+  end
+    
+    
+  def get_details()
+    details =  "Name                       : #{@name}\n"
+    details += "Version                    : #{@version}\n"
+    details += "Minimum Storage Space in Gb: #{@minimumStorageSpace}\n"
+    details += "Default Admin Username     : #{@defaultAdministratorUsername}\n"
+    details += "Disk Expandable            : #{@diskExpandable}\n"
+    return details
+  end
+  
+  
+  def get_name
+    return @name
+  end
+  
+  def get_version
+    return @version
+  end
+  
+  def get_minimum_storage_space
+    return @minimumStorageSpace
+  end
+  
+  def get_administrator_username
+    return @defaultAdministratorUsername
+  end
+  
+  def get_disk_expandable
+    return @diskExpandable
+  end
+  
+  
+end

data/lib/secured_cloud_api_client/sc_connection.rb

@@ -0,0 +1,43 @@
+
+##
+# Class SecuredCloudConnection stores the details of a connection to the Secured Cloud API. 
+# An object of this type is needed whenever making calls to the API.
+#
+# @author::  Alan Vella
+##
+
+class SecuredCloudConnection
+  
+  #The URL must be in the format "http://10.239.32.201:8080/cloud-external-api-rest"
+  def initialize(url, applicationKey, sharedSecret)
+    
+    #validation
+    raise ArgumentError, 'SecuredCloudConnection URL needs to be initialized' unless url != nil
+    raise ArgumentError, 'SecuredCloudConnection URL needs to be a valid string' unless url.respond_to?(:to_str)
+    raise ArgumentError, 'SecuredCloudConnection applicationKey needs to be initialized' unless applicationKey != nil
+    raise ArgumentError, 'SecuredCloudConnection applicationKey needs to be a valid string' unless applicationKey.respond_to?(:to_str)
+    raise ArgumentError, 'SecuredCloudConnection sharedSecret needs to be initialized' unless sharedSecret != nil
+    raise ArgumentError, 'SecuredCloudConnection sharedSecret needs to be a valid string' unless sharedSecret.respond_to?(:to_str)
+
+    @url = url
+    @applicationKey = applicationKey
+    @sharedSecret = sharedSecret
+    
+  end
+  
+  
+  def getUrl
+    return @url
+  end
+  
+  
+  def getApplicationKey
+    return @applicationKey
+  end
+  
+  
+  def getSharedSecret
+    return @sharedSecret
+  end
+  
+end

data/lib/secured_cloud_api_client/task_status.rb

@@ -0,0 +1,62 @@
+
+##
+# Status of asynchronous tasks in Secured Cloud.
+#
+# @author::  Alan Vella
+##
+
+class TaskStatus
+
+
+  def initialize(percentageComplete, requestStateEnum, result, errorCode, errorMessage, latestTaskDescription, processDescription, createdTimestamp, lastUpdatedTimeStamp)
+    @percentageComplete = percentageComplete
+    @requestStateEnum = requestStateEnum
+    @result = result
+    @errorCode = errorCode
+    @errorMessage = errorMessage
+    @latestTaskDescription = latestTaskDescription
+    @processDescription = processDescription
+    @createdTimestamp = createdTimestamp
+    @lastUpdatedTimeStamp = lastUpdatedTimeStamp
+  end
+  
+  
+  def get_details()
+    details  = "Percentage Complete    : #{@percentageComplete}\n"
+    details += "Request State          : #{@requestStateEnum}\n"
+    details += "Result                 : #{@result}\n"
+    details += "Error Code             : #{@errorCode}\n"
+    details += "Error Message          : #{@errorMessage}\n"
+    details += "Latest Task Description: #{@latestTaskDescription}\n"
+    details += "Process Description    : #{@processDescription}\n"
+    details += "Created Timestamp      : #{@createdTimestamp}\n"
+    details += "Last Updated Timestamp : #{@lastUpdatedTimeStamp}\n"
+    return details
+  end
+
+
+  def get_result
+    return (@result.nil?) ? nil : @result["resourceURL"]
+  end
+  
+  def get_error_code
+	return @errorCode
+  end
+  
+  
+  def get_error_message
+	return @errorMessage
+  end
+  
+  
+  def get_percentage_completed
+    return @percentageComplete
+  end
+  
+  
+  def get_latest_task_description
+    return @latestTaskDescription
+  end
+  
+  
+end

data/lib/secured_cloud_api_client/virtual_machine.rb

@@ -0,0 +1,87 @@
+
+##
+# Virtual machines.
+#
+# @author::  Alan Vella
+##
+
+class VirtualMachine
+
+
+  def initialize(name, description, storageGB, storageType, memoryMB, vCPUs, powerStatus, nodeResource, organizationResource,
+    operatingSystemTemplate, imageResource, disks, macAddress, deducedPrivateIps, ipMappings)
+    @name = name
+    @description = description
+    @storageGB = storageGB
+    @storageType = storageType
+    @memoryMB = memoryMB
+    @vCPUs = vCPUs
+    @powerStatus = powerStatus
+    @nodeResource = nodeResource
+    @organizationResource = organizationResource
+    @operatingSystemTemplate = operatingSystemTemplate
+    @imageResource = imageResource
+    @disks = disks
+    @macAddress = macAddress
+    @deducedPrivateIps = deducedPrivateIps
+    @ipMappings = ipMappings
+  end
+  
+  
+  def get_details()
+    details  = "Name                     : #{@name}\n"
+    details += "Description              : #{@description}\n"
+    details += "Storage (GB)             : #{@storageGB}\n"
+    details += "Storage Type             : #{@storageType}\n"
+    details += "Memory (Mb)              : #{@memoryMB}\n"
+    details += "vCPUs                    : #{@vCPUs}\n"
+    details += "Power Status             : #{@powerStatus}\n"
+    details += "Node Resource            : #{@nodeResource}\n"
+    details += "Organization Resource    : #{@organizationResource}\n"
+    details += "Operation System Template: #{@operatingSystemTemplate}\n"
+    details += "Image Resource           : #{@imageResource}\n"
+    if (@disks == nil) then
+      details += "Disks                    : -\n"
+    else
+      details += "Disks                    : #{@disks.join(", ")}\n"
+    end
+    if (@deducedPrivateIps == nil) then
+      details += "Deduced Private IPs      : -\n"
+    else
+      details += "Deduced Private IPs      : #{@deducedPrivateIps.join(", ")}\n"
+    end
+    details += "IP Mappings:"
+    @ipMappings.each do |ipMapping|
+      details += "\n\t#{ipMapping.get_details()}"
+    end
+    details += "\nMAC Address              : #{@macAddress}\n"
+    return details
+  end
+
+  
+  def get_power_status
+    return @powerStatus
+  end
+  
+  
+  def get_os_template_resource_url
+    return @operatingSystemTemplate
+  end
+  
+  
+  def get_image_resource_url
+    return @imageResource
+  end
+  
+  
+  def get_ip_mappings
+    return @ipMappings
+  end
+  
+  
+  def get_name
+    return @name
+  end
+
+
+end

data/lib/secured_cloud_api_client/vm_private_ip.rb

@@ -0,0 +1,30 @@
+
+##
+# A private IP of a virtual machine.
+#
+# @author::  Alan Vella
+##
+
+class VmPrivateIp
+ 
+ 
+  def initialize(ipAddress, assignedTo, publicIpMappings, nodeResource, organizationResource)
+    @ipAddress = ipAddress
+    @assignedTo = assignedTo
+    @publicIpMappings = publicIpMappings
+    @nodeResource = nodeResource
+    @organizationResource = organizationResource
+  end
+   
+   
+  def get_details()
+    details  = "IP Address           : #{@ipAddress}\n"
+    details += "Assigned To          : #{@assignedTo.join(", ")}\n"
+    details += "Public IP Mappings   : #{@publicIpMappings.join(", ")}\n"
+    details += "Node Resource        : #{@nodeResource}\n"
+    details += "Organization Resource: #{@organizationResource}\n"
+    return details
+  end
+  
+   
+end

data/lib/secured_cloud_api_client/vm_public_ip.rb

@@ -0,0 +1,34 @@
+
+##
+# A public IP of a virtual machine.
+#
+# @author::  Alan Vella
+##
+
+class VmPublicIp
+ 
+         
+  def initialize(ipAddress, ipType, reserved, assignedTo, privateIpMapping, nodeResource, organizationResource)
+    @ipAddress = ipAddress
+    @ipType = ipType
+    @reserved = reserved
+    @assignedTo = assignedTo
+    @privateIpMapping = privateIpMapping
+    @nodeResource = nodeResource
+    @organizationResource = organizationResource
+  end
+  
+ 
+  def get_details()
+    details  = "IP Address           : #{@ipAddress}\n"
+    details += "IP Type              : #{@ipType}\n"
+    details += "Reserved             : #{@reserved}\n"
+    details += "Assigned To          : #{@assignedTo.join(", ")}\n"
+    details += "Private IP Mapping   : #{@privateIpMapping}\n"
+    details += "Node Resource        : #{@nodeResource}\n"
+    details += "Organization Resource: #{@organizationResource}\n"
+    return details
+  end
+  
+ 
+end

data/lib/secured_cloud_api_client.rb

@@ -0,0 +1,534 @@
+require "json"
+
+require_relative "secured_cloud_api_client/http_client"
+require_relative "secured_cloud_api_client/sc_connection"
+require_relative "secured_cloud_api_client/os_template"
+require_relative "secured_cloud_api_client/task_status"
+require_relative "secured_cloud_api_client/virtual_machine"
+require_relative "secured_cloud_api_client/ip_mapping"
+require_relative "secured_cloud_api_client/vm_private_ip"
+require_relative "secured_cloud_api_client/vm_public_ip"
+
+
+##
+# Class SecuredCloudRestClient provides a collection of methods that 
+# issue requests to the Secured Cloud RESTful External API.
+#
+# @author::  Alan Vella, Secured Cloud
+##
+
+class SecuredCloudRestClient
+  
+  
+  #validation for sc_connection objects used by all api calls
+  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
+  private_class_method :validate_sc_connection
+  
+  #validation for resource URLs used by all api calls
+  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_method :validate_sc_connection
+  
+  
+  # Returns a list of available nodes for a given organization.
+  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
+  
+  
+  # Returns a list of available OS templates for a given organization and node.
+  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
+  
+  
+  # Returns the details of an OS template
+  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
+  
+  
+  # Starts a Create VM transaction.
+  # Returns the response code as well as the task resource 
+  # if the transaction is triggered successfully.
+  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
+  
+  #Gets the details of a VM
+  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
+  
+  
+  #Returns all public IPs on a VM
+  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
+
+
+
+  #Returns all private IPs on a VM
+  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
+
+  
+  #Returns the details of a VM public IP
+  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
+    
+    
+  # Returns the details of a VM private IP
+  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
+    
+    
+  # 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.
+  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
+
+
+  
+  
+  # Starts a Delete VM transaction.
+  # Returns the response code as well as the task resource 
+  # if the transaction is triggered successfully.
+  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 
+
+  
+  # Starts a Power On/Off transaction.
+  # Returns the response code as well as the task resource 
+  # if the transaction is triggered successfully.
+  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
+  
+  
+  # Starts a Reboot VM transaction.
+  # Returns the response code as well as the task resource 
+  # if the transaction is triggered successfully.
+  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 
+
+
+  
+  
+  # Returns the status of a task.
+  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
+  
+  
+  def self.createVMJSONBody(name, description, storageGB, memoryMB, vCPUCount, powerStatus, imageResource, osTemplateResource, osPassword)
+    
+    if (name == nil) then 
+      name = 'null' 
+    else
+      raise ArgumentError, '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, 'description needs to be a valid string' unless description.respond_to?(:to_str)
+      description = '"' + description + '"'
+    end
+    
+    storageType = '"SATA"'
+    
+    if (storageGB == nil) then 
+      storageGB = 'null'
+    else 
+      raise ArgumentError, 'storageGB needs to be a valid number' unless storageGB.is_a? Numeric
+    end
+    
+    if (memoryMB == nil) then 
+      memoryMB = 'null' 
+    else 
+      raise ArgumentError, 'memoryMB needs to be a valid number' unless memoryMB.is_a? Numeric
+    end
+    
+    if (vCPUCount == nil) then 
+      vCPUCount = 'null' 
+    else 
+      raise ArgumentError, 'vCPUCount needs to be a valid number' unless vCPUCount.is_a? Numeric
+    end
+    
+    if (powerStatus == nil) then 
+      powerStatus = 'null' 
+    else
+      raise ArgumentError, '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, '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, '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, '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
+  private_class_method :createVMJSONBody
+
+
+end
+

metadata

@@ -0,0 +1,52 @@
+--- !ruby/object:Gem::Specification
+name: secured_cloud_api_client
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+platform: ruby
+authors:
+- Alan Vella
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-01-13 00:00:00.000000000 Z
+dependencies: []
+description: A simple API client for the Secured Cloud
+email: alanv@ccbilleu.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/secured_cloud_api_client.rb
+- lib/secured_cloud_api_client/http_client.rb
+- lib/secured_cloud_api_client/ip_mapping.rb
+- lib/secured_cloud_api_client/os_template.rb
+- lib/secured_cloud_api_client/sc_connection.rb
+- lib/secured_cloud_api_client/task_status.rb
+- lib/secured_cloud_api_client/virtual_machine.rb
+- lib/secured_cloud_api_client/vm_private_ip.rb
+- lib/secured_cloud_api_client/vm_public_ip.rb
+homepage: http://www.phoenixnap.com/secured-cloud/about-our-cloud/api.php
+licenses:
+- SecuredCloud
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.1
+signing_key: 
+specification_version: 4
+summary: Secured Cloud API Client
+test_files: []