vagrant-vcloudair 0.5.0

data/lib/vagrant-vcloudair/driver/meta.rb

@@ -0,0 +1,202 @@
+#
+#  Copyright 2012 Stefano Tortarolo
+#  Copyright 2013 Fabio Rapposelli and Timo Sugliani
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#   limitations under the License.
+#
+
+require 'forwardable'
+require 'log4r'
+require 'nokogiri'
+require 'httpclient'
+
+require File.expand_path('../base', __FILE__)
+
+module VagrantPlugins
+  module VCloudAir
+    module Driver
+      class Meta < Base
+        # We use forwardable to do all our driver forwarding
+        extend Forwardable
+        attr_reader :driver
+
+        def initialize(cloud_id, username, password, vdc_name)
+          # Setup the base
+          super()
+
+          @username = username
+          @password = password
+
+          @logger = Log4r::Logger.new('vagrant::provider::vcloudair::meta')
+
+          # Logging into vCloud Air
+          params = {
+            'method'  => :post,
+            'command' => '/vchs/sessions'
+          }
+
+          _response, headers = send_vcloudair_request(params)
+
+          unless headers.key?('x-vchs-authorization')
+            fail Errors::InvalidRequestError,
+                 :message => 'Failed to authenticate: ' \
+                             'missing x-vchs-authorization header'
+          end
+
+          @vcloudair_auth_key = headers['x-vchs-authorization']
+
+          # Get Services available
+          params = {
+            'method'  => :get,
+            'command' => '/vchs/services'
+          }
+
+          response, _headers = send_vcloudair_request(params)
+          services = response.css('Services Service')
+
+          service_id = cloud_id || vdc_name
+          services.each do |service|
+            if service['serviceId'] == service_id
+              @compute_id = URI(service['href']).path.gsub('/api', '')
+            end
+          end
+
+          fail Errors::ServiceNotFound if @compute_id.nil?
+
+          # Get Service Link to vCloud Director
+          params = {
+            'method'  => :get,
+            'command' => @compute_id
+          }
+
+          response, _headers = send_vcloudair_request(params)
+
+          vdcs = response.css('Compute VdcRef')
+
+          vdcs.each do |vdc|
+            if vdc['name'] == vdc_name
+              @vdc_id = URI(vdc['href']).path.gsub('/api', '')
+            end
+          end
+
+          fail Errors::VdcNotFound, :message => vdc_name if @vdc_id.nil?
+
+          # Authenticate to vCloud Director
+          params = {
+            'method'  => :post,
+            'command' => "#{@vdc_id}/vcloudsession"
+          }
+
+          response, _headers = send_vcloudair_request(params)
+
+          vdclinks = response.css('VCloudSession VdcLink')
+
+          vdclinks.each do |vdclink|
+            if vdclink['name'] == service_id
+              uri = URI(vdclink['href'])
+              @api_url = "#{uri.scheme}://#{uri.host}:#{uri.port}/api"
+              @host_url = "#{uri.scheme}://#{uri.host}:#{uri.port}"
+              @auth_key = vdclink['authorizationToken']
+            end
+          end
+
+          fail Errors::ObjectNotFound,
+               :message => 'Cannot find link to backend \
+               vCloud Director Instance' if @api_url.nil?
+
+          @org_name = vdc_name
+
+          # Read and assign the version of vCloud Air we know which
+          # specific driver to instantiate.
+          @logger.debug("Asking API Version with host_url: #{@host_url}")
+          @version = get_api_version(@host_url) || ''
+
+          # Instantiate the proper version driver for vCloud Air
+          @logger.debug("Finding driver for vCloud Air version: #{@version}")
+          driver_map   = {
+            '5.1' => Version_5_1,
+            '5.5' => Version_5_1,
+            '5.6' => Version_5_1,
+            '5.7' => Version_5_1
+          }
+
+          if @version.start_with?('0.9') ||
+             @version.start_with?('1.0') ||
+             @version.start_with?('1.5')
+            # We only support vCloud Air 5.1 or higher.
+            fail Errors::VCloudAirOldVersion, :version => @version
+          end
+
+          driver_klass = nil
+          driver_map.each do |key, klass|
+            if @version.start_with?(key)
+              driver_klass = klass
+              break
+            end
+          end
+
+          unless driver_klass
+            supported_versions = driver_map.keys.sort.join(', ')
+            fail Errors::VCloudAirInvalidVersion,
+                 :supported_versions => supported_versions
+          end
+
+          @logger.info("Using vCloud Air driver: #{driver_klass}")
+          @driver = driver_klass.new(@api_url, @host_url, @auth_key, @org_name)
+        end
+
+        def_delegators  :@driver,
+                        :login,
+                        :logout,
+                        :get_organizations,
+                        :get_organization_id_by_name,
+                        :get_organization_by_name,
+                        :get_organization,
+                        :get_catalog,
+                        :get_catalog_id_by_name,
+                        :get_catalog_by_name,
+                        :get_vdc,
+                        :get_vdc_id_by_name,
+                        :get_vdc_by_name,
+                        :get_catalog_item,
+                        :get_catalog_item_by_name,
+                        :get_vapp,
+                        :delete_vapp,
+                        :poweroff_vapp,
+                        :suspend_vapp,
+                        :reboot_vapp,
+                        :reset_vapp,
+                        :poweron_vapp,
+                        :create_vapp_from_template,
+                        :compose_vapp_from_vm,
+                        :get_vapp_template,
+                        :set_vapp_port_forwarding_rules,
+                        :get_vapp_port_forwarding_rules,
+                        :get_vapp_edge_public_ip,
+                        :upload_ovf,
+                        :get_task,
+                        :wait_task_completion,
+                        :set_vapp_network_config,
+                        :set_vm_network_config,
+                        :set_vm_guest_customization,
+                        :get_vm,
+                        :send_request,
+                        :upload_file,
+                        :convert_vapp_status
+
+        protected
+
+      end
+    end
+  end
+end

data/lib/vagrant-vcloudair/driver/version_5_1.rb

@@ -0,0 +1,2019 @@
+#
+#  Copyright 2012 Stefano Tortarolo
+#  Copyright 2013 Fabio Rapposelli and Timo Sugliani
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+#
+
+require 'ruby-progressbar'
+require 'set'
+require 'netaddr'
+require 'uri'
+
+module VagrantPlugins
+  module VCloudAir
+    module Driver
+      # Main class to access vCloud Air rest APIs
+      class Version_5_1 < Base
+        attr_reader :auth_key, :id
+
+        ##
+        # Init the driver with the Vagrantfile information
+        def initialize(api_url, host_url, auth_key, org_name)
+          @logger = Log4r::Logger.new('vagrant::provider::vcloudair::driver_5_1')
+          @api_url = api_url
+          @host_url = host_url
+          @auth_key = auth_key
+          @org_name = org_name
+          @api_version = '5.1'
+          @id = nil
+
+          @cached_vapp_edge_public_ips = {}
+        end
+
+        ##
+        # Authenticate against the specified server
+        def login
+        end
+
+        ##
+        # Destroy the current session
+        def logout
+          params = {
+            'method'  => :delete,
+            'command' => '/session'
+          }
+
+          _response, _headers = send_request(params)
+          # reset auth key to nil
+          @auth_key = nil
+        end
+
+        ##
+        # Fetch existing organizations and their IDs
+        def get_organizations
+          params = {
+            'method'  => :get,
+            'command' => '/org'
+          }
+
+          response, _headers = send_request(params)
+          orgs = response.css('OrgList Org')
+
+          results = {}
+          orgs.each do |org|
+            results[org['name']] = URI(org['href']).path.gsub('/api/org/', '')
+          end
+          results
+        end
+
+        ##
+        # friendly helper method to fetch an Organization Id by name
+        # - name (this isn't case sensitive)
+        def get_organization_id_by_name(name)
+          result = nil
+
+          # Fetch all organizations
+          organizations = get_organizations
+
+          organizations.each do |organization|
+            if organization[0].downcase == name.downcase
+              result = organization[1]
+            end
+          end
+          result
+        end
+
+        ##
+        # friendly helper method to fetch an Organization by name
+        # - name (this isn't case sensitive)
+        def get_organization_by_name(name)
+          result = nil
+
+          # Fetch all organizations
+          organizations = get_organizations
+
+          organizations.each do |organization|
+            if organization[0].downcase == name.downcase
+              result = get_organization(organization[1])
+            end
+          end
+          result
+        end
+
+        ##
+        # Fetch details about an organization:
+        # - catalogs
+        # - vdcs
+        # - networks
+        def get_organization(org_id)
+          params = {
+            'method'  => :get,
+            'command' => "/org/#{org_id}"
+          }
+
+          response, _headers = send_request(params)
+
+          catalogs = {}
+          response.css(
+            "Link[type='application/vnd.vmware.vcloud.catalog+xml']"
+          ).each do |item|
+            catalogs[item['name']] = URI(item['href']).path.gsub(
+              '/api/catalog/', ''
+            )
+          end
+
+          vdcs = {}
+          response.css(
+            "Link[type='application/vnd.vmware.vcloud.vdc+xml']"
+          ).each do |item|
+            vdcs[item['name']] = URI(item['href']).path.gsub(
+              '/api/vdc/', ''
+            )
+          end
+
+          networks = {}
+          response.css(
+            "Link[type='application/vnd.vmware.vcloud.orgNetwork+xml']"
+          ).each do |item|
+            networks[item['name']] = URI(item['href']).path.gsub(
+              '/api/network/', ''
+            )
+          end
+
+          tasklists = {}
+          response.css(
+            "Link[type='application/vnd.vmware.vcloud.tasksList+xml']"
+          ).each do |item|
+            tasklists[item['name']] = URI(item['href']).path.gsub(
+              '/api/tasksList/', ''
+            )
+          end
+
+          {
+            :catalogs   => catalogs,
+            :vdcs       => vdcs,
+            :networks   => networks,
+            :tasklists  => tasklists
+          }
+        end
+
+        ##
+        # Fetch details about a given catalog
+        def get_catalog(catalog_id)
+          params = {
+            'method'  => :get,
+            'command' => "/catalog/#{catalog_id}"
+          }
+
+          response, _headers = send_request(params)
+          description = response.css('Description').first
+          description = description.text unless description.nil?
+
+          items = {}
+          response.css(
+            "CatalogItem[type='application/vnd.vmware.vcloud.catalogItem+xml']"
+          ).each do |item|
+            items[item['name']] = URI(item['href']).path.gsub(
+              '/api/catalogItem/', ''
+            )
+          end
+          { :description => description, :items => items }
+        end
+
+        ##
+        # Friendly helper method to fetch an catalog id by name
+        # - organization hash (from get_organization/get_organization_by_name)
+        # - catalog name
+        def get_catalog_id_by_name(organization, catalog_name)
+          result = nil
+
+          organization[:catalogs].each do |catalog|
+            if catalog[0].downcase == catalog_name.downcase
+              result = catalog[1]
+            end
+          end
+
+          if result.nil?
+            # catalog not found, search in global catalogs as well
+            # that are not listed in organization directly
+            params = {
+              'method'  => :get,
+              'command' => '/catalogs/query/',
+              'cacheable' => true
+            }
+
+            response, _headers = send_request(params)
+
+            catalogs = {}
+            response.css(
+              'CatalogRecord'
+            ).each do |item|
+              catalogs[item['name']] = URI(item['href']).path.gsub(
+                '/api/catalog/', ''
+              )
+            end
+
+            catalogs.each do |catalog|
+              if catalog[0].downcase == catalog_name.downcase
+                result = catalog[1]
+              end
+            end
+
+          end
+
+          result
+        end
+
+        ##
+        # Friendly helper method to fetch an catalog by name
+        # - organization hash (from get_organization/get_organization_by_name)
+        # - catalog name
+        def get_catalog_by_name(organization, catalog_name)
+          result = nil
+
+          organization[:catalogs].each do |catalog|
+            if catalog[0].downcase == catalog_name.downcase
+              result = get_catalog(catalog[1])
+            end
+          end
+
+          result
+        end
+
+        ##
+        # Fetch details about a given vdc:
+        # - description
+        # - vapps
+        # - networks
+        def get_vdc(vdc_id)
+          params = {
+            'method'  => :get,
+            'command' => "/vdc/#{vdc_id}"
+          }
+
+          response, _headers = send_request(params)
+          description = response.css('Description').first
+          description = description.text unless description.nil?
+
+          vapps = {}
+          response.css(
+            "ResourceEntity[type='application/vnd.vmware.vcloud.vApp+xml']"
+          ).each do |item|
+            vapps[item['name']] = URI(item['href']).path.gsub(
+              '/api/vApp/vapp-', ''
+            )
+          end
+
+          networks = {}
+          response.css(
+            "Network[type='application/vnd.vmware.vcloud.network+xml']"
+          ).each do |item|
+            networks[item['name']] = URI(item['href']).path.gsub(
+              '/api/network/', ''
+            )
+          end
+          {
+            :description => description, :vapps => vapps, :networks => networks
+          }
+        end
+
+        ##
+        # Friendly helper method to fetch a Organization VDC Id by name
+        # - Organization object
+        # - Organization VDC Name
+        def get_vdc_id_by_name(organization, vdc_name)
+          result = nil
+
+          organization[:vdcs].each do |vdc|
+            if vdc[0].downcase == vdc_name.downcase
+              result = vdc[1]
+            end
+          end
+
+          result
+        end
+
+        ##
+        # Friendly helper method to fetch a Organization VDC by name
+        # - Organization object
+        # - Organization VDC Name
+        def get_vdc_by_name(organization, vdc_name)
+          result = nil
+
+          organization[:vdcs].each do |vdc|
+            if vdc[0].downcase == vdc_name.downcase
+              result = get_vdc(vdc[1])
+            end
+          end
+
+          result
+        end
+
+        ##
+        # Fetch details about a given catalog item:
+        # - description
+        # - vApp templates
+        def get_catalog_item(catalog_item_id)
+          params = {
+            'method'  => :get,
+            'command' => "/catalogItem/#{catalog_item_id}"
+          }
+
+          response, _headers = send_request(params)
+          description = response.css('Description').first
+          description = description.text unless description.nil?
+
+          items = {}
+          response.css(
+            "Entity[type='application/vnd.vmware.vcloud.vAppTemplate+xml']"
+          ).each do |item|
+            items[item['name']] = URI(item['href']).path.gsub(
+              '/api/vAppTemplate/vappTemplate-', ''
+            )
+          end
+          { :description => description, :items => items }
+        end
+
+        ##
+        # friendly helper method to fetch an catalogItem  by name
+        # - catalogId (use get_catalog_name(org, name))
+        # - catalagItemName
+        def get_catalog_item_by_name(catalog_id, catalog_item_name)
+          result = nil
+          catalog_elems = get_catalog(catalog_id)
+
+          catalog_elems[:items].each do |catalog_elem|
+
+            catalog_item = get_catalog_item(catalog_elem[1])
+            if catalog_item[:items][catalog_item_name]
+              # This is a vApp Catalog Item
+
+              # fetch CatalogItemId
+              catalog_item_id = catalog_item[:items][catalog_item_name]
+
+              # Fetch the catalogItemId information
+              params = {
+                'method'  => :get,
+                'command' => "/vAppTemplate/vappTemplate-#{catalog_item_id}"
+              }
+              response, _headers = send_request(params)
+
+              # VMs Hash for all the vApp VM entities
+              vms_hash = {}
+              response.css('/VAppTemplate/Children/Vm').each do |vm_elem|
+                vm_name = vm_elem['name']
+                vm_id = URI(vm_elem['href']).path.gsub(
+                  '/api/vAppTemplate/vm-', ''
+                )
+
+                # Add the VM name/id to the VMs Hash
+                vms_hash[vm_name] = { :id => vm_id }
+              end
+              result = {
+                catalog_item_name => catalog_item_id, :vms_hash => vms_hash
+              }
+            end
+          end
+          result
+        end
+
+        ##
+        # Fetch details about a given vapp:
+        # - name
+        # - description
+        # - status
+        # - IP
+        # - Children VMs:
+        #   -- IP addresses
+        #   -- status
+        #   -- ID
+        def get_vapp(vapp_id)
+          params = {
+            'method'  => :get,
+            'command' => "/vApp/vapp-#{vapp_id}"
+          }
+
+          response, _headers = send_request(params)
+
+          vapp_node = response.css('VApp').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 = {}
+
+          # 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'].to_sym] = {
+              :addresses            => addresses,
+              :status               => convert_vapp_status(vm['status']),
+              :id                   => URI(vm['href']).path.gsub('/api/vApp/vm-', ''),
+              :vapp_scoped_local_id => vapp_local_id.text
+            }
+          end
+
+          # TODO: EXPAND INFO FROM RESPONSE
+          {
+            :name         => name,
+            :description  => description,
+            :status       => status,
+            :ip           => ip,
+            :vms_hash     => vms_hash
+          }
+        end
+
+        ##
+        # Delete a given vapp
+        # NOTE: It doesn't verify that the vapp is shutdown
+        def delete_vapp(vapp_id)
+          params = {
+            'method'  => :delete,
+            'command' => "/vApp/vapp-#{vapp_id}"
+          }
+
+          _response, headers = send_request(params)
+          task_id = URI(headers['Location']).path.gsub('/api/task/', '')
+          task_id
+        end
+
+        ##
+        # Shutdown a given vapp
+        def poweroff_vapp(vapp_id)
+          builder = Nokogiri::XML::Builder.new do |xml|
+            xml.UndeployVAppParams(
+              'xmlns' => 'http://www.vmware.com/vcloud/v1.5'
+            ) { xml.UndeployPowerAction 'powerOff' }
+          end
+
+          params = {
+            'method'  => :post,
+            'command' => "/vApp/vapp-#{vapp_id}/action/undeploy"
+          }
+
+          _response, headers = send_request(
+            params,
+            builder.to_xml,
+            'application/vnd.vmware.vcloud.undeployVAppParams+xml'
+          )
+          task_id = URI(headers['Location']).path.gsub('/api/task/', '')
+          task_id
+        end
+
+        ##
+        # Suspend a given vapp
+        def suspend_vapp(vapp_id)
+          params = {
+            'method'  => :post,
+            'command' => "/vApp/vapp-#{vapp_id}/power/action/suspend"
+          }
+
+          _response, headers = send_request(params)
+          task_id = URI(headers['Location']).path.gsub('/api/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(vapp_id)
+          params = {
+            'method'  => :post,
+            'command' => "/vApp/vapp-#{vapp_id}/power/action/reboot"
+          }
+
+          _response, headers = send_request(params)
+          task_id = URI(headers['Location']).path.gsub('/api/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(vapp_id)
+          params = {
+            'method'  => :post,
+            'command' => "/vApp/vapp-#{vapp_id}/power/action/reset"
+          }
+
+          _response, headers = send_request(params)
+          task_id = URI(headers['Location']).path.gsub('/api/task/', '')
+          task_id
+        end
+
+        ##
+        # Boot a given vapp
+        def poweron_vapp(vapp_id)
+          params = {
+            'method'  => :post,
+            'command' => "/vApp/vapp-#{vapp_id}/power/action/powerOn"
+          }
+
+          _response, headers = send_request(params)
+          task_id = URI(headers['Location']).path.gsub('/api/task/', '')
+          task_id
+        end
+
+        #### VM operations ####
+        ##
+        # Delete a given vm
+        # NOTE: It doesn't verify that the vm is shutdown
+        def delete_vm(vm_id)
+          params = {
+            'method'  => :delete,
+            'command' => "/vApp/vm-#{vm_id}"
+          }
+
+          _response, headers = send_request(params)
+          task_id = URI(headers['Location']).path.gsub('/api/task/', '')
+          task_id
+        end
+
+        ##
+        # Shutdown a given VM
+        # Using undeploy as a REAL powerOff
+        # Only poweroff will put the VM into a partially powered off state.
+        def poweroff_vm(vm_id)
+          builder = Nokogiri::XML::Builder.new do |xml|
+            xml.UndeployVAppParams(
+            'xmlns' => 'http://www.vmware.com/vcloud/v1.5'
+          ) { xml.UndeployPowerAction 'powerOff' }
+          end
+
+          params = {
+            'method'  => :post,
+            'command' => "/vApp/vm-#{vm_id}/action/undeploy"
+          }
+
+          _response, headers = send_request(
+            params,
+            builder.to_xml,
+            'application/vnd.vmware.vcloud.undeployVAppParams+xml'
+          )
+          task_id = URI(headers['Location']).path.gsub('/api/task/', '')
+          task_id
+        end
+
+        ##
+        # Suspend a given VM
+        def suspend_vm(vm_id)
+          builder = Nokogiri::XML::Builder.new do |xml|
+            xml.UndeployVAppParams(
+              'xmlns' => 'http://www.vmware.com/vcloud/v1.5'
+            ) { xml.UndeployPowerAction 'suspend' }
+          end
+
+          params = {
+            'method'  => :post,
+            'command' => "/vApp/vm-#{vm_id}/action/undeploy"
+          }
+
+          _response, headers = send_request(
+            params,
+            builder.to_xml,
+            'application/vnd.vmware.vcloud.undeployVAppParams+xml'
+          )
+          task_id = URI(headers['Location']).path.gsub('/api/task/', '')
+          task_id
+        end
+
+        ##
+        # reboot a given VM
+        # 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_vm(vm_id)
+          params = {
+            'method'  => :post,
+            'command' => "/vApp/vm-#{vm_id}/power/action/reboot"
+          }
+
+          _response, headers = send_request(params)
+          task_id = URI(headers['Location']).path.gsub('/api/task/', '')
+          task_id
+        end
+
+        ##
+        # reset a given VM
+        # This will basically reset the VMs within the vApp
+        # vShield Edge devices are not affected.
+        def reset_vm(vm_id)
+          params = {
+            'method'  => :post,
+            'command' => "/vApp/vm-#{vm_id}/power/action/reset"
+          }
+
+          _response, headers = send_request(params)
+          task_id = URI(headers['Location']).path.gsub('/api/task/', '')
+          task_id
+        end
+
+        ##
+        # Boot a given VM
+        def poweron_vm(vm_id)
+          params = {
+            'method'  => :post,
+            'command' => "/vApp/vm-#{vm_id}/power/action/powerOn"
+          }
+
+          _response, headers = send_request(params)
+          task_id = URI(headers['Location']).path.gsub('/api/task/', '')
+          task_id
+        end
+
+        ##
+        # Create a catalog in an organization
+        def create_catalog(org_id, catalog_name, catalog_description)
+          builder = Nokogiri::XML::Builder.new do |xml|
+            xml.AdminCatalog(
+              'xmlns' => 'http://www.vmware.com/vcloud/v1.5',
+              'name' => catalog_name
+            ) { xml.Description catalog_description }
+
+          end
+
+          params = {
+            'method'  => :post,
+            'command' => "/admin/org/#{org_id}/catalogs"
+          }
+
+          response, _headers = send_request(
+            params,
+            builder.to_xml,
+            'application/vnd.vmware.admin.catalog+xml'
+          )
+          task_id = URI(response.css(
+              "AdminCatalog Tasks Task[operationName='catalogCreateCatalog']"
+            ).first[:href]).path.gsub('/api/task/', '')
+
+          catalog_id = URI(response.css(
+              "AdminCatalog Link [type='application/vnd.vmware.vcloud.catalog+xml']"
+            ).first[:href]).path.gsub('/api/catalog/', '')
+
+          { :task_id => task_id, :catalog_id => catalog_id }
+        end
+
+        ##
+        # Create a vapp starting from a template
+        #
+        # Params:
+        # - vdc: the associated VDC
+        # - vapp_name: name of the target vapp
+        # - vapp_description: description of the target vapp
+        # - vapp_templateid: ID of the vapp template
+        def create_vapp_from_template(vdc, vapp_name, vapp_description, vapp_template_id, poweron = false)
+          builder = Nokogiri::XML::Builder.new do |xml|
+            xml.InstantiateVAppTemplateParams(
+              'xmlns'     => 'http://www.vmware.com/vcloud/v1.5',
+              'xmlns:xsi' => 'http://www.w3.org/2001/XMLSchema-instance',
+              'xmlns:ovf' => 'http://schemas.dmtf.org/ovf/envelope/1',
+              'name'      => vapp_name,
+              'deploy'    => 'true',
+              'powerOn'   => poweron
+            ) { xml.Description vapp_description xml.Source(
+                'href' => "#{@api_url}/vAppTemplate/#{vapp_template_id}"
+              )
+            }
+          end
+
+          params = {
+            'method'  => :post,
+            'command' => "/vdc/#{vdc}/action/instantiateVAppTemplate"
+          }
+
+          response, headers = send_request(
+            params,
+            builder.to_xml,
+            'application/vnd.vmware.vcloud.instantiateVAppTemplateParams+xml'
+          )
+
+          vapp_id = URI(headers['Location']).path.gsub('/api/vApp/vapp-', '')
+
+          task = response.css(
+            "VApp Task[operationName='vdcInstantiateVapp']"
+          ).first
+
+          task_id = URI(task['href']).path.gsub("/api/task/", '')
+
+          { :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 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,
+            'deploy' => 'false',
+            'powerOn' => 'false') {
+            xml.Description vapp_description
+            xml.InstantiationParams {
+              xml.NetworkConfigSection {
+                xml['ovf'].Info 'Configuration parameters for logical networks'
+                xml.NetworkConfig('networkName' => network_config[:name]) {
+                  xml.Configuration {
+                    if network_config[:fence_mode] != 'bridged'
+                      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]
+                            }
+                          }
+                        }
+                      }
+                    end
+                    xml.ParentNetwork("href" => "#{@api_url}/network/#{network_config[:parent_network]}")
+                    xml.FenceMode network_config[:fence_mode]
+                    if network_config[:fence_mode] != 'bridged'
+                      xml.Features {
+                        xml.FirewallService {
+                          xml.IsEnabled(network_config[:enable_firewall] || "false")
+                        }
+                        xml.NatService {
+                          xml.IsEnabled "true"
+                          xml.NatType "portForwarding"
+                          xml.Policy(network_config[:nat_policy_type] || "allowTraffic")
+                        }
+                      }
+                    end
+                  }
+                }
+              }
+            }
+            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 = URI(headers['Location']).path.gsub("/api/vApp/vapp-", '')
+
+          task = response.css("VApp Task[operationName='vdcComposeVapp']").first
+          task_id = URI(task['href']).path.gsub('/api/task/', '')
+
+          { :vapp_id => vapp_id, :task_id => task_id }
+        end
+
+        ##
+        # Recompose an existing 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 recompose_vapp_from_vm(vapp_id, vm_list = {}, network_config = {})
+          original_vapp = get_vapp(vapp_id)
+
+          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' => original_vapp[:name]) {
+            xml.Description original_vapp[:description]
+            xml.InstantiationParams {}
+            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' => "/vApp/vapp-#{vapp_id}/action/recomposeVApp"
+          }
+
+          response, headers = send_request(
+            params,
+            builder.to_xml,
+            'application/vnd.vmware.vcloud.recomposeVAppParams+xml'
+          )
+
+          vapp_id = URI(headers['Location']).path.gsub('/api/vApp/vapp-', '')
+
+          task = response.css("Task [operationName='vdcRecomposeVapp']").first
+          task_id = URI(task['href']).path.gsub('/api/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(vapp_id)
+          params = {
+            'method'  => :get,
+            'command' => "/vAppTemplate/vappTemplate-#{vapp_id}"
+          }
+
+          response, _headers = send_request(params)
+
+          vapp_node = response.css('VAppTemplate').first
+          if vapp_node
+            name = vapp_node['name']
+            convert_vapp_status(vapp_node['status'])
+          end
+
+          description = response.css('Description').first
+          description = description.text unless description.nil?
+
+          vms = response.css('Children Vm')
+          vms_hash = {}
+
+          vms.each do |vm|
+            vms_hash[vm['name']] = {
+              :id => URI(vm['href']).path.gsub('/api/vAppTemplate/vm-', '')
+            }
+          end
+
+          { :name => name, :description => description, :vms_hash => vms_hash }
+        end
+
+        ##
+        # Set vApp port forwarding rules
+        #
+        # - vapp_id: 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(vapp_id, 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[:vapp_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-#{vapp_id}/networkConfigSection"
+          }
+
+          _response, headers = send_request(
+            params,
+            builder.to_xml,
+            'application/vnd.vmware.vcloud.networkConfigSection+xml'
+          )
+
+          task_id = URI(headers['Location']).path.gsub("/api/task/", '')
+          task_id
+        end
+
+        ##
+        # Add vApp port forwarding rules
+        #
+        # - vapp_id: 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 add.
+        #   nat_rules << {
+        #     :nat_external_port    => j.to_s,
+        #     :nat_internal_port    => "22",
+        #     :nat_protocol         => "TCP",
+        #     :vm_scoped_local_id   => value[:vapp_scoped_local_id]
+        #   }
+
+        def add_vapp_port_forwarding_rules(vapp_id, 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')
+
+                      pre_existing = get_vapp_port_forwarding_rules(vapp_id)
+
+                      config[:nat_rules].concat(pre_existing)
+
+                      config[:nat_rules].each do |nat_rule|
+                        xml.NatRule {
+                          xml.VmRule {
+                            xml.ExternalPort nat_rule[:nat_external_port]
+                            xml.VAppScopedVmId nat_rule[:vapp_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-#{vapp_id}/networkConfigSection"
+          }
+
+          _response, headers = send_request(
+            params,
+            builder.to_xml,
+            'application/vnd.vmware.vcloud.networkConfigSection+xml'
+          )
+
+          task_id = URI(headers['Location']).path.gsub('/api/task/', '')
+          task_id
+        end
+        ##
+        # Get vApp port forwarding rules
+        #
+        # - vapp_id: id of the vApp
+        def get_vapp_port_forwarding_rules(vapp_id)
+          params = {
+            'method'  => :get,
+            'command' => "/vApp/vapp-#{vapp_id}/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'
+          )
+          fence_mode = config.css('/FenceMode').text
+          nat_type = config.css('/Features/NatService/NatType').text
+
+          unless fence_mode == 'natRouted'
+            fail Errors::InvalidStateError,
+                 'Invalid request because FenceMode must be natRouted.'
+          end
+
+          unless nat_type == 'portForwarding'
+            fail Errors::InvalidStateError,
+                 'Invalid request because NatType must be portForwarding.'
+          end
+
+          nat_rules = []
+          config.css('/Features/NatService/NatRule').each do |rule|
+            # portforwarding rules information
+            vm_rule = rule.css('VmRule')
+
+            nat_rules << {
+              :nat_external_ip      => vm_rule.css('ExternalIpAddress').text,
+              :nat_external_port    => vm_rule.css('ExternalPort').text,
+              :vapp_scoped_local_id => vm_rule.css('VAppScopedVmId').text,
+              :vm_nic_id            => vm_rule.css('VmNicId').text,
+              :nat_internal_port    => vm_rule.css('InternalPort').text,
+              :nat_protocol         => vm_rule.css('Protocol').text
+            }
+          end
+          nat_rules
+        end
+
+        ##
+        # Find an edge gateway id from the edge name and vdc_id
+        #
+        # - edge_gateway_name: Name of the vSE
+        # - vdc_id: virtual datacenter id
+        #
+        def find_edge_gateway_id(edge_gateway_name, vdc_id)
+          params = {
+            'method'  => :get,
+            'command' => "/admin/vdc/#{vdc_id}/edgeGateways"
+          }
+
+          response, _headers = send_request(params)
+          edge_gateways = response.css('EdgeGatewayRecord')
+
+          edge_gateways.each do |edge_gateway|
+            if edge_gateway['name'] == edge_gateway_name
+              @edge_gateway_id = URI(edge_gateway['href']).path.gsub(
+                                '/api/admin/edgeGateway/', '')
+            end
+          end
+
+          fail Errors::EdgeGWNotFound, :message => edge_gateway_name if @edge_gateway_id.nil?
+
+          @edge_gateway_id
+        end
+
+        ##
+        # Redeploy the vShield Edge Gateway VM, due to some knowns issues
+        # where the current rules are not "applied" and the EdgeGW is in an
+        # unmanageable state.
+        #
+        def redeploy_edge_gateway(edge_gateway_id)
+          params = {
+            'method'  => :post,
+            'command' => "/admin/edgeGateway/#{edge_gateway_id}/action/redeploy"
+          }
+
+          _response, headers = send_request(params)
+          task_id = URI(headers['Location']).path.gsub('/api/task/', '')
+          task_id
+        end
+
+        ##
+        # Find an edge gateway network from the edge name and vdc_id, and ip
+        #
+        # - edge_gateway_name: Name of the vSE
+        # - vdc_id: virtual datacenter id
+        # - edge_gateway_ip: public ip associated to that vSE
+        #
+
+        def find_edge_gateway_network(edge_gateway_name, vdc_id, edge_gateway_ip)
+          edge_gateway_id = find_edge_gateway_id(edge_gateway_name, vdc_id)
+
+          params = {
+            'method'  => :get,
+            'command' => "/admin/edgeGateway/#{edge_gateway_id}"
+          }
+
+          response, _headers = send_request(params)
+          response.css(
+            'EdgeGateway Configuration GatewayInterfaces GatewayInterface'
+          ).each do |gw|
+            # Only check uplinks, avoid another check
+            if gw.css('InterfaceType').text == 'uplink'
+
+              # Loop on all sub-allocation pools
+              gw.css('SubnetParticipation IpRanges IpRange').each do |cur_range|
+
+                low_ip = cur_range.css('StartAddress').first.text
+                high_ip = cur_range.css('EndAddress').first.text
+
+                range_ip_low = NetAddr.ip_to_i(low_ip)
+                range_ip_high = NetAddr.ip_to_i(high_ip)
+                @test_ip = NetAddr.ip_to_i(edge_gateway_ip)
+
+                @logger.debug("Our IP range: #{range_ip_low..range_ip_high}")
+                @logger.debug("Our Test IP #{@test_ip}")
+
+                case @test_ip
+                when range_ip_low..range_ip_high then
+                  @logger.debug("Found IP #{NetAddr.i_to_ip(@test_ip)}")
+                  @network_id = gw.css('Network').first[:href]
+                end
+              end
+            end
+          end
+
+          fail Errors::EdgeGWIPNotFound,
+               :message => NetAddr.i_to_ip(@test_ip) if @network_id.nil?
+
+          @network_id
+        end
+
+        ##
+        # Check wether the specified Network is connected to the specified
+        # Organization Edge
+        #
+        # - edge_gateway_name: Name of the vSE
+        # - vdc_id: virtual datacenter id
+        # - vdc_network_name: VDC Network Name to check
+        #
+
+        def check_edge_gateway_network(edge_gateway_name, vdc_id, vdc_network_name)
+          edge_gateway_id = find_edge_gateway_id(edge_gateway_name, vdc_id)
+
+          params = {
+            'method'  => :get,
+            'command' => "/admin/edgeGateway/#{edge_gateway_id}"
+          }
+
+          response, _headers = send_request(params)
+          response.css(
+            'EdgeGateway Configuration GatewayInterfaces GatewayInterface'
+          ).each do |gw|
+            # Only check internal connections, avoid another check
+            if gw.css('InterfaceType').text == 'internal'
+
+              # Loop on all sub-allocation pools
+              networks = gw.css('Network')
+
+              networks.each do |network|
+                @network_test = true if network['name'] == vdc_network_name
+              end
+            end
+          end
+
+          fail Errors::EdgeGWNotConnected,
+               :edge => edge_gateway_name,
+               :network => vdc_network_name unless @network_test
+
+          @network_test
+        end
+
+        ##
+        # Get Org Edge port forwarding and firewall rules
+        #
+        # - vapp_id: 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 get_edge_gateway_rules(edge_gateway_name, vdc_id)
+          edge_gateway_id = find_edge_gateway_id(edge_gateway_name, vdc_id)
+
+          params = {
+            'method'  => :get,
+            'command' => "/admin/edgeGateway/#{edge_gateway_id}"
+          }
+
+          response, _headers = send_request(params)
+
+          nat_fw_rules = []
+
+          interesting = response.css(
+            'EdgeGateway Configuration EdgeGatewayServiceConfiguration'
+          )
+          interesting.css('NatService NatRule').each do |node|
+            if node.css('RuleType').text == 'DNAT'
+              gw_node = node.css('GatewayNatRule')
+              nat_fw_rules << {
+                :rule_type        => 'DNAT',
+                :original_ip      => gw_node.css('OriginalIp').text,
+                :original_port    => gw_node.css('OriginalPort').text,
+                :translated_ip    => gw_node.css('TranslatedIp').text,
+                :translated_port  => gw_node.css('TranslatedPort').text,
+                :protocol         => gw_node.css('Protocol').text,
+                :is_enabled       => node.css('IsEnabled').text
+              }
+
+            end
+            if node.css('RuleType').text == 'SNAT'
+              gw_node = node.css('GatewayNatRule')
+              nat_fw_rules << {
+                :rule_type      => 'SNAT',
+                :interface_name => gw_node.css('Interface').first['name'],
+                :original_ip    => gw_node.css('OriginalIp').text,
+                :translated_ip  => gw_node.css('TranslatedIp').text,
+                :is_enabled     => node.css('IsEnabled').text
+              }
+            end
+          end
+
+          interesting.css('FirewallService FirewallRule').each do |node|
+            if node.css('Port').text == '-1'
+              nat_fw_rules << {
+                :rule_type             => 'Firewall',
+                :id                    => node.css('Id').text,
+                :policy                => node.css('Policy').text,
+                :description           => node.css('Description').text,
+                :destination_ip        => node.css('DestinationIp').text,
+                :destination_portrange => node.css('DestinationPortRange').text,
+                :source_ip             => node.css('SourceIp').text,
+                :source_portrange      => node.css('SourcePortRange').text,
+                :is_enabled            => node.css('IsEnabled').text
+              }
+            end
+          end
+
+          nat_fw_rules
+        end
+
+        ##
+        # Remove NAT/FW rules from a edge gateway device
+        #
+        # - edge_gateway_name: Name of the vSE
+        # - vdc_id: virtual datacenter id
+        # - edge_gateway_ip: public ip associated the vSE
+        # - vapp_id: vApp identifier to correlate with the vApp Edge
+
+        def remove_edge_gateway_rules(edge_gateway_name, vdc_id, edge_gateway_ip, vapp_id)
+          edge_vapp_ip = get_vapp_edge_public_ip(vapp_id)
+          edge_gateway_id = find_edge_gateway_id(edge_gateway_name, vdc_id)
+
+          params = {
+           'method'  => :get,
+           'command' => "/admin/edgeGateway/#{edge_gateway_id}"
+          }
+
+          response, _headers = send_request(params)
+
+          interesting = response.css(
+            'EdgeGateway Configuration EdgeGatewayServiceConfiguration'
+          )
+          interesting.css('NatService NatRule').each do |node|
+            if node.css('RuleType').text == 'DNAT' &&
+               node.css('GatewayNatRule/OriginalIp').text == edge_gateway_ip &&
+               node.css('GatewayNatRule/TranslatedIp').text == edge_vapp_ip
+              node.remove
+            end
+            if node.css('RuleType').text == 'SNAT' &&
+               node.css('GatewayNatRule/OriginalIp').text == edge_vapp_ip &&
+               node.css('GatewayNatRule/TranslatedIp').text == edge_gateway_ip
+              node.remove
+            end
+          end
+
+          interesting.css('FirewallService FirewallRule').each do |node|
+            if node.css('Port').text == '-1' &&
+               node.css('DestinationIp').text == edge_gateway_ip &&
+               node.css('DestinationPortRange').text == 'Any'
+              node.remove
+            end
+          end
+
+          builder = Nokogiri::XML::Builder.new
+          builder << interesting
+
+          remove_edge_rules = Nokogiri::XML(builder.to_xml)
+
+          xml = remove_edge_rules.at_css 'EdgeGatewayServiceConfiguration'
+          xml['xmlns'] = 'http://www.vmware.com/vcloud/v1.5'
+
+          params = {
+            'method'  => :post,
+            'command' => "/admin/edgeGateway/#{edge_gateway_id}/action/" +
+                         'configureServices'
+          }
+
+          _response, headers = send_request(
+            params,
+            remove_edge_rules.to_xml,
+            'application/vnd.vmware.admin.edgeGatewayServiceConfiguration+xml'
+          )
+
+          task_id = URI(headers['Location']).path.gsub('/api/task/', '')
+          task_id
+        end
+
+        #
+        # Add Org Edge port forwarding and firewall rules
+        #
+        # - vapp_id: id of the vapp to be modified
+        # - network_name: name of the vapp network to be modified
+        # - ports: array with port numbers to forward 1:1 to vApp.
+        def add_edge_gateway_rules(edge_gateway_name, vdc_id, edge_gateway_ip, vapp_id, ports)
+          edge_vapp_ip = get_vapp_edge_public_ip(vapp_id)
+          edge_network_id = find_edge_gateway_network(
+            edge_gateway_name,
+            vdc_id,
+            edge_gateway_ip
+          )
+          edge_gateway_id = find_edge_gateway_id(edge_gateway_name, vdc_id)
+
+          ### FIXME: tsugliani
+          # We need to check the previous variables, especially (edge_*)
+          # which can fail in some *weird* situations.
+          params = {
+             'method'   => :get,
+             'command'  => "/admin/edgeGateway/#{edge_gateway_id}"
+           }
+
+          response, _headers = send_request(params)
+
+          interesting = response.css(
+            'EdgeGateway Configuration EdgeGatewayServiceConfiguration'
+          )
+
+          add_snat_rule = true
+          interesting.css('NatService NatRule').each do |node|
+            if node.css('RuleType').text == 'DNAT' &&
+               node.css('GatewayNatRule/OriginalIp').text == edge_gateway_ip &&
+               node.css('GatewayNatRule/TranslatedIp').text == edge_vapp_ip &&
+               node.css('GatewayNatRule/OriginalPort').text == 'any'
+               # remove old DNAT rule any -> any from older vagrant-vcloudair versions
+              node.remove
+            end
+            if node.css('RuleType').text == 'SNAT' &&
+               node.css('GatewayNatRule/OriginalIp').text == edge_vapp_ip &&
+               node.css('GatewayNatRule/TranslatedIp').text == edge_gateway_ip
+              add_snat_rule = false
+            end
+          end
+
+          add_firewall_rule = true
+          interesting.css('FirewallService FirewallRule').each do |node|
+            if node.css('Port').text == '-1' &&
+               node.css('DestinationIp').text == edge_gateway_ip &&
+               node.css('DestinationPortRange').text == 'Any'
+              add_firewall_rule = false
+            end
+          end
+
+          builder = Nokogiri::XML::Builder.new
+          builder << interesting
+
+          set_edge_rules = Nokogiri::XML(builder.to_xml) do |config|
+            config.default_xml.noblanks
+          end
+
+          nat_rules = set_edge_rules.at_css('NatService')
+
+          # Add all DNAT port rules edge -> vApp for the given list
+          ports.each do |port|
+            nat_rule = Nokogiri::XML::Builder.new do |xml|
+                xml.NatRule {
+                  xml.RuleType 'DNAT'
+                  xml.IsEnabled 'true'
+                  xml.GatewayNatRule {
+                    xml.Interface('href' => edge_network_id )
+                    xml.OriginalIp edge_gateway_ip
+                    xml.OriginalPort port
+                    xml.TranslatedIp edge_vapp_ip
+                    xml.TranslatedPort port
+                    xml.Protocol 'tcpudp'
+                  }
+                }
+            end
+            nat_rules << nat_rule.doc.root.to_xml
+          end
+
+          if (add_snat_rule)
+            snat_rule = Nokogiri::XML::Builder.new do |xml|
+                xml.NatRule {
+                  xml.RuleType 'SNAT'
+                  xml.IsEnabled 'true'
+                  xml.GatewayNatRule {
+                    xml.Interface('href' => edge_network_id )
+                    xml.OriginalIp edge_vapp_ip
+                    xml.TranslatedIp edge_gateway_ip
+                    xml.Protocol 'any'
+                  }
+                }
+            end
+            nat_rules << snat_rule.doc.root.to_xml
+          end
+
+
+          if (add_firewall_rule)
+          firewall_rule_1 = Nokogiri::XML::Builder.new do |xml|
+              xml.FirewallRule {
+                xml.IsEnabled 'true'
+                xml.Description 'Allow Vagrant Communications'
+                xml.Policy 'allow'
+                xml.Protocols {
+                  xml.Any 'true'
+                }
+                xml.DestinationPortRange 'Any'
+                xml.DestinationIp edge_gateway_ip
+                xml.SourcePortRange 'Any'
+                xml.SourceIp 'Any'
+                xml.EnableLogging 'false'
+              }
+          end
+          fw_rules = set_edge_rules.at_css('FirewallService')
+            fw_rules << firewall_rule_1.doc.root.to_xml
+          end
+
+          xml = set_edge_rules.at_css 'EdgeGatewayServiceConfiguration'
+          xml['xmlns'] = 'http://www.vmware.com/vcloud/v1.5'
+
+          params = {
+            'method'  => :post,
+            'command' => "/admin/edgeGateway/#{edge_gateway_id}/action/" +
+                         'configureServices'
+          }
+
+          _response, headers = send_request(
+            params,
+            set_edge_rules.to_xml,
+            'application/vnd.vmware.admin.edgeGatewayServiceConfiguration+xml'
+          )
+
+          task_id = URI(headers['Location']).path.gsub('/api/task/', '')
+          task_id
+        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(vapp_id)
+          return @cached_vapp_edge_public_ips[vapp_id] unless @cached_vapp_edge_public_ips[vapp_id].nil?
+
+          # Check the network configuration section
+          params = {
+            'method' => :get,
+            'command' => "/vApp/vapp-#{vapp_id}/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'
+          )
+
+          fence_mode = config.css('/FenceMode').text
+          nat_type = config.css('/Features/NatService/NatType').text
+
+          unless fence_mode == 'natRouted'
+            fail Errors::InvalidStateError,
+                 'Invalid request because FenceMode must be natRouted.'
+          end
+
+          unless nat_type == 'portForwarding'
+            fail Errors::InvalidStateError,
+                 'Invalid request because NatType must be portForwarding.'
+          end
+
+          # Check the routerInfo configuration where the global external IP
+          # is defined
+          edge_ip = config.css('/RouterInfo/ExternalIp').text
+          if edge_ip == ''
+            return nil
+          else
+            @cached_vapp_edge_public_ips[vapp_id] = edge_ip
+            return edge_ip
+          end
+        end
+
+        ##
+        # Upload an OVF package
+        # - vdc_id
+        # - vappName
+        # - vappDescription
+        # - ovfFile
+        # - catalogId
+        # - uploadOptions {}
+        def upload_ovf(vdc_id, vapp_name, vapp_description, ovf_file, catalog_id, upload_options = {})
+          # if send_manifest is not set, setting it true
+          if upload_options[:send_manifest].nil? ||
+             upload_options[:send_manifest]
+            upload_manifest = 'true'
+          else
+            upload_manifest = 'false'
+          end
+
+          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' => upload_manifest,
+              'name' => vapp_name) {
+              xml.Description vapp_description
+            }
+          end
+
+          params = {
+            'method'  => :post,
+            'command' => "/vdc/#{vdc_id}/action/uploadVAppTemplate"
+          }
+
+          @logger.debug('Sending uploadVAppTemplate request...')
+
+          response, headers = send_request(
+            params,
+            builder.to_xml,
+            'application/vnd.vmware.vcloud.uploadVAppTemplateParams+xml'
+          )
+
+          # Get vAppTemplate Link from location
+          vapp_template = URI(headers['Location']).path.gsub(
+            '/api/vAppTemplate/vappTemplate-', ''
+          )
+
+          @logger.debug("Getting vAppTemplate ID: #{vapp_template}")
+          descriptor_upload = URI(response.css(
+            "Files Link [rel='upload:default']"
+          ).first[:href]).path.gsub('/transfer/', '')
+          transfer_guid = descriptor_upload.gsub('/descriptor.ovf', '')
+
+          ovf_file_basename = File.basename(ovf_file, '.ovf')
+          ovf_dir = File.dirname(ovf_file)
+
+          # Send OVF Descriptor
+          @logger.debug('Sending OVF Descriptor...')
+          upload_url = "/transfer/#{descriptor_upload}"
+          upload_filename = "#{ovf_dir}/#{ovf_file_basename}.ovf"
+          upload_file(
+            upload_url,
+            upload_filename,
+            vapp_template,
+            upload_options
+          )
+
+          # Begin the catch for upload interruption
+          begin
+            params = {
+              'method'  => :get,
+              'command' => "/vAppTemplate/vappTemplate-#{vapp_template}"
+            }
+
+            response, _headers = send_request(params)
+
+            task = response.css(
+              "VAppTemplate Task[operationName='vdcUploadOvfContents']"
+            ).first
+            task_id = URI(task['href']).path.gsub('/api/task/', '')
+
+            # Loop to wait for the upload links to show up in the vAppTemplate
+            # we just created
+            @logger.debug(
+              'Waiting for the upload links to show up in the vAppTemplate ' \
+              'we just created.'
+            )
+            while true
+              response, _headers = send_request(params)
+              @logger.debug('Request...')
+              break unless response.css("Files Link [rel='upload:default']").count == 1
+              sleep 1
+            end
+
+            if upload_manifest == 'true'
+              upload_url = "/transfer/#{transfer_guid}/descriptor.mf"
+              upload_filename = "#{ovf_dir}/#{ovf_file_basename}.mf"
+              upload_file(
+                upload_url,
+                upload_filename,
+                vapp_template,
+                upload_options
+              )
+            end
+
+            # Start uploading OVF VMDK files
+            params = {
+              'method'  => :get,
+              'command' => "/vAppTemplate/vappTemplate-#{vapp_template}"
+            }
+            response, _headers = send_request(params)
+            response.css(
+              "Files File [bytesTransferred='0'] Link [rel='upload:default']"
+            ).each do |file|
+              file_name = URI(file[:href]).path.gsub("/transfer/#{transfer_guid}/", '')
+              upload_filename = "#{ovf_dir}/#{file_name}"
+              upload_url = "/transfer/#{transfer_guid}/#{file_name}"
+              upload_file(
+                upload_url,
+                upload_filename,
+                vapp_template,
+                upload_options
+              )
+            end
+
+            # Add item to the catalog catalog_id
+            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' => vapp_name) {
+                xml.Description vapp_description
+                xml.Entity(
+                  'href' => "#{@api_url}/vAppTemplate/" +
+                            "vappTemplate-#{vapp_template}"
+                  )
+              }
+            end
+
+            params = {
+              'method'  => :post,
+              'command' => "/catalog/#{catalog_id}/catalogItems"
+            }
+            # No debug here (tsugliani)
+            _response, _headers = send_request(
+              params,
+              builder.to_xml,
+              'application/vnd.vmware.vcloud.catalogItem+xml'
+            )
+
+            task_id
+
+            ######
+
+          rescue Exception => e
+            puts "Exception detected: #{e.message}."
+            puts 'Aborting task...'
+
+            # Get vAppTemplate Task
+            params = {
+              'method'  => :get,
+              'command' => "/vAppTemplate/vappTemplate-#{vapp_template}"
+            }
+            response, _headers = send_request(params)
+
+            # Cancel Task
+            cancel_hook = URI(response.css(
+              "Tasks Task Link [rel='task:cancel']"
+            ).first[:href]).path.gsub('/api', '')
+
+            params = {
+              'method'  => :post,
+              'command' => cancel_hook
+            }
+            # FIXME: No debug here (tsugliani)
+            _response, _headers = send_request(params)
+            raise
+          end
+        end
+
+        ##
+        # Fetch information for a given task
+        def get_task(task_id)
+          params = {
+            'method'  => :get,
+            'command' => "/task/#{task_id}"
+          }
+
+          response, _headers = send_request(params)
+
+          task = response.css('Task').first
+          status = task['status']
+          start_time = task['startTime']
+          end_time = task['endTime']
+
+          {
+            :status     => status,
+            :start_time => start_time,
+            :end_time   => end_time,
+            :response   => response
+          }
+        end
+
+        ##
+        # Poll a given task until completion
+        def wait_task_completion(task_id)
+          task, errormsg = nil
+          loop do
+            task = get_task(task_id)
+            # @logger.debug(
+            #  "Evaluating taskid: #{task_id}, current status #{task[:status]}"
+            # )
+            break if !['queued','preRunning','running'].include?(task[:status])
+            sleep 5
+          end
+
+          if task[:status] == 'error'
+            @logger.debug('Task Error')
+            errormsg = task[:response].css('Error').first
+            @logger.debug(
+              "Task Error Message #{errormsg['majorErrorCode']} - " +
+              "#{errormsg['message']}"
+            )
+            errormsg =
+            "Error code #{errormsg['majorErrorCode']} - #{errormsg['message']}"
+          end
+
+          {
+            :status     => task[:status],
+            :errormsg   => errormsg,
+            :start_time => task[:start_time],
+            :end_time   => task[:end_time]
+          }
+        end
+
+        ##
+        # Set vApp Network Config
+        def set_vapp_network_config(vapp_id, 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.FenceMode(config[:fence_mode] || 'isolated')
+                  xml.RetainNetInfoAcrossDeployments(config[:retain_net] || false)
+                  xml.ParentNetwork('href' => config[:parent_network])
+                }
+              }
+            }
+          end
+
+          params = {
+            'method'  => :put,
+            'command' => "/vApp/vapp-#{vapp_id}/networkConfigSection"
+          }
+
+          _response, headers = send_request(
+            params,
+            builder.to_xml,
+            'application/vnd.vmware.vcloud.networkConfigSection+xml'
+          )
+
+          task_id = URI(headers['Location']).path.gsub('/api/task/', '')
+          task_id
+        end
+
+        ##
+        # Set VM Network Config
+        def set_vm_network_config(vm_id, network_name, config = {})
+          builder = Nokogiri::XML::Builder.new do |xml|
+            xml.NetworkConnectionSection(
+              '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.NetworkConnection(
+                'network' => network_name,
+                'needsCustomization' => true
+              ) {
+                xml.NetworkConnectionIndex(config[:network_index] || 0)
+                xml.IpAddress config[:ip] if config[:ip]
+                xml.IsConnected(config[:is_connected] || true)
+                xml.IpAddressAllocationMode config[:ip_allocation_mode] if config[:ip_allocation_mode]
+              }
+            }
+          end
+
+          params = {
+            'method'  => :put,
+            'command' => "/vApp/vm-#{vm_id}/networkConnectionSection"
+          }
+
+          _response, headers = send_request(
+            params,
+            builder.to_xml,
+            'application/vnd.vmware.vcloud.networkConnectionSection+xml'
+          )
+
+          task_id = URI(headers['Location']).path.gsub('/api/task/', '')
+          task_id
+        end
+
+        ##
+        # Set VM Guest Customization Config
+        def set_vm_guest_customization(vm_id, computer_name, config = {})
+          builder = Nokogiri::XML::Builder.new do |xml|
+          xml.GuestCustomizationSection(
+            'xmlns' => 'http://www.vmware.com/vcloud/v1.5',
+            'xmlns:ovf' => 'http://schemas.dmtf.org/ovf/envelope/1') {
+              xml['ovf'].Info 'VM Guest Customization configuration'
+              xml.Enabled config[:enabled] if config[:enabled]
+              xml.AdminPasswordEnabled config[:admin_passwd_enabled] if config[:admin_passwd_enabled]
+              xml.AdminPassword config[:admin_passwd] if config[:admin_passwd]
+              xml.ComputerName computer_name
+          }
+          end
+
+          params = {
+            'method'  => :put,
+            'command' => "/vApp/vm-#{vm_id}/guestCustomizationSection"
+          }
+
+          _response, headers = send_request(
+            params,
+            builder.to_xml,
+            'application/vnd.vmware.vcloud.guestCustomizationSection+xml'
+          )
+          task_id = URI(headers['Location']).path.gsub('/api/task/', '')
+          task_id
+        end
+
+        # Enable VM Nested Hardware-Assisted Virtualization
+        def set_vm_nested_hypervisor(vm_id, enable)
+          action = enable ? "enable" : "disable"
+          params = {
+            'method'  => :post,
+            'command' => "/vApp/vm-#{vm_id}/action/#{action}NestedHypervisor"
+          }
+
+          _response, headers = send_request(params)
+          task_id = URI(headers['Location']).path.gsub('/api/task/', '')
+          task_id
+        end
+
+        ##
+        # Set memory and number of cpus in virtualHardwareSection of a given vm
+        # returns task_id or nil if there is no task to wait for
+        def set_vm_hardware(vm_id, cfg)
+          params = {
+            'method'  => :get,
+            'command' => "/vApp/vm-#{vm_id}/virtualHardwareSection"
+          }
+
+          changed = false
+          response, _headers = send_request(params)
+
+          response.css('ovf|Item').each do |item|
+            type = item.css('rasd|ResourceType').first
+            if type.content == '3'
+              # cpus
+              if cfg.cpus
+                if item.at_css('rasd|VirtualQuantity').content != cfg.cpus.to_s
+                  item.at_css('rasd|VirtualQuantity').content = cfg.cpus
+                  item.at_css('rasd|ElementName').content = "#{cfg.cpus} virtual CPU(s)"
+                  changed = true
+                end
+              end
+            elsif type.content == '4'
+              # memory
+              if cfg.memory
+                if item.at_css('rasd|VirtualQuantity').content != cfg.memory.to_s
+                  item.at_css('rasd|VirtualQuantity').content = cfg.memory
+                  item.at_css('rasd|ElementName').content = "#{cfg.memory} MB of memory"
+                  changed = true
+                end
+              end
+            end 
+          end
+
+          if changed
+            params = {
+              'method'  => :put,
+              'command' => "/vApp/vm-#{vm_id}/virtualHardwareSection"
+            }
+
+            _response, headers = send_request(
+              params,
+              response.to_xml,
+              'application/vnd.vmware.vcloud.virtualhardwaresection+xml'
+            )
+
+            task_id = URI(headers['Location']).path.gsub('/api/task/', '')
+            task_id
+          else
+            return nil
+          end
+        end
+
+
+        ##
+        # Fetch details about a given VM
+        def get_vm(vm_id)
+          params = {
+            'method'  => :get,
+            'command' => "/vApp/vm-#{vm_id}"
+          }
+
+          response, _headers = send_request(params)
+
+          os_desc = response.css(
+            'ovf|OperatingSystemSection ovf|Description'
+          ).first.text
+
+          networks = {}
+          response.css('NetworkConnection').each do |network|
+            ip = network.css('IpAddress').first
+            ip = ip.text if ip
+
+            networks[network['network']] = {
+              :index              => network.css(
+                                     'NetworkConnectionIndex'
+                                     ).first.text,
+              :ip                 => ip,
+              :is_connected       => network.css(
+                                     'IsConnected'
+                                     ).first.text,
+              :mac_address        => network.css(
+                                     'MACAddress'
+                                     ).first.text,
+              :ip_allocation_mode => network.css(
+                                     'IpAddressAllocationMode'
+                                     ).first.text
+            }
+          end
+
+          admin_password = response.css(
+            'GuestCustomizationSection AdminPassword'
+          ).first
+          admin_password = admin_password.text if admin_password
+
+          # make the lines shorter by adjusting the nokogiri css namespace
+          guest_css = response.css('GuestCustomizationSection')
+          guest_customizations = {
+            :enabled                => guest_css.css('Enabled').first.text,
+            :admin_passwd_enabled   => guest_css.css(
+                                       'AdminPasswordEnabled'
+                                       ).first.text,
+            :admin_passwd_auto      => guest_css.css(
+                                       'AdminPasswordAuto'
+                                       ).first.text,
+            :admin_passwd           => admin_password,
+            :reset_passwd_required  => guest_css.css(
+                                       'ResetPasswordRequired'
+                                       ).first.text,
+            :computer_name          => guest_css.css('ComputerName').first.text
+          }
+
+          {
+            :os_desc              => os_desc,
+            :networks             => networks,
+            :guest_customizations => guest_customizations
+          }
+        end
+      end # Class Version 5.1
+    end # Module Driver
+  end # module VCloudAir
+end # Module VagrantPlugins