aws_sdk 3.1.5

data/lib/aws/auto_scaling/request.rb

@@ -0,0 +1,23 @@
+# Copyright 2011-2012 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"). You
+# may not use this file except in compliance with the License. A copy of
+# the License is located at
+#
+#     http://aws.amazon.com/apache2.0/
+#
+# or in the "license" file accompanying this file. This file is
+# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
+# ANY KIND, either express or implied. See the License for the specific
+# language governing permissions and limitations under the License.
+
+module AWS
+  class AutoScaling
+
+    # @private
+    class Request < Core::Http::Request
+      include Core::Signature::Version2
+    end
+
+  end
+end

data/lib/aws/auto_scaling/scaling_policy.rb

@@ -0,0 +1,125 @@
+# Copyright 2011-2012 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"). You
+# may not use this file except in compliance with the License. A copy of
+# the License is located at
+#
+#     http://aws.amazon.com/apache2.0/
+#
+# or in the "license" file accompanying this file. This file is
+# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
+# ANY KIND, either express or implied. See the License for the specific
+# language governing permissions and limitations under the License.
+
+module AWS
+  class AutoScaling
+    class ScalingPolicy < Core::Resource
+
+      include ScalingPolicyOptions
+
+      # @private
+      def initialize auto_scaling_group, policy_name, options = {}
+        @group = auto_scaling_group
+        @name = policy_name
+        super
+      end
+
+      # @return [Group]
+      attr_reader :group
+
+      alias_method :auto_scaling_group, :group
+
+      # @return [String]
+      attr_reader :name
+
+      attribute :arn, :as => :policy_arn, :static => true
+
+      attribute :adjustment_type
+
+      attribute :scaling_adjustment
+
+      attribute :alarms do
+        translates_output do |alarms|
+          alarms.inject({}) do |hash,alarm|
+            hash.merge(alarm.alarm_name => alarm.alarm_arn)
+          end
+        end
+      end
+
+      attribute :cooldown
+
+      populates_from(:describe_policies) do |resp|
+        resp.scaling_policies.find do |p| 
+          p.policy_name == name and
+          p.auto_scaling_group_name == group.name
+        end
+      end
+
+      # Updates this scaling policy.
+      # @param (see ScalingPolicyOptions#scaling_policy_options)
+      # @option (see ScalingPolicyOptions#scaling_policy_options)
+      # @return [nil]
+      def update options = {}
+        client_opts = scaling_policy_options(group, name, options)
+        resp = client.put_scaling_policy(client_opts)
+        static_attributes[:arn] = resp.policy_arn
+        nil
+      end
+      alias_method :put, :update
+
+      # Runs this policy against it's Auto Scaling group.
+      #
+      # @param [Hash] options
+      #
+      # @option options [Boolean] :honor_cooldown (false) Set to true if you
+      #   want Auto Scaling to reject this request when the Auto Scaling 
+      #   group is in cooldown.
+      #
+      # @raise [Errors::ScalingActivityInProgress]
+      #
+      # @return [nil]
+      #
+      def execute options = {}
+        client_opts = {}
+        client_opts[:auto_scaling_group_name] = group.name
+        client_opts[:policy_name] = name
+        client_opts[:honor_cooldown] = options[:honor_cooldown] == true
+        client.execute_policy(client_opts)
+        nil
+      end
+
+      # Deletes this scaling policy.
+      # @return [nil]
+      def delete
+        client_opts = {}
+        client_opts[:auto_scaling_group_name] = group.name
+        client_opts[:policy_name] = name
+        client.delete_policy(client_opts)
+        nil
+      end
+
+      # @return [Boolean] Returns true if the policy exists.
+      def exists?
+        client_opts = {}
+        client_opts[:auto_scaling_group_name] = group.name
+        client_opts[:policy_names] = [name]
+        resp = client.describe_policies(client_opts)
+        !resp.scaling_policies.empty?
+      end
+
+      protected
+
+      def get_resource attr_name = nil
+        client_opts = {}
+        client_opts[:auto_scaling_group_name] = group.name
+        client_opts[:policy_names] = [name]
+        client.describe_policies(client_opts)
+      end
+
+      def resource_identifiers
+        [[:group, group], [:name, name]]
+      end
+
+    end
+  end
+end

data/lib/aws/auto_scaling/scaling_policy_collection.rb

@@ -0,0 +1,72 @@
+# Copyright 2011-2012 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"). You
+# may not use this file except in compliance with the License. A copy of
+# the License is located at
+#
+#     http://aws.amazon.com/apache2.0/
+#
+# or in the "license" file accompanying this file. This file is
+# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
+# ANY KIND, either express or implied. See the License for the specific
+# language governing permissions and limitations under the License.
+
+module AWS
+  class AutoScaling
+    class ScalingPolicyCollection
+
+      include Core::Collection::Limitable
+      include ScalingPolicyOptions
+      
+      def initialize auto_scaling_group, options = {}
+        @group = auto_scaling_group
+        super
+      end
+
+      # @return [Group]
+      attr_reader :group
+
+      alias_method :auto_scaling_group, :group
+
+    
+      # @param [String] name The name of the policy you want to create or update.
+      # @param (see ScalingPolicyOptions#scaling_policy_options)
+      # @option (see ScalingPolicyOptions#scaling_policy_options)
+      # @return [ScalingPolicy]
+      def create name, options = {}
+        scaling_policy = self[name]
+        scaling_policy.put(options)
+        scaling_policy
+      end
+      alias_method :put, :create
+
+      # @param [String] policy_name
+      # @return [ScalingPolicy]
+      def [] policy_name
+        ScalingPolicy.new(group, policy_name)
+      end
+      
+      protected
+
+      def _each_item next_token, limit, options = {}, &block
+
+        options[:next_token] = next_token if next_token
+        options[:max_records] = limit if limit
+        options[:auto_scaling_group_name] = group.name
+
+        resp = client.describe_policies(options)
+        resp.scaling_policies.each do |details|
+          
+          scaling_policy = ScalingPolicy.new_from(
+            :describe_policies, details, 
+            group, details.policy_name)
+
+          yield(scaling_policy)
+          
+        end
+        resp.data[:next_token]
+      end
+
+    end
+  end
+end

data/lib/aws/auto_scaling/scaling_policy_options.rb

@@ -0,0 +1,61 @@
+# Copyright 2011-2012 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"). You
+# may not use this file except in compliance with the License. A copy of
+# the License is located at
+#
+#     http://aws.amazon.com/apache2.0/
+#
+# or in the "license" file accompanying this file. This file is
+# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
+# ANY KIND, either express or implied. See the License for the specific
+# language governing permissions and limitations under the License.
+
+module AWS
+  class AutoScaling
+
+    # Provides a hepler method for parsing scaling policy options.
+    # @private
+    module ScalingPolicyOptions
+
+      protected
+
+      # @param [Hash] options
+      #
+      # @option options [required,String] :adjustment_type Specifies whether
+      #   the adjustment is an absolute number or a percentage of the current
+      #   capacity.  Valid values are:
+      #   * 'ChangeInCapacity'
+      #   * 'ExactCapacity'
+      #   * 'PercentChangeInCapacity'
+      #
+      # @option options [required,Integer] :scaling_adjustment The number of
+      #   instances by which to scale. +:adjustment_type+ determines the 
+      #   interpretation of this umber (e.g., as an absolute number or as a
+      #   percentage of the existing Auto Scaling group size). A positive 
+      #   increment adds to the current capacity and a negative value 
+      #   removes from the current capacity.
+      #
+      # @option options [Integer] :cooldown The amount of time, in seconds,
+      #   after a scaling activity completes before any further 
+      #   trigger-related scaling activities can start.
+      #
+      # @return [Hash]
+      #
+      def scaling_policy_options auto_scaling_group, policy_name, options
+        opts = {}
+        opts[:auto_scaling_group_name] = auto_scaling_group.name
+        opts[:policy_name] = policy_name
+        [
+          :cooldown,
+          :adjustment_type,
+          :scaling_adjustment,
+        ].each do |opt|
+          opts[opt] = options[opt] if options.key?(opt)
+        end
+        opts
+      end
+
+    end
+  end
+end

data/lib/aws/auto_scaling/scheduled_action.rb

@@ -0,0 +1,145 @@
+# Copyright 2011-2012 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"). You
+# may not use this file except in compliance with the License. A copy of
+# the License is located at
+#
+#     http://aws.amazon.com/apache2.0/
+#
+# or in the "license" file accompanying this file. This file is
+# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
+# ANY KIND, either express or implied. See the License for the specific
+# language governing permissions and limitations under the License.
+
+require 'time'
+
+module AWS
+  class AutoScaling
+
+    # @attr_reader [String] auto_scaling_group_name
+    #
+    # @attr_reader [Integer] desired_capacity
+    #
+    # @attr_reader [String] recurrence
+    #
+    # @attr_reader [Time] start_time
+    #
+    # @attr_reader [Time] end_time
+    #
+    # @attr_reader [Integer] min_size
+    #
+    # @attr_reader [Integer] max_size
+    #
+    # @attr_reader [String] arn
+    #
+    class ScheduledAction < Core::Resource
+
+      # @private
+      def initialize name, options = {}
+        @name = name
+        super
+      end
+
+      # @return [String]
+      attr_reader :name
+
+      attribute :arn, :as => :scheduled_action_arn
+
+      attribute :auto_scaling_group_name, :static => true
+
+      attribute :desired_capacity
+
+      attribute :recurrence
+
+      attribute :start_time
+
+      attribute :end_time
+
+      attribute :max_size
+
+      attribute :min_size
+
+      populates_from(:describe_scheduled_actions) do |resp|
+        resp.scheduled_update_group_actions.find do |action|
+          action.scheduled_action_name == name
+        end
+      end
+
+      # @return [Group]
+      def group
+        Group.new(auto_scaling_group_name, :config => config)
+      end
+
+      # Updates the scheduled action.  If you omit an option,
+      # the corresponding value remains unchanged in the Auto 
+      # Scaling group.
+      #
+      # @param [Hash] options
+      #
+      # @option options [Integer] :desired_capacity
+      #
+      # @option options [String] :recurrence
+      #
+      # @option options [Time,String] :start_time
+      #
+      # @option options [Time,String] :end_time
+      #
+      # @option options [Integer] :min_size
+      #
+      # @option options [Integer] :max_size
+      #
+      # @return [nil]
+      #
+      def update options = {}
+
+        client_opts = options.dup
+        client_opts[:scheduled_action_name] = name
+        client_opts[:auto_scaling_group_name] = auto_scaling_group_name
+
+        # convert these options to timestamps 
+        [:start_time, :end_time].each do |opt|
+          if client_opts[opt].is_a?(Time)
+            client_opts[opt] = client_opts[opt].iso8601
+          end
+        end
+
+        client.put_scheduled_update_group_action(client_opts)
+
+        nil
+
+      end
+      alias_method :put, :update
+
+      # @return [Boolean]
+      def exists?
+        client_opts = {}  
+        client_opts[:scheduled_action_names] = [name]
+        resp = client.describe_scheduled_actions(client_opts)
+        !resp.scheduled_update_group_actions.empty?
+      end
+
+      # Deletes the current scheduled action.
+      # @return [nil]
+      def delete
+        client_opts = {}
+        client_opts[:scheduled_action_name] = name
+        client_opts[:auto_scaling_group_name] = auto_scaling_group_name
+        client.delete_scheduled_action(client_opts)
+        nil
+      end
+
+      protected
+
+      def resource_identifiers
+        [[:name, name]]
+      end
+
+      def get_resource attr_name = nil
+        client_opts = {}
+        client_opts[:scheduled_action_names] = [name]
+        client.describe_scheduled_actions(client_opts)
+      end
+
+    end
+  end
+end

data/lib/aws/auto_scaling/scheduled_action_collection.rb

@@ -0,0 +1,195 @@
+# Copyright 2011-2012 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"). You
+# may not use this file except in compliance with the License. A copy of
+# the License is located at
+#
+#     http://aws.amazon.com/apache2.0/
+#
+# or in the "license" file accompanying this file. This file is
+# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
+# ANY KIND, either express or implied. See the License for the specific
+# language governing permissions and limitations under the License.
+
+require 'time'
+
+module AWS
+  class AutoScaling
+
+    class ScheduledActionCollection
+
+      include Core::Collection::Limitable
+      
+      # @private
+      def initialize options = {}
+        @filters = options[:filters] || {}
+        super
+      end
+
+      # Creates a scheduled scaling action for an Auto Scaling group. 
+      # If you leave a parameter unspecified, the corresponding attribute
+      # remains unchanged in the group.
+      #
+      # You must specify an Auto Scaling group.  This can be implicit
+      # or explicit:
+      #
+      #   # given explicity
+      #   auto_scaling.secheduled_actions.create('action-name', :group => 'group-name')
+      #
+      #   # implied by the group
+      #   group = auto_scaling.groups.first
+      #   group.secheduled_actions.create('action-name')
+      #
+      # @param [String] name
+      #
+      # @param [Hash] options
+      #
+      # @option options [Group,String] :group
+      #
+      # @option options [Integer] :desired_capacity
+      #
+      # @option options [Integer] :max_size
+      #
+      # @option options [Integer] :min_size
+      #
+      # @option options [String] :recurrence
+      #
+      # @option options [Time] :start_time
+      # 
+      # @option options [Time] :end_time
+      #
+      # @return [ScheduledAction]
+      #
+      def create name, options = {}
+        
+        scheduled_action = ScheduledAction.new(name, 
+          :auto_scaling_group_name => auto_scaling_group_name_opt(options),
+          :config => config)
+
+        scheduled_action.update(options)
+        scheduled_action
+
+      end
+      alias_method :put, :create
+
+      # @param [String] name The name of the scheduled action.
+      # @return [ScheduledAction]
+      def [] name
+        options = {}
+        options[:config] = config
+        if group = @filters[:auto_scaling_group_name]
+          options[:auto_scaling_group_name] = group
+        end
+        ScheduledAction.new(name, options)
+      end
+
+      # Returns a new {ScheduledActionCollection} filtered
+      # by the given options.
+      #
+      #   auto_scaling.scheduled_actions.filter(:end_time => Time.now).each do |a|
+      #      # ...
+      #   end
+      #
+      # You can chain filter calls:
+      #
+      #   actions = auto_scaling.scheduled_actions.
+      #      filter(:group => 'auto-scaling-group-name').
+      #      filter(:start_time => Time.now - 3600).
+      #      filter(:end_time => Time.now)
+      #
+      #   actions.each {|scheduled_action| ... }
+      # 
+      # @param [Hash] filters
+      #
+      # @option filters [Group,String] :group
+      #
+      # @option filters [Array<String>] :scheduled_actions
+      #    A list of scheduled actions to be described. If this list is 
+      #    omitted, all scheduled actions are described. The list of 
+      #    requested scheduled actions cannot contain more than 50 items. 
+      #    If an Auto Scaling group name is provided, 
+      #    the results are limited to that group. If unknown scheduled 
+      #    actions are requested, they are ignored with no error.
+      #
+      # @option opitons [Time,String] :start_time The earliest scheduled 
+      #   start time to return. If +:scheduled_actions+ is provided, 
+      #   this field will be ignored.  Should be a Time object or
+      #   an iso8601 string.
+      #
+      # @option filters [Time,String] :end_time 
+      #
+      # @return [ScheduledActionCollection] Returns a scheduled action
+      #   collection that will filter the actions returned by the
+      #   given criteria.
+      #
+      def filter filters = {}
+        init_opts = {}
+        init_opts[:config] = config
+        init_opts[:filters] = @filters
+        init_opts[:filters].merge!(filter_opts(filters))
+        ScheduledActionCollection.new(init_opts)
+      end
+
+      protected
+
+      def auto_scaling_group_name_opt options
+
+        group = options.delete(:group)
+        group ||= @filters[:auto_scaling_group_name]
+        group = group.name if group.is_a?(Group)
+
+        unless group
+          raise ArgumentError, 'missing required option :group'
+        end
+
+        group
+
+      end
+
+      def filter_opts options
+
+        opts = {}
+
+        if g = options[:group]
+          opts[:auto_scaling_group_name] = g.is_a?(Group) ? g.name : g
+        end
+
+        if actions = options[:scheduled_actions]
+          opts[:scheduled_action_names] = actions
+        end
+
+        [:end_time, :start_time].each do |opt|
+          if options[opt].is_a?(Time)
+            opts[opt] = options[opt].iso8601
+          end
+        end
+
+        opts
+
+      end
+
+      def _each_item next_token, limit, options = {}, &block
+
+        options[:next_token] = next_token if next_token
+        options[:max_records] = limit if limit
+
+        resp = client.describe_scheduled_actions(options.merge(@filters))
+        resp.scheduled_update_group_actions.each do |details|
+          
+          scheduled_action = ScheduledAction.new_from(
+            :describe_scheduled_actions,
+            details,
+            details.scheduled_action_name,
+            :config => config)
+
+          yield(scheduled_action)
+          
+        end
+
+        resp.data[:next_token]
+
+      end
+
+    end
+  end
+end