fog-vcloud-director 0.1.0

data/tests/vcloud_director/requests/compute/ovf_descriptor_tests.rb

@@ -0,0 +1,36 @@
+Shindo.tests('Compute::VcloudDirector | ovf requests', ['vclouddirector']) do
+
+  @service = Fog::Compute::VcloudDirector.new
+  @org = VcloudDirector::Compute::Helper.current_org(@service)
+
+  tests('Get first vDC') do
+    session = @service.get_current_session.body
+    link = @org[:Link].find do |l|
+      l[:type] == 'application/vnd.vmware.vcloud.vdc+xml'
+    end
+    @vdc = @service.get_vdc(link[:href].split('/').last).body
+  end
+
+  # 'Envelope' is the outer type of the parsed XML document.
+  tests('#get_vapp_ovf_descriptor').returns('Envelope') do
+    pending if Fog.mocking?
+    link = @vdc[:ResourceEntities][:ResourceEntity].find do |l|
+      l[:type] == 'application/vnd.vmware.vcloud.vApp+xml'
+    end
+    pending if link.nil?
+    body = @service.get_vapp_ovf_descriptor(link[:href].split('/').last).body
+    Nokogiri::XML::Document.parse(body).children.first.name
+  end
+
+  # 'Envelope' is the outer type of the parsed XML document.
+  tests('#get_vapp_template_ovf_descriptor').returns('Envelope') do
+    pending if Fog.mocking?
+    link = @vdc[:ResourceEntities][:ResourceEntity].find do |l|
+      l[:type] == 'application/vnd.vmware.vcloud.vAppTemplate+xml'
+    end
+    pending if link.nil?
+    body = @service.get_vapp_template_ovf_descriptor(link[:href].split('/').last).body
+    Nokogiri::XML::Document.parse(body).children.first.name
+  end
+
+end

data/tests/vcloud_director/requests/compute/query_tests.rb

@@ -0,0 +1,99 @@
+Shindo.tests('Compute::VcloudDirector | query requests', ['vclouddirector']) do
+
+  @service = Fog::Compute::VcloudDirector.new
+
+  tests('retrieve a summary list of all typed queries types') do
+    tests('#get_execute_query') do
+      @query_list = @service.get_execute_query.body
+      tests(':type').returns('application/vnd.vmware.vcloud.query.queryList+xml') do
+        @query_list[:type]
+      end
+    end
+  end
+
+  # for each queriable type, query and check that each available format
+  # returns a result that matches the base schema
+  #
+  @query_list[:Link].select do |link|
+    link[:rel] == 'down'
+  end.sort_by do |link|
+    [link[:name], link[:href]]
+  end.each do |link|
+
+    href = Nokogiri::XML.fragment(link[:href])
+    query = CGI.parse(URI.parse(href.text).query)
+    type = query['type'].first
+    format = query['format'].first
+    next if %w[right role strandedUser].include?(type)
+    tests("type => #{type}, format => #{format}") do
+
+      pending if Fog.mocking? && (format != 'records' || type != 'orgVdcNetwork')
+
+      tests("#get_execute_query").data_matches_schema(VcloudDirector::Compute::Schema::CONTAINER_TYPE) do
+        @body = @service.get_execute_query(type, :format => format).body
+      end
+      tests("resource type").returns(link[:type]) { @body[:type] }
+
+      unless ( type == 'event' || type == 'edgeGateway' )
+        records_key = @body.keys.find {|key| key.to_s =~ /Record|Reference$/}
+        if records = @body[records_key]
+          records.first do |record|
+            case format
+            when 'records'
+              tests("record is correct schema").data_matches_schema(VcloudDirector::Compute::Schema::REFERENCE_TYPE) do
+                record
+              end
+            end
+          end
+        end
+      end
+
+    end
+  end
+
+  if Fog.mocking?
+    tests('ensure Mock logic is sound') do
+      tests('#get_execute_query') do
+        tests('orgVdcNetwork') do
+          output = @service.get_execute_query('orgVdcNetwork').body
+          tests('all records').returns(@service.data[:networks].size) do
+            output[:OrgVdcNetworkRecords].size
+          end
+          output = @service.get_execute_query('orgVdcNetwork', :filter => 'name==vDC1 backend network').body
+          tests(':filter by name').returns(1) do
+            output[:OrgVdcNetworkRecords].size
+          end
+          tests(':page option is ok if :page == 1').returns(@service.data[:networks].size) do
+            output = @service.get_execute_query('orgVdcNetwork', :page => '1').body
+            output[:OrgVdcNetworkRecords].size
+          end
+          tests('AND expression in :filter raises MockNotImplemented').raises(Fog::Errors::MockNotImplemented) do
+            @service.get_execute_query('orgVdcNetwork', :filter => 'name==Default Network;thing==wibble')
+          end
+          tests('OR expression in :filter raises MockNotImplemented').raises(Fog::Errors::MockNotImplemented) do
+            @service.get_execute_query('orgVdcNetwork', :filter => 'name==Default Network,thing==wibble')
+          end
+          tests('sortAsc option raises MockNotImplemented').raises(Fog::Errors::MockNotImplemented) do
+            @service.get_execute_query('orgVdcNetwork', :sortAsc => 'name')
+          end
+          tests('sortDesc option raises MockNotImplemented').raises(Fog::Errors::MockNotImplemented) do
+            @service.get_execute_query('orgVdcNetwork', :sortDesc => 'name')
+          end
+          tests('page option raises MockNotImplemented').raises(Fog::Errors::MockNotImplemented) do
+            @service.get_execute_query('orgVdcNetwork', :page => '2')
+          end
+          tests('pageSize option raises MockNotImplemented').raises(Fog::Errors::MockNotImplemented) do
+            @service.get_execute_query('orgVdcNetwork', :pageSize => '50')
+          end
+          tests('offset option raises MockNotImplemented').raises(Fog::Errors::MockNotImplemented) do
+            @service.get_execute_query('orgVdcNetwork', :offset => '5')
+          end
+          tests('fields option raises MockNotImplemented').raises(Fog::Errors::MockNotImplemented) do
+            @service.get_execute_query('orgVdcNetwork', :fields => 'name,thing')
+          end
+        end
+      end
+    end
+  end
+
+end

data/tests/vcloud_director/requests/compute/schema_helper.rb

@@ -0,0 +1,663 @@
+class VcloudDirector
+  module Compute
+    module Schema
+      # Mapping of a content media type to a xsd complex type.
+      MEDIA_TYPE_MAPPING_TYPE = {
+        :MediaType => String,
+        :ComplexTypeName => String,
+        :SchemaLocation => String
+      }
+
+      # Information for one version of the API.
+      VERSION_INFO_TYPE = {
+        :Version => String,
+        :LoginUrl => String,
+        :MediaTypeMapping => [MEDIA_TYPE_MAPPING_TYPE]
+      }
+
+      # List all supported versions.
+      SUPPORTED_VERSIONS_TYPE = {
+        :VersionInfo => [VERSION_INFO_TYPE]
+      }
+
+      # The standard error message type used in the vCloud REST API.
+      ERROR_TYPE = {
+        :majorErrorCode => String,
+        :message => String,
+        :minorErrorCode => String,
+        :stackTrace => Fog::Nullable::String,
+        :vendorSpecificErrorCode => Fog::Nullable::String
+      }
+
+      # The base type for all objects in the vCloud model. Has an optional list
+      # of links and href and type attributes.
+      REFERENCE_TYPE = {
+        :href => String,
+        :id => Fog::Nullable::String,
+        :name => Fog::Nullable::String,
+        :type => Fog::Nullable::String
+      }
+
+      # Extends reference type by adding relation attribute. Defines a
+      # hyper-link with a relationship, hyper-link reference, and an optional
+      # MIME type.
+      LINK_TYPE = REFERENCE_TYPE.merge({
+        :rel => String
+      })
+
+      # Represents a reference to a resource. Contains an href attribute, a
+      # resource status attribute, and optional name and type attributes.
+      RESOURCE_REFERENCE_TYPE = REFERENCE_TYPE.merge({
+        :status => Fog::Nullable::String
+      })
+
+      # The base type for all objects in the vCloud model. Has an optional list
+      # of links and href and type attributes.
+      RESOURCE_TYPE = {
+        :href => Fog::Nullable::String,
+        :type => Fog::Nullable::String,
+      # :Link => [LINK_TYPE] -- FIXME: not required
+      }
+
+      # The base type for all resource types which contain an id attribute.
+      IDENTIFIABLE_RESOURCE_TYPE = RESOURCE_TYPE.merge({
+        :id => Fog::Nullable::String,
+        :operationKey => Fog::Nullable::String,
+      })
+
+      # Basic entity type in the vCloud object model. Includes a name, an
+      # optional description, and an optional list of links.
+      ENTITY_TYPE = IDENTIFIABLE_RESOURCE_TYPE.merge({
+        :name => String
+      })
+
+      # Represents a file to be transferred (uploaded or downloaded).
+      FILE_TYPE = ENTITY_TYPE.merge({
+        :bytesTransfered => Fog::Nullable::String,
+        :checksum => Fog::Nullable::String, # normalizedString
+        :size => Fog::Nullable::String
+      })
+
+      # Represents a list of files to be transferred (uploaded or downloaded).
+      FILES_LIST_TYPE = {
+        :File => [FILE_TYPE]
+      }
+
+      # Container for query result sets.
+      CONTAINER_TYPE = RESOURCE_TYPE.merge({
+        :name => String,
+        :page => String,
+        :pageSize => String,
+        :total => String
+      })
+
+      # Represents an asynchronous operation in vCloud Director.
+      TASK_TYPE = ENTITY_TYPE.merge({
+        :cancelRequested => Fog::Nullable::String,
+        :endTime => Fog::Nullable::String,
+        :expiryTime => String,
+        :operation => Fog::Nullable::String,
+        :operationName => Fog::Nullable::String,
+        :serviceNamespace => Fog::Nullable::String,
+        :startTime => Fog::Nullable::String,
+        :status => String,
+      # :Tasks => TASKS_IN_PROGRESS_TYPE, # not happening!
+        :Owner => REFERENCE_TYPE,
+      # :Error => ERROR_TYPE,
+        :User => REFERENCE_TYPE,
+        :Organization => REFERENCE_TYPE,
+        :Progress => Fog::Nullable::String,
+      # :Params => anyType,
+        :Details => Fog::Nullable::String
+      })
+
+      # A list of queued, running, or recently completed tasks.
+      TASKS_IN_PROGRESS_TYPE = {
+        :Task => [TASK_TYPE]
+      }
+
+      # Base type that represents a resource entity such as a vApp template or
+      # virtual media.
+      RESOURCE_ENTITY_TYPE = ENTITY_TYPE.merge({
+        :status => Fog::Nullable::String,
+        :Description => Fog::Nullable::String,
+      # :Tasks => TASKS_IN_PROGRESS_TYPE,
+      #  :Files => FILES_LIST_TYPE
+      })
+
+      # Container for references to ResourceEntity objects in this vDC.
+      RESOURCE_ENTITIES_TYPE = {
+        :ResourceEntity => [RESOURCE_REFERENCE_TYPE]
+      }
+
+      # Represents a supported virtual hardware version.
+      SUPPORTED_HARDWARE_VERSION_TYPE = String
+
+      # Contains a list of VMware virtual hardware versions supported in this
+      # vDC.
+      SUPPORTED_HARDWARE_VERSIONS_TYPE = {
+        :SupportedHardwareVersion => SUPPORTED_HARDWARE_VERSION_TYPE
+      }
+
+      # Represents a base type for VAppType and VmType.
+      ABSTRACT_VAPP_TYPE = RESOURCE_ENTITY_TYPE.merge({
+        :deployed => String,
+        :DateCreated => String
+      })
+
+      VAPP_CHILDREN_TYPE = {
+        #:VApp => ABSTRACT_VAPP_TYPE,
+        :Vm => [ABSTRACT_VAPP_TYPE]
+      }
+
+      # Controls access to the resource.
+      ACCESS_SETTING_TYPE = {
+        :Subject => REFERENCE_TYPE,
+        :AccessLevel => String
+      }
+
+      # A list of access settings for a resource.
+      ACCESS_SETTINGS_TYPE = {
+        :AccessSettingType => [ACCESS_SETTING_TYPE]
+      }
+
+      # Container for references to available organization vDC networks.
+      AVAILABLE_NETWORKS_TYPE = {
+        :Network => [REFERENCE_TYPE]
+      }
+
+      # Collection of supported hardware capabilities.
+      CAPABILITIES_TYPE = {
+        :SupportedHardwareVersions => SUPPORTED_HARDWARE_VERSIONS_TYPE
+      }
+
+      # Represents the capacity of a given resource.
+      CAPACITY_TYPE = {
+        :Units => String,
+        :Allocated => Fog::Nullable::String,
+        :Limit => String
+      }
+
+      # Represents a capacity and usage of a given resource.
+      CAPACITY_WITH_USAGE_TYPE = CAPACITY_TYPE.merge({
+        :Reserved => String,
+        :Used => Fog::Nullable::String,
+        :Overhead => Fog::Nullable::String
+      })
+
+      # Represents vDC compute capacity.
+      COMPUTE_CAPACITY_TYPE = {
+        :Cpu => CAPACITY_WITH_USAGE_TYPE,
+        :Memory => CAPACITY_WITH_USAGE_TYPE
+      }
+
+      # Represents a guest customization settings.
+      GUEST_CUSTOMIZATION_SECTION_TYPE = { # TODO: extends Section_Type
+        :Enabled => Fog::Nullable::String,
+        :ChangeSid => Fog::Nullable::String,
+        :VirtualMachineId => Fog::Nullable::String,
+        :JoinDomainEnabled => Fog::Nullable::String,
+        :UseOrgSettings => Fog::Nullable::String,
+        :DomainName => Fog::Nullable::String,
+        :DomainUserName => Fog::Nullable::String,
+        :DomainUserPassword => Fog::Nullable::String,
+        :MachineObjectOU => Fog::Nullable::String,
+        :AdminPasswordEnabled => Fog::Nullable::String,
+        :AdminPasswordAuto => Fog::Nullable::String,
+        :AdminPassword => Fog::Nullable::String,
+        :ResetPasswordRequired => Fog::Nullable::String,
+        :CustomizationScript => Fog::Nullable::String,
+        :ComputerName => String,
+        :Link => LINK_TYPE
+      }
+
+      # Represents the owner of this entity.
+      OWNER_TYPE = RESOURCE_TYPE.merge({
+        :User => REFERENCE_TYPE
+      })
+
+      # VMware Tools and other runtime information for this virtual machine.
+      RUNTIME_INFO_SECTION_TYPE = { # TODO: extends Section_Type
+        :VMWareTools => {
+          :version => Fog::Nullable::String
+        }
+      }
+
+      # Container for references to storage profiles associated with a vDC.
+      VDC_STORAGE_PROFILES_TYPE = {
+        :VdcStorageProfile => [REFERENCE_TYPE]
+      }
+
+      # Allows you to specify certain capabilities of this virtual machine.
+      VM_CAPABILITIES_TYPE = RESOURCE_TYPE.merge({
+        :MemoryHotAddEnabled => String,
+        :CpuHotAddEnabled => String
+      })
+
+      # Represents the user view of a Catalog object.
+      CATALOG_TYPE = ENTITY_TYPE.merge({
+        #:Owner => OWNER_TYPE,
+        #:CatalogItems => CATALOG_ITEMS_TYPE,
+        :IsPublished => String,
+        :DateCreated => String
+      })
+
+      # Specifies access controls for a resource.
+      CONTROL_ACCESS_PARAMS_TYPE = {
+        :IsSharedToEveryone => String,
+        :EveryoneAccessLevel => Fog::Nullable::String,
+      # :AccessSettings => ACCESS_SETTINGS_TYPE
+      }
+
+      # Represents a Media object.
+      MEDIA_TYPE = RESOURCE_ENTITY_TYPE.merge({
+        :imageType => String,
+        :size => String,
+        :Owner => OWNER_TYPE,
+        :VdcStorageProfile => REFERENCE_TYPE
+      })
+
+      METADATA_TYPE = RESOURCE_TYPE.merge({
+        #:MetadataEntry => METADATA_ENTRY_TYPE
+      })
+
+      # Represents a list of organizations.
+      ORG_LIST_TYPE = RESOURCE_TYPE.merge({
+        :Org => [REFERENCE_TYPE]
+      })
+
+      # Represents the user view of a vCloud Director organization.
+      ORG_TYPE = ENTITY_TYPE.merge({
+        :Description => Fog::Nullable::String,
+        :Tasks => TASKS_IN_PROGRESS_TYPE,
+        :FullName => String,
+        :IsEnabled => Fog::Nullable::String
+      })
+
+      # Represents a vCloud Session.
+      SESSION_TYPE = RESOURCE_TYPE.merge({
+        :org => String,
+        :user => String,
+        :Link => [LINK_TYPE]
+      })
+
+      # A list of tasks.
+      TASKS_LIST_TYPE = ENTITY_TYPE.merge({
+        #:Task => TASK_TYPE
+      })
+      # Represents a vApp.
+      VAPP_TYPE = ABSTRACT_VAPP_TYPE.merge({
+        :ovfDescriptorUploaded => String,
+        :Owner => OWNER_TYPE,
+        :InMaintenanceMode => String,
+        :Children => VAPP_CHILDREN_TYPE
+      })
+
+      # Represents the user view of an organization vDC.
+      VDC_TYPE = ENTITY_TYPE.merge({
+        :status => Fog::Nullable::String,
+        :AllocationModel => String,
+      # :StorageCapacity => CAPACITY_WITH_USAGE_TYPE,
+        :ComputeCapacity => COMPUTE_CAPACITY_TYPE,
+        :ResourceEntities => RESOURCE_ENTITIES_TYPE,
+        :AvailableNetworks => AVAILABLE_NETWORKS_TYPE,
+        :Capabilities => CAPABILITIES_TYPE,
+        :NicQuota => String,
+        :NetworkQuota => String,
+        :UsedNetworkCount => String,
+        :VmQuota => Fog::Nullable::String,
+        :IsEnabled => Fog::Nullable::String,
+        :VdcStorageProfiles => VDC_STORAGE_PROFILES_TYPE # >= 5.1
+      })
+
+      # Represents a storage profile in an organization vDC.
+      VDC_STORAGE_PROFILE_TYPE = ENTITY_TYPE.merge({
+        :Enabled => Fog::Nullable::String,
+        :Units => String,
+        :Limit => String,
+        :Default => String
+      })
+
+      # Information about an individual operating system.
+      OPERATING_SYSTEM_INFO_TYPE = {
+        :OperatingSystemId => String,
+        :DefaultHardDiskAdapterType => String,
+        :MinimumHardDiskSizeGigabytes => String,
+        :MinimumMemoryMegabytes => String,
+        :Name => String,
+        :InternalName => String,
+        :Supported => String,
+        :x64 => String,
+        :MaximumCpuCount => String,
+        :MinimumHardwareVersion => String,
+        :PersonalizationEnabled => String,
+        :PersonalizationAuto => String,
+        :SysprepPackagingSupported => String,
+        :SupportsMemHotAdd => String,
+        :cimOsId => String,
+        :CimVersion => String,
+        :SupportedForCreate => String
+      }
+
+      # Represents an operating system family.
+      OPERATING_SYSTEM_FAMILY_INFO_TYPE = {
+        :Name => String,
+        :OperatingSystemFamilyId => String,
+        :OperatingSystem => [OPERATING_SYSTEM_INFO_TYPE]
+      }
+
+      # Operating systems available for use on virtual machines owned by this
+      # organization.
+      SUPPORTED_OPERATING_SYSTEMS_INFO_TYPE = RESOURCE_TYPE.merge({
+        :OperatingSystemFamilyInfo => [OPERATING_SYSTEM_FAMILY_INFO_TYPE]
+      })
+
+      # Container for query results in records format.
+      #   Combine with QUERY_RESULT_RECORD_TYPE subtypes to validate query results
+      QUERY_RESULT_RECORDS_TYPE = CONTAINER_TYPE
+
+      # Base type for a single record from query result in records format.
+      # Subtypes define more specific elements.
+      QUERY_RESULT_RECORD_TYPE = {
+        :href => String,
+        :id => Fog::Nullable::String,
+        :type => Fog::Nullable::String
+      }
+
+      # Type for a single edgeGateway query result in records format.
+      QUERY_RESULT_EDGE_GATEWAY_RECORD_TYPE = QUERY_RESULT_RECORD_TYPE.merge({
+        :gatewayStatus => String,
+        :haStatus => String,
+        :isBusy => String,
+        :name => String,
+        :numberOfExtNetworks => String,
+        :numberOfOrgNetworks=> String,
+        :vdc => String
+      })
+
+      FIREWALL_RULE_TYPE__PROTOCOLS = {
+        :Icmp => Fog::Nullable::String,
+        :Asny => Fog::Nullable::String,
+        :Other => Fog::Nullable::String
+      }
+
+      # Represents a firewall rule.
+      FIREWALL_RULE_TYPE = {
+        :Id => String,
+        :IsEnabled => String,
+        :MatchOnTranslate => Fog::Nullable::String,
+        :Description => Fog::Nullable::String,
+        :Policy => Fog::Nullable::String,
+        :IcmpSubType => Fog::Nullable::String,
+        :Port => Fog::Nullable::String,
+        :DestinationPortRange => String,
+        :SourcePort => Fog::Nullable::String,
+        :SourcePortRange => String,
+        :Direction => Fog::Nullable::String,
+        :EnableLogging => Fog::Nullable::String,
+        :Protocols => FIREWALL_RULE_TYPE__PROTOCOLS
+      }
+
+      # Represents a network firewall service.
+      FIREWALL_SERVICE_TYPE = {
+        :IsEnabled => String,
+        :DefaultAction => String,
+        :LogDefaultAction => String,
+        #:FirewallRule => [FIREWALL_RULE_TYPE]  # not required
+      }
+
+      #Represents the SNAT and DNAT rules.
+      GATEWAY_NAT_RULE_TYPE = {
+        :Interface => REFERENCE_TYPE,
+        :OriginalIp => String,
+        :OriginalPort => Fog::Nullable::String,
+        :TranslatedIp => String,
+        :TranslatedPort => Fog::Nullable::String,
+        :Protocol => Fog::Nullable::String,
+        :IcmpSubType => Fog::Nullable::String
+      }
+
+      #Represents a NAT rule.
+      NAT_RULE_TYPE = {
+        :Description => Fog::Nullable::String,
+        :RuleType => String,
+        :IsEnabled => String,
+        :Id => String,
+        :GatewayNatRule => GATEWAY_NAT_RULE_TYPE
+      }
+
+      # Represents a NAT network service.
+      NAT_SERVICE_TYPE = {
+        :IsEnabled => String,
+        :NatType => Fog::Nullable::String,
+        :Policy => Fog::Nullable::String,
+        #:NatRule => [NAT_RULE_TYPE],  # not required
+        :ExternalIp => Fog::Nullable::String
+      }
+
+      # Represents a service port in a load balancer pool.
+      LB_POOL_SERVICE_PORT_TYPE = {
+        :IsEnabled => Fog::Nullable::String,
+        :Protocol => String,
+        :Algorithm => Fog::Nullable::String,
+        :Port => String,
+        :HealthCheckPort => String,
+        #:HealthCheck => LBPoolHealthCheckType  # not required
+      }
+
+      # Represents a member in a load balancer pool.
+      LB_POOL_MEMBER_TYPE = {
+        :IpAddress => String,
+        :Weight => String,
+        :ServicePort => [LB_POOL_SERVICE_PORT_TYPE]
+      }
+
+      # Represents a load balancer pool.
+      LOAD_BALANCER_POOL_TYPE = {
+        :Id => Fog::Nullable::String,
+        :Name => String,
+        :Description => Fog::Nullable::String,
+        :ServicePort => [LB_POOL_SERVICE_PORT_TYPE],
+        :Member => [LB_POOL_MEMBER_TYPE],
+        :Operational => String,
+        :ErrorDetails => Fog::Nullable::String
+      }
+
+      # Represents persistence type for a load balancer service profile.
+      LB_PERSISTENCE_TYPE = {
+        :Method => String,
+        :CookieName => Fog::Nullable::String,
+        :CookieMode => Fog::Nullable::String
+      }
+
+      # Represents service profile for a load balancing virtual server.
+      LB_VIRTUAL_SERVER_SERVICE_PROFILE_TYPE = {
+        :IsEnabled => String,
+        :Protocol => String,
+        :Port => String,
+        :Persistence => LB_PERSISTENCE_TYPE
+      }
+
+      # Information about a vendor service template. This is optional.
+      VENDOR_TEMPLATE_TYPE = {
+        :Name => String,
+        :Id => String
+      }
+
+      # Represents a load balancer virtual server.
+      LOAD_BALANCER_VIRTUAL_SERVER_TYPE = {
+        :IsEnabled => String,
+        :Name => String,
+        :Description => Fog::Nullable::String,
+        :Interface => REFERENCE_TYPE,
+        :IpAddress => String,
+        :ServiceProfile => [LB_VIRTUAL_SERVER_SERVICE_PROFILE_TYPE],
+        :Logging => String,
+        :Pool => String,
+        #:LoadBalancerTemplates => VENDOR_TEMPLATE_TYPE  # not required
+      }
+
+      # Represents gateway load balancer service.
+      LOAD_BALANCER_SERVICE_TYPE = {
+        :Pool => LOAD_BALANCER_POOL_TYPE,
+        :VirtualServer => LOAD_BALANCER_VIRTUAL_SERVER_TYPE,
+        :IsEnabled => Fog::Nullable::String
+      }
+
+      # Represents Gateway DHCP service.
+      GATEWAY_DHCP_SERVICE_TYPE = {
+        :IsEnabled => String,
+        #:Pool => DHCP_POOL_SERVICE_TYPE  # not required
+      }
+
+      # Represents edge gateway services.
+      GATEWAY_FEATURES_TYPE = {
+        #:StaticRoutingService => STATIC_ROUTING_SERVICE_TYPE, #not required
+        #:GatewayIpsecVpnService => GATEWAY_IPSEC_VPN_SERVICE_TYPE, #not required
+        #:GatewayDhcpService => GATEWAY_DHCP_SERVICE_TYPE, #not required
+        #:LoadBalancerService => LOAD_BALANCER_SERVICE_TYPE,  #not required
+        #:NatService => NAT_SERVICE_TYPE,  #not required
+        :FirewallService => FIREWALL_SERVICE_TYPE
+      }
+
+      # Represents a range of IP addresses, start and end inclusive.
+      IP_RANGE_TYPE = {
+        :StartAddress => String,
+        :EndAddress => String
+      }
+
+      # Represents a list of IP ranges.
+      IP_RANGES_TYPE = {
+        :IpRange => [IP_RANGE_TYPE]
+      }
+
+      # Allows to chose which subnets a gateway can be part of
+      SUBNET_PARTICIPATION_TYPE = {
+        :Gateway => String,
+        :Netmask => String,
+        :IpAddress => String,
+        :IpRanges => IP_RANGES_TYPE
+      }
+
+      # Gateway Interface configuration.
+      GATEWAY_INTERFACE_TYPE = {
+        :Name => String,
+        :DisplayName => String,
+        :Network => REFERENCE_TYPE,
+        :InterfaceType => String,
+        #:SubnetParticipation => [SUBNET_PARTICIPATION_TYPE], #bug in parser means list or hash
+        :ApplyRateLimit => String,
+        :InRateLimit => Fog::Nullable::String,
+        :OutRateLimit => Fog::Nullable::String,
+        :UseForDefaultRoute => String,
+      }
+
+      # A list of Gateway Interfaces.
+      GATEWAY_INTERFACES_TYPE = {
+        :GatewayInterface => [GATEWAY_INTERFACE_TYPE]
+      }
+
+      # Gateway Configuration.
+      GATEWAY_CONFIGURATION_TYPE = {
+        :BackwardCompatibilityMode => Fog::Nullable::String,
+        :GatewayBackingConfig => String,
+        :GatewayInterfaces => GATEWAY_INTERFACES_TYPE,
+        :EdgeGatewayServiceConfiguration => GATEWAY_FEATURES_TYPE,
+        :HaEnabled => Fog::Nullable::String,
+        :UseDefaultRouteForDnsRelay => Fog::Nullable::String
+      }
+
+      # Represents a gateway.
+      GATEWAY_TYPE = {
+        :href => String,
+        :type => String,
+        :id => String,
+        :operationKey => Fog::Nullable::String,
+        :name => String,
+        :status => Fog::Nullable::String,
+        #:Link => LINK_TYPE, # not required
+        :Description => Fog::Nullable::String,
+        #:Tasks => TASKS_IN_PROGRESS_TYPE,  # not required
+        :Configuration => GATEWAY_CONFIGURATION_TYPE
+      }
+
+      ORGANIZATION_REFERENCE_TYPE = REFERENCE_TYPE
+      PROVIDER_VDC_REFERENCE_TYPE = REFERENCE_TYPE
+      RIGHT_REFERENCE_TYPE = REFERENCE_TYPE
+      ROLE_REFERENCE_TYPE = REFERENCE_TYPE
+
+      # Represents the admin view of this cloud.
+      ORGANIZATION_REFERENCES_TYPE = {
+        :OrganizationReference => [REFERENCE_TYPE]
+      }
+
+      # Container for references to Provider vDCs.
+      PROVIDER_VDC_REFERENCES_TYPE = {
+        :ProviderVdcReference => [PROVIDER_VDC_REFERENCE_TYPE]
+      }
+
+      # Container for references to rights.
+      RIGHT_REFERENCES_TYPE = {
+        :RightReference => [RIGHT_REFERENCE_TYPE]
+      }
+
+      # Container for references to roles.
+      ROLE_REFERENCES_TYPE = {
+        :RoleReference => [ROLE_REFERENCE_TYPE]
+      }
+
+      # Container for references to ExternalNetwork objects.
+      NETWORKS_TYPE = {
+        :Network => [REFERENCE_TYPE]
+      }
+
+      NETWORK_CONFIGURATION_TYPE = {
+        :IpScopes => {
+          :IpScope => {
+            :IsInherited => String,
+            :Gateway => Fog::Nullable::String,
+            :Netmask => String,
+            :Dns1 => String,
+            :Dns2 => String,
+            :DnsSuffix => String,
+            :IsEnabled=> String,
+            :IpRanges=> IP_RANGES_TYPE,
+          }
+        },
+        :FenceMode => Fog::Nullable::String,
+        :RetainNetInfoAcrossDeployments => String,
+      }
+
+      NETWORK_TYPE = {
+        :name => String,
+        :href => String,
+        :type => String,
+        :id => String,
+        :Description => String,
+        :Configuration => NETWORK_CONFIGURATION_TYPE,
+        :IsShared => String,
+      }
+
+      VCLOUD_TYPE = ENTITY_TYPE.merge({
+        :OrganizationReferences => ORGANIZATION_REFERENCES_TYPE,
+        :ProviderVdcReferences => PROVIDER_VDC_REFERENCES_TYPE,
+        :RightReferences => RIGHT_REFERENCES_TYPE,
+        :RoleReferences => ROLE_REFERENCES_TYPE,
+        :Networks => NETWORKS_TYPE
+      })
+
+      # Represents a named disk.
+      DISK_TYPE = RESOURCE_ENTITY_TYPE.merge({
+        :busSubType => Fog::Nullable::String,
+        :busType => Fog::Nullable::String,
+        :size => String,
+        :StorageProfile => REFERENCE_TYPE,
+        :Owner => OWNER_TYPE
+      })
+
+      VMS_TYPE = RESOURCE_TYPE.merge({
+        :VmReference => [REFERENCE_TYPE]
+      })
+    end
+  end
+end