fog 0.1.8 → 0.1.9

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

@@ -0,0 +1,32 @@
+require 'fog/model'
+
+module Fog
+  module Vcloud
+    module Terremark
+      module Ecloud
+        class Network < Fog::Vcloud::Model
+
+          identity :href
+
+          attribute :name
+          attribute :features
+          attribute :configuration
+          attribute :ips_link
+          attribute :type
+          attribute :xmlns
+
+          def ips
+            unless @loaded
+              reload
+            end
+            @ips ||= Fog::Vcloud::Terremark::Ecloud::Ips.
+              new( :connection => connection,
+                   :href => ips_link.href )
+          end
+        end
+      end
+    end
+  end
+end
+
+

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

@@ -0,0 +1,38 @@
+module Fog
+  module Vcloud
+    module Terremark
+      module Ecloud
+
+        module Mock
+          def networks(options = {})
+            @networks ||= Fog::Vcloud::Terremark::Ecloud::Networks.new(options.merge(:connection => self))
+          end
+        end
+
+        module Real
+          def networks(options = {})
+            @networks ||= Fog::Vcloud::Terremark::Ecloud::Networks.new(options.merge(:connection => self))
+          end
+        end
+
+        class Networks < Fog::Vcloud::Collection
+
+          undef_method :create
+
+          model Fog::Vcloud::Terremark::Ecloud::Network
+
+          get_request :get_network
+          vcloud_type "application/vnd.vmware.vcloud.network+xml"
+          all_request lambda { |networks| networks.connection.get_vdc(networks.href).body.networks }
+
+          #def all
+          #  pp connection.get_vdc(href).body.networks
+          #  load(connection.get_vdc(href).body.networks.map { |network| { } } )
+          #end
+
+        end
+      end
+    end
+  end
+end
+

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

@@ -13,11 +13,13 @@ module Fog
           attribute :id
 
           def internet_services
+            unless @loaded
+              reload
+            end
             @internet_services ||= Fog::Vcloud::Terremark::Ecloud::InternetServices.
               new( :connection => connection,
                    :href => href.to_s + "/internetServices" )
           end
-
         end
       end
     end

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

@@ -17,7 +17,7 @@ module Fog
 
         class PublicIps < Fog::Vcloud::Collection
 
-          attr_accessor :href
+          undef_method :create
 
           model Fog::Vcloud::Terremark::Ecloud::PublicIp
 

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

@@ -14,6 +14,9 @@ module Fog
           attribute :instantiated_vm_quota
 
           def public_ips
+            unless @loaded
+              reload
+            end
             @public_ips ||= Fog::Vcloud::Terremark::Ecloud::PublicIps.new( :connection => connection,
                                                                            :href => other_links.detect { |link| link.type == "application/vnd.tmrk.ecloud.publicIpsList+xml" }.href )
           end
@@ -24,6 +27,12 @@ module Fog
                    :href => href.to_s.gsub('vdc','extensions/vdc') + "/internetServices" )
           end
 
+          def networks
+            @networks ||= Fog::Vcloud::Terremark::Ecloud::Networks.
+              new( :connection => connection,
+                   :href => href )
+          end
+
         end
       end
     end

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

@@ -16,6 +16,8 @@ module Fog
 
         class Vdcs < Fog::Vcloud::Vdcs
 
+          undef_method :create
+
           model Fog::Vcloud::Terremark::Ecloud::Vdc
 
           #get_request :get_vdc

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

@@ -0,0 +1,28 @@
+module Fog
+  module Parsers
+    module Vcloud
+      module Terremark
+        module Ecloud
+
+          class Network < Fog::Parsers::Vcloud::Network
+
+            def reset
+              @response = Struct::TmrkEcloudNetwork.new([])
+            end
+
+            def start_element(name,attributes=[])
+              super
+              case name
+              when "Link"
+                @response.ips_link = generate_link(attributes)
+              end
+            end
+
+          end
+        end
+      end
+    end
+  end
+end
+
+

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

@@ -0,0 +1,31 @@
+module Fog
+  module Parsers
+    module Vcloud
+      module Terremark
+        module Ecloud
+
+          class NetworkIps< Fog::Parsers::Vcloud::Base
+
+            def reset
+              @response = Struct::TmrkEcloudNetworkIps.new([])
+              @ip_address = Struct::TmrkEcloudNetworkIp.new
+            end
+
+            def end_element(name)
+              case name
+              when 'Name', 'Status', 'Server'
+                @ip_address[name.downcase] = @value
+              when 'IpAddress'
+                @response.addresses << @ip_address
+                @ip_address = Struct::TmrkEcloudNetworkIp.new
+              end
+            end
+
+          end
+        end
+      end
+    end
+  end
+end
+
+

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

@@ -17,15 +17,18 @@ module Fog
             }
           end
 
-          def self.validate_internet_service_request_data(service_data)
+          def self.validate_internet_service_data(service_data, configure=false)
             valid_opts = [:name, :protocol, :port, :description, :enabled, :description]
+            if configure
+              valid_opts + [ :id, :href, :timeout ]
+            end
             unless valid_opts.all? { |opt| service_data.keys.include?(opt) }
               raise ArgumentError.new("Required Internet Service data missing: #{(valid_opts - service_data.keys).map(&:inspect).join(", ")}")
             end
           end
 
-          def add_internet_service(internet_service_uri, service_data)
-            Fog::Vcloud::Terremark::Ecloud::Real.validate_internet_service_request_data(service_data)
+          def add_internet_service(internet_services_uri, service_data)
+            Fog::Vcloud::Terremark::Ecloud::Real.validate_internet_service_data(service_data)
 
             request(
               :body     => Fog::Vcloud::Terremark::Ecloud::Real.generate_internet_service_request(service_data),
@@ -33,7 +36,7 @@ module Fog
               :headers  => {'Content-Type' => 'application/vnd.tmrk.ecloud.internetService+xml'},
               :method   => 'POST',
               :parser   => Fog::Parsers::Vcloud::Terremark::Ecloud::InternetService.new,
-              :uri      => internet_service_uri
+              :uri      => internet_services_uri
             )
           end
 
@@ -45,10 +48,10 @@ module Fog
           # http://support.theenterprisecloud.com/kb/default.asp?id=561&Lang=1&SID=
           #
 
-          def add_internet_service(internet_service_uri, service_data)
-            Fog::Vcloud::Terremark::Ecloud::Real.validate_internet_service_request_data(service_data)
+          def add_internet_service(internet_services_uri, service_data)
+            Fog::Vcloud::Terremark::Ecloud::Real.validate_internet_service_data(service_data)
 
-            if ip = Fog::Vcloud::Mock.ip_from_uri(internet_service_uri.to_s)
+            if ip = Fog::Vcloud::Mock.ip_from_uri(internet_services_uri.to_s)
               new_service = service_data.merge!( { :id => rand(1000), :timeout => 2 } )
               ip[:services] << new_service
               builder = Builder::XmlMarkup.new

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

@@ -0,0 +1,99 @@
+module Fog
+  module Vcloud
+    module Terremark
+      module Ecloud
+        module Real
+
+          def self.generate_configure_internet_service_request(service_data,ip_address_data)
+            builder = Builder::XmlMarkup.new
+            builder.InternetService(:"xmlns:i" => "http://www.w3.org/2001/XMLSchema-instance",
+                                    :xmlns => "urn:tmrk:eCloudExtensions-2.0") {
+              builder.Id(service_data[:id])
+              builder.Href(service_data[:href].to_s)
+              builder.Name(service_data[:name])
+              builder.Protocol(service_data[:protocol])
+              builder.Port(service_data[:port])
+              builder.Enabled(service_data[:enabled])
+              builder.Description(service_data[:description])
+              builder.Timeout(service_data[:timeout])
+              builder.PublicIpAddress {
+                builder.Id(ip_address_data[:id])
+                builder.Href(ip_address_data[:href].to_s)
+                builder.Name(ip_address_data[:name])
+              }
+            }
+          end
+
+          def self.validate_public_ip_address_data(ip_address_data)
+            valid_opts = [:name, :href, :id]
+            unless valid_opts.all? { |opt| ip_address_data.keys.include?(opt) }
+              raise ArgumentError.new("Required Internet Service data missing: #{(valid_opts - ip_address_data.keys).map(&:inspect).join(", ")}")
+            end
+          end
+
+          def configure_internet_service(internet_service_uri, service_data, ip_address_data)
+            Fog::Vcloud::Terremark::Ecloud::Real.validate_internet_service_data(service_data, true)
+
+            Fog::Vcloud::Terremark::Ecloud::Real.validate_public_ip_address_data(ip_address_data)
+
+            request(
+              :body     => Fog::Vcloud::Terremark::Ecloud::Real.generate_configure_internet_service_request(service_data, ip_address_data),
+              :expects  => 200,
+              :headers  => {'Content-Type' => 'application/vnd.tmrk.ecloud.internetService+xml'},
+              :method   => 'PUT',
+              :parser   => Fog::Parsers::Vcloud::Terremark::Ecloud::InternetService.new,
+              :uri      => internet_service_uri
+            )
+          end
+
+        end
+
+        module Mock
+          #
+          # Based on
+          # http://support.theenterprisecloud.com/kb/default.asp?id=583&Lang=1&SID=
+          #
+
+          def configure_internet_service(internet_service_uri, service_data, ip_address_data)
+            Fog::Vcloud::Terremark::Ecloud::Real.validate_internet_service_data(service_data, true)
+
+            Fog::Vcloud::Terremark::Ecloud::Real.validate_public_ip_address_data(ip_address_data)
+
+            found = false
+            xml = nil
+            if ip = Fog::Vcloud::Mock.ip_from_uri(ip_address_data[:href])
+              if service = ip[:services].detect { |service| service[:id] == internet_service_uri.to_s.split('/')[-1].to_i }
+                found = true
+                ip[:services][ip[:services].index(service)] = service_data
+
+                builder = Builder::XmlMarkup.new
+                xml = builder.InternetService(:xmlns => "urn:tmrk:eCloudExtensions-2.0",
+                                              :"xmlns:i" => "http://www.w3.org/2001/XMLSchema-instance") {
+                  builder.Id(service_data[:id])
+                  builder.Href(Fog::Vcloud::Terremark::Ecloud::Mock.internet_service_href(service_data))
+                  builder.Name(service_data[:name])
+                  builder.PublicIpAddress {
+                    builder.Id(ip[:id])
+                    builder.Href(Fog::Vcloud::Terremark::Ecloud::Mock.public_ip_href(ip))
+                    builder.Name(ip[:name])
+                  }
+                  builder.Protocol(service_data[:protocol])
+                  builder.Port(service_data[:port])
+                  builder.Enabled(service_data[:enabled])
+                  builder.Description(service_data[:description])
+                  builder.Timeout(service_data[:timeout])
+                }
+              end
+            end
+            if found
+              mock_it Fog::Parsers::Vcloud::Terremark::Ecloud::InternetService.new, 200, xml, {'Content-Type' => 'application/vnd.tmrk.ecloud.internetService+xml'}
+            else
+              mock_error 200, "401 Unauthorized"
+            end
+          end
+        end
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,54 @@
+module Fog
+  module Vcloud
+    module Terremark
+      module Ecloud
+        module Real
+
+          def get_network(network_uri)
+           request(
+              :expects  => 200,
+              :method   => 'GET',
+              :parser   => Fog::Parsers::Vcloud::Terremark::Ecloud::Network.new,
+              :uri      => network_uri
+            )
+          end
+
+        end
+
+        module Mock
+
+          def get_network(network_uri)
+            #
+            # Based off of:
+            # http://support.theenterprisecloud.com/kb/default.asp?id=546&Lang=1&SID=
+            #
+            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 }
+              xml = Builder::XmlMarkup.new
+              mock_it Fog::Parsers::Vcloud::Terremark::Ecloud::Network.new, 200,
+                xml.Network(xmlns.merge(:href => network[:href], :name => network[:name], :type => type)) {
+                  xml.Link( :rel => "down", :href => network[:href] + "/ips", :type => "application/xml", :name => "IP Addresses" )
+                  xml.Configuration {
+                    xml.Gateway(network[:gateway])
+                    xml.Netmask(network[:netmask])
+                  }
+                  if network[:features]
+                    xml.Features {
+                      if feature = network[:features].detect { |feature| feature[:type] == :fencemode }
+                        xml.FenceMode(feature[:value])
+                      end
+                    }
+                  end
+                },
+                { 'Content-Type' => type }
+            else
+              mock_error 200, "401 Unauthorized"
+            end
+          end
+        end
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,51 @@
+module Fog
+  module Vcloud
+    module Terremark
+      module Ecloud
+        module Real
+
+          def get_network_ips(network_ips_uri)
+            request(
+              :expects  => 200,
+              :method   => 'GET',
+              :parser   => Fog::Parsers::Vcloud::Terremark::Ecloud::NetworkIps.new,
+              :uri      => network_ips_uri
+            )
+          end
+
+        end
+
+        module Mock
+          require 'ipaddr'
+
+          def get_network_ips(network_ips_uri)
+            response = Excon::Response.new
+            if network = mock_data[:organizations].map { |org| org[:vdcs].map { |vdc| vdc[:networks] } }.flatten.detect { |network| network[:href] == network_ips_uri.to_s.gsub(%r:/ips$:,'') }
+              xml = Builder::XmlMarkup.new
+              mock_it Fog::Parsers::Vcloud::Terremark::Ecloud::NetworkIps.new, 200,
+                xml.IpAddresses {
+                  IPAddr.new(network[:name]).to_range.to_a[3..-2].each do |ip|
+                    xml.IpAddress {
+                      xml.Name(ip.to_s)
+                      if network[:ips].has_key?(ip.to_s)
+                        xml.Status("Assigned")
+                        xml.Server(network[:ips][ip.to_s])
+                      else
+                        xml.Status("Available")
+                      end
+                    }
+                  end
+                },
+                { 'Content-Type' => 'application/vnd.tmrk.ecloud.ipAddressesList+xml' }
+            else
+              mock_error 200, "401 Unauthorized"
+            end
+            
+
+          end
+
+        end
+      end
+    end
+  end
+end

data/spec/aws/models/s3/file_spec.rb

@@ -103,4 +103,19 @@ describe 'Fog::AWS::S3::File' do
 
   end
 
+  describe "#url" do
+
+    it "should return a signed expiring url" do
+      data = File.open(File.dirname(__FILE__) + '/../../../lorem.txt', 'r')
+      file = @directory.files.create(:key => 'fogfilename', :body => data)
+      url = file.url(Time.now + 60 * 10)
+      url.should include("fogfilename", "Expires")
+      unless Fog.mocking?
+        open(url).read.should == File.open(File.dirname(__FILE__) + '/../../../lorem.txt', 'r').read
+      end
+      file.destroy
+    end
+
+  end
+
 end