fog 0.5.3 → 0.6.0

data/lib/fog/compute/models/aws/key_pair.rb

@@ -5,8 +5,6 @@ module Fog
     class Compute
 
       class KeyPair < Fog::Model
-        extend Fog::Deprecation
-        deprecate(:material, :private_key)
 
         identity  :name,        :aliases => 'keyName'
 

data/lib/fog/compute/models/aws/security_group.rb

@@ -42,7 +42,7 @@ module Fog
           requires :name
 
           connection.authorize_security_group_ingress(
-            'GroupName'                   => name,
+            name,
             'SourceSecurityGroupName'     => group,
             'SourceSecurityGroupOwnerId'  => owner
           )
@@ -80,9 +80,9 @@ module Fog
           requires :name
 
           connection.authorize_security_group_ingress(
+            name,
             'CidrIp'      => options[:cidr_ip] || '0.0.0.0/0',
             'FromPort'    => range.min,
-            'GroupName'   => name,
             'ToPort'      => range.max,
             'IpProtocol'  => options[:ip_protocol] || 'tcp'
           )
@@ -134,7 +134,7 @@ module Fog
           requires :name
 
           connection.revoke_security_group_ingress(
-            'GroupName'                   => name,
+            name,
             'SourceSecurityGroupName'     => group,
             'SourceSecurityGroupOwnerId'  => owner
           )
@@ -172,9 +172,9 @@ module Fog
           requires :name
 
           connection.revoke_security_group_ingress(
+            name,
             'CidrIp'      => options[:cidr_ip] || '0.0.0.0/0',
             'FromPort'    => range.min,
-            'GroupName'   => name,
             'ToPort'      => range.max,
             'IpProtocol'  => options[:ip_protocol] || 'tcp'
           )

data/lib/fog/compute/models/aws/server.rb

@@ -5,6 +5,8 @@ module Fog
     class Compute
 
       class Server < Fog::Model
+        extend Fog::Deprecation
+        deprecate :ip_address, :public_ip_address
 
         identity  :id,                    :aliases => 'instanceId'
 
@@ -18,7 +20,6 @@ module Fog
         attribute :flavor_id,             :aliases => 'instanceType'
         attribute :image_id,              :aliases => 'imageId'
         attr_accessor :instance_initiated_shutdown_behavior
-        attribute :ip_address,            :aliases => 'ipAddress'
         attribute :kernel_id,             :aliases => 'kernelId'
         attribute :key_name,              :aliases => 'keyName'
         attribute :created_at,            :aliases => 'launchTime'
@@ -26,6 +27,7 @@ module Fog
         attribute :product_codes,         :aliases => 'productCodes'
         attribute :private_dns_name,      :aliases => 'privateDnsName'
         attribute :private_ip_address,    :aliases => 'privateIpAddress'
+        attribute :public_ip_address,     :aliases => 'ipAddress'
         attribute :ramdisk_id,            :aliases => 'ramdiskId'
         attribute :reason
         attribute :root_device_name,      :aliases => 'rootDeviceName'
@@ -177,11 +179,19 @@ module Fog
         end
 
         def ssh(commands)
-          requires :identity, :ip_address, :username
+          requires :identity, :public_ip_address, :username
+
+          options = {}
+          options[:key_data] = [private_key] if private_key
+          Fog::SSH.new(public_ip_address, username, options).run(commands)
+        end
+
+        def scp(local_path, remote_path)
+          requires :public_ip_address, :username
 
           options = {}
           options[:key_data] = [private_key] if private_key
-          Fog::SSH.new(ip_address, username, options).run(commands)
+          Fog::SCP.new(public_ip_address, username, options).upload(local_path, remote_path)
         end
 
         def start

data/lib/fog/compute/models/aws/snapshot.rb

@@ -5,8 +5,6 @@ module Fog
     class Compute
 
       class Snapshot < Fog::Model
-        extend Fog::Deprecation
-        deprecate(:status, :state)
 
         identity  :id,          :aliases => 'snapshotId'
 

data/lib/fog/compute/models/aws/volume.rb

@@ -5,8 +5,6 @@ module Fog
     class Compute
 
       class Volume < Fog::Model
-        extend Fog::Deprecation
-        deprecate(:status, :state)
 
         identity  :id,                    :aliases => 'volumeId'
 

data/lib/fog/compute/models/bluebox/server.rb

@@ -7,11 +7,6 @@ module Fog
       class BlockInstantiationError < StandardError; end
 
       class Server < Fog::Model
-        extend Fog::Deprecation
-        deprecate(:ssh_key, :public_key)
-        deprecate(:ssh_key=, :public_key=)
-        deprecate(:user, :username)
-        deprecate(:user=, :username=)
 
         identity :id
 
@@ -50,6 +45,10 @@ module Fog
           connection.images.get(image_id)
         end
 
+        def private_ip_address
+          nil
+        end
+
         def private_key_path
           @private_key_path ||= Fog.credentials[:private_key_path]
           @private_key_path &&= File.expand_path(@private_key_path)
@@ -59,6 +58,10 @@ module Fog
           @private_key ||= private_key_path && File.read(private_key_path)
         end
 
+        def public_ip_address
+          ips.first
+        end
+
         def public_key_path
           @public_key_path ||= Fog.credentials[:public_key_path]
           @public_key_path &&= File.expand_path(@public_key_path)
@@ -81,13 +84,14 @@ module Fog
         def save
           raise Fog::Errors::Error.new('Resaving an existing object may create a duplicate') if identity
           requires :flavor_id, :image_id
-          options = if !password && !public_key
-            raise(ArgumentError, "password or public_key is required for this operation")
-          elsif public_key
-            {'ssh_public_key' => public_key}
-          elsif @password
-            {'password' => password}
+          options = {}
+
+          if identity.nil?  # new record
+            raise(ArgumentError, "password or public_key is required for this operation") if !password && !public_key
+            options['ssh_public_key'] = public_key if @public_key
+            options['password'] = password if @password
           end
+
           options['username'] = username
           data = connection.create_block(flavor_id, image_id, options)
           merge_attributes(data.body)
@@ -115,6 +119,14 @@ module Fog
           Fog::SSH.new(ips.first['address'], username, options).run(commands)
         end
 
+        def scp(local_path, remote_path)
+          requires :ips, :username
+
+          options = {}
+          options[:key_data] = [private_key] if private_key
+          Fog::SCP.new(ips.first['address'], username, options).upload(local_path, remote_path)
+        end
+
         def username
           @username ||= 'deploy'
         end

data/lib/fog/compute/models/brightbox/server.rb

@@ -71,6 +71,14 @@ module Fog
           connection.images.get(image_id)
         end
 
+        def private_ip_address
+          nil
+        end
+
+        def public_ip_address
+          cloud_ips.first
+        end
+
         def ready?
           status == 'active'
         end

data/lib/fog/compute/models/ecloud/backup_internet_service.rb

@@ -0,0 +1,56 @@
+module Fog
+  module Ecloud
+    class Compute
+      class BackupInternetService < Fog::Ecloud::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::Ecloud::Compute::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

data/lib/fog/compute/models/ecloud/backup_internet_services.rb

@@ -0,0 +1,33 @@
+require 'fog/compute/models/ecloud/backup_internet_service'
+
+module Fog
+  module Ecloud
+    class Compute
+      class BackupInternetServices < Fog::Ecloud::Collection
+
+        model Fog::Ecloud::Compute::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

data/lib/fog/compute/models/ecloud/catalog.rb

@@ -0,0 +1,28 @@
+module Fog
+  module Ecloud
+    class Compute
+      class Catalog < Fog::Ecloud::Collection
+
+        model Fog::Ecloud::Compute::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

data/lib/fog/compute/models/ecloud/catalog_item.rb

@@ -0,0 +1,29 @@
+module Fog
+  module Ecloud
+    class Compute
+      class CatalogItem < Fog::Ecloud::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

data/lib/fog/compute/models/ecloud/firewall_acl.rb

@@ -0,0 +1,24 @@
+module Fog
+  module Ecloud
+    class Compute
+      class FirewallAcl < Fog::Ecloud::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

data/lib/fog/compute/models/ecloud/firewall_acls.rb

@@ -0,0 +1,31 @@
+require 'fog/compute/models/ecloud/firewall_acl'
+
+module Fog
+  module Ecloud
+    class Compute
+      class FirewallAcls < Fog::Ecloud::Collection
+
+        model Fog::Ecloud::Compute::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

data/lib/fog/compute/models/ecloud/internet_service.rb

@@ -0,0 +1,117 @@
+module Fog
+  module Ecloud
+    class Compute
+      class InternetService < Fog::Ecloud::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::Ecloud::Compute::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