vcloud-rest 1.2.0 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f5423c402bd67bd07893da3ed80210af1ae63b0c
-  data.tar.gz: 389acab1aaec5d6cbf9733dc02d5143f8fcdaabf
+  metadata.gz: 470e97ca321d742340571fff5cbbaa6e5a8fbe2b
+  data.tar.gz: 0460be22738dca2e1b05668a861777d6380dd3d4
 SHA512:
-  metadata.gz: 66eaeeec2baa31c8903f80ef68fd9315b260bcf72ea4180f014c118fa8cdaf1cff64f21f91af8aecb7b234534ac0f4bdc9a4726fa27feedd2e9f6e066bf76c47
-  data.tar.gz: a45669ed115205cd51fda43166b99d64892834f9128c04a78e2bba7ca0fcfb31b08a902d10f12eb2f08b75f3d5d272ca2fef65e766b9f340d30bc26926911925
+  metadata.gz: acbace49f0444b3bff99e21ef01c9947597cba62adedf0b4385967627d4898cee59463cfbe1216f9abfdc75312344cd43146dd5608b48cc33eb894313f1e749c
+  data.tar.gz: 813bdcc2737e13da061b0b76d659fe0147275e8d61c80220106dca631dfa5688ae48bbc35e6510cc5016ae3c686b87afd9cccec543f0d62d7def955c88523596

data/CHANGELOG.md

@@ -1,5 +1,26 @@
 Changes
 ==
+2014-06-03 (1.3.0)
+
+Note that starting from this release Ruby 1.8.7+ and 1.9.2 are not explicitly tested against anymore.
+
+FEATURES:
+
+* Add "media" item type management to `get_catalog_item`
+* Add `discard_suspend_state_[vapp|vm]` to discard suspended state of a vApp or VM
+* Add independent disk capabilities
+* `get_vapp` returns also network IDs
+* Add `discard_[vm|vapp]_snapshot` to discard snapshots
+* Add `acquire_ticket_vm` that retrieves a screen ticket (VMRC) for a given VM
+
+FIXES:
+
+* Fix add network to VM for API v.5.5
+* Fix VM IP address retrieval with different interfaces on same network
+* Don't use hardcoded rasd:Parent in `add_disk`
+
+Note that now `get_vm` appends NetworkConnectionIndex to network name to generate a unique hash key.
+
 2014-02-06 (1.2.0)
 
 FEATURES:

data/README.md

@@ -17,7 +17,7 @@ This plugin is distributed as a Ruby Gem. To install it, run:
 
 Depending on your system's configuration, you may need to run this command with root privileges.
 
-vcloud-rest is tested against ruby 2.1.0, 2.0.0, 1.9.x and 1.8.7+.
+vcloud-rest is tested against ruby 2.1.2, 2.0.0, 1.9.3 and ruby-head.
 
 FEATURES
 --
@@ -49,10 +49,12 @@ TODO
 
 PREREQUISITES
 --
-- nokogiri ~> 1.6.0
-- rest-client ~> 1.6.7
-- httpclient ~> 2.3.3
-- ruby-progressbar ~> 1.1.1
+- nokogiri
+- rest-client
+- httpclient
+- ruby-progressbar
+
+(see *vcloud_rest.gemspec* for details)
 
 For testing purpose:
 - minitest (included in ruby 1.9)
@@ -88,14 +90,55 @@ Or:
 
     ruby spec/connection_spec.rb
 
-Note: in order to run tests with ruby 1.8.7+ you need to export RUBYOPT="rubygems"
+Note: in order to run tests with ruby 1.8.x you need to export RUBYOPT="rubygems"
+
+### Write new tests
+
+Tests are now managed using VCR and thus real interactions are recorded and replayed.
+
+In order to write new tests the following steps are required:
+
+1. create a file *test_credentials.yml*
+1. create a new test entry specifying a new VCR cassette *my_test_case.yml*
+1. review and anonymize data if necessary under *spec/fixtures/vcr_cassettes/my_test_case.yml*
+
+**Note:** values in *test_credentials.yml* are automatically anonymized.
+
+Examples:
+
+    => test_credentials.yml
+    :host: https://vcloud_instance_url
+    :username: test_username
+    :password: test_password
+    :org: test_organization
+
+
+    => Test entry in connection_spec.rb
+      it "should power off a given vapp" do
+        VCR.use_cassette('vapps/poweroff_vapp') do
+          connection.login
+          task_id = connection.poweroff_vapp("65b4dbc9-b0b1-46e4-a420-8f8147369f8b")
+          expect(task_id).to eq "ae791b59-4c9f-4fe2-9916-703f1fc3cbd5"
+        end
+      end
+
+    => Recorded fixture (credentials auto-anonymized)
+    ---
+    http_interactions:
+    - request:
+        method: post
+        uri: https://testuser%40testorg:testpass@testurl.local/api/sessions
+        body:
+          encoding: UTF-8
+    ...
+
 
 LICENSE
 --
 
 Author:: Stefano Tortarolo <stefano.tortarolo@gmail.com>
 
-Copyright:: Copyright (c) 2012-2013
+Copyright:: Copyright (c) 2012-2014
 License:: Apache License, Version 2.0
 
 Licensed under the Apache License, Version 2.0 (the "License");

data/lib/vcloud-rest/connection.rb

@@ -21,6 +21,7 @@ require 'nokogiri'
 require 'httpclient'
 require 'ruby-progressbar'
 require 'logger'
+require 'uri'
 
 require 'vcloud-rest/vcloud/vapp'
 require 'vcloud-rest/vcloud/org'
@@ -28,7 +29,9 @@ require 'vcloud-rest/vcloud/catalog'
 require 'vcloud-rest/vcloud/vdc'
 require 'vcloud-rest/vcloud/vm'
 require 'vcloud-rest/vcloud/ovf'
+require 'vcloud-rest/vcloud/media'
 require 'vcloud-rest/vcloud/network'
+require 'vcloud-rest/vcloud/disk'
 
 module VCloudClient
   class UnauthorizedAccess < StandardError; end
@@ -82,6 +85,7 @@ module VCloudClient
       }
 
       response, headers = send_request(params)
+    ensure
       # reset auth key to nil
       @auth_key = nil
     end
@@ -130,20 +134,21 @@ module VCloudClient
       # Sends a synchronous request to the vCloud API and returns the response as parsed XML + headers.
       def send_request(params, payload=nil, content_type=nil)
         headers = {:accept => "application/*+xml;version=#{@api_version}"}
+        invocation_params = {:method => params['method'],
+                             :headers => headers,
+                             :url => "#{@api_url}#{params['command']}",
+                             :payload => payload}
+
         if @auth_key
           headers.merge!({:x_vcloud_authorization => @auth_key})
+        else
+          invocation_params.merge!({:user => "#{@username}@#{@org_name}",
+                                    :password => @password })
         end
 
-        if content_type
-          headers.merge!({:content_type => content_type})
-        end
+        headers.merge!({:content_type => content_type}) if content_type
 
-        request = RestClient::Request.new(:method => params['method'],
-                                         :user => "#{@username}@#{@org_name}",
-                                         :password => @password,
-                                         :headers => headers,
-                                         :url => "#{@api_url}#{params['command']}",
-                                         :payload => payload)
+        request = RestClient::Request.new(invocation_params)
 
         begin
           response = request.execute
@@ -236,6 +241,18 @@ module VCloudClient
       task_id
     end
 
+    ##
+    # Discard suspended state of a vApp/VM
+    def discard_suspended_state_action(id, type=:vapp)
+      params = {
+          "method" => :post,
+          "command" => "/vApp/#{type}-#{id}/action/discardSuspendedState"
+      }
+      response, headers = send_request(params)
+      task_id = headers[:location].gsub(/.*\/task\//, "")
+      task_id
+    end
+
     ##
     # Create a new vapp/vm snapshot (overwrites any existing)
     def create_snapshot_action(id, description="New Snapshot", type=:vapp)
@@ -266,6 +283,109 @@ module VCloudClient
       task_id
     end
 
+    ##
+    # Discard all existing snapshots (vapp/vm)
+    def discard_snapshot_action(id, type=:vapp)
+      params = {
+          "method" => :post,
+          "command" => "/vApp/#{type}-#{id}/action/removeAllSnapshots"
+      }
+      response, headers = send_request(params)
+      task_id = headers[:location].gsub(/.*\/task\//, "")
+      task_id
+    end
+
+    ##
+    # Upload a large file in configurable chunks, output an optional progressbar
+    def upload_file(uploadURL, uploadFile, progressUrl, config={})
+      raise ::IOError, "#{uploadFile} not found." unless File.exists?(uploadFile)
+
+      # Set chunksize to 10M if not specified otherwise
+      chunkSize = (config[:chunksize] || 10485760)
+
+      # Set progress bar to default format if not specified otherwise
+      progressBarFormat = (config[:progressbar_format] || "%e <%B> %p%% %t")
+
+      # Set progress bar length to 120 if not specified otherwise
+      progressBarLength = (config[:progressbar_length] || 120)
+
+      # Open our file for upload
+      uploadFileHandle = File.new(uploadFile, "rb" )
+      fileName = File.basename(uploadFileHandle)
+
+      progressBarTitle = "Uploading: " + uploadFile.to_s
+
+      # Create a progressbar object if progress bar is enabled
+      if config[:progressbar_enable] == true && uploadFileHandle.size.to_i > chunkSize
+        progressbar = ProgressBar.create(
+          :title => progressBarTitle,
+          :starting_at => 0,
+          :total => uploadFileHandle.size.to_i,
+          :length => progressBarLength,
+          :format => progressBarFormat
+        )
+      else
+        @logger.info progressBarTitle
+      end
+      # Create a new HTTP client
+      clnt = HTTPClient.new
+
+      # Disable SSL cert verification
+      clnt.ssl_config.verify_mode=(OpenSSL::SSL::VERIFY_NONE)
+
+      # Suppress SSL depth message
+      clnt.ssl_config.verify_callback=proc{ |ok, ctx|; true };
+
+      # Perform ranged upload until the file reaches its end
+      until uploadFileHandle.eof?
+
+        # Create ranges for this chunk upload
+        rangeStart = uploadFileHandle.pos
+        rangeStop = uploadFileHandle.pos.to_i + chunkSize
+
+        # Read current chunk
+        fileContent = uploadFileHandle.read(chunkSize)
+
+        # If statement to handle last chunk transfer if is > than filesize
+        if rangeStop.to_i > uploadFileHandle.size.to_i
+          contentRange = "bytes #{rangeStart.to_s}-#{uploadFileHandle.size.to_s}/#{uploadFileHandle.size.to_s}"
+          rangeLen = uploadFileHandle.size.to_i - rangeStart.to_i
+        else
+          contentRange = "bytes #{rangeStart.to_s}-#{rangeStop.to_s}/#{uploadFileHandle.size.to_s}"
+          rangeLen = rangeStop.to_i - rangeStart.to_i
+        end
+
+        # Build headers
+        extheader = {
+          'x-vcloud-authorization' => @auth_key,
+          'Content-Range' => contentRange,
+          'Content-Length' => rangeLen.to_s
+        }
+
+        begin
+          uploadRequest = "#{@host_url}#{uploadURL}"
+          connection = clnt.request('PUT', uploadRequest, nil, fileContent, extheader)
+
+          if config[:progressbar_enable] == true && uploadFileHandle.size.to_i > chunkSize
+            params = {
+              'method' => :get,
+              'command' => progressUrl
+            }
+            response, headers = send_request(params)
+
+            response.css("Files File [name='#{fileName}']").each do |file|
+              progressbar.progress=file[:bytesTransferred].to_i
+            end
+          end
+        rescue
+          retryTime = (config[:retry_time] || 5)
+          @logger.warn "Range #{contentRange} failed to upload, retrying the chunk in #{retryTime.to_s} seconds, to stop the action press CTRL+C."
+          sleep retryTime.to_i
+          retry
+        end
+      end
+      uploadFileHandle.close
+    end
 
   end # class
 end

data/lib/vcloud-rest/vcloud/catalog.rb

@@ -66,31 +66,41 @@ module VCloudClient
       description = description.text unless description.nil?
 
       items = []
-      response.css("Entity[type='application/vnd.vmware.vcloud.vAppTemplate+xml']").each do |item|
-        itemId = item['href'].gsub(/.*\/vAppTemplate\/vappTemplate\-/, "")
-
-        # Fetch the catalogItemId information
-        params = {
-          'method' => :get,
-          'command' => "/vAppTemplate/vappTemplate-#{itemId}"
-        }
-        response, headers = send_request(params)
-
-        # VMs Hash for all the vApp VM entities
-        vms_hash = {}
-        response.css("/VAppTemplate/Children/Vm").each do |vmElem|
-          vmName = vmElem["name"]
-          vmId = vmElem["href"].gsub(/.*\/vAppTemplate\/vm\-/, "")
-
-          # Add the VM name/id to the VMs Hash
-          vms_hash[vmName] = { :id => vmId }
+      # manage two different types of catalog items: vAppTemplate and media
+      if response.css("Entity[type='application/vnd.vmware.vcloud.vAppTemplate+xml']").size > 0
+        response.css("Entity[type='application/vnd.vmware.vcloud.vAppTemplate+xml']").each do |item|
+          itemId = item['href'].gsub(/.*\/vAppTemplate\/vappTemplate\-/, "")
+
+          # Fetch the catalogItemId information
+          params = {
+            'method' => :get,
+            'command' => "/vAppTemplate/vappTemplate-#{itemId}"
+          }
+          response, headers = send_request(params)
+
+          # VMs Hash for all the vApp VM entities
+          vms_hash = {}
+          response.css("/VAppTemplate/Children/Vm").each do |vmElem|
+            vmName = vmElem["name"]
+            vmId = vmElem["href"].gsub(/.*\/vAppTemplate\/vm\-/, "")
+
+            # Add the VM name/id to the VMs Hash
+            vms_hash[vmName] = { :id => vmId }
+          end
+
+          items << { :id => itemId,
+                     :name => item['name'],
+                     :vms_hash => vms_hash }
         end
 
-        items << { :id => itemId,
-                   :name => item['name'],
-                   :vms_hash => vms_hash }
+        { :id => catalogItemId, :description => description, :items => items, :type => 'vAppTemplate' }
+      elsif response.css("Entity[type='application/vnd.vmware.vcloud.media+xml']").size > 0
+        name = response.css("Entity[type='application/vnd.vmware.vcloud.media+xml']").first['name']
+        { :id => catalogItemId, :description => description, :name => name, :type => 'media' }
+      else
+        @logger.warn 'WARNING: either this catalog item is empty or contains something not managed by vcloud-rest'
+        { :id => catalogItemId, :description => description, :type => 'unknown' }
       end
-      { :id => catalogItemId, :description => description, :items => items }
     end
 
     ##

data/lib/vcloud-rest/vcloud/disk.rb

@@ -0,0 +1,113 @@
+##
+# Manage independent disks
+# Independent disks are stand-alone virtual disks created in organization vDCs.
+# Every disk is associated with an organization vDC but not with a VM and
+# can be later attached to any VM deployed in that vDC.
+#
+# VERY IMPORTANT NOTE: independent disks size, unlike set_vm_disk_info, is in Kb
+##
+module VCloudClient
+  class Connection
+    def create_disk(name, size, vdc_id, description="")
+      builder = Nokogiri::XML::Builder.new do |xml|
+        xml.DiskCreateParams(
+          "xmlns" => "http://www.vmware.com/vcloud/v1.5") {
+          xml.Disk("name" => name, "size" => size) {
+            xml.Description description
+          }
+        }
+      end
+
+      params = {
+        'method' => :post,
+        'command' => "/vdc/#{vdc_id}/disk"
+      }
+
+      @logger.debug "Creating independent disk #{name} in VDC #{vdc_id}"
+      response, headers = send_request(params, builder.to_xml, "application/vnd.vmware.vcloud.diskCreateParams+xml")
+
+      # Get the id of the new disk
+      disk_url = response.css("Disk").first[:href]
+      disk_id = disk_url.gsub(/.*\/disk\//, "")
+      @logger.debug "Independent disk created = #{disk_id}"
+
+      task = response.css("Task[operationName='vdcCreateDisk']").first
+      task_id = task["href"].gsub(/.*\/task\//, "")
+
+      { :disk_id => disk_id, :task_id => task_id }
+    end
+
+    def get_disk(disk_id)
+      params = {
+        'method' => :get,
+        'command' => "/disk/#{disk_id}"
+      }
+
+      @logger.debug "Fetching independent disk #{disk_id}"
+      response, headers = send_request(params)
+
+      name = response.css("Disk").attribute("name").text
+      size = response.css("Disk").attribute("size").text
+      description = response.css("Description").first
+      description = description.text unless description.nil?
+      storage_profile = response.css("StorageProfile").first[:name]
+      owner = response.css("User").first[:name]
+      { :id => disk_id, :name => name, :size => size, :description => description, :storage_profile => storage_profile, :owner => owner }
+    end
+
+    def get_disk_by_name(organization, vdcName, diskName)
+      result = nil
+
+      get_vdc_by_name(organization, vdcName)[:disks].each do |disk|
+        if disk[0].downcase == diskName.downcase
+          result = get_disk(disk[1])
+        end
+      end
+
+      result
+    end
+
+    def attach_disk_to_vm(disk_id, vm_id)
+      disk_attach_action(disk_id, vm_id, 'attach')
+    end
+
+    def detach_disk_from_vm(disk_id, vm_id)
+      disk_attach_action(disk_id, vm_id, 'detach')
+    end
+
+    def delete_disk(disk_id)
+      params = {
+        'method' => :delete,
+        'command' => "/disk/#{disk_id}"
+      }
+
+      @logger.debug "Deleting independent disk #{disk_id}"
+      response, headers = send_request(params)
+
+      task = response.css("Task").first
+      task_id = task["href"].gsub(/.*\/task\//, "")
+    end
+
+    private
+
+    def disk_attach_action(disk_id, vm_id, action)
+      builder = Nokogiri::XML::Builder.new do |xml|
+        xml.DiskAttachOrDetachParams("xmlns" => "http://www.vmware.com/vcloud/v1.5") {
+          xml.Disk(
+            "type" => "application/vnd.vmware.vcloud.disk+xml",
+            "href" => "#{@api_url}/disk/#{disk_id}")
+        }
+      end
+
+      params = {
+        'method' => :post,
+        'command' => "/vApp/vm-#{vm_id}/disk/action/#{action}"
+      }
+
+      response, headers = send_request(params, builder.to_xml, "application/vnd.vmware.vcloud.diskAttachOrDetachParams+xml")
+
+      task = response.css("Task").first
+      task_id = task["href"].gsub(/.*\/task\//, "")
+    end
+  end
+end

data/lib/vcloud-rest/vcloud/media.rb

@@ -0,0 +1,100 @@
+module VCloudClient
+  class Connection
+
+    def upload_media(vdcId, mediaName, mediaDescription, mediaFile, type, catalogId, uploadOptions={})
+      raise ::IOError, "File #{mediaFile} is missing." unless File.exists?(mediaFile)
+
+      fileName = File.basename(mediaFile)
+      mediaName = File.basename(fileName, ".*") if mediaName.nil? || mediaName.empty?
+      type = File.extname(fileName).delete(".") if type.nil? || type.empty?
+      size = File.size(mediaFile)
+
+      builder = Nokogiri::XML::Builder.new do |xml|
+        xml.Media(
+          "xmlns" => "http://www.vmware.com/vcloud/v1.5",
+          "xmlns:ovf" => "http://schemas.dmtf.org/ovf/envelope/1",
+          "size" => size,
+          "imageType" => type,
+          "name" => mediaName) {
+            xml.Description mediaDescription
+          }
+      end
+
+      params = {
+        'method' => :post,
+        'command' => "/vdc/#{vdcId}/media"
+      }
+
+      @logger.debug "Creating Media item"
+      response, headers = send_request(params, builder.to_xml, "application/vnd.vmware.vcloud.media+xml")
+
+      # Get the new media id from response
+      mediaUrl = response.css("Media").first[:href]
+      mediaId = mediaUrl.gsub(/.*\/media\//, "")
+      @logger.debug "Media item created - #{mediaId}"
+
+      # Get File upload:default link from response
+      uploadHref = response.css("Files Link [rel='upload:default']").first[:href]
+      fileUpload = uploadHref.gsub(/(.*)(\/transfer\/.*)/, "\\2")
+
+      begin
+        @logger.debug "Uploading #{mediaFile}"
+        upload_file(fileUpload, mediaFile, "/media/#{mediaId}", uploadOptions)
+
+        # Add item to the catalog catalogId
+        builder = Nokogiri::XML::Builder.new do |xml|
+          xml.CatalogItem(
+            "xmlns" => "http://www.vmware.com/vcloud/v1.5",
+            "type" => "application/vnd.vmware.vcloud.catalogItem+xml",
+            "name" => mediaName) {
+            xml.Description mediaDescription
+            xml.Entity("href" => "#{@api_url}/media/#{mediaId}")
+          }
+        end
+
+        params = {
+          'method' => :post,
+          'command' => "/catalog/#{catalogId}/catalogItems"
+        }
+
+        @logger.debug "Adding media item #{mediaName} to catalog."
+        response, headers = send_request(params, builder.to_xml, "application/vnd.vmware.vcloud.catalogItem+xml")
+
+        # TODO: the best thing would detect the real importing status.
+        entity = response.css("Entity").first
+        result = {}
+        if entity
+          result[:id] = entity['href'].gsub(/.*\/media\//, "")
+          result[:name] = entity['name']
+        end
+        result
+      rescue Exception => e
+        @logger.error "Exception detected: #{e.message}."
+
+        # Get Media Task
+        params = {
+          'method' => :get,
+          'command' => "/media/#{mediaId}"
+        }
+        response, headers = send_request(params)
+
+        # Cancel Task
+        # Note that it might not exist (i.e., error for existing vdc entity)
+        tasks = response.css("Tasks")
+        unless tasks.empty?
+          tasks.css("Task").each do |task|
+            if task['status'] == 'error'
+              @logger.error task.css('Error').first['message']
+            else
+              id = task['href'].gsub(/.*\/task\//, "")
+              @logger.error "Aborting task #{id}..."
+              cancel_task(id)
+            end
+          end
+        end
+
+        raise e
+      end
+    end
+  end
+end

data/lib/vcloud-rest/vcloud/network.rb

@@ -1,7 +1,7 @@
 module VCloudClient
   class Connection
     ##
-    # Fetch details about a given network
+    # Fetch details about a given Org VDC network
     def get_network(networkId)
       response = get_base_network(networkId)
 

data/lib/vcloud-rest/vcloud/ovf.rb

@@ -10,6 +10,7 @@ module VCloudClient
     # - uploadOptions {}
     def upload_ovf(vdcId, vappName, vappDescription, ovfFile, catalogId, uploadOptions={})
       raise ::IOError, "OVF #{ovfFile} is missing." unless File.exists?(ovfFile)
+      raise ::IOError, "Only .ovf files are supported" unless File.extname(ovfFile) =~ /\.ovf/ 
 
       # if send_manifest is not set, setting it true
       if uploadOptions[:send_manifest].nil? || uploadOptions[:send_manifest]
@@ -52,7 +53,7 @@ module VCloudClient
       # Send OVF Descriptor
       uploadURL = "/transfer/#{descriptorUpload}"
       uploadFile = "#{ovfDir}/#{ovfFileBasename}.ovf"
-      upload_file(uploadURL, uploadFile, vAppTemplate, uploadOptions)
+      upload_file(uploadURL, uploadFile, "/vAppTemplate/vappTemplate-#{vAppTemplate}", uploadOptions)
 
       @logger.debug "OVF Descriptor uploaded."
 
@@ -80,7 +81,7 @@ module VCloudClient
         if uploadManifest == "true"
           uploadURL = "/transfer/#{transferGUID}/descriptor.mf"
           uploadFile = "#{ovfDir}/#{ovfFileBasename}.mf"
-          upload_file(uploadURL, uploadFile, vAppTemplate, uploadOptions)
+          upload_file(uploadURL, uploadFile, "/vAppTemplate/vappTemplate-#{vAppTemplate}", uploadOptions)
           @logger.debug "OVF Manifest uploaded."
         end
 
@@ -94,7 +95,7 @@ module VCloudClient
           fileName = file[:href].gsub(/.*\/transfer\/#{transferGUID}\//, "")
           uploadFile = "#{ovfDir}/#{fileName}"
           uploadURL = "/transfer/#{transferGUID}/#{fileName}"
-          upload_file(uploadURL, uploadFile, vAppTemplate, uploadOptions)
+          upload_file(uploadURL, uploadFile, "/vAppTemplate/vappTemplate-#{vAppTemplate}", uploadOptions)
         end
 
         # Add item to the catalog catalogId
@@ -156,98 +157,5 @@ module VCloudClient
         raise e
       end
     end
-
-    private
-      ##
-      # Upload a large file in configurable chunks, output an optional progressbar
-      def upload_file(uploadURL, uploadFile, vAppTemplate, config={})
-        raise ::IOError, "#{uploadFile} not found." unless File.exists?(uploadFile)
-
-        # Set chunksize to 10M if not specified otherwise
-        chunkSize = (config[:chunksize] || 10485760)
-
-        # Set progress bar to default format if not specified otherwise
-        progressBarFormat = (config[:progressbar_format] || "%e <%B> %p%% %t")
-
-        # Set progress bar length to 120 if not specified otherwise
-        progressBarLength = (config[:progressbar_length] || 120)
-
-        # Open our file for upload
-        uploadFileHandle = File.new(uploadFile, "rb" )
-        fileName = File.basename(uploadFileHandle)
-
-        progressBarTitle = "Uploading: " + uploadFile.to_s
-
-        # Create a progressbar object if progress bar is enabled
-        if config[:progressbar_enable] == true && uploadFileHandle.size.to_i > chunkSize
-          progressbar = ProgressBar.create(
-            :title => progressBarTitle,
-            :starting_at => 0,
-            :total => uploadFileHandle.size.to_i,
-            :length => progressBarLength,
-            :format => progressBarFormat
-          )
-        else
-          @logger.info progressBarTitle
-        end
-        # Create a new HTTP client
-        clnt = HTTPClient.new
-
-        # Disable SSL cert verification
-        clnt.ssl_config.verify_mode=(OpenSSL::SSL::VERIFY_NONE)
-
-        # Suppress SSL depth message
-        clnt.ssl_config.verify_callback=proc{ |ok, ctx|; true };
-
-        # Perform ranged upload until the file reaches its end
-        until uploadFileHandle.eof?
-
-          # Create ranges for this chunk upload
-          rangeStart = uploadFileHandle.pos
-          rangeStop = uploadFileHandle.pos.to_i + chunkSize
-
-          # Read current chunk
-          fileContent = uploadFileHandle.read(chunkSize)
-
-          # If statement to handle last chunk transfer if is > than filesize
-          if rangeStop.to_i > uploadFileHandle.size.to_i
-            contentRange = "bytes #{rangeStart.to_s}-#{uploadFileHandle.size.to_s}/#{uploadFileHandle.size.to_s}"
-            rangeLen = uploadFileHandle.size.to_i - rangeStart.to_i
-          else
-            contentRange = "bytes #{rangeStart.to_s}-#{rangeStop.to_s}/#{uploadFileHandle.size.to_s}"
-            rangeLen = rangeStop.to_i - rangeStart.to_i
-          end
-
-          # Build headers
-          extheader = {
-            'x-vcloud-authorization' => @auth_key,
-            'Content-Range' => contentRange,
-            'Content-Length' => rangeLen.to_s
-          }
-
-          begin
-            uploadRequest = "#{@host_url}#{uploadURL}"
-            connection = clnt.request('PUT', uploadRequest, nil, fileContent, extheader)
-
-            if config[:progressbar_enable] == true && uploadFileHandle.size.to_i > chunkSize
-              params = {
-                'method' => :get,
-                'command' => "/vAppTemplate/vappTemplate-#{vAppTemplate}"
-              }
-              response, headers = send_request(params)
-
-              response.css("Files File [name='#{fileName}']").each do |file|
-                progressbar.progress=file[:bytesTransferred].to_i
-              end
-            end
-          rescue
-            retryTime = (config[:retry_time] || 5)
-            @logger.warn "Range #{contentRange} failed to upload, retrying the chunk in #{retryTime.to_s} seconds, to stop the action press CTRL+C."
-            sleep retryTime.to_i
-            retry
-          end
-        end
-        uploadFileHandle.close
-      end
-  end
+  end # class
 end

data/lib/vcloud-rest/vcloud/vapp.rb

@@ -34,6 +34,9 @@ module VCloudClient
 
       networks = response.css('NetworkConfig').reject{|n| n.attribute('networkName').text == 'none'}.
         collect do |network|
+          net_id = network.css('Link [rel=repair]')
+          net_id = net_id.attribute('href').text.gsub(/.*\/network\/(.*)\/action.*/, '\1') unless net_id.nil?
+
           net_name = network.attribute('networkName').text
 
           gateway = network.css('Gateway')
@@ -62,6 +65,7 @@ module VCloudClient
             }
 
           {
+            :id => net_id,
             :name => net_name,
             :scope => ipscope
           }
@@ -163,6 +167,12 @@ module VCloudClient
       power_action(vAppId, 'suspend')
     end
 
+    ##
+    # Discard suspended state of a given vapp
+    def discard_suspend_state_vapp(vAppId)
+      discard_suspended_state_action(vAppId, :vapp)
+    end
+
     ##
     # reboot a given vapp
     # This will basically initial a guest OS reboot, and will only work if
@@ -310,7 +320,52 @@ module VCloudClient
       { :vapp_id => vapp_id, :task_id => task_id }
     end
 
+    ##
+    # Create a new virtual machine from a template in an existing vApp.
+    #
+    # Params:
+    # - vapp: the target vapp
+    # - vm: hash with template ID and new VM name
+    # - network_config: hash of the network configuration for the VM
+    def add_vm_to_vapp(vapp, vm, network_config={})
+      builder = Nokogiri::XML::Builder.new do |xml|
+        xml.RecomposeVAppParams(
+          "xmlns" => "http://www.vmware.com/vcloud/v1.5",
+          "xmlns:ovf" => "http://schemas.dmtf.org/ovf/envelope/1",
+          "name" => vapp[:name]) {
+            xml.SourcedItem {
+              xml.Source("href" => "#{@api_url}/vAppTemplate/vm-#{vm[:template_id]}", "name" => vm[:vm_name])
+              xml.InstantiationParams {
+                xml.NetworkConnectionSection(
+                  "xmlns:ovf" => "http://schemas.dmtf.org/ovf/envelope/1",
+                  "type" => "application/vnd.vmware.vcloud.networkConnectionSection+xml",
+                  "href" => "#{@api_url}/vAppTemplate/vm-#{vm[:template_id]}/networkConnectionSection/") {
+                    xml['ovf'].Info "Network config for sourced item"
+                    xml.PrimaryNetworkConnectionIndex "0"
+                    xml.NetworkConnection("network" => network_config[:name]) {
+                      xml.NetworkConnectionIndex "0"
+                      xml.IsConnected "true"
+                      xml.IpAddressAllocationMode(network_config[:ip_allocation_mode] || "POOL")
+                    }
+                  }
+              }
+              xml.NetworkAssignment("containerNetwork" => network_config[:name], "innerNetwork" => network_config[:name])
+            }
+            xml.AllEULAsAccepted "true"
+          }
+      end
+
+      params = {
+        "method" => :post,
+        "command" => "/vApp/vapp-#{vapp[:id]}/action/recomposeVApp"
+      }
 
+      response, headers = send_request(params, builder.to_xml, "application/vnd.vmware.vcloud.recomposeVAppParams+xml")
+
+      task = response.css("Task[operationName='vdcRecomposeVapp']").first
+      task_id = task["href"].gsub(/.*\/task\//, "")
+      task_id
+    end
 
     ##
     # Create a new vm snapshot (overwrites any existing)
@@ -340,6 +395,12 @@ module VCloudClient
       revert_snapshot_action(vmId, :vapp)
     end
 
+    ##
+    # Discard all existing snapshots
+    def discard_vapp_snapshot(vmId)
+      discard_snapshot_action(vmId, :vapp)
+    end
+
     ##
     # Clone a vapp in a given VDC to a new Vapp
     def clone_vapp(vdc_id, source_vapp_id, name, deploy="true", poweron="false", linked="false", delete_source="false")

data/lib/vcloud-rest/vcloud/vdc.rb

@@ -4,6 +4,8 @@ module VCloudClient
     # Fetch details about a given vdc:
     # - description
     # - vapps
+    # - templates
+    # - disks
     # - networks
     def get_vdc(vdcId)
       params = {
@@ -24,12 +26,24 @@ module VCloudClient
         vapps[item['name']] = item['href'].gsub(/.*\/vApp\/vapp\-/, "")
       end
 
+      templates = {}
+      response.css("ResourceEntity[type='application/vnd.vmware.vcloud.vAppTemplate+xml']").each do |item|
+        templates[item['name']] = item['href'].gsub(/.*\/vAppTemplate\/vappTemplate\-/, "")
+      end
+
+      disks = {}
+      response.css("ResourceEntity[type='application/vnd.vmware.vcloud.disk+xml']").each do |item|
+        disks[item['name']] = item['href'].gsub(/.*\/disk\//, "")
+      end
+
       networks = {}
       response.css("Network[type='application/vnd.vmware.vcloud.network+xml']").each do |item|
         networks[item['name']] = item['href'].gsub(/.*\/network\//, "")
       end
+
       { :id => vdcId, :name => name, :description => description,
-        :vapps => vapps, :networks => networks }
+        :vapps => vapps, :templates => templates, :disks => disks,
+        :networks => networks }
     end
 
     ##

data/lib/vcloud-rest/vcloud/vm.rb

@@ -186,8 +186,9 @@ module VCloudClient
       # For some reasons these elements must be removed
       netconfig_response.css("Link").each {|n| n.remove}
 
-      # Delete placeholder network
-      netconfig_response.css('NetworkConnection').find{|n| n.attribute('network').text == 'none'}.remove
+      # Delete placeholder network if present (since vcloud 5.5 has been removed)
+      none_network = netconfig_response.css('NetworkConnection').find{|n| n.attribute('network').text == 'none'}
+      none_network.remove if none_network
 
       networks_count = netconfig_response.css('NetworkConnection').count
 
@@ -349,7 +350,11 @@ module VCloudClient
         external_ip = network.css('ExternalIpAddress').first
         external_ip = external_ip.text if external_ip
 
-        networks[network['network']] = {
+        # Append NetworkConnectionIndex to network name to generate a unique hash key,
+        # otherwise different interfaces on the same network would use the same hash key
+        key = "#{network['network']}_#{network.css('NetworkConnectionIndex').first.text}"
+
+        networks[key] = {
           :index => network.css('NetworkConnectionIndex').first.text,
           :ip => ip,
           :external_ip => external_ip,
@@ -422,6 +427,12 @@ module VCloudClient
       power_action(vmId, 'suspend', :vm)
     end
 
+    ##
+    # Discard suspended state of a given vm
+    def discard_suspend_state_vm(vmId)
+      discard_suspended_state_action(vmId, :vm)
+    end
+
     ##
     # reboot a given vm
     # This will basically initial a guest OS reboot, and will only work if
@@ -455,11 +466,52 @@ module VCloudClient
       revert_snapshot_action(vmId, :vm)
     end
 
+    ##
+    # Discard all existing snapshots
+    def discard_vm_snapshot(vmId)
+      discard_snapshot_action(vmId, :vm)
+    end
+
+    ##
+    # Retrieve a screen ticket that you can use with the VMRC browser plug-in
+    # to gain access to the console of a running VM.
+    def acquire_ticket_vm(vmId)
+
+      params = {
+        'method' => :post,
+        'command' => "/vApp/vm-#{vmId}/screen/action/acquireTicket"
+      }
+
+      response, headers = send_request(params)
+
+      screen_ticket = response.css("ScreenTicket").text
+
+      result = {}
+
+      if screen_ticket =~ /mks:\/\/([^\/]*)\/([^\?]*)\?ticket=(.*)/
+        result = { host: $1, moid: $2, token: $3 }
+        result[:token] = URI.unescape result[:token]
+      end
+      result
+    end
 
     private
       def add_disk(source_xml, disk_info)
+
         disks_count = source_xml.css("Item").css("rasd|HostResource").count
 
+        disk_parent_ids = Set.new
+
+        source_xml.css("Item").each do |entry|
+          parent_id = entry.css('rasd|Parent').first.text unless entry.css('rasd|Parent').empty?
+          resource_type = entry.css('rasd|ResourceType').first.text unless entry.css('rasd|ResourceType').empty?
+          disk_parent_ids << parent_id if resource_type == '17'
+        end
+
+        raise InvalidStateError, "Could not handle this request because multiple nodes with ResourceType 17 and different rasd:Parent exist" if disk_parent_ids.size > 1
+
+        raise InvalidStateError, "Could not handle this request because I could not find a node with ResourceType 17" if disk_parent_ids.size == 0
+
         # FIXME: This is a hack, but dealing with nokogiri APIs can be quite
         # frustrating sometimes...
         sibling = source_xml.css("Item").first
@@ -478,7 +530,7 @@ module VCloudClient
                   ns12:busSubType=\"lsilogic\"
                   ns12:busType=\"6\"/>
             <rasd:InstanceID>200#{disks_count}</rasd:InstanceID>
-            <rasd:Parent>1</rasd:Parent>
+            <rasd:Parent>#{disk_parent_ids.first}</rasd:Parent>
             <rasd:ResourceType>17</rasd:ResourceType>
           </Item>""")
       end

data/lib/vcloud-rest/version.rb

@@ -1,3 +1,3 @@
 module VCloudClient
-  VERSION = "1.2.0"
+  VERSION = "1.3.0"
 end

metadata

@@ -1,71 +1,179 @@
 --- !ruby/object:Gem::Specification
 name: vcloud-rest
 version: !ruby/object:Gem::Version
-  version: 1.2.0
+  version: 1.3.0
 platform: ruby
 authors:
 - Stefano Tortarolo
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-02-06 00:00:00.000000000 Z
+date: 2014-06-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: nokogiri
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: 1.5.10
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: 1.5.10
 - !ruby/object:Gem::Dependency
   name: rest-client
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+    - - ">="
       - !ruby/object:Gem::Version
         version: 1.6.7
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+    - - ">="
       - !ruby/object:Gem::Version
         version: 1.6.7
 - !ruby/object:Gem::Dependency
   name: httpclient
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.3'
+    - - ">="
       - !ruby/object:Gem::Version
         version: 2.3.3
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.3'
+    - - ">="
       - !ruby/object:Gem::Version
         version: 2.3.3
 - !ruby/object:Gem::Dependency
   name: ruby-progressbar
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.4.0
+        version: '1.5'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.5.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.5.1
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.1'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.14'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.14'
+- !ruby/object:Gem::Dependency
+  name: webmock
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.13'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.13'
+- !ruby/object:Gem::Dependency
+  name: vcr
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.4.0
+        version: '2.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.9'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.8.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.8.2
+- !ruby/object:Gem::Dependency
+  name: coveralls
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Ruby bindings to create, list and manage vCloud servers
 email:
 - stefano.tortarolo@gmail.com
@@ -74,10 +182,12 @@ extensions: []
 extra_rdoc_files: []
 files:
 - CHANGELOG.md
-- README.md
 - LICENSE
+- README.md
 - lib/vcloud-rest/connection.rb
 - lib/vcloud-rest/vcloud/catalog.rb
+- lib/vcloud-rest/vcloud/disk.rb
+- lib/vcloud-rest/vcloud/media.rb
 - lib/vcloud-rest/vcloud/network.rb
 - lib/vcloud-rest/vcloud/org.rb
 - lib/vcloud-rest/vcloud/ovf.rb
@@ -96,19 +206,18 @@ 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.1.11
+rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
 summary: Unofficial ruby bindings for VMWare vCloud's API
 test_files: []
-has_rdoc: