fog 1.22.1 → 1.23.0

data/lib/fog/vcloud_director/compute.rb

@@ -54,6 +54,8 @@ module Fog
       collection :organizations
       model      :catalog_item
       collection :catalog_items
+      model      :custom_field
+      collection :custom_fields
       model      :vdc
       collection :vdcs
       model      :vapp
@@ -245,7 +247,9 @@ module Fog
       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
@@ -488,17 +492,24 @@ module Fog
             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
 
             hash[key] = {
               :catalogs => {
-                uuid => {
+                catalog_uuid => {
                   :name => 'Default Catalog'
                 }
               },
               :catalog_items => {
                 uuid => {
-                  :type => 'vAppTemplate',
-                  :name => 'vAppTemplate 1'
+                  :type    => 'vAppTemplate',
+                  :name    => 'vAppTemplate 1',
+                  :catalog => catalog_uuid,
                 }
               },
               :disks => {},
@@ -546,7 +557,7 @@ module Fog
                   }],
                   :IsInherited => false,
                   :Netmask => '255.255.255.0',
-                  :name => 'Default Network',
+                  :name => 'vDC1 Default Network',
                   :SubnetParticipation => {
                       :Gateway => "192.168.1.0",
                       :Netmask => "255.255.0.0",
@@ -644,6 +655,26 @@ module Fog
                 :uuid => uuid
               },
               :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,
@@ -654,6 +685,7 @@ module Fog
                   :vdc => vdc1_uuid,
                 }
               },
+
               :vdcs => {
                 vdc1_uuid => {
                   :description => 'vDC1 for mocking',
@@ -663,7 +695,44 @@ module Fog
                   :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

data/lib/fog/vcloud_director/generators/compute/edge_gateway_service_configuration.rb

@@ -13,12 +13,73 @@ module Fog
                 build_firewall_service(xml)
                 build_nat_service(xml)
                 build_load_balancer_service(xml)
+                build_vpn(xml)
+                build_dhcp(xml)
               }
             end.to_xml
           end
 
           private
 
+          def build_dhcp(xml)
+            dhcp_config = @configuration[:GatewayDhcpService]
+            return unless dhcp_config
+
+            xml.GatewayDhcpService {
+              xml.IsEnabled dhcp_config[:IsEnabled] if dhcp_config.key?(:IsEnabled)
+              dhcp_config[:pools].each do |pool|
+                xml.Pool {
+                  xml.IsEnabled pool[:IsEnabled]
+                  xml.Network pool[:Network]
+                  xml.DefaultLeaseTime pool[:DefaultLeaseTime]
+                  xml.MaxLeaseTime pool[:MaxLeaseTime]
+                  xml.LowIpAddress pool[:LowIpAddress]
+                  xml.HighIpAddress pool[:HighIpAddress]
+                }
+              end
+            }
+          end
+
+          def build_vpn(xml)
+            vpn_config = @configuration[:GatewayIpsecVpnService]
+            return unless vpn_config
+
+            xml.GatewayIpsecVpnService {
+              xml.IsEnabled vpn_config[:IsEnabled] if vpn_config.key?(:IsEnabled)
+              tunnel_config = vpn_config[:Tunnel]
+              xml.Tunnel {
+                xml.Name tunnel_config[:Name]
+                xml.Description tunnel_config[:Description]
+                xml.IpsecVpnLocalPeer {
+                  xml.Id tunnel_config[:IpsecVpnLocalPeerId]
+                  xml.Name tunnel_config[:IpsecVpnLocalPeerName]
+                }
+                xml.PeerIpAddress tunnel_config[:PeerIpAddress]
+                xml.PeerId tunnel_config[:PeerId]
+                xml.LocalIpAddress tunnel_config[:LocalIpAddress]
+                xml.LocalId tunnel_config[:LocalId]            
+                tunnel_config[:LocalSubnet].each do |subnet|
+                  xml.LocalSubnet {
+                    xml.Name subnet[:Name]
+                    xml.Gateway subnet[:Gateway]
+                    xml.Netmask subnet[:Netmask]
+                  }
+                end
+                peer_subnet_config = tunnel_config[:PeerSubnet]
+                xml.PeerSubnet {
+                  xml.Name peer_subnet_config[:Name]
+                  xml.Gateway peer_subnet_config[:Gateway]
+                  xml.Netmask peer_subnet_config[:Netmask]
+                }
+                xml.SharedSecret tunnel_config[:SharedSecret]
+                xml.SharedSecretEncrypted tunnel_config[:SharedSecretEncrypted] if tunnel_config.key?(:SharedSecretEncrypted)
+                xml.EncryptionProtocol tunnel_config[:EncryptionProtocol]
+                xml.Mtu tunnel_config[:Mtu]
+                xml.IsEnabled tunnel_config[:IsEnabled]
+              }
+            }
+          end
+
           def build_load_balancer_service(xml)
             lb_config = @configuration[:LoadBalancerService]
             return unless lb_config

data/lib/fog/vcloud_director/models/compute/custom_field.rb

@@ -0,0 +1,18 @@
+require 'fog/core/model'
+
+module Fog
+  module Compute
+    class VcloudDirector
+
+      class CustomField < Model
+
+        identity  :id
+        attribute :value
+        attribute :type
+        attribute :password
+        attribute :user_configurable
+
+      end
+    end
+  end
+end

data/lib/fog/vcloud_director/models/compute/custom_fields.rb

@@ -0,0 +1,67 @@
+require 'fog/core/collection'
+require 'fog/vcloud_director/models/compute/custom_field'
+
+module Fog
+  module Compute
+    class VcloudDirector
+
+      class CustomFields < Collection
+        model Fog::Compute::VcloudDirector::CustomField
+
+        attribute :vapp
+
+        def get_by_id(item_id)
+          item_list.detect{|i| i[:id] == item_id}
+        end
+
+        def [](key)
+          get key.to_s
+        end
+
+        def set(key, value, opts={:type => 'string', :password => 'false', :user_configurable => 'true'})
+          new_items = item_list.each.reject{|item| item[:id] == key}
+          new_items << {
+            :id                => key,
+            :value             => value,
+            :type              => opts[:type],
+            :password          => opts[:password],
+            :user_configurable => opts[:user_configurable]
+          }
+          response = service.put_product_sections(vapp.id, new_items)
+          service.process_task(response.body)
+        end
+
+        def []=(key,value)
+          set(key,value)
+        end
+
+        def delete(item_id)
+          id = item_id.to_s
+          new_items = item_list.each.reject{|item| item[:id] == id}
+          response = service.put_product_sections(vapp.id, new_items)
+          service.process_task(response.body)
+        end
+
+        def item_list
+          return @items if @items
+
+          resp = service.get_product_sections_vapp(vapp.id).body
+
+          collection = resp["ovf:ProductSection".to_sym]["ovf:Property".to_sym] rescue []
+          collection = [collection] if collection.is_a?(Hash)
+
+          @items = collection.collect do |property|
+            {
+              :id                => property[:ovf_key],
+              :value             => property[:ovf_value],
+              :type              => property[:ovf_type],
+              :password          => property[:ovf_password],
+              :user_configurable => property[:ovf_userConfigurable]
+            }
+          end rescue []
+        end
+      end
+
+    end
+  end
+end

data/lib/fog/vcloud_director/models/compute/vapp.rb

@@ -28,6 +28,11 @@ module Fog
           service.tags(:vm => self)
         end
 
+        def custom_fields
+          requires :id
+          service.custom_fields( :vapp => self)
+        end
+
         # @param [String] action The specified action is applied to all virtual
         #   machines in the vApp. All values other than **default** ignore
         #   actions, order, and delay specified in the StartupSection. One of:

data/lib/fog/vcloud_director/requests/compute/get_cpu_rasd_item.rb

@@ -22,7 +22,44 @@ module Fog
             :path       => "vApp/#{id}/virtualHardwareSection/cpu"
           )
         end
+
       end
+
+      class Mock
+
+        def get_cpu_rasd_item(id)
+          type = 'application/vnd.vmware.vcloud.rasdItem+xml'
+
+          unless vm = data[:vms][id]
+            raise Fog::Compute::VcloudDirector::Forbidden.new(
+              'This operation is denied.'
+            )
+          end
+
+          Excon::Response.new(
+            :status => 200,
+            :headers => {'Content-Type' => "#{type};version=#{api_version}"},
+            :body => get_cpu_rasd_item_body(id, vm)
+          )
+        end
+
+        def get_cpu_rasd_item_body(id, vm)
+          {
+            :ns12_href => make_href("vApp/#{id}/virtualHardwareSection/cpu"),
+            :ns12_type => "application/vnd.vmware.vcloud.rasdItem+xml",
+            :"rasd:AllocationUnits"=>"hertz * 10^6",
+            :"rasd:Description"=>"Number of Virtual CPUs",
+            :"rasd:ElementName"=>"#{vm[:cpu_count]} virtual CPU(s)",
+            :"rasd:InstanceID"=>"4",
+            :"rasd:Reservation"=>"0",
+            :"rasd:ResourceType"=>"3",
+            :"rasd:VirtualQuantity"=>"#{vm[:cpu_count]}",
+            :"rasd:Weight"=>"0",
+          }
+        end
+
+      end
+
     end
   end
 end

data/lib/fog/vcloud_director/requests/compute/get_disks_rasd_items_list.rb

@@ -21,6 +21,70 @@ module Fog
           )
         end
       end
+
+      class Mock
+
+        def get_disks_rasd_items_list(id)
+          type = 'application/vnd.vmware.vcloud.rasdItemsList+xml'
+
+          unless vm = data[:vms][id]
+            raise Fog::Compute::VcloudDirector::Forbidden.new(
+              'This operation is denied.'
+            )
+          end
+
+          body = {
+            :type => type,
+            :href => make_href("vApp/#{id}/virtualHardwareSection/disks"),
+            :Link => {
+              :rel=>"edit",
+              :type=>"application/vnd.vmware.vcloud.rasdItemsList+xml",
+              :href=>make_href("vApp/#{id}/virtualHardwareSection/disks"),
+            },
+            :Item => [
+              get_disks_rasd_items_list_body(id, vm),
+              get_media_rasd_item_ide_controller_body(id, vm),
+            ].flatten
+          }
+
+          Excon::Response.new(
+            :status => 200,
+            :headers => {'Content-Type' => "#{type};version=#{api_version}"},
+            :body => body
+          )
+        end
+
+        def get_disks_rasd_items_list_body(id, vm)
+          [
+            {
+              :"rasd:Address"=>"0",
+              :"rasd:Description"=>"SCSI Controller",
+              :"rasd:ElementName"=>"SCSI Controller 0",
+              :"rasd:InstanceID"=>"2",
+              :"rasd:ResourceSubType"=>"lsilogic",
+              :"rasd:ResourceType"=>"6"
+            },
+
+            # TODO: Add support for adding disks
+            {
+              :"rasd:AddressOnParent"=>"0",
+              :"rasd:Description"=>"Hard disk",
+              :"rasd:ElementName"=>"Hard disk 1",
+              :"rasd:HostResource"=>{
+                :ns12_capacity=>"51200",
+                :ns12_busSubType=>"lsilogic",
+                :ns12_busType=>"6"
+              },
+              :"rasd:InstanceID"=>"2000",
+              :"rasd:Parent"=>"2",
+              :"rasd:ResourceType"=>"17"
+            },
+
+          ]
+        end
+
+      end
+
     end
   end
 end

data/lib/fog/vcloud_director/requests/compute/get_execute_query.rb

@@ -164,6 +164,10 @@ module Fog
         def fetch_items(type, opts)
           if opts.key?(:filter) && opts[:filter] =~ /^name==([^;,]+)$/
             name = $1
+          elsif type == 'vAppTemplate' && opts.key?(:filter) &&
+            opts[:filter] =~ /^name==([^;,]+);catalogName==([^;,]+)$/ #TODO also match in other order
+            name = $1
+            catalog_name = $2
           elsif opts.key?(:filter)
             Fog::Mock.not_implemented("Complex filters are not yet implemented in get_execute_query Mock for #{type}: #{opts[:filter]}")
           end
@@ -177,7 +181,30 @@ module Fog
             :xsi_schemaLocation=>xsi_schema_location,
           }
 
-          if type == 'orgVdcNetwork'
+          if type == 'orgVdc'
+            record_type = :OrgVdcRecord
+            vdc_id = data[:vdcs].keys[0]
+            vdc_name = data[:vdcs][vdc_id][:name]
+            records = [{
+              :storageUsedMB=>"123967",
+              :storageLimitMB=>"8388608",
+              :storageAllocationMB=>"0",
+              :status=>"READY",
+              :orgName=>"orgName",
+              :name=>vdc_name,
+              :memoryUsedMB=>"0",
+              :memoryLimitMB=>"0",
+              :memoryAllocationMB=>"0",
+              :isSystemVdc=>"false",
+              :isEnabled=>"true",
+              :isBusy=>"false",
+              :href=>make_href("vdc/#{vdc_id}"),
+            }]
+            body[:page]     = 1.to_s             # TODO: Support pagination
+            body[:pageSize] = records.size.to_s  # TODO: Support pagination
+            body[:total]    = records.size.to_s
+            body[record_type] = records
+          elsif type == 'orgVdcNetwork'
             record_type = :OrgVdcNetworkRecords
             data_type = :networks
             records = []
@@ -215,6 +242,64 @@ module Fog
             body[:pageSize] = records.size.to_s  # TODO: Support pagination
             body[:total]    = records.size.to_s
             body[record_type] = records
+          elsif type == 'edgeGateway'
+            record_type = :EdgeGatewayRecord
+            edge_gateway_id = data[:edge_gateways].keys[0]
+            vdc_id = data[:edge_gateways][edge_gateway_id][:vdc]
+            records = [{
+              :vdc=>make_href("vdc/#{vdc_id}"),
+              :numberOfOrgNetworks=>"1",
+              :numberOfExtNetworks=>"1",
+              :name=>"Test EdgeGateway Name",
+              :isBusy=>"false",
+              :haStatus=>"DISABLED",
+              :gatewayStatus=>"READY",
+              :href=>make_href("edgeGateway/#{edge_gateway_id}"),
+              :taskStatus=>"success",
+              :taskOperation=>"networkConfigureEdgeGatewayServices",
+              :task=>make_href("task/#{uuid}"),
+              :taskDetails=>" "
+            }]
+            body[:page]     = 1.to_s             # TODO: Support pagination
+            body[:pageSize] = records.size.to_s  # TODO: Support pagination
+            body[:total]    = records.size.to_s
+            body[record_type] = records
+          elsif type == 'vAppTemplate'
+            record_type = :VAappTemplateRecord
+            records = [{
+              :vdcName=>"Bogus vDC",
+              :vdc=>make_href("vdc/#{uuid}"),
+              :storageProfileName=>"*",
+              :status=>"RESOLVED",
+              :ownerName=>"system",
+              :org=> make_href("org/#{data[:org][:uuid]}"),
+              :name=> name,
+              :isPublished=>"true",
+              :isGoldMaster=>"false",
+              :isExpired=>"false",
+              :isEnabled=>"true",
+              :isDeployed=>"false",
+              :isBusy=>"false",
+              :creationDate=>"2013-09-19T22:55:30.257+01:00",
+              :catalogName=> catalog_name,
+              :href=> make_href("vAppTemplate/vappTemplate-#{uuid}"),
+              :honorBootOrder=>"false",
+              :isVdcEnabled=>"true",
+              :isInCatalog=>"true",
+              :cpuAllocationMhz=>"8",
+              :cpuAllocationInMhz=>"16000",
+              :storageKB=>"52428800",
+              :numberOfShadowVMs=>"0",
+              :numberOfVMs=>"1",
+              :isAutoDeleteNotified=>"false",
+              :numberOfCpus=>"8",
+              :isAutoUndeployNotified=>"false",
+              :memoryAllocationMB=>"32768"
+            }]
+            body[:page]     = 1.to_s             # TODO: Support pagination
+            body[:pageSize] = records.size.to_s  # TODO: Support pagination
+            body[:total]    = records.size.to_s
+            body[record_type] = records
           else
             Fog::Mock.not_implemented("No 'get by name' get_execute_query Mock for #{type} (#{name})")
           end