fog 0.2.0 → 0.2.1

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

@@ -11,7 +11,7 @@ module Fog
             'Authorization' => authorization_header
           },
           :method   => 'POST',
-          :parser   => Fog::Parsers::Vcloud::Login.new,
+          :parse    => true,
           :uri      => @login_uri
         })
       end
@@ -29,10 +29,10 @@ module Fog
         #
         xml = Builder::XmlMarkup.new
 
-        mock_it Fog::Parsers::Vcloud::Login.new, 200,
+        mock_it 200,
           xml.OrgList(xmlns) {
-              Fog::Vcloud::Mock.data[:organizations].each do |org|
-                xml.Org( org[:info].merge( "type" => "application/vnd.vmware.vcloud.org+xml" ) ) {}
+              mock_data[:organizations].each do |org|
+                xml.Org( :type => "application/vnd.vmware.vcloud.org+xml", :href => org[:info][:href], :name => org[:info][:name] )
               end
             },
             { 'Set-Cookie' => 'vcloud-token=fc020a05-21d7-4f33-9b2a-25d8cd05a44e; path=/',

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

@@ -2,14 +2,130 @@ module Fog
   module Vcloud
     module Terremark
       module Ecloud
+        extend Fog::Vcloud::Extension
+
+        model_path 'fog/vcloud/terremark/ecloud/models'
+        model :catalog_item
+        model :catalog
+        model :internet_service
+        model :internet_services
+        model :ip
+        model :ips
+        model :network
+        model :networks
+        model :node
+        model :nodes
+        model :public_ip
+        model :public_ips
+        model :server
+        model :servers
+        model :task
+        model :tasks
+        model :vdc
+        model :vdcs
+
+        request_path 'fog/vcloud/terremark/ecloud/requests'
+        request :add_internet_service
+        request :add_node
+        request :configure_internet_service
+        request :configure_network
+        request :configure_network_ip
+        request :configure_node
+        request :configure_vapp
+        request :delete_internet_service
+        request :delete_node
+        request :delete_vapp
+        request :get_catalog
+        request :get_catalog_item
+        request :get_customization_options
+        request :get_internet_services
+        request :get_network
+        request :get_network_ip
+        request :get_network_ips
+        request :get_network_extensions
+        request :get_node
+        request :get_nodes
+        request :get_public_ip
+        request :get_public_ips
+        request :get_task
+        request :get_task_list
+        request :get_vapp
+        request :get_vdc
+        request :power_off
+        request :power_on
+        request :power_reset
+        request :power_shutdown
+
+        versions "v0.8b-ext2.3"
 
         module Mock
           def self.base_url
-            "https://fakey.com/api/v0.8a-ext2.0"
+            "https://fakey.com/api/v0.8b-ext2.3"
+          end
+
+          def self.data_reset
+            @mock_data = nil
+            Fog::Vcloud::Mock.data_reset
+          end
+
+          def self.extension_url
+            self.base_url + "/extensions"
           end
 
-          def self.data
-            @mock_data ||= Fog::Vcloud::Mock.data
+          def self.data( base_url = self.base_url )
+            @mock_data ||= begin
+              extension_href = 
+              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", :port => "80", :protocol => 'HTTP', :enabled => "true", :timeout => "2", :name => 'Web Site', :description => 'Web Servers' },
+                        { :id => "72", :port => "7000", :protocol => 'HTTP', :enabled => "true", :timeout => "2", :name => 'An SSH Map', :description => 'SSH 1' }
+                      ]
+                    },
+                    { :id => "52",
+                      :href => extension_url + "/publicIp/52",
+                      :name => "99.1.2.4",
+                      :services => [
+                        { :id => "73", :port => "80", :protocol => 'HTTP', :enabled => "true", :timeout => "2", :name => 'Web Site', :description => 'Web Servers' },
+                        { :id => "74", :port => "7000", :protocol => 'HTTP', :enabled => "true", :timeout => "2", :name => 'An SSH Map', :description => 'SSH 2' }
+                      ]
+                    },
+                    { :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]
+                  end
+                end
+              end
+
+              vcloud_data
+            end
           end
 
           def self.public_ip_href(ip)
@@ -19,62 +135,17 @@ module Fog
           def self.internet_service_href(internet_service)
             "#{base_url}/extensions/internetService/#{internet_service[:id]}"
           end
-        end
 
-        module Versions
-          SUPPORTED = ["v0.8", "v0.8a-ext2.0"]
-        end
-
-        def self.extended(klass)
-          #Do anything we need to do here that's specific to ecloud
-          unless @required
-            require 'fog/vcloud/terremark/all'
-            require 'fog/vcloud/terremark/ecloud/models/internet_service'
-            require 'fog/vcloud/terremark/ecloud/models/internet_services'
-            require 'fog/vcloud/terremark/ecloud/models/ip'
-            require 'fog/vcloud/terremark/ecloud/models/ips'
-            require 'fog/vcloud/terremark/ecloud/models/network'
-            require 'fog/vcloud/terremark/ecloud/models/networks'
-            require 'fog/vcloud/terremark/ecloud/models/public_ip'
-            require 'fog/vcloud/terremark/ecloud/models/public_ips'
-            require 'fog/vcloud/terremark/ecloud/models/vdc'
-            require 'fog/vcloud/terremark/ecloud/models/vdcs'
-            require 'fog/vcloud/terremark/ecloud/parsers/get_internet_services'
-            require 'fog/vcloud/terremark/ecloud/parsers/get_public_ip'
-            require 'fog/vcloud/terremark/ecloud/parsers/get_public_ips'
-            require 'fog/vcloud/terremark/ecloud/parsers/get_vdc'
-            require 'fog/vcloud/terremark/ecloud/parsers/internet_service'
-            require 'fog/vcloud/terremark/ecloud/parsers/network'
-            require 'fog/vcloud/terremark/ecloud/parsers/network_ips'
-            require 'fog/vcloud/terremark/ecloud/requests/add_internet_service'
-            require 'fog/vcloud/terremark/ecloud/requests/configure_internet_service'
-            require 'fog/vcloud/terremark/ecloud/requests/delete_internet_service'
-            require 'fog/vcloud/terremark/ecloud/requests/get_internet_services'
-            require 'fog/vcloud/terremark/ecloud/requests/get_network'
-            require 'fog/vcloud/terremark/ecloud/requests/get_network_ips'
-            require 'fog/vcloud/terremark/ecloud/requests/get_public_ip'
-            require 'fog/vcloud/terremark/ecloud/requests/get_public_ips'
-            require 'fog/vcloud/terremark/ecloud/requests/login'
-            require 'fog/vcloud/terremark/ecloud/requests/get_vdc'
-            Struct.new("TmrkEcloudVdc", :links, :resource_entities, :networks, :cpu_capacity, :storage_capacity, 
-                                        :memory_capacity, :deployed_vm_quota, :instantiated_vm_quota, :href, :type,
-                                        :name, :xmlns, :description)
-            Struct.new("TmrkEcloudList", :links)
-            Struct.new("TmrkEcloudPublicIp", :type, :href, :name, :id)
-            Struct.new("TmrkEcloudInternetService", :type, :href, :id, :name, :public_ip, :port, :protocol, 
-                                                    :enabled, :timeout, :description, :url_send_string, :http_header)
-            Struct.new("TmrkEcloudNetwork", :features, :configuration, :ips_link, :name, :type, :href, :xmlns)
-            Struct.new("TmrkEcloudNetworkIps", :addresses)
-            Struct.new("TmrkEcloudNetworkIp", :name, :status, :server)
-            @required = true
+          def ecloud_xmlns
+            { :xmlns => "urn:tmrk:eCloudExtensions-2.3", :"xmlns:i" => "http://www.w3.org/2001/XMLSchema-instance" }
           end
-          if Fog.mocking?
-            klass.extend Fog::Vcloud::Terremark::Ecloud::Mock
-          else
-            klass.extend Fog::Vcloud::Terremark::Ecloud::Real
+
+          def mock_data
+            Fog::Vcloud::Terremark::Ecloud::Mock.data
           end
         end
 
+
         private
 
         # If we don't support any versions the service does, then raise an error.

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

@@ -0,0 +1,30 @@
+module Fog
+  module Vcloud
+    module Terremark
+      module Ecloud
+
+        class Catalog < Fog::Vcloud::Collection
+
+          model Fog::Vcloud::Terremark::Ecloud::CatalogItem
+
+          attribute :href, :aliases => :Href
+
+          def all
+            if data = connection.get_catalog(href).body[:CatalogItems][:CatalogItem]
+              load(data)
+            end
+          end
+
+          def get(uri)
+            if data = connection.get_catalog_item(uri)
+              new(data.body)
+            end
+          rescue Fog::Errors::NotFound
+            nil
+          end
+
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+module Fog
+  module Vcloud
+    module Terremark
+      module Ecloud
+        class CatalogItem < Fog::Vcloud::Model
+
+          identity :href, :Href
+
+          ignore_attributes :xmlns, :xmlns_i, :xmlns_xsi, :xmlns_xsd
+
+          attribute :type
+          attribute :name
+          attribute :entity, :aliases => :Entity
+          attribute :link, :aliases => :Link
+          attribute :property, :aliases => :Property
+
+          def customization_options
+            load_unless_loaded!
+            if data = connection.get_customization_options( link[:href] ).body
+              data.delete_if { |key, value| [:xmlns_i, :xmlns].include?(key) }
+              data
+            else
+              nil
+            end
+          end
+
+        end
+      end
+    end
+  end
+end

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

@@ -1,49 +1,48 @@
-require 'fog/model'
-
 module Fog
   module Vcloud
     module Terremark
       module Ecloud
         class InternetService < Fog::Vcloud::Model
 
-          identity :href
+          identity :href, :Href
 
-          attribute :name
-          attribute :id
-          attribute :type
-          attribute :protocol
-          attribute :port
-          attribute :enabled
-          attribute :description
-          attribute :public_ip
-          attribute :timeout
-          attribute :url_send_string
-          attribute :http_header
+          ignore_attributes :xmlns, :xmlns_i
 
-          attr_accessor :new
+          attribute :name, :aliases => :Name
+          attribute :id, :aliases => :Id
+          attribute :protocol, :aliases => :Protocol
+          attribute :port, :aliases => :Port
+          attribute :enabled, :aliases => :Enabled
+          attribute :description, :aliases => :Description
+          attribute :public_ip, :aliases => :PublicIpAddress
+          attribute :timeout, :aliases => :Timeout
+          attribute :redirect_url, :aliases => :RedirectURL
+          attribute :monitor, :aliases => :Monitor
 
           def delete
             requires :href
 
-            connection.delete_internet_service( self.href )
-            collection.reload
+            connection.delete_internet_service( href )
           end
 
           def save
             if new_record?
               result = connection.add_internet_service( collection.href, _compose_service_data )
-              self.href = result.body.href
-              self.reload
+              merge_attributes(result.body)
             else
-              connection.configure_internet_service( self.href, _compose_service_data, _compose_ip_data )
+              connection.configure_internet_service( href, _compose_service_data, _compose_ip_data )
             end
           end
 
+          def nodes
+            @nodes ||= Fog::Vcloud::Terremark::Ecloud::Nodes.new( :connection => connection, :href => href + "/nodeServices" )
+          end
+
           private
 
           def _compose_service_data
             service_data = {}
-            self.class.attributes.select{ |attribute| !attribute.nil? }.each { |attribute| service_data[attribute] = send(attribute).to_s }
+            self.class.attributes.select{ |attribute| !send(attribute).nil? }.each { |attribute| service_data[attribute] = send(attribute).to_s }
             service_data
           end
 
@@ -51,7 +50,7 @@ module Fog
             if public_ip.nil?
               {}
             else
-              { :id => self.public_ip.id, :href => self.public_ip.href.to_s, :name => self.public_ip.name }
+              { :id => public_ip[:Id], :href => public_ip[:Href], :name => public_ip[:Name] }
             end
           end
 

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

@@ -3,12 +3,6 @@ module Fog
     module Terremark
       module Ecloud
 
-        module Mock
-          def internet_services(options = {})
-            @internet_services ||= Fog::Vcloud::Terremark::Ecloud::InternetServices.new(options.merge(:connection => self))
-          end
-        end
-
         module Real
           def internet_services(options = {})
             @internet_services ||= Fog::Vcloud::Terremark::Ecloud::InternetServices.new(options.merge(:connection => self))
@@ -19,29 +13,21 @@ module Fog
 
           model Fog::Vcloud::Terremark::Ecloud::InternetService
 
-          vcloud_type "application/vnd.tmrk.ecloud.internetService+xml"
-          all_request lambda { |internet_services| internet_services.send(:raw_results) }
+          attribute :href, :aliases => :Href
 
-          def get(uri)
-            if internet_service = get_raw(uri)
-              item = new(:href => internet_service.href)
-              item.reload
+          def all
+            if data = connection.get_internet_services(href).body[:InternetService]
+              load(data)
             end
           end
 
-          def get_raw(uri)
-            raw_results.body.links.detect { |link| link.href.to_s == uri.to_s }
-          end
-
-          def reload
-            super
-            @raw_results = nil
-          end
-
-          private
-
-          def raw_results
-            @raw_results ||= connection.get_internet_services(self.href)
+          # Optimize later, no need to get_internet_services again
+          def get(uri)
+            if data = connection.get_internet_services(href).body[:InternetService].detect { |service| service[:Href] == uri }
+              new(data)
+            end
+          rescue Fog::Errors::NotFound
+            nil
           end
 
         end

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

@@ -1,15 +1,48 @@
-require 'fog/model'
-
 module Fog
   module Vcloud
     module Terremark
       module Ecloud
         class Ip < Fog::Vcloud::Model
 
-          identity :name
+          ignore_attributes :xmlns_i, :xmlns
+
+          identity :href, :Href
+
+          attribute :name, :Name
+          attribute :status, :aliases => :Status
+          attribute :server, :aliases => :Server
+          attribute :rnat, :aliases => :RnatAddress
+          attribute :id, :aliases => :Id, :type => :integer
+
+          def rnat=(new_rnat)
+            @rnat = new_rnat
+            @changed = true
+          end
+
+          def save
+            if @changed
+              connection.configure_network_ip( href, _compose_network_ip_data )
+            end
+            true
+          end
+
+          def reload
+            super
+            @changed = false
+            true
+          end
 
-          attribute :status
-          attribute :server
+          private
+          def _compose_network_ip_data
+            {
+              :id => id,
+              :href => href,
+              :name => name,
+              :status => status,
+              :server => server,
+              :rnat => rnat
+            }
+          end
 
         end
       end