vcloud-rest 0.2.2 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: dbde7288973c310f0a12f5b1bbd8980a25af4397
-  data.tar.gz: 75c6edc2047b5ce235e9951bf6f723aabd0f928f
+  metadata.gz: 2c88e00c344ec71b95abf4340a2a1401d6617747
+  data.tar.gz: 07d79063ef3ab8906b30196c47758471c1473d88
 SHA512:
-  metadata.gz: ce2ca0f2908846add8a5beaf12c23e0722d9cd4d3fd8433225e0247249a6f232d887c441df21064566abe1bcc08bb6006a403f1982fc19e9ccee19f30f5cc063
-  data.tar.gz: e898766c0f2d3f0b85b0f2b343401cfa18c925983a753124e1a0c878c204322cb6dc802ca63c49c0a05188c58e2f819f83d3d7a1eca82568491fe24e6c700528
+  metadata.gz: bdd41a731e6204c0b1279904412dc5546bb57540e8c43b646274e44c3f17f84359d90665d122bb3f8c43c154f5459cbb7e3b4d5006917b0bc0830c4f0d3ba7e9
+  data.tar.gz: 144ce4ac54ef6b04b072306a86e9ea724091f419be29c2f8b6c681248c1ee264f214641decf658200c3d71ced465d5a37dbfe929c407cd019a269e954fb871c9

data/CHANGELOG.md

@@ -1,5 +1,30 @@
 Changes
 ==
+2013-07-25 (0.3.0)
+
+FEATURES:
+
+* Add ```compose_vapp_from_vm``` to compose a vapp using VMs in a catalog
+* Add ```get_vapp_template``` to get information on VMs inside a vapp template
+* Add ```set_vapp_port_forwarding_rules``` to set NAT port forwarding rules in an existing vapp
+* ```set_vapp_network_config```: add parent network specification
+* ```get_vapp```: ```vms_hash``` now contains also ```vapp_scoped_local_id```
+* Add ```get_vapp_edge_public_ip``` to fetch the public IP of a vApp (vShield Edge)
+* Add ```get_vapp_port_forwarding_rules``` to return vApp portforwarding rules
+* Add ``reboot_vapp/suspend_vapp/reset_vapp``
+* Add ```upload_ovf``` to upload an OVF Package
+
+CHANGES:
+
+* ```RetainNetInfoAcrossDeployments``` now defaults to false (fenced deployments)
+
+FIXES:
+
+* Better handling of 500 errors
+
+REMARKS:
+A big thanks to Fabio Rapposelli and Timo Sugliani for the great work done!
+
 2013-05-13 (0.2.2)
 --
 

data/README.md

@@ -19,7 +19,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 1.9.x and 1.8.7+.
+vcloud-rest is tested against ruby 2.0.0, 1.9.x and 1.8.7+.
 
 FEATURES
 --
@@ -33,6 +33,9 @@ FEATURES
 - basic vApp network configuration
 - basic VM network configuration
 - basic VM Guest Customization configuration
+- basic vApp compose capabilities
+- basic vApp NAT port forwarding creation
+- Catalog item upload with byterange upload and retry capabilities
 
 TODO
 --
@@ -41,8 +44,10 @@ TODO
 
 PREREQUISITES
 --
-- nokogiri ~> 1.5.5
+- nokogiri ~> 1.6.0
 - rest-client ~> 1.6.7
+- httpclient ~> 2.3.3
+- ruby-progressbar ~> 1.1.1
 
 For testing purpose:
 - minitest (included in ruby 1.9)
@@ -56,6 +61,12 @@ USAGE
     conn.login
     conn.list_organizations
 
+EXAMPLE
+--
+A (mostly complete) example can be found in
+
+	examples/example.rb
+
 TESTING
 --
 Simply run:
@@ -72,7 +83,7 @@ LICENSE
 
 Author:: Stefano Tortarolo <stefano.tortarolo@gmail.com>
 
-Copyright:: Copyright (c) 2012
+Copyright:: Copyright (c) 2012-2013
 License:: Apache License, Version 2.0
 
 Licensed under the Apache License, Version 2.0 (the "License");

data/lib/vcloud-rest/connection.rb

@@ -18,14 +18,18 @@
 
 require 'rest-client'
 require 'nokogiri'
+require 'httpclient'
+require 'ruby-progressbar'
 
 module VCloudClient
   class UnauthorizedAccess < StandardError; end
   class WrongAPIVersion < StandardError; end
   class WrongItemIDError < StandardError; end
   class InvalidStateError < StandardError; end
+  class InternalServerError < StandardError; end
   class UnhandledError < StandardError; end
 
+
   # Main class to access vCloud rest APIs
   class Connection
     attr_reader :api_url, :auth_key
@@ -33,6 +37,7 @@ module VCloudClient
     def initialize(host, username, password, org_name, api_version)
       @host = host
       @api_url = "#{host}/api"
+      @host_url = "#{host}"
       @username = username
       @password = password
       @org_name = org_name
@@ -68,8 +73,8 @@ module VCloudClient
     end
 
     ##
-    # List existing organizations and their IDs
-    def list_organizations
+    # Fetch existing organizations and their IDs
+    def get_organizations
       params = {
         'method' => :get,
         'command' => '/org'
@@ -86,11 +91,11 @@ module VCloudClient
     end
 
     ##
-    # Show details about an organization:
+    # Fetch details about an organization:
     # - catalogs
     # - vdcs
     # - networks
-    def show_organization(orgId)
+    def get_organization(orgId)
       params = {
         'method' => :get,
         'command' => "/org/#{orgId}"
@@ -117,12 +122,12 @@ module VCloudClient
         tasklists[item['name']] = item['href'].gsub("#{@api_url}/tasksList/", "")
       end
 
-      [catalogs, vdcs, networks, tasklists]
+      { :catalogs => catalogs, :vdcs => vdcs, :networks => networks, :tasklists => tasklists }
     end
 
     ##
-    # Show details about a given catalog
-    def show_catalog(catalogId)
+    # Fetch details about a given catalog
+    def get_catalog(catalogId)
       params = {
         'method' => :get,
         'command' => "/catalog/#{catalogId}"
@@ -136,16 +141,15 @@ module VCloudClient
       response.css("CatalogItem[type='application/vnd.vmware.vcloud.catalogItem+xml']").each do |item|
         items[item['name']] = item['href'].gsub("#{@api_url}/catalogItem/", "")
       end
-
-      [description, items]
+      { :description => description, :items => items }
     end
 
     ##
-    # Show details about a given vdc:
+    # Fetch details about a given vdc:
     # - description
     # - vapps
     # - networks
-    def show_vdc(vdcId)
+    def get_vdc(vdcId)
       params = {
         'method' => :get,
         'command' => "/vdc/#{vdcId}"
@@ -164,15 +168,14 @@ module VCloudClient
       response.css("Network[type='application/vnd.vmware.vcloud.network+xml']").each do |item|
         networks[item['name']] = item['href'].gsub("#{@api_url}/network/", "")
       end
-
-      [description, vapps, networks]
+      { :description => description, :vapps => vapps, :networks => networks }
     end
 
     ##
-    # Show details about a given catalog item:
+    # Fetch details about a given catalog item:
     # - description
     # - vApp templates
-    def show_catalog_item(catalogItemId)
+    def get_catalog_item(catalogItemId)
       params = {
         'method' => :get,
         'command' => "/catalogItem/#{catalogItemId}"
@@ -186,12 +189,11 @@ module VCloudClient
       response.css("Entity[type='application/vnd.vmware.vcloud.vAppTemplate+xml']").each do |item|
         items[item['name']] = item['href'].gsub("#{@api_url}/vAppTemplate/vappTemplate-", "")
       end
-
-      [description, items]
+      { :description => description, :items => items }
     end
 
     ##
-    # Show details about a given vapp:
+    # Fetch details about a given vapp:
     # - name
     # - description
     # - status
@@ -200,7 +202,7 @@ module VCloudClient
     #   -- IP addresses
     #   -- status
     #   -- ID
-    def show_vapp(vAppId)
+    def get_vapp(vAppId)
       params = {
         'method' => :get,
         'command' => "/vApp/vapp-#{vAppId}"
@@ -225,15 +227,18 @@ module VCloudClient
 
       # ipAddress could be namespaced or not: see https://github.com/astratto/vcloud-rest/issues/3
       vms.each do |vm|
+        vapp_local_id = vm.css('VAppScopedLocalId')
         addresses = vm.css('rasd|Connection').collect{|n| n['vcloud:ipAddress'] || n['ipAddress'] }
-        vms_hash[vm['name']] = {:addresses => addresses,
+        vms_hash[vm['name']] = {
+          :addresses => addresses,
           :status => convert_vapp_status(vm['status']),
-          :id => vm['href'].gsub("#{@api_url}/vApp/vm-", '')
+          :id => vm['href'].gsub("#{@api_url}/vApp/vm-", ''),
+          :vapp_scoped_local_id => vapp_local_id.text
         }
       end
 
       # TODO: EXPAND INFO FROM RESPONSE
-      [name, description, status, ip, vms_hash]
+      { :name => name, :description => description, :status => status, :ip => ip, :vms_hash => vms_hash }
     end
 
     ##
@@ -271,6 +276,50 @@ module VCloudClient
       task_id
     end
 
+    ##
+    # Suspend a given vapp
+    def suspend_vapp(vAppId)
+      params = {
+        'method' => :post,
+        'command' => "/vApp/vapp-#{vAppId}/power/action/suspend"
+      }
+
+      response, headers = send_request(params)
+      task_id = headers[:location].gsub("#{@api_url}/task/", "")
+      task_id
+    end
+
+    ##
+    # reboot a given vapp
+    # This will basically initial a guest OS reboot, and will only work if
+    # VMware-tools are installed on the underlying VMs.
+    # vShield Edge devices are not affected
+    def reboot_vapp(vAppId)
+      params = {
+        'method' => :post,
+        'command' => "/vApp/vapp-#{vAppId}/power/action/reboot"
+      }
+
+      response, headers = send_request(params)
+      task_id = headers[:location].gsub("#{@api_url}/task/", "")
+      task_id
+    end
+
+    ##
+    # reset a given vapp
+    # This will basically reset the VMs within the vApp
+    # vShield Edge devices are not affected.
+    def reset_vapp(vAppId)
+      params = {
+        'method' => :post,
+        'command' => "/vApp/vapp-#{vAppId}/power/action/reset"
+      }
+
+      response, headers = send_request(params)
+      task_id = headers[:location].gsub("#{@api_url}/task/", "")
+      task_id
+    end
+
     ##
     # Boot a given vapp
     def poweron_vapp(vAppId)
@@ -318,12 +367,372 @@ module VCloudClient
       task = response.css("VApp Task[operationName='vdcInstantiateVapp']").first
       task_id = task["href"].gsub("#{@api_url}/task/", "")
 
-      [vapp_id, task_id]
+      { :vapp_id => vapp_id, :task_id => task_id }
+    end
+
+    ##
+    # Compose a vapp using existing virtual machines
+    #
+    # Params:
+    # - vdc: the associated VDC
+    # - vapp_name: name of the target vapp
+    # - vapp_description: description of the target vapp
+    # - vm_list: hash with IDs of the VMs to be used in the composing process
+    # - network_config: hash of the network configuration for the vapp
+    def compose_vapp_from_vm(vdc, vapp_name, vapp_description, vm_list={}, network_config={})
+      builder = Nokogiri::XML::Builder.new do |xml|
+      xml.ComposeVAppParams(
+        "xmlns" => "http://www.vmware.com/vcloud/v1.5",
+        "xmlns:ovf" => "http://schemas.dmtf.org/ovf/envelope/1",
+        "name" => vapp_name) {
+        xml.Description vapp_description
+        xml.InstantiationParams {
+          xml.NetworkConfigSection {
+            xml['ovf'].Info "Configuration parameters for logical networks"
+            xml.NetworkConfig("networkName" => network_config[:name]) {
+              xml.Configuration {
+                xml.IpScopes {
+                  xml.IpScope {
+                    xml.IsInherited(network_config[:is_inherited] || "false")
+                    xml.Gateway network_config[:gateway]
+                    xml.Netmask network_config[:netmask]
+                    xml.Dns1 network_config[:dns1] if network_config[:dns1]
+                    xml.Dns2 network_config[:dns2] if network_config[:dns2]
+                    xml.DnsSuffix network_config[:dns_suffix] if network_config[:dns_suffix]
+                    xml.IpRanges {
+                      xml.IpRange {
+                        xml.StartAddress network_config[:start_address]
+                        xml.EndAddress network_config[:end_address]
+                      }
+                    }
+                  }
+                }
+                xml.ParentNetwork("href" => "#{@api_url}/network/#{network_config[:parent_network]}")
+                xml.FenceMode network_config[:fence_mode]
+
+                xml.Features {
+                  xml.FirewallService {
+                    xml.IsEnabled(network_config[:enable_firewall] || "false")
+                  }
+                }
+              }
+            }
+          }
+        }
+        vm_list.each do |vm_name, vm_id|
+          xml.SourcedItem {
+            xml.Source("href" => "#{@api_url}/vAppTemplate/vm-#{vm_id}", "name" => 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_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])
+          }
+        end
+        xml.AllEULAsAccepted "true"
+      }
+      end
+
+      params = {
+        "method" => :post,
+        "command" => "/vdc/#{vdc}/action/composeVApp"
+      }
+
+      response, headers = send_request(params, builder.to_xml, "application/vnd.vmware.vcloud.composeVAppParams+xml")
+
+      vapp_id = headers[:location].gsub("#{@api_url}/vApp/vapp-", "")
+
+      task = response.css("VApp Task[operationName='vdcComposeVapp']").first
+      task_id = task["href"].gsub("#{@api_url}/task/", "")
+
+      { :vapp_id => vapp_id, :task_id => task_id }
+    end
+
+    # Fetch details about a given vapp template:
+    # - name
+    # - description
+    # - Children VMs:
+    #   -- ID
+    def get_vapp_template(vAppId)
+      params = {
+        'method' => :get,
+        'command' => "/vAppTemplate/vappTemplate-#{vAppId}"
+      }
+
+      response, headers = send_request(params)
+
+      vapp_node = response.css('VAppTemplate').first
+      if vapp_node
+        name = vapp_node['name']
+        status = convert_vapp_status(vapp_node['status'])
+      end
+
+      description = response.css("Description").first
+      description = description.text unless description.nil?
+
+      ip = response.css('IpAddress').first
+      ip = ip.text unless ip.nil?
+
+      vms = response.css('Children Vm')
+      vms_hash = {}
+
+      vms.each do |vm|
+        vms_hash[vm['name']] = {
+          :id => vm['href'].gsub("#{@api_url}/vAppTemplate/vm-", '')
+        }
+      end
+
+      # TODO: EXPAND INFO FROM RESPONSE
+      { :name => name, :description => description, :vms_hash => vms_hash }
+    end
+
+    ##
+    # Set vApp port forwarding rules
+    #
+    # - vappid: id of the vapp to be modified
+    # - network_name: name of the vapp network to be modified
+    # - config: hash with network configuration specifications, must contain an array inside :nat_rules with the nat rules to be applied.
+    def set_vapp_port_forwarding_rules(vappid, network_name, config={})
+      builder = Nokogiri::XML::Builder.new do |xml|
+      xml.NetworkConfigSection(
+        "xmlns" => "http://www.vmware.com/vcloud/v1.5",
+        "xmlns:ovf" => "http://schemas.dmtf.org/ovf/envelope/1") {
+        xml['ovf'].Info "Network configuration"
+        xml.NetworkConfig("networkName" => network_name) {
+          xml.Configuration {
+            xml.ParentNetwork("href" => "#{@api_url}/network/#{config[:parent_network]}")
+            xml.FenceMode(config[:fence_mode] || 'isolated')
+            xml.Features {
+              xml.NatService {
+                xml.IsEnabled "true"
+                xml.NatType "portForwarding"
+                xml.Policy(config[:nat_policy_type] || "allowTraffic")
+                config[:nat_rules].each do |nat_rule|
+                  xml.NatRule {
+                    xml.VmRule {
+                      xml.ExternalPort nat_rule[:nat_external_port]
+                      xml.VAppScopedVmId nat_rule[:vm_scoped_local_id]
+                      xml.VmNicId(nat_rule[:nat_vmnic_id] || "0")
+                      xml.InternalPort nat_rule[:nat_internal_port]
+                      xml.Protocol(nat_rule[:nat_protocol] || "TCP")
+                    }
+                  }
+                end
+              }
+            }
+          }
+        }
+      }
+      end
+
+      params = {
+        'method' => :put,
+        'command' => "/vApp/vapp-#{vappid}/networkConfigSection"
+      }
+
+      response, headers = send_request(params, builder.to_xml, "application/vnd.vmware.vcloud.networkConfigSection+xml")
+
+      task_id = headers[:location].gsub("#{@api_url}/task/", "")
+      task_id
+    end
+
+    ##
+    # Get vApp port forwarding rules
+    #
+    # - vappid: id of the vApp
+    def get_vapp_port_forwarding_rules(vAppId)
+      params = {
+        'method' => :get,
+        'command' => "/vApp/vapp-#{vAppId}/networkConfigSection"
+      }
+
+      response, headers = send_request(params)
+
+      # FIXME: this will return nil if the vApp uses multiple vApp Networks
+      # with Edge devices in natRouted/portForwarding mode.
+      config = response.css('NetworkConfigSection/NetworkConfig/Configuration')
+      fenceMode = config.css('/FenceMode').text
+      natType = config.css('/Features/NatService/NatType').text
+
+      raise InvalidStateError, "Invalid request because FenceMode must be set to natRouted." unless fenceMode == "natRouted"
+      raise InvalidStateError, "Invalid request because NatType must be set to portForwarding." unless natType == "portForwarding"
+
+      nat_rules = {}
+      config.css('/Features/NatService/NatRule').each do |rule|
+        # portforwarding rules information
+        ruleId = rule.css('Id').text
+        vmRule = rule.css('VmRule')
+
+        nat_rules[rule.css('Id').text] = {
+          :ExternalIpAddress  => vmRule.css('ExternalIpAddress').text,
+          :ExternalPort       => vmRule.css('ExternalPort').text,
+          :VAppScopedVmId     => vmRule.css('VAppScopedVmId').text,
+          :VmNicId            => vmRule.css('VmNicId').text,
+          :InternalPort       => vmRule.css('InternalPort').text,
+          :Protocol           => vmRule.css('Protocol').text
+        }
+      end
+      nat_rules
+    end
+    ##
+    # get vApp edge public IP from the vApp ID
+    # Only works when:
+    # - vApp needs to be poweredOn
+    # - FenceMode is set to "natRouted"
+    # - NatType" is set to "portForwarding
+    # This will be required to know how to connect to VMs behind the Edge device.
+    def get_vapp_edge_public_ip(vAppId)
+      # Check the network configuration section
+      params = {
+        'method' => :get,
+        'command' => "/vApp/vapp-#{vAppId}/networkConfigSection"
+      }
+
+      response, headers = send_request(params)
+
+      # FIXME: this will return nil if the vApp uses multiple vApp Networks
+      # with Edge devices in natRouted/portForwarding mode.
+      config = response.css('NetworkConfigSection/NetworkConfig/Configuration')
+
+      fenceMode = config.css('/FenceMode').text
+      natType = config.css('/Features/NatService/NatType').text
+
+      raise InvalidStateError, "Invalid request because FenceMode must be set to natRouted." unless fenceMode == "natRouted"
+      raise InvalidStateError, "Invalid request because NatType must be set to portForwarding." unless natType == "portForwarding"
+
+      # Check the routerInfo configuration where the global external IP is defined
+      edgeIp = config.css('/RouterInfo/ExternalIp')
+      edgeIp = edgeIp.text unless edgeIp.nil?
+    end
+
+    ##
+    # Upload an OVF package
+    # - vdcId
+    # - vappName
+    # - vappDescription
+    # - ovfFile
+    # - catalogId
+    # - uploadOptions {}
+    def upload_ovf(vdcId, vappName, vappDescription, ovfFile, catalogId, uploadOptions={})
+      builder = Nokogiri::XML::Builder.new do |xml|
+        xml.UploadVAppTemplateParams(
+          "xmlns" => "http://www.vmware.com/vcloud/v1.5",
+          "xmlns:ovf" => "http://schemas.dmtf.org/ovf/envelope/1",
+          "manifestRequired" => "true",
+          "name" => vappName) {
+          xml.Description vappDescription
+        }
+      end
+
+      params = {
+        'method' => :post,
+        'command' => "/vdc/#{vdcId}/action/uploadVAppTemplate"
+      }
+
+      response, headers = send_request(params, builder.to_xml,
+                      "application/vnd.vmware.vcloud.uploadVAppTemplateParams+xml")
+
+      # Get vAppTemplate Link from location
+      vAppTemplate = headers[:location].gsub("#{@api_url}/vAppTemplate/vappTemplate-", "")
+      descriptorUpload = response.css("Files Link [rel='upload:default']").first[:href].gsub("#{@host_url}/transfer/", "")
+      transferGUID = descriptorUpload.gsub("/descriptor.ovf", "")
+
+      ovfFileBasename = File.basename(ovfFile, ".ovf")
+      ovfDir = File.dirname(ovfFile)
+
+      # Send OVF Descriptor
+      uploadURL = "/transfer/#{descriptorUpload}"
+      uploadFile = "#{ovfDir}/#{ovfFileBasename}.ovf"
+      upload_file(uploadURL, uploadFile, vAppTemplate, uploadOptions)
+
+      # Begin the catch for upload interruption
+      begin
+        params = {
+          'method' => :get,
+          'command' => "/vAppTemplate/vappTemplate-#{vAppTemplate}"
+        }
+
+        # Loop to wait for the upload links to show up in the vAppTemplate we just created
+        while true
+          response, headers = send_request(params)
+          break unless response.css("Files Link [rel='upload:default']").count == 1
+          sleep 1
+        end
+
+        # Send Manifest
+        uploadURL = "/transfer/#{transferGUID}/descriptor.mf"
+        uploadFile = "#{ovfDir}/#{ovfFileBasename}.mf"
+        upload_file(uploadURL, uploadFile, vAppTemplate, uploadOptions)
+
+        # Start uploading OVF VMDK files
+        params = {
+          'method' => :get,
+          'command' => "/vAppTemplate/vappTemplate-#{vAppTemplate}"
+        }
+        response, headers = send_request(params)
+        response.css("Files File [bytesTransferred='0'] Link [rel='upload:default']").each do |file|
+          fileName = file[:href].gsub("#{@host_url}/transfer/#{transferGUID}/","")
+          uploadFile = "#{ovfDir}/#{fileName}"
+          uploadURL = "/transfer/#{transferGUID}/#{fileName}"
+          upload_file(uploadURL, uploadFile, vAppTemplate, uploadOptions)
+        end
+
+        # 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" => vappName) {
+            xml.Description vappDescription
+            xml.Entity(
+              "href" => "#{@api_url}/vAppTemplate/vappTemplate-#{vAppTemplate}"
+              )
+          }
+        end
+
+        params = {
+          'method' => :post,
+          'command' => "/catalog/#{catalogId}/catalogItems"
+        }
+
+        response, headers = send_request(params, builder.to_xml,
+                        "application/vnd.vmware.vcloud.catalogItem+xml")
+
+      rescue Exception => e
+        puts "Exception detected: #{e.message}."
+        puts "Aborting task..."
+
+        # Get vAppTemplate Task
+        params = {
+          'method' => :get,
+          'command' => "/vAppTemplate/vappTemplate-#{vAppTemplate}"
+        }
+        response, headers = send_request(params)
+
+        # Cancel Task
+        cancelHook = response.css("Tasks Task Link [rel='task:cancel']").first[:href].gsub("#{@api_url}","")
+        params = {
+          'method' => :post,
+          'command' => cancelHook
+        }
+        response, headers = send_request(params)
+        raise
+      end
     end
 
     ##
-    # Show a given task
-    def show_task(taskid)
+    # Fetch information for a given task
+    def get_task(taskid)
       params = {
         'method' => :get,
         'command' => "/task/#{taskid}"
@@ -336,7 +745,7 @@ module VCloudClient
       start_time = task['startTime']
       end_time = task['endTime']
 
-      [status, start_time, end_time, response]
+      { :status => status, :start_time => start_time, :end_time => end_time, :response => response }
     end
 
     ##
@@ -344,8 +753,8 @@ module VCloudClient
     def wait_task_completion(taskid)
       status, errormsg, start_time, end_time, response = nil
       loop do
-        status, start_time, end_time, response = show_task(taskid)
-        break if status != 'running'
+        task = get_task(taskid)
+        break if task[:status] != 'running'
         sleep 1
       end
 
@@ -354,7 +763,7 @@ module VCloudClient
         errormsg = "Error code #{errormsg['majorErrorCode']} - #{errormsg['message']}"
       end
 
-      [status, errormsg, start_time, end_time]
+      { :status => status, :errormsg => errormsg, :start_time => start_time, :end_time => end_time }
     end
 
     ##
@@ -367,8 +776,9 @@ module VCloudClient
         xml['ovf'].Info "Network configuration"
         xml.NetworkConfig("networkName" => network_name) {
           xml.Configuration {
-            xml.FenceMode (config[:fence_mode] || 'isolated')
-            xml.RetainNetInfoAcrossDeployments (config[:retain_net] || true)
+            xml.FenceMode(config[:fence_mode] || 'isolated')
+            xml.RetainNetInfoAcrossDeployments(config[:retain_net] || false)
+            xml.ParentNetwork("href" => config[:parent_network])
           }
         }
       }
@@ -393,11 +803,11 @@ module VCloudClient
         "xmlns" => "http://www.vmware.com/vcloud/v1.5",
         "xmlns:ovf" => "http://schemas.dmtf.org/ovf/envelope/1") {
         xml['ovf'].Info "VM Network configuration"
-        xml.PrimaryNetworkConnectionIndex (config[:primary_index] || 0)
+        xml.PrimaryNetworkConnectionIndex(config[:primary_index] || 0)
         xml.NetworkConnection("network" => network_name, "needsCustomization" => true) {
-          xml.NetworkConnectionIndex (config[:network_index] || 0)
+          xml.NetworkConnectionIndex(config[:network_index] || 0)
           xml.IpAddress config[:ip] if config[:ip]
-          xml.IsConnected (config[:is_connected] || true)
+          xml.IsConnected(config[:is_connected] || true)
           xml.IpAddressAllocationMode config[:ip_allocation_mode] if config[:ip_allocation_mode]
         }
       }
@@ -442,8 +852,8 @@ module VCloudClient
     end
 
     ##
-    # Show details about a given VM
-    def show_vm(vmId)
+    # Fetch details about a given VM
+    def get_vm(vmId)
       params = {
         'method' => :get,
         'command' => "/vApp/vm-#{vmId}"
@@ -479,7 +889,7 @@ module VCloudClient
         :computer_name => response.css('GuestCustomizationSection ComputerName').first.text
       }
 
-      [os_desc, networks, guest_customizations]
+      { :os_desc => os_desc, :networks => networks, :guest_customizations => guest_customizations }
     end
 
     private
@@ -501,6 +911,8 @@ module VCloudClient
                                          :headers => headers,
                                          :url => "#{@api_url}#{params['command']}",
                                          :payload => payload)
+
+
         begin
           response = request.execute
           if ![200, 201, 202, 204].include?(response.code)
@@ -531,9 +943,98 @@ module VCloudClient
           body = Nokogiri.parse(e.http_body)
           message = body.css("Error").first["message"]
           raise UnauthorizedAccess, "Operation not permitted: #{message}."
+        rescue RestClient::InternalServerError => e
+          body = Nokogiri.parse(e.http_body)
+          message = body.css("Error").first["message"]
+          raise InternalServerError, "Internal Server Error: #{message}."
         end
       end
 
+      ##
+      # Upload a large file in configurable chunks, output an optional progressbar
+      def upload_file(uploadURL, uploadFile, vAppTemplate, config={})
+
+        # 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
+          puts 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)
+            puts "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
+
+
       ##
       # Convert vApp status codes into human readable description
       def convert_vapp_status(status_code)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: vcloud-rest
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 0.3.0
 platform: ruby
 authors:
 - Stefano Tortarolo
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-05-13 00:00:00.000000000 Z
+date: 2013-07-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: nokogiri
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 1.5.9
+        version: 1.6.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 1.5.9
+        version: 1.6.0
 - !ruby/object:Gem::Dependency
   name: rest-client
   requirement: !ruby/object:Gem::Requirement
@@ -38,6 +38,34 @@ dependencies:
     - - ~>
       - !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.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !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.1.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.1.1
 description: Ruby bindings to create, list and manage vCloud servers
 email:
 - stefano.tortarolo@gmail.com