aws-sdk-v1 1.52.0

data/lib/aws/auto_scaling/group_collection.rb

@@ -0,0 +1,96 @@
+# 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 GroupCollection
+
+      include GroupOptions
+      include Core::Collection::WithLimitAndNextToken
+
+      # Creates an Auto Scaling Group.
+      #
+      #     group = auto_scaling.groups.create('group-name',
+      #       :launch_configuration => 'launch-config-name',
+      #       :availability_zones => %(us-west-2a us-west-2b),
+      #       :min_size => 1,
+      #       :max_size => 4)
+      #
+      # @param [String] name The name of the Auto Scaling group.
+      #   Must be unique within the scope of your AWS account.
+      #
+      # @param [Hash] options
+      #
+      # @option (see GroupOptions#group_options)
+      #
+      # @option options [Array<ELB::LoadBalancer>,Array<String>] :load_balancers
+      #   A list of load balancers to use.  This can be an array of
+      #   {ELB::LoadBalancer} objects or an array of load balancer names.
+      #
+      # @return [Group]
+      #
+      def create name, options = {}
+
+        unless options[:launch_configuration]
+          raise ArgumentError, 'missing required option :launch_configuration'
+        end
+
+        group_opts = group_options(options)
+        group_opts[:auto_scaling_group_name] = name
+
+        if balancers = options[:load_balancers]
+          group_opts[:load_balancer_names] = balancers.collect do |balancer|
+            balancer.is_a?(ELB::LoadBalancer) ? balancer.name : balancer
+          end
+        end
+
+        client.create_auto_scaling_group(group_opts)
+
+        self[name]
+
+      end
+
+      # @param [String] name The name of the Auto Scaling group.
+      # @return [Group]
+      def [] name
+        Group.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_auto_scaling_groups(options)
+        resp.auto_scaling_groups.each do |details|
+
+          group = Group.new_from(
+            :describe_auto_scaling_groups,
+            details,
+            details.auto_scaling_group_name,
+            :config => config)
+
+          yield(group)
+
+        end
+
+        resp.data[:next_token]
+
+      end
+
+    end
+  end
+end

data/lib/aws/auto_scaling/group_options.rb

@@ -0,0 +1,155 @@
+# 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
+
+    # This mixin provides a method for parsing Auto Scaling group options
+    # (for create and update methods).
+    # @api private
+    module GroupOptions
+
+      protected
+
+      # @param [Hash] options
+      #
+      # @option options [required,Integer] :min_size
+      #   The maximum size of the Auto Scaling group.
+      #
+      # @option options [required,Integer] :max_size
+      #   The minimum size of the Auto Scaling group.
+      #
+      # @option options [required,LaunchConfiguration,String] :launch_configuration
+      #   The launch configuration to use with the Auto Scaling group.
+      #   This may be a {LaunchConfiguration} object or a launch configuration
+      #   name string.
+      #
+      # @option options [required,Array<String>] :availability_zones
+      #   A list of Availability Zones for the Auto Scaling group.
+      #   This can be {EC2::AvailabilityZone} objects or availability
+      #   zone names.
+      #
+      # @option options [Integer] :default_cooldown
+      #   The amount of time, in seconds, after a scaling activity completes
+      #   before any further trigger-related scaling activities can start.
+      #
+      # @option options [Integer] :desired_capacity
+      #   The number of Amazon EC2 instances that should be running in
+      #   the group.
+      #
+      # @option options [Integer] :health_check_grace_period
+      #   Length of time in seconds after a new Amazon EC2 instance comes
+      #   into service that Auto Scaling starts checking its health.
+      #
+      # @option options [Symbol] :health_check_type
+      #   The service you want the health status from,
+      #   Amazon EC2 or Elastic Load Balancer. Valid values are
+      #   `:ec2` or `:elb`.
+      #
+      # @option options [String] :placement_group
+      #   Physical location of your cluster placement group created in
+      #   Amazon EC2. For more information about cluster placement group, see
+      #   [Using Cluster Instances](http://docs.amazonwebservices.com/AWSEC2/latest/UserGuide/using_cluster_computing.html).
+      #
+      # @option options [Array<String>] :termination_policies
+      #   A standalone termination policy or a list of termination policies used
+      #   to select the instance to terminate. The policies are executed in the
+      #   order they are listed. For more information on creating a termination
+      #   policy for your Auto Scaling group, go to
+      #   [Instance Termination Policy for Your Auto Scaling Group](http://docs.aws.amazon.com/AutoScaling/latest/DeveloperGuide/us-termination-policy.html)
+      #   in the Auto Scaling Developer Guide.
+      #
+      # @option options [Array<Hash>] :tags A list of tags to apply launched
+      #   instances.  Each tag hash may have the following keys:
+      #
+      #     * `:key` - (required,String) The tag name.
+      #     * `:value` - (String) The optional tag value.
+      #     * `:propagate_at_launch` - (Boolean) Whether or not to propagate
+      #       to instances, defaults to true.
+      #
+      # @option options [Array<EC2::Subnet>,Array<String>] :subnets
+      #   A list of subnet identifiers of Amazon Virtual Private Clouds
+      #   (Amazon VPCs). Ensure the subnets' Availability Zones match the
+      #   Availability Zones specified.
+      #
+      # @return [Hash]
+      #
+      def group_options options
+
+        group_opts = {}
+
+        group_opts[:launch_configuration_name] = launch_config_opt(options) if
+          options.key?(:launch_configuration)
+
+        group_opts[:availability_zones] = az_opt(options) if
+          options.key?(:availability_zones)
+
+        group_opts[:vpc_zone_identifier] = subnets_opt(options) if
+          options.key?(:subnets)
+
+        group_opts[:health_check_type] = health_check_type_opt(options) if
+          options.key?(:health_check_type)
+
+        group_opts[:tags] = tags_opt(options) if
+          options.key?(:tags)
+
+        [
+          :min_size,
+          :max_size,
+          :default_cooldown,
+          :desired_capacity,
+          :health_check_grace_period,
+          :placement_group,
+          :termination_policies,
+        ].each do |opt|
+          group_opts[opt] = options[opt] if options.key?(opt)
+        end
+
+        group_opts
+      end
+
+      def launch_config_opt options
+        lc = options[:launch_configuration]
+        lc.is_a?(LaunchConfiguration) ? lc.name : lc
+      end
+
+      def az_opt options
+        zones = options[:availability_zones]
+        zones.map {|zone| zone.is_a?(EC2::AvailabilityZone) ? zone.name : zone }
+      end
+
+      def load_balancers_opt options
+        options[:load_balancers].collect do |lb|
+          lb.is_a?(ELB::LoadBalancer) ? lb.name : lb
+        end
+      end
+
+      def subnets_opt options
+        options[:subnets].collect do |subnet|
+          subnet.is_a?(EC2::Subnet) ? subnet.id : subnet
+        end.join(',')
+      end
+
+      def health_check_type_opt options
+        options[:health_check_type].to_s.upcase
+      end
+
+      def tags_opt options
+        options[:tags].map(&:to_hash).each do |tag|
+          tag[:propagate_at_launch] = true unless tag.key?(:propagate_at_launch)
+        end
+      end
+
+    end
+  end
+end

data/lib/aws/auto_scaling/instance.rb

@@ -0,0 +1,192 @@
+# 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
+
+    # A small wrapper around an {EC2::Instance}.
+    #
+    # ## Getting Auto Scaling Instances
+    #
+    # If you know the EC2 instance id, you can use {InstanceCollection#[]}
+    # to get the Auto Scaling instance.
+    #
+    #     instance = auto_scaling.instances['i-1234578']
+    #     instance.health_statue #=> :healthy
+    #     instance.ec2_instance #=> <AWS::EC2::Instance instance_id:i-1234578>
+    #
+    # ## Enumerating Auto Scaling Instances
+    #
+    # You can enumerate *ALL* instances like so:
+    #
+    #     auto_scaling = AWS::AutoScaling.new
+    #     auto_scaling.instances.each do |auto_scaling_instance|
+    #       # ...
+    #     end
+    #
+    # If you want the instances for a single auto scaling group:
+    #
+    #     group = auto_scaling.groups['group-name']
+    #     group.auto_scaling_instances.each do |instance|
+    #       # ...
+    #     end
+    #
+    # If you prefer {EC2::Instance} objects you should use
+    # {Group#ec2_instances} instead.
+    #
+    # @attr_reader [String] auto_scaling_group_name
+    #
+    # @attr_reader [String] launch_configuration_name
+    #
+    # @attr_reader [String] health_status Returns the instance health status
+    #   (e.g. 'Healthly' or 'Unhealthly').
+    #
+    # @attr_reader [String] availability_zone_name
+    #
+    # @attr_reader [String] lifecycle_state
+    #
+    class Instance < Core::Resource
+
+      # @api private
+      def initialize instance_id, options = {}
+        @instance_id = instance_id
+        super
+      end
+
+      # @return [String] instance_id Returns the EC2 id instance.
+      attr_reader :instance_id
+
+      alias_method :id, :instance_id
+
+      attribute :auto_scaling_group_name, :static => true
+
+      attribute :availability_zone_name,
+        :from => :availability_zone,
+        :static => true
+
+      attribute :health_status
+
+      attribute :launch_configuration_name, :static => true
+
+      attribute :lifecycle_state
+
+      populates_from(:describe_auto_scaling_instances) do |resp|
+        resp.auto_scaling_instances.find do |i|
+          i.instance_id == instance_id
+        end
+      end
+
+      # describe auto scaling groups returns ALL attributes
+      # except :auto_scaling_group_name
+      provider(:describe_auto_scaling_groups) do |provider|
+        provider.find do |resp|
+          instance = nil
+          resp.auto_scaling_groups.each do |group|
+            group.instances.each do |i|
+              instance = i if i.instance_id == instance_id
+            end
+          end
+          instance
+        end
+        provider.provides(*(attributes.keys - [:auto_scaling_group_name]))
+      end
+
+      # @return [EC2::Instance]
+      def ec2_instance
+        EC2::Instance.new(instance_id, :config => config)
+      end
+
+      # @return [AutoScaling::Group]
+      def auto_scaling_group
+        Group.new(auto_scaling_group_name, :config => config)
+      end
+      alias_method :group, :auto_scaling_group
+
+      # @return [EC2::AvailabilityZone]
+      def availability_zone
+        EC2::AvailabilityZone.new(availability_zone_name, :config => config)
+      end
+
+      # @return [LaunchConfiguration]
+      def launch_configuration
+        LaunchConfiguration.new(launch_configuration_name, :config => config)
+      end
+
+      # @param [String] status Sets the health status of an instance.
+      #   Valid values inculde 'Healthy' and 'Unhealthy'
+      #
+      # @param [Hash] options
+      #
+      # @option options [Boolean] :respect_grace_period (false) If true,
+      #   this call should respect the grace period associated with
+      #   this instance's Auto Scaling group.
+      #
+      # @return [nil]
+      #
+      def set_health status, options = {}
+        client_opts = {}
+        client_opts[:instance_id] = instance_id
+        client_opts[:health_status] = status
+        client_opts[:should_respect_grace_period] =
+          options[:respect_grace_period] == true
+        client.set_instance_health(client_opts)
+      end
+
+      # @return [Boolean] Returns true if there exists an Auto Scaling
+      #   instance with this instance id.
+      def exists?
+        !get_resource.auto_scaling_instances.empty?
+      end
+
+      # Terminates the current Auto Scaling instance.
+      #
+      # @param [Boolean] decrement_desired_capacity Specifies whether or not
+      #   terminating this instance should also decrement the size of
+      #   the AutoScalingGroup.
+      #
+      # @return [Activity] Returns an activity that represents the
+      #   termination of the instance.
+      #
+      def terminate decrement_desired_capacity
+
+        client_opts = {}
+        client_opts[:instance_id] = instance_id
+        client_opts[:should_decrement_desired_capacity] =
+          decrement_desired_capacity
+
+        resp = client.terminate_instance_in_auto_scaling_group(client_opts)
+
+        Activity.new_from(
+          :terminate_instance_in_auto_scaling_group,
+          resp.activity,
+          resp.activity.activity_id,
+          :config => config)
+
+      end
+      alias_method :delete, :terminate
+
+      protected
+
+      def resource_identifiers
+        [[:instance_id, instance_id]]
+      end
+
+      def get_resource attr_name = nil
+        client_opts = {}
+        client_opts[:instance_ids] = [instance_id]
+        client.describe_auto_scaling_instances(client_opts)
+      end
+
+    end
+  end
+end

data/lib/aws/auto_scaling/instance_collection.rb

@@ -0,0 +1,63 @@
+# 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 Auto Scaling instances.
+    #
+    #     auto_scaling = AWS::AutoScaling.new
+    #     auto_scaling.instances.each do |instance|
+    #       # ...
+    #     end
+    #
+    # You can also get an Auto Scaling instance by its EC2 instance id.
+    #
+    #     auto_scaling_instance = auto_scaling.instances['i-12345678']
+    #     auto_scaling_instance.class #=> AWS::AutoScaling::Instance
+    #
+    class InstanceCollection
+
+      include Core::Collection::WithLimitAndNextToken
+
+      # @param [String] instance_id An {EC2::Instance} id string.
+      # @return [AutoScaling::Instance]
+      def [] instance_id
+        Instance.new(instance_id, :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_auto_scaling_instances(options)
+        resp.auto_scaling_instances.each do |details|
+
+          instance = Instance.new_from(
+            :describe_auto_scaling_instances,
+            details,
+            details.instance_id,
+            :config => config)
+
+          yield(instance)
+
+        end
+        resp.data[:next_token]
+      end
+
+    end
+  end
+end