fog 0.3.16 → 0.3.17

data/lib/fog/vcloud/requests/get_network.rb

@@ -18,19 +18,19 @@ module Fog
         network_uri = ensure_unparsed(network_uri)
         type = "application/vnd.vmware.vcloud.network+xml"
         response = Excon::Response.new
-        if network = mock_data[:organizations].map { |org| org[:vdcs].map { |vdc| vdc[:networks] } }.flatten.detect { |network| network[:href] == network_uri.to_s }
+        if network = mock_data.organizations.map { |org| org.vdcs.map { |vdc| vdc.networks } }.flatten.detect { |network| network.href == network_uri.to_s }
           xml = Builder::XmlMarkup.new
           mock_it 200,
-            xml.Network(xmlns.merge(:href => network[:href], :name => network[:name], :type => type)) {
-              xml.Description(network[:name])
+            xml.Network(xmlns.merge(:href => network.href, :name => network.name, :type => type)) {
+              xml.Description(network.name)
               xml.Configuration {
-                xml.Gateway(network[:gateway])
-                xml.Netmask(network[:netmask])
-                xml.Dns(network[:dns])
+                xml.Gateway(network.gateway)
+                xml.Netmask(network.netmask)
+                xml.Dns(network.dns)
               }
-              if network[:features]
+              if network.features
                 xml.Features {
-                  if feature = network[:features].detect { |feature| feature[:type] == :fencemode }
+                  if feature = network.features.detect { |feature| feature[:type] == :FenceMode }
                     xml.FenceMode(feature[:value])
                   end
                 }

data/lib/fog/vcloud/requests/get_organization.rb

@@ -11,29 +11,29 @@ module Fog
         #
         # Based off of:
         # http://support.theenterprisecloud.com/kb/default.asp?id=540&Lang=1&SID=
-        # 
+        #
         # vCloud API Guide v0.9 - Page 26
         #
         organization_uri = ensure_unparsed(organization_uri)
-        if org = mock_data[:organizations].detect { |org| org[:info][:href] == organization_uri }
+        if organization = mock_data.organization_from_href(organization_uri)
           xml = Builder::XmlMarkup.new
 
           mock_it 200,
-            xml.Org(xmlns.merge(:href => org[:info][:href], :name => org[:info][:name])) {
+            xml.Org(xmlns.merge(:href => organization.href, :name => organization.name)) {
 
-              org[:vdcs].each do |vdc|
+              organization.vdcs.each do |vdc|
                 xml.Link(:rel => "down",
-                         :href => vdc[:href],
+                         :href => vdc.href,
                          :type => "application/vnd.vmware.vcloud.vdc+xml",
-                         :name => vdc[:name])
+                         :name => vdc.name)
                 xml.Link(:rel => "down",
-                         :href => "#{vdc[:href]}/catalog",
+                         :href => vdc.catalog.href,
                          :type => "application/vnd.vmware.vcloud.catalog+xml",
-                         :name => "#{vdc[:name]} Catalog")
+                         :name => vdc.catalog.name)
                 xml.Link(:rel => "down",
-                         :href => "#{vdc[:href]}/tasksList",
+                         :href => vdc.task_list.href,
                          :type => "application/vnd.vmware.vcloud.tasksList+xml",
-                         :name => "#{vdc[:name]} Tasks List")
+                         :name => vdc.task_list.name)
               end
             },
             {'Content-Type' => "application/vnd.vmware.vcloud.org+xml" }

data/lib/fog/vcloud/requests/get_vdc.rb

@@ -12,59 +12,59 @@ module Fog
 
       def get_vdc(vdc_uri)
         vdc_uri = ensure_unparsed(vdc_uri)
-        if vdc = mock_data[:organizations].map { |org| org[:vdcs] }.flatten.detect { |vdc| vdc[:href] == vdc_uri }
+        if vdc = mock_data.organizations.map { |org| org.vdcs }.flatten.detect { |vdc| vdc.href == vdc_uri }
           xml = Builder::XmlMarkup.new
           mock_it 200,
-            xml.Vdc(xmlns.merge(:href => vdc[:href], :name => vdc[:name])) {
+            xml.Vdc(xmlns.merge(:href => vdc.href, :name => vdc.name)) {
               xml.Link(:rel => "up",
-                       :href => Fog::Vcloud::Mock.data[:organizations].detect { |org| org[:vdcs].detect { |_vdc| vdc[:href] == _vdc[:href] }[:href] == vdc[:href] }[:info][:href],
+                       :href => mock_data.organizations.detect { |org| org.vdcs.detect { |_vdc| vdc.href == _vdc.href }.href == vdc.href }.href,
                        :type => "application/vnd.vmware.vcloud.org+xml")
               xml.Link(:rel => "add",
-                       :href => vdc[:href] + "/action/uploadVAppTemplate",
+                       :href => vdc.href + "/action/uploadVAppTemplate",
                        :type => "application/vnd.vmware.vcloud.uploadVAppTemplateParams+xml")
               xml.Link(:rel => "add",
-                       :href => vdc[:href] + "/media",
+                       :href => vdc.href + "/media",
                        :type => "application/vnd.vmware.vcloud.media+xml")
               xml.Link(:rel => "add",
-                       :href => vdc[:href] + "/action/instantiateVAppTemplate",
+                       :href => vdc.href + "/action/instantiateVAppTemplate",
                        :type => "application/vnd.vmware.vcloud.instantiateVAppTemplateParams+xml")
               xml.Link(:rel => "add",
                        :type => "application/vnd.vmware.vcloud.cloneVAppParams+xml",
-                       :href => vdc[:href] + "/action/cloneVApp")
+                       :href => vdc.href + "/action/cloneVApp")
               xml.Link(:rel => "add",
                        :type => "application/vnd.vmware.vcloud.captureVAppParams+xml",
-                       :href => vdc[:href] + "/action/captureVApp")
+                       :href => vdc.href + "/action/captureVApp")
               xml.Link(:rel => "add",
                        :type => "application/vnd.vmware.vcloud.composeVAppParams+xml",
-                       :href => vdc[:href] + "/action/composeVApp")
+                       :href => vdc.href + "/action/composeVApp")
               xml.AllocationModel("AllocationPool")
               xml.Description(vdc[:name] + " VDC")
               xml.ResourceEntities {
-                Fog::Vcloud::Mock.data[:vdc_resources].each do |resource|
+                mock_data.organizations.first.vdcs.first.virtual_machines.each do |resource|
                   xml.ResourceEntity(resource)
                 end
               }
               xml.AvailableNetworks {
-                vdc[:networks].each do |network|
-                  xml.Network( :name => network[:name], :href => network[:href], :type => "application/vnd.vmware.vcloud.network+xml" )
+                vdc.networks.each do |network|
+                  xml.Network( :name => network.name, :href => network.href, :type => "application/vnd.vmware.vcloud.network+xml" )
                 end
               }
               xml.ComputeCapacity{
                 xml.Cpu {
                   xml.Units("Mhz")
-                  xml.Allocated(vdc[:cpu][:allocated])
-                  xml.Limit(vdc[:cpu][:allocated])
+                  xml.Allocated(vdc.cpu_allocated)
+                  xml.Limit(vdc.cpu_allocated)
                 }
                 xml.Memory {
                   xml.Units("MB")
-                  xml.Allocated(vdc[:memory][:allocated])
-                  xml.Limit(vdc[:memory][:allocated])
+                  xml.Allocated(vdc.memory_allocated)
+                  xml.Limit(vdc.memory_allocated)
                 }
               }
               xml.StorageCapacity{
                 xml.Units("MB")
-                xml.Allocated(vdc[:storage][:allocated])
-                xml.Limit(vdc[:storage][:allocated])
+                xml.Allocated(vdc.storage_allocated)
+                xml.Limit(vdc.storage_allocated)
               }
               xml.VmQuota(0)
               xml.NicQuota(0)

data/lib/fog/vcloud/requests/get_versions.rb

@@ -19,10 +19,10 @@ module Fog
         mock_it 200,
           xml.SupportedVersions( xmlns.merge("xmlns" => "http://www.vmware.com/vcloud/versions")) {
 
-            mock_data[:versions].select {|version| version[:supported] }.each do |version|
+            mock_data.versions.select {|version| version.supported }.each do |version|
               xml.VersionInfo {
-                xml.Version(version[:version])
-                xml.LoginUrl(version[:login_url])
+                xml.Version(version.version)
+                xml.LoginUrl(version.login_url)
               }
             end
           }

data/lib/fog/vcloud/requests/login.rb

@@ -31,8 +31,8 @@ module Fog
 
         mock_it 200,
           xml.OrgList(xmlns) {
-              mock_data[:organizations].each do |org|
-                xml.Org( :type => "application/vnd.vmware.vcloud.org+xml", :href => org[:info][:href], :name => org[:info][:name] )
+              mock_data.organizations.each do |organization|
+                xml.Org( :type => "application/vnd.vmware.vcloud.org+xml", :href => organization.href, :name => organization.name )
               end
             },
             { 'Set-Cookie' => 'vcloud-token=fc020a05-21d7-4f33-9b2a-25d8cd05a44e; path=/',

data/lib/fog/vcloud/terremark/ecloud.rb

@@ -76,125 +76,81 @@ module Fog
             Fog::Vcloud::Mock.data_reset
           end
 
-          def self.extension_url
-            self.base_url + "/extensions"
-          end
-
           def self.data( base_url = self.base_url )
-            @mock_data ||= begin
-              vcloud_data = Fog::Vcloud::Mock.data(base_url)
-              vcloud_data.delete( :versions )
-              vcloud_data.merge!( :versions => [ { :version => "v0.8b-ext2.3", :login_url => "#{base_url}/login", :supported => true } ] )
-
-              vcloud_data[:organizations][0][:vdcs][0][:public_ips] =
-                  [
-                    { :id => "51",
-                      :href => extension_url + "/publicIp/51",
-                      :name => "99.1.2.3",
-                      :services => [
-                        { :id => "71", :href => extension_url + "/internetService/71", :port => "80", :protocol => 'HTTP', :enabled => "true",
-                          :timeout => "2", :name => 'Web Site', :description => 'Web Servers', :redirect_url => 'http://fakey.com',
-                          :nodes => [ {:id => "81", :href => extension_url + "/nodeService/81", :ip_address => "1.2.3.5",
-                                       :name => "Test Node 1", :port => "80", :enabled => "true", :description => "web 1" },
-                                      {:id => "82", :href => extension_url + "/nodeService/82", :ip_address => "1.2.3.6",
-                                       :name => "Test Node 2", :port => "80", :enabled => "true", :description => "web 2" },
-                                    ] },
-                        { :id => "72", :href => extension_url + "/internetService/72", :port => "7000", :protocol => 'HTTP', :enabled => "true",
-                          :timeout => "2", :name => 'An SSH Map', :description => 'SSH 1', :redirect_url => '',
-                          :nodes => [ {:id => "83", :href => extension_url + "/nodeService/83", :ip_address => "1.2.3.5",
-                                       :name => "SSH", :port => "22", :enabled => "true", :description => "web ssh" }
-                                    ] }
-                      ]
-                    },
-                    { :id => "52",
-                      :href => extension_url + "/publicIp/52",
-                      :name => "99.1.2.4",
-                      :services => [
-                        { :id => "73", :href => extension_url + "/internetService/73", :port => "80", :protocol => 'HTTP', :enabled => "true",
-                          :timeout => "2", :name => 'Web Site', :description => 'Web Servers', :redirect_url => 'http://fakey.com',
-                          :nodes => [] },
-                        { :id => "74", :href => extension_url + "/internetService/74", :port => "7000", :protocol => 'HTTP', :enabled => "true",
-                          :timeout => "2", :name => 'An SSH Map', :description => 'SSH 2', :redirect_url => '',
-                          :nodes => [] }
-                      ]
-                    },
-                    { :id => "53",
-                      :href => extension_url + "/publicIp/53",
-                      :name => "99.1.9.7",
-                      :services => []
-                    }
-                  ]
-
-              vcloud_data[:organizations][0][:vdcs][1][:public_ips] =
-                  [
-                    { :id => "54",
-                      :href => extension_url + "/publicIp/54",
-                      :name => "99.99.99.99",
-                      :services => []
-                    }
-                  ]
-
-              vcloud_data[:organizations].each do |organization|
-                organization[:info][:extension_href] = extension_url
-                organization[:vdcs].each do | vdc|
-                  vdc[:extension_href] = "#{base_url}/extensions/vdc/#{vdc[:id]}"
-                  vdc[:networks].each do |network|
-                    network[:extension_href] = "#{extension_url}/network/#{network[:id]}"
-                    network[:rnat] = vdc[:public_ips].first[:name]
+            @mock_data ||= Fog::Vcloud::Mock.data(base_url).tap do |vcloud_mock_data|
+              vcloud_mock_data.versions.clear
+              vcloud_mock_data.versions << MockVersion.new(:version => "v0.8b-ext2.3")
+
+              vcloud_mock_data.organizations.detect {|o| o.name == "Boom Inc." }.tap do |mock_organization|
+                mock_organization.vdcs.detect {|v| v.name == "Boomstick" }.tap do |mock_vdc|
+                  mock_vdc.public_ip_collection.items << MockPublicIp.new(:name => "99.1.2.3").tap do |mock_public_ip|
+                    mock_public_ip.internet_service_collection.items << MockPublicIpInternetService.new({
+                                                                                                          :protocol => "HTTP",
+                                                                                                          :port => 80,
+                                                                                                          :name => "Web Site",
+                                                                                                          :description => "Web Servers",
+                                                                                                          :redirect_url => "http://fakey.com"
+                                                                                                        }, mock_public_ip.internet_service_collection
+                                                                                                        ).tap do |mock_public_ip_service|
+                      mock_public_ip_service.node_collection.items << MockPublicIpInternetServiceNode.new({:ip_address => "1.2.3.5", :name => "Test Node 1", :description => "web 1"}, mock_public_ip_service.node_collection)
+                      mock_public_ip_service.node_collection.items << MockPublicIpInternetServiceNode.new({:ip_address => "1.2.3.6", :name => "Test Node 2", :description => "web 2"}, mock_public_ip_service.node_collection)
+                      mock_public_ip_service.node_collection.items << MockPublicIpInternetServiceNode.new({:ip_address => "1.2.3.7", :name => "Test Node 3", :description => "web 3"}, mock_public_ip_service.node_collection)
+                    end
+
+                    mock_public_ip.internet_service_collection.items << MockPublicIpInternetService.new({
+                                                                                                          :protocol => "TCP",
+                                                                                                          :port => 7000,
+                                                                                                          :name => "An SSH Map",
+                                                                                                          :description => "SSH 1"
+                                                                                                        }, mock_public_ip.internet_service_collection
+                                                                                                        ).tap do |mock_public_ip_service|
+                      mock_public_ip_service.node_collection.items << MockPublicIpInternetServiceNode.new({ :ip_address => "1.2.3.5", :port => 22, :name => "SSH", :description => "web ssh" }, mock_public_ip_service.node_collection)
+                    end
                   end
-                end
-              end
-
-              vcloud_data
-            end
-          end
-
-          def self.public_ip_href(ip)
-            "#{base_url}/extensions/publicIp/#{ip[:id]}"
-          end
-
-          def self.internet_service_href(internet_service)
-            "#{base_url}/extensions/internetService/#{internet_service[:id]}"
-          end
-
-          def self.vapp_href(options)
-            "#{base_url}/vapp/#{options[:id]}"
-          end
-
-          def self.vapp_template_href(options)
-            "#{base_url}/vappTemplate/#{options[:id]}"
-          end
 
-          def self.catalog_item_customization_href(options)
-            "#{base_url}/extensions/template/#{options[:id]}/options/customization"
-          end
+                  mock_vdc.public_ip_collection.items << MockPublicIp.new(:name => "99.1.2.4").tap do |mock_public_ip|
+                    mock_public_ip.internet_service_collection.items << MockPublicIpInternetService.new({
+                                                                                                          :protocol => "HTTP",
+                                                                                                          :port => 80,
+                                                                                                          :name => "Web Site",
+                                                                                                          :description => "Web Servers",
+                                                                                                          :redirect_url => "http://fakey.com"
+                                                                                                        }, mock_public_ip.internet_service_collection
+                                                                                                        )
+
+                    mock_public_ip.internet_service_collection.items << MockPublicIpInternetService.new({
+                                                                                                          :protocol => "TCP",
+                                                                                                          :port => 7000,
+                                                                                                          :name => "An SSH Map",
+                                                                                                          :description => "SSH 2"
+                                                                                                        }, mock_public_ip.internet_service_collection
+                                                                                                        )
+                  end
 
-          def ecloud_xmlns
-            { :xmlns => "urn:tmrk:eCloudExtensions-2.3", :"xmlns:i" => "http://www.w3.org/2001/XMLSchema-instance" }
-          end
+                  mock_vdc.public_ip_collection.items << MockPublicIp.new(:name => "99.1.9.7")
+                end
 
-          def mock_ip_from_service_url(uri)
-            mock_data[:organizations].map { |org| org[:vdcs] }.flatten.map { |vdc| vdc[:public_ips] }.flatten.compact.detect { |pip| pip[:services].detect { |service| service[:href] == uri } }
-          end
+                mock_organization.vdcs.detect {|v| v.name == "Rock-n-Roll" }.tap do |mock_vdc|
+                  mock_vdc.public_ip_collection.items << MockPublicIp.new(:name => "99.99.99.99")
+                end
+              end
 
-          def mock_ip_and_service_from_service_url(uri)
-            if ip = mock_data[:organizations].map { |org| org[:vdcs] }.flatten.map { |vdc| vdc[:public_ips] }.flatten.compact.detect { |pip| pip[:services].detect { |service| service[:href] == uri } }
-              if desired_service = ip[:services].detect { |service| service[:href] == uri }
-                [ip, desired_service]
-              else
-                [ip, nil]
+              vcloud_mock_data.organizations.each do |organization|
+                organization.vdcs.each do |vdc|
+                  vdc.networks.each do |network|
+                    network[:rnat] = vdc.public_ip_collection.items.first.name
+                  end
+                  vdc.virtual_machines.each do |virtual_machine|
+                    virtual_machine.disks << MockVirtualMachineDisk.new(:size => 25 * 1024)
+                    virtual_machine.disks << MockVirtualMachineDisk.new(:size => 50 * 1024)
+                  end
+                end
               end
-            else
-              [nil, nil]
             end
           end
 
-          def mock_node_from_url(uri)
-            mock_data[:organizations].map { |org| org[:vdcs] }.flatten.map { |vdc| vdc[:public_ips] }.flatten.map { |pip| pip[:services] }.flatten.map { |service| service[:nodes] }.flatten.detect { |node| node[:href] == uri }
-          end
-
-          def mock_service_from_node_url(uri)
-            mock_data[:organizations].map { |org| org[:vdcs] }.flatten.map { |vdc| vdc[:public_ips] }.flatten.map { |pip| pip[:services] }.flatten.map { |service| service }.detect {|service| service[:nodes].map { |node| node[:href] }.include?(uri) }
+          def ecloud_xmlns
+            { :xmlns => "urn:tmrk:eCloudExtensions-2.3", :"xmlns:i" => "http://www.w3.org/2001/XMLSchema-instance" }
           end
 
           def mock_data

data/lib/fog/vcloud/terremark/ecloud/models/catalog.rb

@@ -10,6 +10,7 @@ module Fog
           attribute :href, :aliases => :Href
 
           def all
+            check_href!
             if data = connection.get_catalog(href).body[:CatalogItems][:CatalogItem]
               load(data)
             end

data/lib/fog/vcloud/terremark/ecloud/models/firewall_acls.rb

@@ -12,6 +12,7 @@ module Fog
           attribute :href, :aliases => :Href
 
           def all
+            check_href! :message => "the Firewall ACL href for the network you want to enumerate"
             if data = connection.get_firewall_acls(href).body[:FirewallAcl]
               data = [ data ] if data.is_a?(Hash)
               load(data)

data/lib/fog/vcloud/terremark/ecloud/models/internet_services.rb

@@ -12,6 +12,7 @@ module Fog
           attribute :href, :aliases => :Href
 
           def all
+            check_href! :message => "the Internet Services for the Vdc you want to enumerate"
             if data = connection.get_internet_services(href).body[:InternetService]
               load(data)
             end

data/lib/fog/vcloud/terremark/ecloud/models/ip.rb

@@ -29,7 +29,7 @@ module Fog
           def reload
             super
             @changed = false
-            true
+            self
           end
 
           private

data/lib/fog/vcloud/terremark/ecloud/models/ips.rb

@@ -14,6 +14,7 @@ module Fog
           attribute :href
 
           def all
+            check_href!( :messages => "Ips href of a Network you want to enumerate" )
             if data = connection.get_network_ips(href).body[:IpAddress]
               load(data)
             end

data/lib/fog/vcloud/terremark/ecloud/models/network.rb

@@ -6,10 +6,10 @@ module Fog
 
           identity :href
 
-          ignore_attributes :xmlns, :xmlns_xsi, :xmlns_xsd, :xmlns_i, :Configuration
+          ignore_attributes :xmlns, :xmlns_xsi, :xmlns_xsd, :xmlns_i, :Configuration, :Id
 
           attribute :name, :aliases => :Name
-          attribute :id, :aliases => :Id
+          #attribute :id, :aliases => :Id
           attribute :features, :aliases => :Features, :type => :array
           attribute :links, :aliases => :Link, :type => :array
           attribute :type
@@ -41,6 +41,7 @@ module Fog
           def reload
             super
             merge_attributes(extension_data.body)
+            self
           end
 
           private

data/lib/fog/vcloud/terremark/ecloud/models/networks.rb

@@ -14,6 +14,7 @@ module Fog
           attribute :href
 
           def all
+            check_href!("Vdc")
             if data = connection.get_vdc(href).body[:AvailableNetworks][:Network]
               load(data)
             end

data/lib/fog/vcloud/terremark/ecloud/models/nodes.rb

@@ -12,6 +12,7 @@ module Fog
           attribute :href, :aliases => :Href
 
           def all
+            check_href!( :messages => "the Nodes href of the Internet Service you want to enumerate" )
             if data = connection.get_nodes(href).body[:NodeService]
               load(data)
             end