aws-sdk-v1 1.52.0

data/lib/aws/auto_scaling/launch_configuration.rb

@@ -0,0 +1,162 @@
+# Copyright 2011-2013 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
+
+    # @attr_reader [String] name
+    #
+    # @attr_reader [Time] created_time
+    #
+    # @attr_reader [String] image_id
+    #
+    # @attr_reader [Boolean] detailed_instance_monitoring
+    #
+    # @attr_reader [String] instance_type
+    #
+    # @attr_reader [String,nil] kernel_id
+    #
+    # @attr_reader [String,nil] key_name
+    #
+    # @attr_reader [String] arn
+    #
+    # @attr_reader [String,nil] ramdisk_id
+    #
+    # @attr_reader [String,nil] user_data
+    #
+    # @attr_reader [Array<Hash>] block_device_mappings
+    #
+    # @attr_reader [String] iam_instance_profile
+    #
+    # @attr_reader [String] spot_price
+    #
+    # @attr_reader [Boolean] associate_public_ip_address
+    #
+    class LaunchConfiguration < Core::Resource
+
+      # @api private
+      def initialize name, options = {}
+        super(options.merge(:name => name))
+      end
+
+      attribute :name, :from => :launch_configuration_name, :static => true
+
+      attribute :created_time, :static => true
+
+      alias_method :created_at, :created_time
+
+      attribute :image_id, :static => true
+
+      attribute :detailed_instance_monitoring,
+        :from => :instance_monitoring,
+        :static => true do
+        translates_output {|value| value[:enabled] }
+      end
+
+      alias_method :detailed_instance_monitoring?, :detailed_instance_monitoring
+
+      attribute :instance_type, :static => true
+
+      attribute :kernel_id, :static => true
+
+      attribute :key_name, :static => true
+
+      attribute :arn, :from => :launch_configuration_arn, :static => true
+
+      attribute :ramdisk_id, :static => true
+
+      attribute :iam_instance_profile, :static => true
+
+      attribute :spot_price, :static => true
+
+      attribute :user_data, :static => true do
+        translates_output{|v| Base64.decode64(v) }
+      end
+
+      attribute :block_device_mappings,
+        :static => true do
+        translates_output{|mappings| mappings.map(&:to_hash) }
+      end
+
+      attribute :security_group_details,
+        :from => :security_groups,
+        :static => true
+
+      attribute :associate_public_ip_address, :static => true
+
+      protected :security_group_details
+
+      populates_from(:describe_launch_configurations) do |resp|
+        resp.launch_configurations.find do |lc|
+          lc.launch_configuration_name == name
+        end
+      end
+
+      # @return [EC2::Image]
+      def image
+        EC2::Image.new(image_id, :config => config)
+      end
+
+      # @return [KeyPair,nil]
+      def key_pair
+        if key_name
+          EC2::KeyPair.new(key_name, :config => config)
+        end
+      end
+
+      # @return [Array<EC2::SecurityGroup>]
+      def security_groups
+        names_or_ids = security_group_details
+        if names_or_ids.all?{|str| str.match(/^sg-[0-9a-f]{8}$/) }
+          names_or_ids.collect do |security_group_id|
+            EC2::SecurityGroup.new(security_group_id, :config => config)
+          end
+        else
+          begin
+            ec2 = EC2.new(:config => config)
+            ec2.security_groups.filter('group-name', *names_or_ids).to_a
+          rescue
+            names_or_ids
+          end
+        end
+      end
+
+      # @return [Boolean] Returns true if this launch configuration exists.
+      def exists?
+        !!get_resource.launch_configurations.first
+      end
+
+      # Deletes the current launch configuration.
+      # @return [nil]
+      def delete
+        client.delete_launch_configuration(resource_options)
+        nil
+      end
+
+      protected
+
+      def resource_identifiers
+        [[:launch_configuration_name, name]]
+      end
+
+      def get_resource attr_name = nil
+        client_opts = {}
+        client_opts[:launch_configuration_names] = [name]
+        client.describe_launch_configurations(client_opts)
+      end
+
+    end
+  end
+end

data/lib/aws/auto_scaling/launch_configuration_collection.rb

@@ -0,0 +1,160 @@
+# Copyright 2011-2013 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::WithLimitAndNextToken
+
+      # 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.
+      #
+      # @option options [String] :iam_instance_profile
+      #
+      # @option options [String] :spot_price
+      #
+      # @option options [Boolean] :associate_public_ip_address
+      #   Used for Auto Scaling groups that launch instances into an
+      #   Amazon Virtual Private Cloud (Amazon VPC). Specifies whether
+      #   to assign a public IP address to each instance launched in a Amazon VPC.
+      #
+      # @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[:instance_monitoring] = instance_monitoring_opt(options) if
+          options.key?(:detailed_instance_monitoring)
+        client_opts[:key_name] = key_name_opt(options) if options[:key_pair]
+        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]
+
+        [
+          :iam_instance_profile,
+          :spot_price,
+          :kernel_id,
+          :ramdisk_id,
+          :block_device_mappings,
+          :associate_public_ip_address
+        ].each do |opt|
+          client_opts[opt] = options[opt] if options.key?(opt)
+        end
+
+        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 configuration.
+      # @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.data[: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-2013 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
+
+      # @api 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
+
+      # @api 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,183 @@
+# Copyright 2011-2013 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::WithLimitAndNextToken
+
+      # @api 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
+
+      # @yield [notification_config]
+      # @yieldparam [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.data[:next_token]
+
+        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