fog 0.2.0 → 0.2.1

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

@@ -0,0 +1,43 @@
+module Fog
+  module Vcloud
+    module Terremark
+      module Ecloud
+
+        class Servers < Fog::Vcloud::Collection
+
+          model Fog::Vcloud::Terremark::Ecloud::Server
+
+          attribute :href, :aliases => :Href
+
+          def all
+            load(_vapps)
+          end
+
+          def get(uri)
+            if data = connection.get_vapp(uri)
+              new(data.body)
+            end
+          rescue Fog::Errors::NotFound
+            nil
+          end
+
+          private
+
+          def _resource_entities
+            connection.get_vdc(href).body[:ResourceEntities][:ResourceEntity]
+          end
+
+          def _vapps
+            resource_entities = _resource_entities
+            if resource_entities.nil?
+              []
+            else
+              resource_entities
+            end
+          end
+
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+module Fog
+  module Vcloud
+    module Terremark
+      module Ecloud
+        class Task < Fog::Vcloud::Model
+
+          identity :href, :Href
+
+          ignore_attributes :xmlns, :xmlns_i, :xmlns_xsi, :xmlns_xsd
+
+          attribute :status
+          attribute :type
+          attribute :result, :aliases => :Result
+          attribute :owner, :aliases => :Owner
+          attribute :start_time, :aliases => :startTime, :type => :time
+          attribute :end_time, :aliases => :endTime, :type => :time
+
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -2,23 +2,27 @@ module Fog
   module Vcloud
     module Terremark
       module Ecloud
-        class Vdc < Fog::Vcloud::Vdc
+        class Vdc < Fog::Vcloud::Model
 
-          delete_attribute :enabled
-          delete_attribute :vm_quota
-          delete_attribute :nic_quota
-          delete_attribute :network_quota
-          delete_attribute :allocation_model
+          identity :href
 
+          ignore_attributes :xmlns, :xmlns_xsi, :xmlns_xsd
+
+          attribute :name
+          attribute :type
+          attribute :description, :aliases => :Description
+          attribute :other_links, :aliases => :Link
+          attribute :compute_capacity, :aliases => :ComputeCapacity
+          attribute :storage_capacity, :aliases => :StorageCapacity
+          attribute :available_networks, :aliases => :AvailableNetworks, :squash => :Network
+          attribute :resource_entities, :aliases => :ResourceEntities, :squash => :ResourceEntity
           attribute :deployed_vm_quota
           attribute :instantiated_vm_quota
 
           def public_ips
-            unless @loaded
-              reload
-            end
+            load_unless_loaded!
             @public_ips ||= Fog::Vcloud::Terremark::Ecloud::PublicIps.new( :connection => connection,
-                                                                           :href => other_links.detect { |link| link.type == "application/vnd.tmrk.ecloud.publicIpsList+xml" }.href )
+                                                                           :href => other_links.detect { |link| link[:type] == "application/vnd.tmrk.ecloud.publicIpsList+xml" }[:href] )
           end
 
           def internet_services
@@ -33,6 +37,24 @@ module Fog
                    :href => href )
           end
 
+          def servers
+            @servers ||= Fog::Vcloud::Terremark::Ecloud::Servers.
+              new( :connection => connection,
+                   :href => href )
+          end
+
+          def tasks
+            @tasks ||= Fog::Vcloud::Terremark::Ecloud::Tasks.
+              new( :connection => connection,
+                   :href => href + "/tasksList" )
+          end
+
+          def catalog
+            @catalog ||= Fog::Vcloud::Terremark::Ecloud::Catalog.
+              new( :connection => connection,
+                   :href => href + "/catalog" )
+          end
+
         end
       end
     end

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

@@ -2,17 +2,20 @@ module Fog
   module Vcloud
     module Terremark
       module Ecloud
-        module Mock
+
+        module Real
           def vdcs(options = {})
             @vdcs ||= Fog::Vcloud::Terremark::Ecloud::Vdcs.new(options.merge(:connection => self))
           end
         end
 
-        module Real
+        #FIXME: Should be no need to do this ... duplicte code ... find a better way
+        module Mock
           def vdcs(options = {})
             @vdcs ||= Fog::Vcloud::Terremark::Ecloud::Vdcs.new(options.merge(:connection => self))
           end
         end
+        #/FIXME
 
         class Vdcs < Fog::Vcloud::Vdcs
 
@@ -20,10 +23,6 @@ module Fog
 
           model Fog::Vcloud::Terremark::Ecloud::Vdc
 
-          #get_request :get_vdc
-          #vcloud_type "application/vnd.vmware.vcloud.vdc+xml"
-          #all_request lambda { |vdcs| vdcs.connection.get_organization(vdcs.organization_uri) }
-
         end
       end
     end

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

@@ -4,21 +4,33 @@ module Fog
       module Ecloud
         module Real
 
-          def self.generate_internet_service_request(service_data)
+          def generate_internet_service_request(service_data)
             builder = Builder::XmlMarkup.new
             builder.CreateInternetServiceRequest(:"xmlns:xsi" => "http://www.w3.org/2001/XMLSchema-instance",
                                                  :"xmlns:xsd" => "http://www.w3.org/2001/XMLSchema",
-                                                 :xmlns => "urn:tmrk:eCloudExtensions-2.0") {
+                                                 :xmlns => "urn:tmrk:eCloudExtensions-2.3") {
               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.RedirectUrl(service_data[:redirect_url])
+              #builder.Monitor {
+              #  builder.MonitorType {}
+              #  builder.UrlSendString {}
+              #  builder.HttpHeader {}
+              #  builder.ReceiveString {}
+              #  builder.Interval {}
+              #  builder.ResponseTimeOut {}
+              #  builder.DownTime {}
+              #  builder.Retries {}
+              #  builder.IsEnabled {}
+              #}
             }
           end
 
-          def self.validate_internet_service_data(service_data, configure=false)
-            valid_opts = [:name, :protocol, :port, :description, :enabled, :description]
+          def validate_internet_service_data(service_data, configure=false)
+            valid_opts = [:name, :protocol, :port, :description, :enabled, :redirect_url]
             if configure
               valid_opts + [ :id, :href, :timeout ]
             end
@@ -28,14 +40,13 @@ module Fog
           end
 
           def add_internet_service(internet_services_uri, service_data)
-            Fog::Vcloud::Terremark::Ecloud::Real.validate_internet_service_data(service_data)
+            validate_internet_service_data(service_data)
 
             request(
-              :body     => Fog::Vcloud::Terremark::Ecloud::Real.generate_internet_service_request(service_data),
+              :body     => generate_internet_service_request(service_data),
               :expects  => 200,
               :headers  => {'Content-Type' => 'application/vnd.tmrk.ecloud.internetService+xml'},
               :method   => 'POST',
-              :parser   => Fog::Parsers::Vcloud::Terremark::Ecloud::InternetService.new,
               :uri      => internet_services_uri
             )
           end
@@ -49,9 +60,11 @@ module Fog
           #
 
           def add_internet_service(internet_services_uri, service_data)
-            Fog::Vcloud::Terremark::Ecloud::Real.validate_internet_service_data(service_data)
+            validate_internet_service_data(service_data)
 
-            if ip = Fog::Vcloud::Mock.ip_from_uri(internet_services_uri.to_s)
+            internet_services_uri = ensure_unparsed(internet_services_uri)
+
+            if ip = ip_from_uri(internet_services_uri)
               new_service = service_data.merge!( { :id => rand(1000), :timeout => 2 } )
               ip[:services] << new_service
               builder = Builder::XmlMarkup.new
@@ -72,7 +85,7 @@ module Fog
                 builder.Timeout(new_service[:timeout])
               }
 
-              mock_it Fog::Parsers::Vcloud::Terremark::Ecloud::InternetService.new, 200, xml, {'Content-Type' => 'application/vnd.tmrk.ecloud.internetService+xml'}
+              mock_it 200, xml, {'Content-Type' => 'application/vnd.tmrk.ecloud.internetService+xml'}
             else
               mock_error 200, "401 Unauthorized"
             end

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

@@ -0,0 +1,54 @@
+module Fog
+  module Vcloud
+    module Terremark
+      module Ecloud
+        module Real
+
+          def add_node(nodes_uri, node_data)
+            validate_node_data(node_data)
+
+            request(
+              :body     => generate_node_request(node_data),
+              :expects  => 200,
+              :headers  => {'Content-Type' => 'application/vnd.tmrk.ecloud.nodeService+xml'},
+              :method   => 'POST',
+              :uri      => nodes_uri
+            )
+          end
+
+          private
+
+          def generate_node_request(node_data)
+            builder = Builder::XmlMarkup.new
+            builder.CreateNodeServiceRequest(:"xmlns:xsi" => "http://www.w3.org/2001/XMLSchema-instance",
+                                             :"xmlns:xsd" => "http://www.w3.org/2001/XMLSchema",
+                                             :xmlns => "urn:tmrk:eCloudExtensions-2.3") {
+              builder.IpAddress(node_data[:ip_address])
+              builder.Name(node_data[:name])
+              builder.Port(node_data[:port])
+              builder.Enabled(node_data[:enabled])
+              builder.Description(node_data[:description])
+            }
+          end
+
+          def validate_node_data(node_data, configure=false)
+            valid_opts = [:name, :port, :enabled, :description, :ip_address]
+            if configure
+              valid_opts.delete_if { |opt| ![:name, :enabled, :description].include?(opt) }
+            end
+            unless valid_opts.all? { |opt| node_data.keys.include?(opt) }
+              raise ArgumentError.new("Required data missing: #{(valid_opts - node_data.keys).map(&:inspect).join(", ")}")
+            end
+          end
+        end
+
+        module Mock
+
+          def add_node(nodes_uri, node_data)
+            Fog::Mock.not_implemented
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -4,10 +4,10 @@ module Fog
       module Ecloud
         module Real
 
-          def self.generate_configure_internet_service_request(service_data,ip_address_data)
+          def 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") {
+                                    :xmlns => "urn:tmrk:eCloudExtensions-2.3") {
               builder.Id(service_data[:id])
               builder.Href(service_data[:href].to_s)
               builder.Name(service_data[:name])
@@ -16,6 +16,7 @@ module Fog
               builder.Enabled(service_data[:enabled])
               builder.Description(service_data[:description])
               builder.Timeout(service_data[:timeout])
+              builder.RedirectUrl(service_data[:redirect_url])
               builder.PublicIpAddress {
                 builder.Id(ip_address_data[:id])
                 builder.Href(ip_address_data[:href].to_s)
@@ -24,7 +25,7 @@ module Fog
             }
           end
 
-          def self.validate_public_ip_address_data(ip_address_data)
+          def 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(", ")}")
@@ -32,16 +33,15 @@ module Fog
           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)
+            validate_internet_service_data(service_data, true)
 
-            Fog::Vcloud::Terremark::Ecloud::Real.validate_public_ip_address_data(ip_address_data)
+            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),
+              :body     => 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
@@ -55,14 +55,16 @@ module Fog
           #
 
           def configure_internet_service(internet_service_uri, service_data, ip_address_data)
-            Fog::Vcloud::Terremark::Ecloud::Real.validate_internet_service_data(service_data, true)
+            validate_internet_service_data(service_data, true)
 
-            Fog::Vcloud::Terremark::Ecloud::Real.validate_public_ip_address_data(ip_address_data)
+            validate_public_ip_address_data(ip_address_data)
+
+            internet_service_uri = ensure_unparsed(internet_service_uri)
 
             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 }
+            if ip = ip_from_uri(ip_address_data[:href])
+              if service = ip[:services].detect { |service| service[:id] == internet_service_uri.split('/')[-1] }
                 found = true
                 ip[:services][ip[:services].index(service)] = service_data
 
@@ -86,7 +88,7 @@ module Fog
               end
             end
             if found
-              mock_it Fog::Parsers::Vcloud::Terremark::Ecloud::InternetService.new, 200, xml, {'Content-Type' => 'application/vnd.tmrk.ecloud.internetService+xml'}
+              mock_it 200, xml, {'Content-Type' => 'application/vnd.tmrk.ecloud.internetService+xml'}
             else
               mock_error 200, "401 Unauthorized"
             end

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

@@ -0,0 +1,53 @@
+module Fog
+  module Vcloud
+    module Terremark
+      module Ecloud
+        module Real
+
+          def validate_network_data(network_data, configure=false)
+            valid_opts = [:id, :href, :name, :rnat, :address, :broadcast, :gateway]
+            unless valid_opts.all? { |opt| network_data.keys.include?(opt) }
+              raise ArgumentError.new("Required data missing: #{(valid_opts - network_data.keys).map(&:inspect).join(", ")}")
+            end
+          end
+
+          def configure_network(network_uri, network_data)
+            validate_network_data(network_data)
+
+            request(
+              :body     => generate_configure_network_request(network_data),
+              :expects  => 200,
+              :headers  => {'Content-Type' => 'application/vnd.tmrk.ecloud.networkService+xml'},
+              :method   => 'PUT',
+              :uri      => network_uri
+            )
+          end
+
+          private
+
+          def generate_configure_network_request(network_data)
+            builder = Builder::XmlMarkup.new
+            builder.Network(:"xmlns:i" => "http://www.w3.org/2001/XMLSchema-instance",
+                            :xmlns => "urn:tmrk:eCloudExtensions-2.3") {
+              builder.Id(network_data[:id])
+              builder.Href(network_data[:href])
+              builder.Name(network_data[:name])
+              builder.RnatAddress(network_data[:rnat])
+              builder.Address(network_data[:address])
+              builder.BroadcastAddress(network_data[:broadcast])
+              builder.GatewayAddress(network_data[:gateway])
+            }
+          end
+
+        end
+
+        module Mock
+
+          def configure_network(network_uri, network_data)
+            Fog::Mock.not_implemented
+          end
+        end
+      end
+    end
+  end
+end