fog 1.0.0 → 1.1.0

data/lib/fog/aws/elb.rb

@@ -64,7 +64,7 @@ module Fog
 
           @region = options[:region] || 'us-east-1'
 
-          unless ['ap-northeast-1', 'ap-southeast-1', 'eu-west-1', 'us-east-1', 'us-west-1'].include?(@region)
+          unless ['ap-northeast-1', 'ap-southeast-1', 'eu-west-1', 'us-east-1', 'us-west-1', 'us-west-2'].include?(@region)
             raise ArgumentError, "Unknown region: #{@region.inspect}"
           end
         end
@@ -94,7 +94,7 @@ module Fog
         #
         # ==== Parameters
         # * options<~Hash> - config arguments for connection.  Defaults to {}.
-        #   * region<~String> - optional region to use, in ['eu-west-1', 'us-east-1', 'us-west-1', 'ap-northeast-1', 'ap-southeast-1']
+        #   * region<~String> - optional region to use, in ['eu-west-1', 'us-east-1', 'us-west-1', 'us-west-2', 'ap-northeast-1', 'ap-southeast-1']
         #
         # ==== Returns
         # * ELB object with connection to AWS.
@@ -118,6 +118,8 @@ module Fog
             'elasticloadbalancing.us-east-1.amazonaws.com'
           when 'us-west-1'
             'elasticloadbalancing.us-west-1.amazonaws.com'
+          when 'us-west-2'
+            'elasticloadbalancing.us-west-2.amazonaws.com'
           else
             raise ArgumentError, "Unknown region: #{options[:region].inspect}"
           end

data/lib/fog/aws/emr.rb

@@ -0,0 +1,133 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'aws'))
+
+module Fog
+  module AWS
+    class EMR < Fog::Service
+
+      class IdentifierTaken < Fog::Errors::Error; end
+
+      requires :aws_access_key_id, :aws_secret_access_key
+      recognizes :region, :host, :path, :port, :scheme, :persistent
+
+      request_path 'fog/aws/requests/emr'
+
+      request :add_instance_groups
+      request :add_job_flow_steps
+      request :describe_job_flows
+      request :modify_instance_groups
+      request :run_job_flow
+      request :set_termination_protection
+      request :terminate_job_flows
+
+      # model_path 'fog/aws/models/rds'
+      # model       :server
+      # collection  :servers
+      # model       :snapshot
+      # collection  :snapshots
+      # model       :parameter_group
+      # collection  :parameter_groups
+      # 
+      # model       :parameter
+      # collection  :parameters
+      # 
+      # model       :security_group
+      # collection  :security_groups
+
+      class Mock
+
+        def initialize(options={})
+          Fog::Mock.not_implemented
+        end
+
+      end
+
+      class Real
+
+        # Initialize connection to EMR
+        #
+        # ==== Notes
+        # options parameter must include values for :aws_access_key_id and
+        # :aws_secret_access_key in order to create a connection
+        #
+        # ==== Examples
+        #   emr = EMR.new(
+        #    :aws_access_key_id => your_aws_access_key_id,
+        #    :aws_secret_access_key => your_aws_secret_access_key
+        #   )
+        #
+        # ==== Parameters
+        # * options<~Hash> - config arguments for connection.  Defaults to {}.
+        #   * region<~String> - optional region to use, in ['eu-west-1', 'us-east-1', 'us-west-1', 'us-west-2', 'ap-southeast-1']
+        #
+        # ==== Returns
+        # * EMR object with connection to AWS.
+        def initialize(options={})
+          @aws_access_key_id      = options[:aws_access_key_id]
+          @aws_secret_access_key  = options[:aws_secret_access_key]
+          @connection_options     = options[:connection_options] || {}
+          @hmac = Fog::HMAC.new('sha256', @aws_secret_access_key)
+
+          options[:region] ||= 'us-east-1'
+          @host = options[:host] || 'elasticmapreduce.amazonaws.com'
+          @path       = options[:path]        || '/'
+          @persistent = options[:persistent]  || false
+          @port       = options[:port]        || 443
+          @scheme     = options[:scheme]      || 'https'
+          @connection = Fog::Connection.new("#{@scheme}://#{@host}:#{@port}#{@path}", @persistent, @connection_options)
+        end
+
+        def reload
+          @connection.reset
+        end
+
+        private
+
+        def request(params)
+          idempotent  = params.delete(:idempotent)
+          parser      = params.delete(:parser)
+
+          body = Fog::AWS.signed_params(
+            params,
+            {
+              :aws_access_key_id  => @aws_access_key_id,
+              :hmac               => @hmac,
+              :host               => @host,
+              :path               => @path,
+              :port               => @port,
+              :version            => '2009-03-31' #'2010-07-28'
+            }
+          )
+
+          begin
+            response = @connection.request({
+              :body       => body,
+              :expects    => 200,
+              :headers    => { 'Content-Type' => 'application/x-www-form-urlencoded' },
+              :idempotent => idempotent,
+              :host       => @host,
+              :method     => 'POST',
+              :parser     => parser
+            })
+          rescue Excon::Errors::HTTPStatusError => error
+            if match = error.message.match(/<Code>(.*)<\/Code>[\s\\\w]+<Message>(.*)<\/Message>/m)
+              # case match[1].split('.').last
+              # when 'DBInstanceNotFound', 'DBParameterGroupNotFound', 'DBSnapshotNotFound', 'DBSecurityGroupNotFound'
+              #   raise Fog::AWS::RDS::NotFound.slurp(error, match[2])
+              # when 'DBParameterGroupAlreadyExists'
+              #   raise Fog::AWS::RDS::IdentifierTaken.slurp(error, match[2])
+              # else
+              #   raise
+              # end
+              raise
+            else
+              raise
+            end
+          end
+
+          response
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/aws/models/cloud_watch/alarm.rb

@@ -0,0 +1,12 @@
+require 'fog/core/model'
+
+module Fog
+  module AWS
+    class CloudWatch
+
+      class Alarm < Fog::Model
+        attribute :alarm_names, :aliases => 'AlarmNames'
+      end
+    end
+  end
+end

data/lib/fog/aws/models/cloud_watch/alarm_data.rb

@@ -0,0 +1,39 @@
+require 'fog/core/collection'
+require 'fog/aws/models/cloud_watch/alarm_datum'
+
+module Fog
+  module AWS
+    class CloudWatch
+      class AlarmData < Fog::Collection
+        model Fog::AWS::CloudWatch::AlarmDatum
+        
+        def all(conditions={})
+          data = connection.describe_alarms(conditions).body['DescribeAlarmsResult']['MetricAlarms']
+          load(data) # data is an array of attribute hashes
+        end
+        
+        def get(namespace, metric_name, dimensions=nil, period=nil, statistic=nil, unit=nil)
+          list_opts = {'Namespace' => namespace, 'MetricName' => metric_name}
+          if dimensions
+            dimensions_array = dimensions.collect do |name, value|
+              {'Name' => name, 'Value' => value}
+            end
+            list_opts.merge!('Dimensions' => dimensions_array) 
+          end
+          if period
+            list_opts.merge!('Period' => period) 
+          end
+          if statistic
+          list_opts.merge!('Statistic' => statistic) 
+          end
+          if unit
+            list_opts.merge!('Unit' => unit) 
+          end
+          data = connection.describe_alarms_for_metric(list_opts).body['DescribeAlarmsForMetricResult']['MetricAlarms']
+          load(data)
+        end
+        
+      end
+    end
+  end
+end

data/lib/fog/aws/models/cloud_watch/alarm_datum.rb

@@ -0,0 +1,66 @@
+require 'fog/core/model'
+
+module Fog
+  module AWS
+    class CloudWatch
+
+      class AlarmDatum < Fog::Model
+        attribute :alarm_name, :aliases => 'AlarmName'
+        attribute :metric_name, :aliases => 'MetricName'
+        attribute :namespace, :aliases => 'Namespace'
+        attribute :dimensions, :aliases => 'Dimensions'
+        attribute :alarm_description, :aliases => 'AlarmDescription'
+        attribute :alarm_arn, :aliases => 'AlarmArn'
+        attribute :state_value, :aliases => 'StateValue'
+        attribute :statistic, :aliases => 'Statistic'
+        attribute :comparison_operator, :aliases => 'ComparisonOperator'
+        attribute :state_reason, :aliases => 'StateReason'
+        attribute :action_enabled, :aliases => 'ActionsEnabled'
+        attribute :period, :aliases => 'Period' 
+        attribute :evaluation_periods, :aliases => 'EvaluationPeriods'
+        attribute :threshold, :aliases => 'Threshold'
+        attribute :alarm_actions, :aliases => 'AlarmActions'
+        attribute :ok_actions, :aliases => 'OKActions'
+        attribute :insufficient_actions, :aliases => 'InsufficientDataActions'
+        attribute :unit, :aliases => 'Unit'
+        attribute :state_updated_timestamp, :aliases => 'StateUpdatedTimestamp'
+        attribute :alarm_configuration_updated_timestamp, :aliases => 'AlarmConfigurationUpdatedTimestamp'
+
+        def save
+          requires :alarm_name
+          requires :comparison_operator
+          requires :evaluation_periods
+          requires :metric_name
+          requires :namespace
+          requires :period
+          requires :statistic
+          requires :threshold
+
+          alarm_definition = {
+              'AlarmName' => alarm_name,
+              'ComparisonOperator' => comparison_operator,
+              'EvaluationPeriods' => evaluation_periods,
+              'MetricName' => metric_name, 
+              'Namespace' => namespace,
+              'Period' => period,
+              'Statistic' => statistic,
+              'Threshold' => threshold
+              }
+
+          alarm_definition.merge!('ActionsEnabled' => action_enabled) if action_enabled
+          alarm_definition.merge!('AlarmActions' => alarm_actions) if alarm_actions
+          alarm_definition.merge!('AlarmDescription' => alarm_description) if alarm_description
+
+          #dimension is an array of Name/Value pairs, ex. [{'Name'=>'host', 'Value'=>'localhost'},{'Name'=>'version', 'Value'=>'0.11.0'}]
+          alarm_definition.merge!('Dimensions' => dimensions) if dimensions
+          alarm_definition.merge!('InsufficientDataActions' => insufficient_actions) if insufficient_actions
+          alarm_definition.merge!('OKActions' => ok_actions) if ok_actions
+          alarm_definition.merge!('Unit' => unit) if unit
+
+          connection.put_metric_alarm(alarm_definition)
+          true
+        end
+      end
+    end
+  end
+end

data/lib/fog/aws/models/cloud_watch/alarm_histories.rb

@@ -0,0 +1,18 @@
+require 'fog/core/collection'
+require 'fog/aws/models/cloud_watch/alarm_history'
+
+module Fog
+  module AWS
+    class CloudWatch
+      class AlarmHistories < Fog::Collection
+        model Fog::AWS::CloudWatch::AlarmHistory
+
+        def all(conditions={})
+          data = connection.describe_alarm_history(conditions).body['DescribeAlarmHistoryResult']['AlarmHistoryItems']
+          load(data) # data is an array of attribute hashes
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/aws/models/cloud_watch/alarm_history.rb

@@ -0,0 +1,16 @@
+require 'fog/core/model'
+
+module Fog
+  module AWS
+    class CloudWatch
+
+      class AlarmHistory < Fog::Model
+        attribute :alarm_name, :aliases => 'AlarmName'
+        attribute :end_date, :aliases => 'EndDate'
+        attribute :history_item_type, :aliases => 'HistoryItemType'
+        attribute :max_records, :aliases => 'MaxRecords'
+        attribute :start_date, :aliases => 'StartDate'
+      end
+    end
+  end
+end

data/lib/fog/aws/models/cloud_watch/alarms.rb

@@ -0,0 +1,30 @@
+require 'fog/core/collection'
+require 'fog/aws/models/cloud_watch/alarm'
+
+module Fog
+  module AWS
+    class CloudWatch
+
+      class Alarms < Fog::Collection
+        model Fog::AWS::CloudWatch::Alarm
+    
+        #alarm_names is an array of alarm names
+        def delete(alarm_names)
+          connection.delete_alarms(alarm_names)
+          true
+        end
+
+        def disable(alarm_names)
+          connection.disable_alarm_actions(alarm_names)
+          true
+        end
+
+        def enable(alarm_names)
+          connection.enable_alarm_actions(alarm_names)
+          true
+        end
+
+      end
+    end
+  end
+end

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

@@ -56,7 +56,7 @@ module Fog
 
         def all(filters = filters)
           unless filters.is_a?(Hash)
-            Fog::Logger.warning("all with #{filters.class} param is deprecated, use all('public-ip' => []) instead [light_black](#{caller.first})[/]")
+            Fog::Logger.deprecation("all with #{filters.class} param is deprecated, use all('public-ip' => []) instead [light_black](#{caller.first})[/]")
             filters = {'public-ip' => [*filters]}
           end
           self.filters = filters

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

@@ -51,7 +51,7 @@ module Fog
 
         def all(filters = filters)
           unless filters.is_a?(Hash)
-            Fog::Logger.warning("all with #{filters.class} param is deprecated, use all('key-name' => []) instead [light_black](#{caller.first})[/]")
+            Fog::Logger.deprecation("all with #{filters.class} param is deprecated, use all('key-name' => []) instead [light_black](#{caller.first})[/]")
             filters = {'key-name' => [*filters]}
           end
           self.filters = filters

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

@@ -57,7 +57,7 @@ module Fog
 
         def all(filters = filters)
           unless filters.is_a?(Hash)
-            Fog::Logger.warning("all with #{filters.class} param is deprecated, use all('group-name' => []) instead [light_black](#{caller.first})[/]")
+            Fog::Logger.deprecation("all with #{filters.class} param is deprecated, use all('group-name' => []) instead [light_black](#{caller.first})[/]")
             filters = {'group-name' => [*filters]}
           end
           self.filters = filters

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

@@ -169,8 +169,10 @@ module Fog
           data = connection.run_instances(image_id, 1, 1, options)
           merge_attributes(data.body['instancesSet'].first)
 
-          if self.tags
-            for key, value in self.tags
+          if tags = self.tags
+            # expect eventual consistency
+            Fog.wait_for { self.reload rescue nil }
+            for key, value in (self.tags = tags)
               connection.tags.create(
                 :key          => key,
                 :resource_id  => self.identity,

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

@@ -57,7 +57,7 @@ module Fog
 
         def all(filters = self.filters)
           unless filters.is_a?(Hash)
-            Fog::Logger.warning("all with #{filters.class} param is deprecated, use all('instance-id' => []) instead [light_black](#{caller.first})[/]")
+            Fog::Logger.deprecation("all with #{filters.class} param is deprecated, use all('instance-id' => []) instead [light_black](#{caller.first})[/]")
             filters = {'instance-id' => [*filters]}
           end
           self.filters = filters

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

@@ -19,7 +19,7 @@ module Fog
 
         def all(filters = filters, options = {})
           unless filters.is_a?(Hash)
-            Fog::Logger.warning("all with #{filters.class} param is deprecated, use all('snapshot-id' => []) instead [light_black](#{caller.first})[/]")
+            Fog::Logger.deprecation("all with #{filters.class} param is deprecated, use all('snapshot-id' => []) instead [light_black](#{caller.first})[/]")
             filters = {'snapshot-id' => [*filters]}
           end
           self.filters = filters

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

@@ -55,6 +55,27 @@ module Fog
           super
         end
 
+        def destroy
+          requires :id
+
+          connection.cancel_spot_instance_requests(id)
+          true
+        end
+
+        def key_pair
+          requires :key_name
+
+          connection.key_pairs.all(key_name).first
+        end
+
+        def key_pair=(new_keypair)
+          self.key_name = new_keypair && new_keypair.name
+        end
+
+        def ready?
+          state == 'active'
+        end
+
         def save
           requires :image_id, :flavor_id, :price
 
@@ -83,10 +104,6 @@ module Fog
           merge_attributes( spot_instance_request )
         end
 
-        def ready?
-          state == 'active'
-        end
-
       end
     end
   end