fog 0.6.0 → 0.7.0

data/lib/fog/compute/models/virtual_box/servers.rb

@@ -0,0 +1,41 @@
+require 'fog/core/collection'
+require 'fog/compute/models/virtual_box/server'
+
+module Fog
+  module VirtualBox
+    class Compute
+
+      class Servers < Fog::Collection
+
+        model Fog::VirtualBox::Compute::Server
+
+        def all
+          data = connection.machines.map do |machine|
+            {
+              :raw => machine
+            }
+          end
+          load(data)
+        end
+
+        def bootstrap(new_attributes = {})
+          raise 'Not Implemented'
+          # server = create(new_attributes)
+          # server.start
+          # server.wait_for { ready? }
+          # server.setup(:password => server.password)
+          # server
+        end
+
+        def get(server_id)
+          machine = connection.find_machine(server_id)
+          new(:raw => machine)
+        rescue ::VirtualBox::Exceptions::ObjectNotFoundException
+          nil
+        end
+
+      end
+
+    end
+  end
+end

data/lib/fog/compute/models/virtual_box/storage_controller.rb

@@ -0,0 +1,83 @@
+require 'fog/core/model'
+
+module Fog
+  module VirtualBox
+    class Compute
+
+      class StorageController < Fog::Model
+
+        identity :name
+
+        attribute :bootable
+        attribute :bus
+        attribute :controller_type
+        attribute :instance
+        attribute :max_devices_per_port_count
+        attribute :max_port_count
+        attribute :min_port_count
+        attribute :port_count
+        attribute :use_host_io_cache
+
+        attr_accessor :machine
+
+        def attach(medium, port, device = 0)
+          requires :identity, :machine
+          with_session do |session|
+            session.machine.attach_device(identity, port, device, medium.device_type, medium.instance_variable_get(:@raw))
+            session.machine.save_settings
+          end
+          true
+        end
+
+        def destroy
+          requires :identity, :machine
+          with_session do |session|
+            session.machine.remove_storage_controller(identity)
+            session.machine.save_settings
+          end
+          true
+        end
+
+        def save
+          requires :bus, :identity, :machine
+          with_session do |session|
+            self.raw = session.machine.add_storage_controller(identity, bus)
+            raw.port_count = 1
+            session.machine.save_settings
+          end
+          true
+        end
+
+        private
+
+        def raw
+          @raw
+        end
+
+        def raw=(new_raw)
+          @raw = new_raw
+          raw_attributes = {}
+          # TODO: pending my patches being accepted :bootable, 
+          for key in [:bus, :controller_type, :instance, :max_devices_per_port_count, :max_port_count, :min_port_count, :port_count, :use_host_io_cache]
+            raw_attributes[key] = @raw.send(key)
+          end
+          merge_attributes(raw_attributes)
+        end
+
+        def session
+          ::VirtualBox::Lib.lib.session
+        end
+
+        def with_session
+          raw_machine = machine.instance_variable_get(:@raw)
+          raw_machine.lock_machine(session, :write)
+          yield session
+          session.unlock_machine
+        end
+
+      end
+
+    end
+  end
+
+end

data/lib/fog/compute/models/virtual_box/storage_controllers.rb

@@ -0,0 +1,38 @@
+require 'fog/core/collection'
+require 'fog/compute/models/virtual_box/storage_controller'
+
+module Fog
+  module VirtualBox
+    class Compute
+
+      class StorageControllers < Fog::Collection
+
+        model Fog::VirtualBox::Compute::StorageController
+
+        attr_accessor :machine
+
+        def all
+          requires :machine
+          data = machine.instance_variable_get(:@raw).storage_controllers.map do |storage_controller|
+            {:raw => storage_controller}
+          end
+          load(data)
+        end
+
+        def get(storage_controller_name)
+          requires :machine
+          all.detect do |storage_controller|
+            storage_controller.name == storage_controller_name
+          end
+        end
+
+        def new(attributes = {})
+          requires :machine
+          super({ :machine => machine }.merge!(attributes))
+        end
+
+      end
+
+    end
+  end
+end

data/lib/fog/compute/models/voxel/servers.rb

@@ -15,12 +15,13 @@ module Fog
 
         def get(device_id)
           if device_id && server = connection.devices_list(device_id).body['devices']
-
-            if server.empty?
-              nil
-            else
-              new(server.first)
-            end
+            new(server.first)
+          end
+        rescue Fog::Service::Error => error
+          if error.message == "The device_id passed in can't be matched to a valid device."
+            nil
+          else
+            raise error
           end
         end
 

data/lib/fog/compute/new_servers.rb

@@ -25,12 +25,6 @@ module Fog
           end
         end
 
-        def self.reset_data(keys=data.keys)
-          for key in [*keys]
-            data.delete(key)
-          end
-        end
-
         def initialize(options={})
           unless options.delete(:provider)
             location = caller.first
@@ -40,6 +34,11 @@ module Fog
           end
 
           @new_server_username = options[:new_servers_username]
+          reset_data
+        end
+
+        def reset_data
+          self.class.data.delete(@new_server_username)
           @data = self.class.data[@new_server_username]
         end
 

data/lib/fog/compute/parsers/aws/monitor_unmonitor_instances.rb

@@ -0,0 +1,35 @@
+module Fog
+  module Parsers
+    module AWS
+      module Compute
+
+        class MonitorUnmonitorInstances < Fog::Parsers::Base
+
+          def reset
+            @response = {}
+            @instance_set = []
+            @current_instance_set = {}
+          end
+
+          def end_element(name)
+            case name
+            when 'requestId'
+              @response['requestId'] = @value
+            when 'instanceId'
+              @current_instance_set['instanceId'] = @value
+            when 'item'
+              @instance_set << @current_instance_set
+              @current_instance_set = {}
+            when 'state'
+              @current_instance_set['monitoring'] = @value
+            when 'instancesSet'
+              @response['instancesSet'] = @instance_set
+            end
+          end
+
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/compute/rackspace.rb

@@ -53,12 +53,6 @@ module Fog
           end
         end
 
-        def self.reset_data(keys=data.keys)
-          for key in [*keys]
-            data.delete(key)
-          end
-        end
-
         def initialize(options={})
           unless options.delete(:provider)
             location = caller.first
@@ -68,6 +62,11 @@ module Fog
           end
 
           @rackspace_username = options[:rackspace_username]
+          reset_data
+        end
+
+        def reset_data
+          self.class.data.delete(@rackspace_username)
           @data = self.class.data[@rackspace_username]
         end
 
@@ -103,7 +102,8 @@ module Fog
                 'X-Auth-Token' => @auth_token
               }.merge!(params[:headers] || {}),
               :host     => @host,
-              :path     => "#{@path}/#{params[:path]}"
+              :path     => "#{@path}/#{params[:path]}",
+              :query    => ('ignore_awful_caching' << Time.now.to_i.to_s)
             }))
           rescue Excon::Errors::Unauthorized => error
             if JSON.parse(response.body)['unauthorized']['message'] == 'Invalid authentication token.  Please renew.'

data/lib/fog/compute/requests/aws/delete_tags.rb

@@ -8,8 +8,8 @@ module Fog
         # Remove tags from resources
         #
         # ==== Parameters
-        # * resources<~String> - One or more resources to tag
-        # * tags<~String> - hash of key value tag pairs to assign
+        # * resources<~String> - One or more resources to remove tags from
+        # * tags<~String> - hash of key value tag pairs to remove
         #
         # ==== Returns
         # * response<~Excon::Response>:
@@ -18,15 +18,18 @@ module Fog
         #     * 'return'<~Boolean> - success?
         def delete_tags(resources, tags)
           resources = [*resources]
-          for key, value in tags
-            if value.nil?
-              tags[key] = ''
-            end
-          end
           params = {}
           params.merge!(AWS.indexed_param('ResourceId', resources))
-          params.merge!(AWS.indexed_param('Tag.%d.Key', tags.keys))
-          params.merge!(AWS.indexed_param('Tag.%d.Value', tags.values))
+
+          # can not rely on indexed_param because nil values should be omitted
+          tags.keys.each_with_index do |key, index|
+            index += 1 # should start at 1 instead of 0
+            params.merge!("Tag.#{index}.Key" => key)
+            unless tags[key].nil?
+              params.merge("Tag.#{index}.Value" => tags[key])
+            end
+          end
+
           request({
             'Action'            => 'DeleteTags',
             :parser             => Fog::Parsers::AWS::Compute::Basic.new

data/lib/fog/compute/requests/aws/monitor_instances.rb

@@ -0,0 +1,52 @@
+module Fog
+  module AWS
+    class Compute
+
+      class Real
+
+        require 'fog/compute/parsers/aws/monitor_unmonitor_instances'
+
+        # Monitor specified instance
+        # http://docs.amazonwebservices.com/AWSEC2/latest/APIReference/ApiReference-query-MonitorInstances.html
+        #
+        # ==== Parameters
+        # * instance_ids<~Array> - Arrays of instances Ids to monitor
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'requestId'<~String> - Id of request
+        #     * 'instancesSet': http://docs.amazonwebservices.com/AWSEC2/latest/APIReference/ApiReference-ItemType-MonitorInstancesResponseSetItemType.html
+        def monitor_instances(instance_ids)
+          params = AWS.indexed_param('InstanceId', instance_ids)
+          request({
+                          'Action' => 'MonitorInstances',
+                          :idempotent => true,
+                          :parser => Fog::Parsers::AWS::Compute::MonitorUnmonitorInstances.new
+                  }.merge!(params))
+        end
+
+      end
+
+      class Mock
+
+        def monitor_instances(instance_ids)
+          response        = Excon::Response.new
+          response.status = 200
+          [*instance_ids].each do |instance_id|
+            if instance = @data[:instances][instance_id]
+              instance['monitoring']['state'] = 'enabled'
+            else
+              raise Fog::AWS::Compute::NotFound.new("The instance ID '#{instance_ids}' does not exist")
+            end
+          end
+          instances_set = [*instance_ids].inject([]) { |memo, id| memo << {'instanceId' => id, 'monitoring' => 'enabled'} }
+          response.body = {'requestId' => 'some_request_id', 'instancesSet' => instances_set}
+          response
+        end
+
+      end
+    end
+
+  end
+end

data/lib/fog/compute/requests/aws/revoke_security_group_ingress.rb

@@ -8,14 +8,13 @@ module Fog
         # Remove permissions from a security group
         #
         # ==== Parameters
+        # * 'GroupName'<~String> - Name of group
         # * options<~Hash>:
-        #   * 'GroupName'<~String> - Name of group
         #   * 'SourceSecurityGroupName'<~String> - Name of security group to authorize
         #   * 'SourceSecurityGroupOwnerId'<~String> - Name of owner to authorize
         #   or
         #   * 'CidrIp' - CIDR range
         #   * 'FromPort' - Start of port range (or -1 for ICMP wildcard)
-        #   * 'GroupName' - Name of group to modify
         #   * 'IpProtocol' - Ip protocol, must be in ['tcp', 'udp', 'icmp']
         #   * 'ToPort' - End of port range (or -1 for ICMP wildcard)
         #
@@ -24,9 +23,18 @@ module Fog
         #   * body<~Hash>:
         #     * 'requestId'<~String> - Id of request
         #     * 'return'<~Boolean> - success?
-        def revoke_security_group_ingress(options = {})
+        def revoke_security_group_ingress(group_name, options = {})
+          if group_name.is_a?(Hash)
+            location = caller.first
+            warning = "[yellow][WARN] Fog::AWS::Compute#revoke_security_group_ingress now requires the 'group_name' parameter. Only specifying an options hash is now deprecated"
+            warning << " [light_black](" << location << ")[/] "
+            Formatador.display_line(warning)
+            options = group_name
+            group_name = options['GroupName']
+          end
           request({
             'Action'    => 'RevokeSecurityGroupIngress',
+            'GroupName' => group_name,
             :idempotent => true,
             :parser     => Fog::Parsers::AWS::Compute::Basic.new
           }.merge!(options))
@@ -36,13 +44,21 @@ module Fog
 
       class Mock
 
-        def revoke_security_group_ingress(options = {})
+        def revoke_security_group_ingress(group_name, options = {})
+          if group_name.is_a?(Hash)
+            location = caller.first
+            warning = "[yellow][WARN] Fog::AWS::Compute#revoke_security_group_ingress now requires the 'group_name' parameter. Only specifying an options hash is now deprecated"
+            warning << " [light_black](" << location << ")[/] "
+            Formatador.display_line(warning)
+            options = group_name
+            group_name = options['GroupName']
+          end
           response = Excon::Response.new
-          group = @data[:security_groups][options['GroupName']]
+          group = @data[:security_groups][group_name]
           if group
-            if options['GroupName'] && options['SourceSecurityGroupName'] && options['SourceSecurityGroupOwnerId']
+            if options['SourceSecurityGroupName'] && options['SourceSecurityGroupOwnerId']
               group['ipPermissions'].delete_if {|permission|
-                permission['groups'].first['groupName'] == options['GroupName']
+                permission['groups'].first['groupName'] == group_name
               }
             else
               ingress = group['ipPermissions'].select {|permission|
@@ -66,7 +82,7 @@ module Fog
             }
             response
           else
-            raise Fog::AWS::Compute::NotFound.new("The security group '#{options['GroupName']}' does not exist")
+            raise Fog::AWS::Compute::NotFound.new("The security group '#{group_name}' does not exist")
           end
         end
 

data/lib/fog/compute/requests/aws/unmonitor_instances.rb

@@ -0,0 +1,53 @@
+module Fog
+  module AWS
+    class Compute
+
+      class Real
+
+        require 'fog/compute/parsers/aws/monitor_unmonitor_instances'
+
+        # UnMonitor specified instance
+        # http://docs.amazonwebservices.com/AWSEC2/latest/APIReference/ApiReference-query-UnmonitorInstances.html
+        #
+        # ==== Parameters
+        # * instance_ids<~Array> - Arrays of instances Ids to monitor
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'requestId'<~String> - Id of request
+        #     * 'instancesSet': http://docs.amazonwebservices.com/AWSEC2/latest/APIReference/ApiReference-ItemType-MonitorInstancesResponseSetItemType.html
+        def unmonitor_instances(instance_ids)
+          params = AWS.indexed_param('InstanceId', instance_ids)
+          request({
+                          'Action' => 'UnmonitorInstances',
+                          :idempotent => true,
+                          :parser => Fog::Parsers::AWS::Compute::MonitorUnmonitorInstances.new
+                  }.merge!(params))
+        end
+
+      end
+
+      class Mock
+
+        def unmonitor_instances(instance_ids)
+          response        = Excon::Response.new
+          response.status = 200
+          [*instance_ids].each do |instance_id|
+            if instance = @data[:instances][instance_id]
+              instance['monitoring']['state'] = 'enabled'
+            else
+              raise Fog::AWS::Compute::NotFound.new("The instance ID '#{instance_ids}' does not exist")
+            end
+          end
+          instances_set = [*instance_ids].inject([]) { |memo, id| memo << {'instanceId' => id, 'monitoring' => 'disabled'} }
+          response.body = {'requestId' => 'some_request_id', 'instancesSet' => instances_set}
+          response
+        end
+        
+      end
+
+    end
+
+  end
+end