fog 0.3.31 → 0.3.32

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

@@ -0,0 +1,60 @@
+module Fog
+  class Vcloud
+    module Terremark
+      class Ecloud
+        class BackupInternetService < Fog::Vcloud::Model
+
+          identity :href, :aliases => :Href
+
+          ignore_attributes :xmlns, :xmlns_i
+
+          attribute :name, :aliases => :Name
+          attribute :id, :aliases => :Id
+          attribute :protocol, :aliases => :Protocol
+          attribute :enabled, :aliases => :Enabled
+          attribute :description, :aliases => :Description
+          attribute :timeout, :aliases => :Timeout
+          attribute :redirect_url, :aliases => :RedirectURL
+          attribute :monitor, :aliases => :Monitor
+
+          def delete
+            requires :href
+
+            connection.delete_internet_service( href )
+          end
+
+          def monitor=(new_monitor = {})
+            if new_monitor.nil? || new_monitor.empty?
+              attributes[:monitor] = nil
+            end
+          end
+
+          def save
+            if new_record?
+              result = connection.add_backup_internet_service( collection.href, _compose_service_data )
+              merge_attributes(result.body)
+            else
+              connection.configure_backup_internet_service( href, _compose_service_data )
+            end
+          end
+
+          def nodes
+            @nodes ||= Fog::Vcloud::Terremark::Ecloud::Nodes.new( :connection => connection, :href => href + "/nodeServices" )
+          end
+
+          private
+
+          def _compose_service_data
+            #For some reason inject didn't work
+            service_data = {}
+            self.class.attributes.select{ |attribute| !send(attribute).nil? }.each { |attribute| service_data[attribute] = send(attribute) }
+            service_data
+          end
+
+        end
+      end
+    end
+  end
+end
+
+

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

@@ -0,0 +1,36 @@
+require 'fog/vcloud/terremark/ecloud/models/backup_internet_service'
+
+module Fog
+  class Vcloud
+    module Terremark
+      class Ecloud
+
+        class BackupInternetServices < Fog::Vcloud::Collection
+
+          model Fog::Vcloud::Terremark::Ecloud::BackupInternetService
+
+          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].find_all {|i| i[:IsBackupService] == "true" }
+              load(data)
+            end
+          end
+
+          # Optimize later, no need to get_internet_services again?
+          def get(uri)
+            internet_services = connection.get_internet_services(href).body[:InternetService]
+            internet_services = [ internet_services ] if internet_services.is_a?(Hash)
+            if data = internet_services.detect { |service| service[:Href] == uri }
+              new(data)
+            end
+          rescue Fog::Errors::NotFound
+            nil
+          end
+
+        end
+      end
+    end
+  end
+end

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

@@ -18,6 +18,7 @@ module Fog
           attribute :timeout, :aliases => :Timeout
           attribute :redirect_url, :aliases => :RedirectURL
           attribute :monitor, :aliases => :Monitor
+          attribute :backup_service_data, :aliases => :BackupService
 
           def delete
             requires :href
@@ -36,19 +37,19 @@ module Fog
 
           def monitor=(new_monitor = {})
             if new_monitor.nil? || new_monitor.empty?
-              @monitor = nil
+              attributes[:monitor] = nil
             elsif new_monitor.is_a?(Hash)
-              @monitor = {}
-              @monitor[:type] = new_monitor[:MonitorType] || new_monitor[:type]
-              @monitor[:url_send_string] = new_monitor[:UrlSendString] || new_monitor[:url_send_string]
-              @monitor[:http_headers] = new_monitor[:HttpHeader] || new_monitor[:http_headers]
-              @monitor[:http_headers] = @monitor[:http_headers].split("\n") unless @monitor[:http_headers].is_a?(Array)
-              @monitor[:receive_string] = new_monitor[:ReceiveString] || new_monitor[:receive_string]
-              @monitor[:interval] = new_monitor[:Interval] || new_monitor[:interval]
-              @monitor[:response_timeout] = new_monitor[:ResponseTimeOut] || new_monitor[:response_timeout]
-              @monitor[:downtime] = new_monitor[:DownTime] || new_monitor[:downtime]
-              @monitor[:retries] = new_monitor[:Retries] || new_monitor[:retries]
-              @monitor[:is_enabled] = new_monitor[:IsEnabled] || new_monitor[:is_enabled]
+              attributes[:monitor] = {}
+              attributes[:monitor][:type] = new_monitor[:MonitorType] || new_monitor[:type]
+              attributes[:monitor][:url_send_string] = new_monitor[:UrlSendString] || new_monitor[:url_send_string]
+              attributes[:monitor][:http_headers] = new_monitor[:HttpHeader] || new_monitor[:http_headers]
+              attributes[:monitor][:http_headers] = attributes[:monitor][:http_headers].split("\n") unless attributes[:monitor][:http_headers].is_a?(Array)
+              attributes[:monitor][:receive_string] = new_monitor[:ReceiveString] || new_monitor[:receive_string]
+              attributes[:monitor][:interval] = new_monitor[:Interval] || new_monitor[:interval]
+              attributes[:monitor][:response_timeout] = new_monitor[:ResponseTimeOut] || new_monitor[:response_timeout]
+              attributes[:monitor][:downtime] = new_monitor[:DownTime] || new_monitor[:downtime]
+              attributes[:monitor][:retries] = new_monitor[:Retries] || new_monitor[:retries]
+              attributes[:monitor][:is_enabled] = new_monitor[:IsEnabled] || new_monitor[:is_enabled]
             else
               raise RuntimeError.new("monitor needs to either be nil or a Hash")
             end
@@ -58,12 +59,26 @@ module Fog
             @nodes ||= Fog::Vcloud::Terremark::Ecloud::Nodes.new( :connection => connection, :href => href + "/nodeServices" )
           end
 
+          def backup_service_uri
+            if backup_service_data
+              backup_service_data[:Href]
+            end
+          end
+
+          def backup_service_uri=(new_value)
+            self.backup_service_data = {
+              :Href => new_value
+            }
+          end
+
           private
 
           def _compose_service_data
             #For some reason inject didn't work
             service_data = {}
-            self.class.attributes.select{ |attribute| !send(attribute).nil? }.each { |attribute| service_data[attribute] = send(attribute) }
+            self.class.attributes.select{ |attribute| attribute != :backup_service_data }.each { |attribute| service_data[attribute] = send(attribute) }
+            service_data[:backup_service_uri] = backup_service_uri
+            service_data.reject! {|k, v| v.nil? }
             service_data
           end
 

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

@@ -13,8 +13,8 @@ module Fog
 
           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)
+            if internet_service_data = connection.get_internet_services(href).body[:InternetService]
+              load(Array[internet_service_data].flatten.find_all {|i| i[:IsBackupService] == "false" })
             end
           end
 

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

@@ -15,7 +15,7 @@ module Fog
           attribute :id, :aliases => :Id, :type => :integer
 
           def rnat=(new_rnat)
-            @rnat = new_rnat
+            attributes[:rnat] = new_rnat
             @changed = true
           end
 

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

@@ -18,6 +18,9 @@ module Fog
           attribute :address, :aliases => :Address
           attribute :rnat, :aliases => :RnatAddress
           attribute :extension_href, :aliases => :Href
+          attribute :network_type, :aliases => :NetworkType
+          attribute :vlan, :aliases => :Vlan
+          attribute :friendly_name, :aliases => :FriendlyName
 
           def ips
             load_unless_loaded!
@@ -27,7 +30,7 @@ module Fog
           end
 
           def rnat=(new_rnat)
-            @rnat = new_rnat
+            attributes[:rnat] = new_rnat
             @changed = true
           end
 

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

@@ -33,17 +33,17 @@ module Fog
 
           def ready?
             load_unless_loaded!
-            @status == '2'
+            status == '2'
           end
 
           def on?
             load_unless_loaded!
-            @status == '4'
+            status == '4'
           end
 
           def off?
             load_unless_loaded!
-            @status == '2'
+            status == '2'
           end
 
           def power_on
@@ -75,7 +75,7 @@ module Fog
           end
 
           def name=(new_name)
-            @name = new_name
+            attributes[:name] = new_name
             @changed = true
           end
 
@@ -199,7 +199,7 @@ module Fog
               connection.send(op.keys.first, href + "/power/action/#{op.values.first}" )
             rescue Excon::Errors::InternalServerError => e
               #Frankly we shouldn't get here ...
-              raise e unless e.to_s =~ /because it is already powered on/
+              raise e unless e.to_s =~ /because it is already powered o(n|ff)/
             end
             true
           end

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

@@ -27,6 +27,10 @@ module Fog
             @internet_services ||= collection_based_on_type("application/vnd.tmrk.ecloud.internetServicesList+xml")
           end
 
+          def backup_internet_services
+            @backup_internet_services ||= collection_based_on_type("application/vnd.tmrk.ecloud.internetServicesList+xml", BackupInternetServices)
+          end
+
           def networks
             @networks ||= Fog::Vcloud::Terremark::Ecloud::Networks.
               new( :connection => connection,
@@ -55,14 +59,14 @@ module Fog
 
           private
 
-          def collection_based_on_type(type)
+          def collection_based_on_type(type, klass = nil)
             load_unless_loaded!
             if link = other_links.detect { |link| link[:type] == type }
               case type
               when "application/vnd.tmrk.ecloud.publicIpsList+xml"
                 Fog::Vcloud::Terremark::Ecloud::PublicIps
               when "application/vnd.tmrk.ecloud.internetServicesList+xml"
-                Fog::Vcloud::Terremark::Ecloud::InternetServices
+                klass || Fog::Vcloud::Terremark::Ecloud::InternetServices
               when "application/vnd.vmware.vcloud.catalog+xml"
                 Fog::Vcloud::Terremark::Ecloud::Catalog
               when "application/vnd.tmrk.ecloud.firewallAclsList+xml"

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

@@ -0,0 +1,111 @@
+module Fog
+  class Vcloud
+    module Terremark
+      class Ecloud
+        module Shared
+          def validate_backup_internet_service_data(service_data, configure=false)
+            required_opts = [:name, :protocol, :description, :enabled]
+            if configure
+              required_opts + [ :id, :href, :timeout ]
+            end
+            unless required_opts.all? { |opt| service_data.keys.include?(opt) }
+              raise ArgumentError.new("Required Backup Internet Service data missing: #{(required_opts - service_data.keys).map(&:inspect).join(", ")}")
+            end
+          end
+        end
+
+        class Real
+          include Shared
+
+          def add_backup_internet_service(internet_services_uri, service_data)
+            validate_backup_internet_service_data(service_data)
+            if monitor = service_data[:monitor]
+              validate_internet_service_monitor(monitor)
+              ensure_monitor_defaults!(monitor)
+            end
+
+            request(
+              :body     => generate_backup_internet_service_request(service_data),
+              :expects  => 200,
+              :headers  => {'Content-Type' => 'application/xml'},
+              :method   => 'POST',
+              :uri      => internet_services_uri,
+              :parse    => true
+            )
+          end
+
+          private
+
+          def generate_backup_internet_service_request(service_data)
+            builder = Builder::XmlMarkup.new
+            builder.CreateBackupInternetServiceRequest("xmlns" => "urn:tmrk:eCloudExtensions-2.5") {
+              builder.Name(service_data[:name])
+              builder.Protocol(service_data[:protocol])
+              builder.Enabled(service_data[:enabled])
+              builder.Description(service_data[:description])
+              builder.RedirectURL(service_data[:redirect_url])
+              if monitor = service_data[:monitor]
+                generate_monitor_section(builder,monitor)
+              end
+            }
+          end
+        end
+
+        class Mock
+          include Shared
+
+          #
+          # Based on
+          # http://support.theenterprisecloud.com/kb/default.asp?id=729&Lang=1&SID=
+          # and many tears shed.
+          #
+
+          def add_backup_internet_service(internet_services_uri, service_data)
+            validate_backup_internet_service_data(service_data)
+
+            internet_services_uri = ensure_unparsed(internet_services_uri)
+
+            if vdc_internet_service_collection = mock_data.vdc_internet_service_collection_from_href(internet_services_uri)
+              new_backup_internet_service = MockBackupInternetService.new(service_data, vdc_internet_service_collection.backup_internet_services)
+              vdc_internet_service_collection.backup_internet_services << new_backup_internet_service
+              xml = generate_backup_internet_service_added_response(new_backup_internet_service)
+
+              mock_it 200, xml, {'Content-Type' => 'application/vnd.tmrk.ecloud.internetService+xml'}
+            else
+              mock_error 200, "401 Unauthorized"
+            end
+          end
+
+          private
+
+          def generate_backup_internet_service_added_response(new_backup_internet_service)
+            builder = Builder::XmlMarkup.new
+            builder.InternetService("xmlns" => "urn:tmrk:eCloudExtensions-2.5", "xmlns:i" => "http://www.w3.org/2001/XMLSchema-instance") {
+              builder.Id new_backup_internet_service.object_id
+              builder.Href new_backup_internet_service.href
+              builder.Name new_backup_internet_service.name
+              # so broken
+              builder.PublicIpAddress do
+                builder.Id -2147483648
+                builder.Id "http://totally.invalid/1234"
+                builder.Name
+              end
+              builder.Port new_backup_internet_service.port
+              builder.Protocol new_backup_internet_service.protocol
+              builder.Enabled new_backup_internet_service.enabled
+              builder.Timeout new_backup_internet_service.timeout
+              builder.Description new_backup_internet_service.description
+              builder.RedirectURL new_backup_internet_service.redirect_url
+              builder.Monitor "i:nil" => true
+              # so broken
+              builder.IsBackupService false
+              builder.BackupService "i:nil" => true
+              builder.BackupOf "i:nil" => true
+            }
+          end
+        end
+      end
+    end
+  end
+end
+

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

@@ -59,9 +59,7 @@ module Fog
 
           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.3") {
+            builder.CreateInternetServiceRequest(ecloud_xmlns) {
               builder.Name(service_data[:name])
               builder.Protocol(service_data[:protocol])
               builder.Port(service_data[:port])
@@ -127,7 +125,7 @@ module Fog
             if public_ip_internet_service_collection = mock_data.public_ip_internet_service_collection_from_href(internet_services_uri)
               new_public_ip_internet_service = MockPublicIpInternetService.new(service_data, public_ip_internet_service_collection)
               public_ip_internet_service_collection.items << new_public_ip_internet_service
-              xml = generate_internet_service_response(new_public_ip_internet_service)
+              xml = generate_internet_service(Builder::XmlMarkup.new, new_public_ip_internet_service, true)
 
               mock_it 200, xml, {'Content-Type' => 'application/vnd.tmrk.ecloud.internetService+xml'}
             else

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

@@ -7,9 +7,7 @@ module Fog
 
           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.CreateNodeServiceRequest(ecloud_xmlns) {
               builder.IpAddress(node_data[:ip_address])
               builder.Name(node_data[:name])
               builder.Port(node_data[:port])

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

@@ -5,30 +5,6 @@ module Fog
         module Shared
           private
 
-          def generate_internet_service_response(public_ip_internet_service)
-            builder = Builder::XmlMarkup.new
-            builder.InternetService(:"xmlns:i" => "http://www.w3.org/2001/XMLSchema-instance",
-                                    :xmlns => "urn:tmrk:eCloudExtensions-2.3") {
-              builder.Id(public_ip_internet_service.object_id)
-              builder.Href(public_ip_internet_service.href)
-              builder.Name(public_ip_internet_service.name)
-              builder.Protocol(public_ip_internet_service.protocol)
-              builder.Port(public_ip_internet_service.port)
-              builder.Enabled(public_ip_internet_service.enabled)
-              builder.Description(public_ip_internet_service.description)
-              builder.Timeout(public_ip_internet_service.timeout)
-              builder.RedirectURL(public_ip_internet_service.redirect_url)
-              builder.PublicIpAddress {
-                builder.Id(public_ip_internet_service._parent._parent.object_id)
-                builder.Href(public_ip_internet_service._parent._parent.href)
-                builder.Name(public_ip_internet_service._parent._parent.name)
-              }
-              if monitor = public_ip_internet_service.monitor
-                generate_monitor_section(builder, public_ip_internet_service.monitor)
-              end
-            }
-          end
-
           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) }
@@ -51,7 +27,7 @@ module Fog
             end
 
             request(
-              :body     => generate_internet_service_response(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',
@@ -60,6 +36,35 @@ module Fog
             )
           end
 
+          private
+
+          def generate_configure_internet_service_request(service_data, ip_address_data)
+            builder = Builder::XmlMarkup.new
+            builder.InternetService(ecloud_xmlns) {
+              builder.Id(service_data[:id])
+              builder.Href(service_data[:href])
+              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.RedirectURL(service_data[:redirect_url])
+              builder.PublicIpAddress {
+                builder.Id(ip_address_data[:id])
+                builder.Href(ip_address_data[:href])
+                builder.Name(ip_address_data[:name])
+              }
+              if monitor = service_data[:monitor]
+                generate_monitor_section(builder, monitor)
+              end
+              if service_data[:backup_service_uri]
+                builder.BackupService do
+                  builder.Href(service_data[:backup_service_uri])
+                end
+              end
+            }
+          end
         end
 
         class Mock
@@ -71,17 +76,24 @@ module Fog
           #
 
           def configure_internet_service(internet_service_uri, service_data, ip_address_data)
+            service_data = service_data.dup
+
             validate_internet_service_data(service_data, true)
 
             validate_public_ip_address_data(ip_address_data)
 
             internet_service_uri = ensure_unparsed(internet_service_uri)
 
+            backup_service_uri = service_data.delete(:backup_service_uri)
+            backup_service = backup_service_uri && mock_data.backup_internet_service_from_href(backup_service_uri)
+
             xml = nil
 
-            if public_ip_internet_service = mock_data.public_ip_internet_service_from_href(internet_service_uri)
+            if (public_ip_internet_service = mock_data.public_ip_internet_service_from_href(internet_service_uri)) &&
+                (backup_service_uri.nil? || backup_service)
               public_ip_internet_service.update(service_data.reject {|k, v| [:id, :href].include?(k) })
-              xml = generate_internet_service_response(public_ip_internet_service)
+              public_ip_internet_service[:backup_service] = backup_service
+              xml = generate_internet_service(Builder::XmlMarkup.new, public_ip_internet_service, true)
             end
 
             if xml