fog 0.5.3 → 0.6.0

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

@@ -1,60 +0,0 @@
-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

@@ -1,36 +0,0 @@
-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/catalog.rb

@@ -1,31 +0,0 @@
-module Fog
-  class Vcloud
-    module Terremark
-      class Ecloud
-
-        class Catalog < Fog::Vcloud::Collection
-
-          model Fog::Vcloud::Terremark::Ecloud::CatalogItem
-
-          attribute :href, :aliases => :Href
-
-          def all
-            check_href!
-            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

@@ -1,31 +0,0 @@
-module Fog
-  class Vcloud
-    module Terremark
-      class Ecloud
-        class CatalogItem < Fog::Vcloud::Model
-
-          identity :href, :aliases => :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/firewall_acl.rb

@@ -1,28 +0,0 @@
-module Fog
-  class Vcloud
-    module Terremark
-      class Ecloud
-        class FirewallAcl < 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 :source, :aliases => :Source
-          attribute :destination, :aliases => :Destination
-          attribute :permission, :aliases => :Permission
-          attribute :port_start, :aliases => :PortStart
-          attribute :port_end, :aliases => :PortEnd
-          attribute :port_type, :aliases => :PortType
-          attribute :type, :aliases => :Type
-
-        end
-      end
-    end
-  end
-end
-
-

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

@@ -1,34 +0,0 @@
-require 'fog/vcloud/terremark/ecloud/models/firewall_acl'
-
-module Fog
-  class Vcloud
-    module Terremark
-      class Ecloud
-
-        class FirewallAcls < Fog::Vcloud::Collection
-
-          model Fog::Vcloud::Terremark::Ecloud::FirewallAcl
-
-          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)
-            end
-          end
-
-          def get(uri)
-            if data = connection.get_firewall_acl(uri).body
-              new(data)
-            end
-          rescue Fog::Errors::NotFound
-            nil
-          end
-
-        end
-      end
-    end
-  end
-end

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

@@ -1,121 +0,0 @@
-module Fog
-  class Vcloud
-    module Terremark
-      class Ecloud
-        class InternetService < 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 :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
-          attribute :backup_service_data, :aliases => :BackupService
-
-          def delete
-            requires :href
-
-            connection.delete_internet_service( href )
-          end
-
-          def save
-            if new_record?
-              result = connection.add_internet_service( collection.href, _compose_service_data )
-              merge_attributes(result.body)
-            else
-              connection.configure_internet_service( href, _compose_service_data, _compose_ip_data )
-            end
-          end
-
-          # disables monitoring for this service
-          def disable_monitor
-            if self.monitor and self.monitor[:type] == "Disabled"
-              raise RuntimeError.new("Monitoring already disabled")
-            else
-              self.monitor = {:type => "Disabled", :is_enabled => "true"}
-              self.save
-            end
-          end
-
-          # enable default ping monitoring, use monitor= for more exotic forms (ECV & HTTP)
-          def enable_ping_monitor
-            self.monitor = nil
-            self.save
-          end
-
-          def monitor=(new_monitor = {})
-            if new_monitor.nil? || new_monitor.empty?
-              attributes[:monitor] = nil
-            elsif new_monitor.is_a?(Hash)
-              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]
-              if attributes[:monitor][:http_headers]
-                if attributes[:monitor][:http_headers].is_a?(String)
-                  attributes[:monitor][:http_headers] = attributes[:monitor][:http_headers].split("\n")
-                else
-                  attributes[:monitor][:http_headers] = attributes[:monitor][:http_headers]
-                end
-              end
-              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
-          end
-
-          def nodes
-            @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| 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
-
-          def _compose_ip_data
-            if public_ip.nil?
-              {}
-            else
-              { :id => public_ip[:Id], :href => public_ip[:Href], :name => public_ip[:Name] }
-            end
-          end
-
-        end
-      end
-    end
-  end
-end
-
-

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

@@ -1,36 +0,0 @@
-require 'fog/vcloud/terremark/ecloud/models/internet_service'
-
-module Fog
-  class Vcloud
-    module Terremark
-      class Ecloud
-
-        class InternetServices < Fog::Vcloud::Collection
-
-          model Fog::Vcloud::Terremark::Ecloud::InternetService
-
-          attribute :href, :aliases => :Href
-
-          def all
-            check_href! :message => "the Internet Services for the Vdc you want to enumerate"
-            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
-
-          # 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/ip.rb

@@ -1,51 +0,0 @@
-module Fog
-  class Vcloud
-    module Terremark
-      class Ecloud
-        class Ip < Fog::Vcloud::Model
-
-          ignore_attributes :xmlns_i, :xmlns
-
-          identity :href, :aliases => :Href
-
-          attribute :name, :aliases => :Name
-          attribute :status, :aliases => :Status
-          attribute :server, :aliases => :Server
-          attribute :rnat, :aliases => :RnatAddress
-          attribute :id, :aliases => :Id, :type => :integer
-
-          def rnat=(new_rnat)
-            attributes[: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
-            self
-          end
-
-          private
-          def _compose_network_ip_data
-            {
-              :id => id,
-              :href => href,
-              :name => name,
-              :status => status,
-              :server => server,
-              :rnat => rnat
-            }
-          end
-
-        end
-      end
-    end
-  end
-end

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

@@ -1,35 +0,0 @@
-require 'fog/vcloud/terremark/ecloud/models/ip'
-
-module Fog
-  class Vcloud
-    module Terremark
-      class Ecloud
-
-        class Ips < Fog::Vcloud::Collection
-
-          model Fog::Vcloud::Terremark::Ecloud::Ip
-
-          undef_method :create
-
-          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
-          end
-
-          def get(uri)
-            if data = connection.get_network_ip(uri).body
-              new(data)
-            end
-          rescue Fog::Errors::NotFound
-            nil
-          end
-
-        end
-      end
-    end
-  end
-end