fog-vcloud-director 0.1.0

data/Rakefile

@@ -0,0 +1,19 @@
+require "rubygems"
+require "bundler/setup"
+
+# Immediately sync all stdout so that tools like buildbot can
+# immediately load in the output.
+$stdout.sync = true
+$stderr.sync = true
+
+# Load all the rake tasks from the "tasks" folder. This folder
+# allows us to nicely separate rake tasks into individual files
+# based on their role, which makes development and debugging easier
+# than one monolithic file.
+task_dir = File.expand_path("../tasks", __FILE__)
+Dir["#{task_dir}/**/*.rake"].each do |task_file|
+  load task_file
+end
+
+desc "Default Task"
+task :default => "test:travis"

data/fog-vcloud-director.gemspec

@@ -0,0 +1,31 @@
+# coding: utf-8
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "fog/vcloud_director/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "fog-vcloud-director"
+  spec.version       = Fog::VcloudDirector::VERSION
+  spec.authors       = ["Luka Zakrajšek"]
+  spec.email         = ["luka@bancek.net"]
+  spec.summary       = "Module for the 'fog' gem to support vCloud Director."
+  spec.description   = 'This library can be used as a module for `fog` or as standalone provider
+                        to use the vCloud Director in applications.'
+  spec.homepage      = "https://github.com/xlab-si/fog-vcloud-director"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.required_ruby_version = "~> 2.0"
+
+  spec.add_dependency "fog-core"
+  spec.add_dependency "fog-xml"
+
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "shindo"
+  spec.add_development_dependency "minitest"
+  spec.add_development_dependency "vcr"
+  spec.add_development_dependency "rubocop"
+end

data/lib/fog/vcloud_director.rb

@@ -0,0 +1 @@
+require 'fog/vcloud_director/compute'

data/lib/fog/vcloud_director/compute.rb

@@ -0,0 +1,916 @@
+require 'fog/vcloud_director/core'
+require 'fog/vcloud_director/query'
+
+class VcloudDirectorParser < Fog::Parsers::Base
+  def extract_attributes(attributes_xml)
+    attributes = {}
+    until attributes_xml.empty?
+      if attributes_xml.first.is_a?(Array)
+        until attributes_xml.first.empty?
+          attribute = attributes_xml.first.shift
+          attributes[attribute.localname.to_sym] = attribute.value
+        end
+      else
+        attribute = attributes_xml.shift
+        attributes[attribute.localname.to_sym] = attribute.value
+      end
+    end
+    attributes
+  end
+end
+
+class NonLoaded
+end
+
+module Fog
+  module Compute
+    class VcloudDirector < Fog::Service
+      module Defaults
+        PATH        = '/api'
+        PORT        = 443
+        SCHEME      = 'https'
+        API_VERSION = '5.1'
+        OMIT_DEFAULT_PORT = true
+      end
+
+      class ServiceError < Fog::VcloudDirector::Errors::ServiceError; end
+
+      class BadRequest < Fog::VcloudDirector::Errors::BadRequest; end
+      class Unauthorized < Fog::VcloudDirector::Errors::Unauthorized; end
+      class Forbidden < Fog::VcloudDirector::Errors::Forbidden; end
+      class Conflict < Fog::VcloudDirector::Errors::Conflict; end
+      class MalformedResponse < Fog::VcloudDirector::Errors::MalformedResponse; end
+
+      class DuplicateName < Fog::VcloudDirector::Errors::DuplicateName; end
+      class TaskError < Fog::VcloudDirector::Errors::TaskError; end
+
+      requires :vcloud_director_username, :vcloud_director_password, :vcloud_director_host
+      recognizes :vcloud_director_api_version, :vcloud_director_show_progress, :path, :vcloud_token
+
+      secrets :vcloud_director_password
+
+      model_path 'fog/vcloud_director/models/compute'
+      model      :catalog
+      collection :catalogs
+      model      :organization
+      collection :organizations
+      model      :catalog_item
+      collection :vapp_templates
+      model      :vapp_template
+      collection :template_vms
+      model      :template_vm
+      collection :catalog_items
+      model      :custom_field
+      collection :custom_fields
+      model      :vdc
+      collection :vdcs
+      model      :vapp
+      collection :vapps
+      model      :task
+      collection :tasks
+      model      :vm
+      collection :vms
+      model      :vm_customization
+      collection :vm_customizations
+      model      :network
+      collection :networks
+      model      :disk
+      collection :disks
+      model      :vm_network
+      collection :vm_networks
+      model      :tag # this is called metadata in vcloud
+      collection :tags
+      model      :media
+      collection :medias # sic
+
+      request_path 'fog/vcloud_director/requests/compute'
+      request :delete_catalog_item
+      request :delete_catalog_item_metadata_item_metadata
+      request :delete_disk
+      request :delete_disk_metadata_item_metadata
+      request :delete_logout
+      request :delete_media
+      request :delete_media_metadata_item_metadata
+      request :delete_network
+      request :delete_shadow_vm
+      request :delete_vapp
+      request :delete_vapp_metadata_item_metadata
+      request :delete_vapp_template
+      request :delete_vapp_template_metadata_item_metadata
+      request :get_allocated_ip_addresses
+      request :get_catalog
+      request :get_catalog_item
+      request :get_catalog_item_metadata
+      request :get_catalog_item_metadata_item_metadata
+      request :get_catalog_metadata
+      request :get_catalog_metadata_item_metadata
+      request :get_catalogs_from_query
+      request :get_control_access_params_catalog
+      request :get_control_access_params_vapp
+      request :get_cpu_rasd_item
+      request :get_current_session
+      request :get_disk
+      request :get_disk_metadata
+      request :get_disk_metadata_item_metadata
+      request :get_disk_owner
+      request :get_disks_from_query
+      request :get_disks_rasd_items_list
+      request :get_edge_gateway
+      request :get_entity
+      request :get_execute_query
+      request :get_groups_from_query
+      request :get_guest_customization_system_section_vapp
+      request :get_guest_customization_system_section_vapp_template
+      request :get_href # this is used for manual testing
+      request :get_lease_settings_section_vapp
+      request :get_lease_settings_section_vapp_template
+      request :get_media
+      request :get_media_drives_rasd_items_list
+      request :get_media_metadata
+      request :get_media_metadata_item_metadata
+      request :get_media_owner
+      request :get_medias_from_query
+      request :get_memory_rasd_item
+      request :get_metadata
+      request :get_network
+      request :get_network_cards_items_list
+      request :get_network_complete
+      request :get_network_config_section_vapp
+      request :get_network_config_section_vapp_template
+      request :get_network_connection_system_section_vapp
+      request :get_network_connection_system_section_vapp_template
+      request :get_network_metadata
+      request :get_network_metadata_item_metadata
+      request :get_network_section_vapp
+      request :get_network_section_vapp_template
+      request :get_operating_system_section
+      request :get_org_settings
+      request :get_org_vdc_gateways
+      request :get_organization
+      request :get_organization_metadata
+      request :get_organization_metadata_item_metadata
+      request :get_organizations
+      request :get_organizations_from_query
+      request :get_product_sections_vapp
+      request :get_product_sections_vapp_template
+      request :get_request # this is used for manual testing
+      request :get_runtime_info_section_type
+      request :get_serial_ports_items_list
+      request :get_shadow_vm
+      request :get_snapshot_section
+      request :get_startup_section
+      request :get_supported_systems_info
+      request :get_supported_versions
+      request :get_task
+      request :get_task_list
+      request :get_template_vm
+      request :get_template_vms
+      request :get_thumbnail
+      request :get_users_from_query
+      request :get_vapp
+      request :get_vapp_metadata
+      request :get_vapp_metadata_item_metadata
+      request :get_vapp_ovf_descriptor
+      request :get_vapp_owner
+      request :get_vapp_template
+      request :get_vapp_template_customization_system_section
+      request :get_vapp_template_metadata
+      request :get_vapp_template_metadata_item_metadata
+      request :get_vapp_template_ovf_descriptor
+      request :get_vapp_template_owner
+      request :get_vapp_templates_from_query
+      request :get_vapps_in_lease_from_query
+      request :get_vcloud
+      request :get_vdc
+      request :get_vdc_metadata
+      request :get_vdc_metadata_item_metadata
+      request :get_vdc_storage_class
+      request :get_vdc_storage_class_metadata
+      request :get_vdc_storage_class_metadata_item_metadata
+      request :get_vdcs_from_query
+      request :get_virtual_hardware_section
+      request :get_vm
+      request :get_vm_capabilities
+      request :get_vm_compliance_results
+      request :get_vm_customization
+      request :get_vm_disks
+      request :get_vm_network
+      request :get_vm_pending_question
+      request :get_vms
+      request :get_vms_by_metadata
+      request :get_vms_disk_attached_to
+      request :get_vms_in_lease_from_query
+      request :instantiate_vapp_template # to be deprecated
+      request :post_acquire_ticket
+      request :post_answer_vm_pending_question
+      request :post_attach_disk
+      request :post_cancel_task
+      request :post_capture_vapp
+      request :post_check_vm_compliance
+      request :post_clone_media
+      request :post_clone_vapp
+      request :post_clone_vapp_template
+      request :post_configure_edge_gateway_services
+      request :post_consolidate_vm_vapp
+      request :post_consolidate_vm_vapp_template
+      request :post_create_catalog_item
+      request :post_create_org_vdc_network
+      request :post_deploy_vapp
+      request :post_compose_vapp
+      request :post_recompose_vapp
+      request :post_detach_disk
+      request :post_disable_nested_hv
+      request :post_disable_vapp_template_download
+      request :post_discard_vapp_state
+      request :post_eject_cd_rom
+      request :post_enable_nested_hv
+      request :post_enable_vapp_template_download
+      request :post_enter_maintenance_mode
+      request :post_exit_maintenance_mode
+      request :post_insert_cd_rom
+      request :post_install_vmware_tools
+      request :post_instantiate_vapp_template
+      request :post_login_session
+      request :post_power_off_vapp
+      request :post_power_on_vapp
+      request :post_reboot_vapp
+      request :post_reconfigure_vm
+      request :post_remove_all_snapshots
+      request :post_reset_vapp
+      request :post_revert_snapshot
+      request :post_shutdown_vapp
+      request :post_suspend_vapp
+      request :post_undeploy_vapp
+      request :post_update_catalog_item_metadata
+      request :post_update_disk_metadata
+      request :post_update_media_metadata
+      request :post_update_vapp_metadata
+      request :post_update_vapp_template_metadata
+      request :post_upgrade_hw_version
+      request :post_upload_disk
+      request :post_upload_media
+      request :post_upload_vapp_template
+      request :post_create_snapshot
+      request :put_catalog_item_metadata_item_metadata
+      request :put_cpu
+      request :put_disk_metadata_item_metadata
+      request :put_disks
+      request :put_guest_customization_section_vapp
+      request :put_media_metadata_item_metadata
+      request :put_memory
+      request :put_metadata_value # deprecated
+      request :put_network
+      request :put_network_connection_system_section_vapp
+      request :put_product_sections
+      request :put_vapp_metadata_item_metadata
+      request :put_vapp_name_and_description
+      request :put_vapp_template_metadata_item_metadata
+      request :put_vm
+      request :put_vm_capabilities
+
+      class Model < Fog::Model
+        def initialize(attrs={})
+          super(attrs)
+          lazy_load_attrs.each do |attr|
+            attributes[attr]= NonLoaded if attributes[attr].nil?
+            make_lazy_load_method(attr)
+          end
+          self.class.attributes.each {|attr| make_attr_loaded_method(attr)}
+        end
+
+        def lazy_load_attrs
+          @lazy_load_attrs ||= self.class.attributes - attributes.keys
+        end
+
+        def make_lazy_load_method(attr)
+          self.class.instance_eval do
+            define_method(attr) do
+              reload if attributes[attr] == NonLoaded and !@inspecting
+              attributes[attr]
+            end
+          end
+        end
+
+        # it adds an attr_loaded? method to know if the value has been loaded
+        # yet or not: ie description_loaded?
+        def make_attr_loaded_method(attr)
+          self.class.instance_eval do
+            define_method("#{attr}_loaded?") do
+              attributes[attr] != NonLoaded
+            end
+          end
+        end
+
+        def inspect
+          @inspecting = true
+          out = super
+          @inspecting = false
+          out
+        end
+      end
+
+      class Collection < Fog::Collection
+        def all(lazy_load=true)
+          lazy_load ? index : get_everyone
+        end
+
+        def get(item_id)
+          item = get_by_id(item_id)
+          return nil unless item
+          new(item)
+        end
+
+        def get_by_name(item_name)
+          item_found = item_list.find {|item| item[:name] == item_name}
+          return nil unless item_found
+          get(item_found[:id])
+        end
+
+        def index
+          load(item_list)
+        end
+
+        def get_everyone
+          items = item_list.map {|item| get_by_id(item[:id])}
+          load(items)
+        end
+      end
+
+      class Real
+        extend Fog::Deprecation
+        deprecate :auth_token, :vcloud_token
+
+        attr_reader :end_point, :api_version, :show_progress
+        alias_method :show_progress?, :show_progress
+
+        def initialize(options={})
+          @vcloud_director_password = options[:vcloud_director_password]
+          @vcloud_director_username = options[:vcloud_director_username]
+          @connection_options = options[:connection_options] || {}
+          @connection_options[:omit_default_port] = Fog::Compute::VcloudDirector::Defaults::OMIT_DEFAULT_PORT unless @connection_options[:omit_default_port]
+          @host       = options[:vcloud_director_host]
+          @path       = options[:path]        || Fog::Compute::VcloudDirector::Defaults::PATH
+          @persistent = options[:persistent]  || false
+          @port       = options[:port]        || Fog::Compute::VcloudDirector::Defaults::PORT
+          @scheme     = options[:scheme]      || Fog::Compute::VcloudDirector::Defaults::SCHEME
+          @connection = Fog::XML::Connection.new("#{@scheme}://#{@host}:#{@port}", @persistent, @connection_options)
+          @end_point = "#{@scheme}://#{@host}#{@path}/"
+          @api_version = options[:vcloud_director_api_version] || Fog::Compute::VcloudDirector::Defaults::API_VERSION
+          @show_progress = options[:vcloud_director_show_progress]
+          @show_progress = $stdin.tty? if @show_progress.nil?
+          @vcloud_token  = options[:vcloud_token]
+        end
+
+        def vcloud_token
+          login if @vcloud_token.nil?
+          @vcloud_token
+        end
+
+        def org_name
+          login if @org_name.nil?
+          @org_name
+        end
+
+        def user_name
+          login if @user_name.nil?
+          @user_name
+        end
+
+        def reload
+          @connection.reset
+        end
+
+        def request(params)
+          begin
+            do_request(params)
+          rescue EOFError
+            # This error can occur if Vcloud receives a request from a network
+            # it deems to be unauthorized; no HTTP response is sent, but the
+            # connection is sent a signal to terminate early.
+            raise(
+              MalformedResponse, "Connection unexpectedly terminated by vcloud"
+            )
+          # this is to know if Excon::Errors::Unauthorized really happens
+          #rescue Excon::Errors::Unauthorized
+          #  login
+          #  do_request(params)
+          end
+        end
+
+        # @api private
+        def do_request(params)
+          headers = {
+            'Accept' => "application/*+xml;version=#{@api_version}",
+            'x-vcloud-authorization' => vcloud_token
+          }
+          if params[:path]
+            if params[:override_path] == true
+              path = params[:path]
+            else
+              path = "#{@path}/#{params[:path]}"
+            end
+          else
+            path = "#{@path}"
+          end
+          @connection.request({
+            :body       => params[:body],
+            :expects    => params[:expects],
+            :headers    => headers.merge!(params[:headers] || {}),
+            :idempotent => params[:idempotent],
+            :method     => params[:method],
+            :parser     => params[:parser],
+            :path       => path,
+            :query      => params[:query]
+          })
+        rescue Excon::Errors::HTTPStatusError => error
+          raise case error
+          when Excon::Errors::BadRequest   then BadRequest.slurp(error);
+          when Excon::Errors::Unauthorized then Unauthorized.slurp(error);
+          when Excon::Errors::Forbidden    then Forbidden.slurp(error);
+          when Excon::Errors::Conflict     then Conflict.slurp(error);
+          else                                  ServiceError.slurp(error)
+          end
+        end
+
+        def process_task(response_body)
+          task = make_task_object(response_body)
+          wait_and_raise_unless_success(task)
+          true
+        end
+
+        def make_task_object(task_response)
+          task_response[:id] = task_response[:href].split('/').last
+          tasks.new(task_response)
+        end
+
+        def wait_and_raise_unless_success(task)
+          task.wait_for { non_running? }
+          raise TaskError.new "status: #{task.status}, error: #{task.error}" unless task.success?
+        end
+
+        def add_id_from_href!(data={})
+          data[:id] = data[:href].split('/').last
+        end
+
+        # Compensate for Fog::ToHashDocument shortcomings.
+        # @api private
+        # @param [Hash] hash
+        # @param [String,Symbol] key1
+        # @param [String,Symbol] key2
+        # @return [Hash]
+        def ensure_list!(hash, key1, key2=nil)
+          if key2.nil?
+            hash[key1] ||= []
+            hash[key1] = [hash[key1]] if hash[key1].is_a?(Hash)
+          else
+            hash[key1] ||= {key2 => []}
+            hash[key1] = {key2 => []} if hash[key1].empty?
+            hash[key1][key2] = [hash[key1][key2]] if hash[key1][key2].is_a?(Hash)
+          end
+          hash
+        end
+
+        private
+
+        def login
+          @vcloud_token ||= ENV['FOG_VCLOUD_TOKEN']
+          if @vcloud_token
+            response = get_current_session
+            session_org = response.body[:org]
+            session_user = response.body[:user]
+
+            check_session_matches_credentials(session_org, session_user)
+          else
+            response = post_login_session
+            x_vcloud_authorization = response.headers.keys.find do |key|
+              key.downcase == 'x-vcloud-authorization'
+            end
+            @vcloud_token = response.headers[x_vcloud_authorization]
+          end
+
+          @org_name = response.body[:org]
+          @user_name = response.body[:user]
+        end
+
+        # @note This isn't needed.
+        def logout
+          delete_logout
+          @vcloud_token = nil
+          @org_name = nil
+        end
+
+        def check_session_matches_credentials(session_org, session_user)
+          fog_credential_org = @vcloud_director_username.split('@').last
+          fog_credential_user = @vcloud_director_username.split('@')[0...-1].join('@')
+
+          if session_org != fog_credential_org
+            raise Fog::Errors::Error.new "FOG_CREDENTIAL specified is for vCloud organisation '#{fog_credential_org}' but " +
+              "your current session is for '#{session_org}'. You should generate a new FOG_VCLOUD_TOKEN."
+          end
+
+          if session_user != fog_credential_user
+            raise Fog::Errors::Error.new "FOG_CREDENTIAL specified is for user '#{fog_credential_user}' but " +
+              "your current session is for '#{session_user}'. You should generate a new FOG_VCLOUD_TOKEN."
+          end
+        end
+      end
+
+      class Mock
+        attr_reader :end_point, :api_version
+
+        # This is used in some mocks so it's a method rather than a variable
+        def default_network_uuid
+          @default_network_uuid ||= uuid
+        end
+
+        def data
+          @@data ||= Hash.new do |hash, key|
+
+            vdc1_uuid = uuid
+            vdc2_uuid = uuid
+            uplink_network_uuid  = uuid
+            isolated_vdc1_network_uuid = uuid
+            isolated_vdc2_network_uuid = uuid
+            vapp1_id = "vapp-#{uuid}"
+            vapp2_id = "vapp-#{uuid}"
+            vapp1vm1_id = "vm-#{uuid}"
+            vapp2vm1_id = "vm-#{uuid}"
+            vapp2vm2_id = "vm-#{uuid}"
+            catalog_uuid = uuid
+            template_uuid = uuid
+
+            hash[key] = {
+              :catalogs => {
+                catalog_uuid => {
+                  :name => 'Default Catalog'
+                }
+              },
+              :catalog_items => {
+                uuid => {
+                  :type    => 'vAppTemplate',
+                  :name    => 'vAppTemplate 1',
+                  :catalog => catalog_uuid,
+                  :template_id => template_uuid
+                }
+              },
+              :disks => {
+                uuid => {
+                  :name => 'Hard Disk 1',
+                  :capacity => 10240,
+                  :parent_vm => vapp1vm1_id
+                }
+              },
+              :edge_gateways => {
+                uuid => {
+                  :name => 'MockEdgeGateway',
+                  :networks => [uplink_network_uuid, default_network_uuid],
+                  :vdc => vdc1_uuid,
+                  :Configuration => {
+                    :GatewayBackingConfig => "compact",
+                    :GatewayInterfaces => {
+                      :GatewayInterface => []},
+                    :EdgeGatewayServiceConfiguration => {
+                      :FirewallService => {
+                        :IsEnabled => "true",
+                        :DefaultAction => "drop",
+                        :LogDefaultAction => "false",
+                        :FirewallRule => []
+                      },
+                      :NatService => {:IsEnabled => "true"}},
+                    :HaEnabled => "false",
+                    :UseDefaultRouteForDnsRelay => "false"
+                  }
+                }
+              },
+
+              :medias => {},
+
+              :networks => {
+
+                default_network_uuid => {
+                  :IsShared => true,
+                  :vdc => vdc1_uuid,
+                  :FenceMode => 'natRouted',
+                  :ApplyRateLimit => "false",
+                  :Description => 'Org Network for mocking',
+                  :Dns1 => '8.8.8.8',
+                  :Dns2 => '8.8.4.4',
+                  :DnsSuffix => 'example.com',
+                  :Gateway => '192.168.1.1',
+                  :InterfaceType => "internal",
+                  :IpRanges => [{
+                    :StartAddress=>'192.168.1.2',
+                    :EndAddress=>'192.168.1.254'
+                  }],
+                  :IsInherited => false,
+                  :Netmask => '255.255.255.0',
+                  :name => 'vDC1 Default Network',
+                  :SubnetParticipation => {
+                      :Gateway => "192.168.1.0",
+                      :Netmask => "255.255.0.0",
+                      :IpAddress => "192.168.1.0"
+                  },
+                  :UseForDefaultRoute => "false"
+                },
+
+                isolated_vdc1_network_uuid => {
+                  :IsShared => false,
+                  :vdc => vdc1_uuid,
+                  :ApplyRateLimit => "false",
+                  :FenceMode => 'isolated',
+                  :Description => 'Org Network for mocking',
+                  :Dns1 => '8.8.8.8',
+                  :Dns2 => '8.8.4.4',
+                  :DnsSuffix => 'example.com',
+                  :InterfaceType => "internal",
+                  :IpRanges => [{
+                    :StartAddress=>'10.1.0.100',
+                    :EndAddress=>'10.1.0.200'
+                  }],
+                  :IsInherited => false,
+                  :Netmask => '255.255.255.0',
+                  :name => 'vDC1 backend network',
+                  :SubnetParticipation => {
+                      :Gateway => "192.168.1.0",
+                      :Netmask => "255.255.0.0",
+                      :IpAddress => "192.168.1.0"
+                  },
+                  :UseForDefaultRoute => "false"
+                },
+
+                isolated_vdc2_network_uuid => {
+                  :IsShared => false,
+                  :vdc => vdc2_uuid,
+                  :ApplyRateLimit => "false",
+                  :Description => 'Org Network for mocking',
+                  :Dns1 => '8.8.8.8',
+                  :Dns2 => '8.8.4.4',
+                  :DnsSuffix => 'example.com',
+                  :InterfaceType => "internal",
+                  :IpRanges => [{
+                    :StartAddress=>'10.2.0.100',
+                    :EndAddress=>'10.2.0.200'
+                  }],
+                  :IsInherited => false,
+                  :Netmask => '255.255.255.0',
+                  :name => 'vDC2 backend network',
+                  :SubnetParticipation => {
+                      :Gateway => "192.168.1.0",
+                      :Netmask => "255.255.0.0",
+                      :IpAddress => "192.168.1.0"
+                  },
+                  :UseForDefaultRoute => "false"
+                },
+
+                uplink_network_uuid => {
+                  :IsShared => false,
+                  :vdc => vdc1_uuid,
+                  :ApplyRateLimit => "false",
+                  :FenceMode => 'bridged',
+                  :Description => 'Uplink Network for mocking',
+                  :Dns1 => '8.8.8.8',
+                  :Dns2 => '8.8.4.4',
+                  :DnsSuffix => 'example.com',
+                  :Gateway => '198.51.100.1',
+                  :InterfaceType => "uplink",
+                  :IpRanges => [{
+                    :StartAddress=>'198.51.100.2',
+                    :EndAddress=>'198.51.100.254'
+                  }],
+                  :IsInherited => false,
+                  :Netmask => '255.255.255.0',
+                  :name => 'uplink Network',
+                  :SubnetParticipation => {
+                    :Gateway => "198.51.100.81",
+                    :Netmask => "255.255.255.248",
+                    :IpAddress => "198.51.100.83",
+                    :IpRanges => {
+                      :IpRange => {
+                        :StartAddress => "198.51.100.84",
+                        :EndAddress => "198.51.100.86"
+                      }
+                    }
+                  },
+                  :UseForDefaultRoute => "true"
+                }
+
+              },
+              :org => {
+                :description => 'Organization for mocking',
+                :full_name => 'Mock Organization',
+                :name => org_name,
+                :uuid => uuid
+              },
+              
+              :tags => {},
+              
+              :tasks => {},
+
+              :vapps => {
+                vapp1_id => {
+                  :name => 'mock-vapp-1',
+                  :vdc_id => vdc1_uuid,
+                  :description => "Mock vApp 1",
+                  :networks => [
+                    { :parent_id => default_network_uuid, },
+                  ],
+                },
+                vapp2_id => {
+                  :name => 'mock-vapp-2',
+                  :vdc_id => vdc2_uuid,
+                  :description => "Mock vApp 2",
+                  :networks => [
+                    { :parent_id => default_network_uuid },
+                  ]
+                },
+              },
+
+              :vdc_storage_classes => {
+                uuid => {
+                  :default => true,
+                  :enabled => true,
+                  :limit => 2 * 1024 * 1024,
+                  :name => 'DefaultMockStorageClass',
+                  :units => 'MB',
+                  :vdc => vdc1_uuid,
+                }
+              },
+
+              :vdcs => {
+                vdc1_uuid => {
+                  :description => 'vDC1 for mocking',
+                  :name => 'MockVDC 1'
+                },
+                vdc2_uuid => {
+                  :description => 'vDC2 for mocking',
+                  :name => 'MockVDC 2'
+                },
+              },
+
+              :vms => {
+                vapp1vm1_id => {
+                  :name => 'mock-vm-1-1',
+                  :parent_vapp => vapp1_id,
+                  :nics => [
+                    {
+                      :network_name => 'Default Network',
+                      :mac_address => "00:50:56:aa:bb:01",
+                      :ip_address => "192.168.1.33",
+                    },
+                  ],
+                },
+                vapp2vm1_id => {
+                  :name => 'mock-vm-2-1',
+                  :parent_vapp => vapp2_id,
+                  :nics => [
+                    {
+                      :network_name => 'Default Network',
+                      :mac_address => "00:50:56:aa:bb:02",
+                      :ip_address => "192.168.1.34",
+                    },
+                  ],
+                },
+                vapp2vm2_id => {
+                  :name => 'mock-vm-2-2',
+                  :parent_vapp => vapp2_id,
+                  :nics => [
+                    {
+                      :network_name => 'Default Network',
+                      :mac_address => "00:50:56:aa:bb:03",
+                      :ip_address => "192.168.1.35",
+                    },
+                  ],
+                },
+              },
+
+            }
+          end[@vcloud_director_username]
+        end
+
+        def initialize(options={})
+          @vcloud_director_password = options[:vcloud_director_password]
+          @vcloud_director_username = options[:vcloud_director_username]
+          #@connection_options = options[:connection_options] || {}
+          @host = options[:vcloud_director_host]
+          @path = options[:path] || Fog::Compute::VcloudDirector::Defaults::PATH
+          @persistent = options[:persistent] || false
+          @port = options[:port] || Fog::Compute::VcloudDirector::Defaults::PORT
+          @scheme = options[:scheme] || Fog::Compute::VcloudDirector::Defaults::SCHEME
+          #@connection = Fog::XML::Connection.new("#{@scheme}://#{@host}:#{@port}", @persistent, @connection_options)
+          @end_point    = "#{@scheme}://#{@host}#{@path}/"
+          @api_version  = options[:vcloud_director_api_version] || Fog::Compute::VcloudDirector::Defaults::API_VERSION
+          @vcloud_token = options[:vcloud_token]
+        end
+
+        def vcloud_token
+          @vcloud_token || Fog::Mock.random_base64(32)
+        end
+
+        def org_name
+          @org_name ||=
+            begin
+              username = @vcloud_director_username.split('@')
+              if username.size >= 2 # may be 'email_address@org_name'
+                username.last
+              else
+                Fog::Logger.warning('vcloud_director_username should be in the form user@org_name')
+                'vcd_org_name'
+              end
+            end
+        end
+
+        def user_name
+          @user_name ||= @vcloud_director_username.split('@').first
+        end
+
+        def user_uuid
+          @user_uuid ||= uuid
+        end
+
+        def uuid
+          [8,4,4,4,12].map {|i| Fog::Mock.random_hex(i)}.join('-')
+        end
+
+        # Create a task.
+        #
+        # @param [String] operation A message describing the operation that is
+        #   tracked by this task.
+        # @param [String] operation_name The short name of the operation that
+        #   is tracked by this task.
+        # @param [Hash] owner Reference to the owner of the task. This is
+        #   typically the object that the task is creating or updating.
+        #   * :href<~String> - Contains the URI to the entity.
+        #   * :type<~String> - Contains the MIME type of the entity.
+        # @return [String] Object identifier of the task.
+        def enqueue_task(operation, operation_name, owner, options={})
+          task_id = uuid
+          now = DateTime.now
+
+          data[:tasks][task_id] = {
+            :cancel_requested => false,
+            :details => '',
+            :expiry_time => now + 86400, # in 24 hours
+            :name => 'task',
+            :progress => 1,
+            :service_namespace => 'com.vmware.vcloud',
+            :start_time => now,
+            :end_time => now + 86400,
+            :status => 'running',
+          }.merge(options).merge(
+            :operation => operation,
+            :operation_name => operation_name,
+            :owner => owner
+          )
+
+          task_id
+        end
+
+        # @note As far as this method is concerned, the only possible task
+        #   states are 'running' and 'success'.
+        #
+        # @param [Hash] response_body
+        # @return [Boolean]
+        def process_task(response_body)
+          task_id = response_body[:href].split('/').last
+          task = data[:tasks][task_id]
+
+          if task[:status] == 'running'
+            task[:end_time] = DateTime.now
+            task[:progress] = 100
+            task[:status] = 'success'
+
+            if task[:on_success]
+              task[:on_success].call
+              task.delete(:on_success)
+            end
+          end
+
+          return true if task[:status] == 'success'
+          raise TaskError.new "status: #{task[:status]}, error: #{task[:Error]}"
+        end
+
+        def add_id_from_href!(data={})
+          data[:id] = data[:href].split('/').last
+        end
+
+        private
+
+        def make_href(path)
+          "#{@end_point}#{path}"
+        end
+
+        def xmlns
+          'http://www.vmware.com/vcloud/v1.5'
+        end
+
+        def xmlns_xsi
+          'http://www.w3.org/2001/XMLSchema-instance'
+        end
+
+        def xsi_schema_location
+          "http://www.vmware.com/vcloud/v1.5 http://#{@host}#{@path}/v1.5/schema/master.xsd"
+        end
+      end
+    end
+  end
+end