aws-sdk 1.3.8 → 1.3.9

data/lib/aws/auto_scaling/launch_configuration_collection.rb

@@ -0,0 +1,144 @@
+# 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 'base64'
+
+module AWS
+  class AutoScaling
+    class LaunchConfigurationCollection
+
+      include Core::Collection::Limitable
+
+      # Creates an Auto Scaling launch configuration.
+      #
+      #   auto_scaling.launch_configurations.create('name', 'ami-12345', 'm1.small')
+      #
+      # @param [String] name The name of the launch configuration to create.
+      #
+      # @param [EC2::Image,String] image An {EC2::Image} or image id string.
+      #   
+      # @param [String] instance_type The type of instance (e.g.
+      #   't1.micro', 'm1.small', 'm2.4xlarge', etc).
+      #
+      # @param [Hash] options
+      #
+      # @option options [Array<Hash>] :block_device_mappings
+      #
+      # @option options [Boolean] :detailed_instance_monitoring (true) 
+      #   When enabled, CloudWatch will generate metrics every minute 
+      #   and your account will be charged a fee. When you disable 
+      #   detailed monitoring, by specifying False, Cloudwatch will 
+      #   generate metrics every 5 minutes.
+      #
+      # @option options [String] :kernel_id The ID of the kernel to
+      #   launch the instances with.
+      #
+      # @option options [KeyPair,String] :key_pair The keypair to launch
+      #   instances with.  This may be an {EC2::KeyPair} object or
+      #   or key pair name string.
+      #
+      # @option options [String] :ramdisk_id The ID of the ramdisk to
+      #   launch the instances with.
+      #
+      # @option options [Array<EC2::SecurityGroup>,Array<String>] :security_groups
+      #   The list of security groups to associate with the instances.
+      #   This may be an array of {EC2::SecurityGroup} objects, security
+      #   group names or security group ids.  
+      #
+      # @option options [String] :user_data The user data available to 
+      #   the launched Amazon EC2 instances.
+      # 
+      # @return [LaunchConfiguration]
+      #
+      def create name, image, instance_type, options = {}
+        
+        client_opts = {}
+        client_opts[:launch_configuration_name] = name
+        client_opts[:image_id] = image_id_opt(image)
+        client_opts[:instance_type] = instance_type
+        client_opts[:block_device_mappings] = options[:block_device_mappings] if
+          options.key?(:block_device_mappings)
+        client_opts[:instance_monitoring] = instance_monitoring_opt(options) if
+          options.key?(:detailed_instance_monitoring)
+        client_opts[:kernel_id] = options[:kernel_id] if options[:kernel_id]
+        client_opts[:key_name] = key_name_opt(options) if options[:key_pair]
+        client_opts[:ramdisk_id] = options[:ramdisk_id] if options[:ramdisk_id]
+        client_opts[:security_groups] = security_groups_opt(options) if
+          options.key?(:security_groups)
+        client_opts[:user_data] = user_data_opt(options) if options[:user_data]
+
+        client.create_launch_configuration(client_opts)
+
+        LaunchConfiguration.new(name,
+          :image_id => client_opts[:image_id],
+          :instance_type => client_opts[:instance_type],
+          :config => config)
+
+      end
+
+      # @param [String] name The name of a launch configuraiton.
+      # @return [LaunchConfiguration]
+      def [] name
+        LaunchConfiguration.new(name, :config => config)
+      end
+
+      protected
+
+      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_launch_configurations(options)
+        resp.launch_configurations.each do |details|
+          
+          launch_configuration = LaunchConfiguration.new_from(
+            :describe_launch_configurations,
+            details,
+            details.launch_configuration_name,
+            :config => config)
+
+          yield(launch_configuration)
+          
+        end
+        resp.next_token if resp.respond_to?(:next_token)
+      end
+
+      def image_id_opt image
+        image.is_a?(EC2::Image) ? image.image_id : image
+      end
+
+      def instance_monitoring_opt options
+        options[:detailed_instance_monitoring] == true ?
+          { :enabled => true } :
+          { :enabled => false }
+      end
+
+      def key_name_opt options
+        key_pair = options[:key_pair]
+        key_pair.is_a?(EC2::KeyPair) ? key_pair.name : key_pair
+      end
+
+      def security_groups_opt options
+        options[:security_groups].collect do |sg|
+          sg.is_a?(EC2::SecurityGroup) ? sg.id : sg
+        end
+      end
+
+      def user_data_opt options
+        Base64.encode64(options[:user_data])
+      end
+
+    end
+  end
+end

data/lib/aws/auto_scaling/notification_configuration.rb

@@ -0,0 +1,89 @@
+# 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 NotificationConfiguration
+
+      # @private
+      def initialize auto_scaling_group, topic_arn, notification_types = []
+        @group = auto_scaling_group
+        @topic_arn = topic_arn
+        @notification_types = notification_types
+      end
+
+      # @return [Group]
+      attr_reader :group
+
+      alias_method :auto_scaling_group, :group
+
+      # @return [String]
+      attr_reader :topic_arn
+
+      # @return [Arra<String>]
+      attr_reader :notification_types
+
+      # @return [SNS::Topic]
+      def topic
+        SNS::Topic.new(topic_arn, :config => group.config)
+      end
+
+      # Updates the notification configuration with a new list of types:
+      #
+      #   config = auto_scaling_group.notification_configurations.first
+      #   config.notification_types = %w(autoscaling:EC2_INSTANCE_LAUNCH)
+      #
+      # @return [nil]
+      #
+      def notification_types= *notification_types
+
+        client_opts = {}
+        client_opts[:topic_arn] = topic_arn
+        client_opts[:notification_types] = notification_types.flatten
+        client_opts[:auto_scaling_group_name] = group.name
+
+        group.client.put_notification_configuration(client_opts)
+
+        @notification_types = notification_types.flatten
+
+        nil
+
+      end
+
+      # Deletes this Auto Scaling notification configuration.
+      # @return [nil]
+      def delete
+
+        client_opts = {}
+        client_opts[:auto_scaling_group_name] = group.name
+        client_opts[:topic_arn] = topic_arn
+
+        group.client.delete_notification_configuration(client_opts)
+
+        nil
+
+      end
+
+      # @private
+      def eql? other
+        other.is_a?(NotificationConfiguration) and
+        other.group == group and
+        other.topic_arn == topic_arn and
+        other.notification_types == notification_types
+      end
+
+      alias_method :==, :eql?
+
+    end
+  end
+end

data/lib/aws/auto_scaling/notification_configuration_collection.rb

@@ -0,0 +1,184 @@
+# 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
+
+    # Allows you to enumerate and create notification configurations.#
+    #
+    # == Enumerating Notification Configurations
+    #
+    # You can enumerated *ALL* configurations from the AWS::AutoScaling class.
+    #
+    #   auto_scaling = AWS::AutoScaling.new
+    #   auto_scaling.notification_configurations.each do |config|
+    #     # ...
+    #   end
+    #
+    # You can also limit them to a single Auto Scaling group:
+    #
+    #   group = auto_scaling.groups['group-name']
+    #   group.notification_configurations.each do |config|
+    #     # ...
+    #   end
+    # 
+    # == Creating Notification Configurations
+    #
+    # You can create a notification configuration like so:
+    #
+    #   auto_scaling.notification_configurations.create(
+    #     :group => 'auto-scaling-group-name',
+    #     :topic => 'sns-topic-arn')
+    #
+    # Just like with enumeration, you can create them from the Auto
+    # Scaling group:
+    #
+    #   group.notification_configurations.create(:topic => 'sns-topic-arn')
+    #
+    class NotificationConfigurationCollection
+
+      include Core::Collection::Limitable
+      
+      # @private
+      def initialize options = {}
+        @group = options[:group]
+        if @group
+          super(@group, options)
+        else
+          super(options)
+        end
+      end
+
+      # @return [Group,nil] If this collection was initialized with
+      #  an Auto Scaling group, then that group is returned, nil otherwise.
+      attr_reader :group
+
+      alias_method :auto_scaling_group, :group
+
+      # Creates a new notification configuration. To create a notification
+      # configuration you need an {SNS::Topic} and an Auto Scaling {Group}.
+      #
+      #   auto_scaling.notification_configurations.create(
+      #     :group => 'auto-scaling-group-name', 
+      #     :topic => 'sns-topic-arn')
+      #
+      # You can also create notification configurations from an Auto Scaling
+      # group and omit the +:group+ option.
+      #
+      #   auto_scaling_group.notification_configurations.create(
+      #     :topic => 'sns-topic-arn')
+      #
+      # You may also pass a list of notification types to publish to the 
+      # topic.  If you omit this option, then all notification types
+      # will be configured.
+      #
+      #   # publish only these two specific notification types
+      #   auto_scaling_group.notification_configurations.create(
+      #     :topic => 'sns-topic-arn',
+      #     :types => [
+      #       'autoscaling:EC2_INSTANCE_LAUNCH',
+      #       'autoscaling:EC2_INSTANCE_TERMINATE',
+      #     ]
+      #   )
+      #
+      # @param [Hash] options
+      #
+      # @option options [required,SNS::Topic,String] :topic An {SNS::Topic} 
+      #   object or a topic arn string.  Notifications will be published
+      #   to this topic.
+      #
+      # @option options [Group,String] :group An Auto Scaling {Group} object
+      #   or the name of an Auto Scaling group.  This is required if you
+      #   this collection is not scoped by a {Group}.
+      #
+      # @option options [Array<String>] :types A list of notification
+      #   types that should publish messages to the given topic.
+      #
+      # @return [NotificationConfiguration]
+      #
+      def create options = {}
+        
+        topic_arn = options[:topic].is_a?(SNS::Topic) ? 
+          options[:topic].arn : options[:topic]
+
+        unless group = @group
+          if group = options[:group]
+            group = Group.new(group) unless group.is_a?(Group)
+          else
+            raise ArgumentError, 'missing required :group option'
+          end
+        end
+
+        unless types = options[:types]
+          types = AutoScaling.new(:config => config).notification_types
+        end
+
+        notification_config = NotificationConfiguration.new(group, topic_arn)
+        notification_config.notification_types = types
+        notification_config
+
+      end
+      alias_method :put, :create
+
+      # @yeild [notification_config] 
+      # @yield_param [NotificationConfiguration] notification_config
+      def each &block
+
+        #
+        # <grumble> We can't use the standard pageable collection mixin here.
+        # When you provide :max_records it returns each notification
+        # type as an individual record, instead of notification configurations
+        # with grouped types.  This makes it very possible to
+        # get a part of a configuration in one page of results with the
+        # rest in the next page.
+        #
+        # So instead we will request and group them all before yielding.
+        # 
+
+        next_token = nil
+
+        groups = {}
+
+        begin
+
+          client_opts = {}
+          client_opts[:next_token] = next_token if next_token
+          client_opts[:auto_scaling_group_names] = [@group.name] if @group
+
+          resp = client.describe_notification_configurations(client_opts)
+          resp.notification_configurations.each do |c|
+            group_name = c.auto_scaling_group_name
+            groups[group_name] ||= {}
+            groups[group_name][c.topic_arn] ||= []
+            groups[group_name][c.topic_arn] << c.notification_type
+          end
+
+          next_token = resp.respond_to?(:next_token) ? resp.next_token : nil
+
+        end while next_token
+
+        groups.each_pair do |group_name, topics|
+          topics.each_pair do |topic_arn, types|
+            
+            notification_config = NotificationConfiguration.new(
+              Group.new(group_name, :config => config), topic_arn, types)
+
+            yield(notification_config)
+
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/aws/auto_scaling/request.rb

@@ -0,0 +1,24 @@
+# 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::AuthorizeV2
+      include Core::AuthorizeWithSessionToken
+    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