aws-sdk-autoscaling 1.2.0 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4b343191eabd9f2d7ba70613a565a16bc1f1839a
-  data.tar.gz: 669591f0e61fddd337987ac4158986338766b8b2
+  metadata.gz: c3866d10256da0a4bb8f5fe1d17410802f5a2294
+  data.tar.gz: 979828c93d1c5be1bcc655c9e0a7183539745c0b
 SHA512:
-  metadata.gz: a70e3e249324c03ea9e2a5963eb023ecddc068ca2e42665f67465e2e47317b9a689432877328a597c0927b0b1978da7ca4982917aa599c32f34d6ff1a38b9022
-  data.tar.gz: 1e3645ead5a3987fbc866942dc0acb2e1c5711bb409e6f02d06f898271de77c674d85ff70e168a8c0b87b44721dc59d292dcea39f8ceec9aca55a72d01cb5714
+  metadata.gz: 0edf212977bb0579bd5dc457aadd4bcdbff60c400becead9fee5748ffc3690f0a9bb0bddcc73916947eb0d8ea7d4c2c766ed37c3cf77ae24737566b6a69c681f
+  data.tar.gz: b422e041107199c3f80ae4251f5417d19311051e7566d8f0b2e512379eb3315bde1fba032dc8c4ccd3e722be3bcd5140ed9c78a19f410f2eb42d99f1cfd9d01d

data/lib/aws-sdk-autoscaling.rb

@@ -53,6 +53,6 @@ require_relative 'aws-sdk-autoscaling/customizations'
 # @service
 module Aws::AutoScaling
 
-  GEM_VERSION = '1.2.0'
+  GEM_VERSION = '1.3.0'
 
 end

data/lib/aws-sdk-autoscaling/activity.rb

@@ -34,55 +34,55 @@ module Aws::AutoScaling
     # The name of the Auto Scaling group.
     # @return [String]
     def auto_scaling_group_name
-      data.auto_scaling_group_name
+      data[:auto_scaling_group_name]
     end
 
     # A friendly, more verbose description of the activity.
     # @return [String]
     def description
-      data.description
+      data[:description]
     end
 
     # The reason the activity began.
     # @return [String]
     def cause
-      data.cause
+      data[:cause]
     end
 
     # The start time of the activity.
     # @return [Time]
     def start_time
-      data.start_time
+      data[:start_time]
     end
 
     # The end time of the activity.
     # @return [Time]
     def end_time
-      data.end_time
+      data[:end_time]
     end
 
     # The current status of the activity.
     # @return [String]
     def status_code
-      data.status_code
+      data[:status_code]
     end
 
     # A friendly, more verbose description of the activity status.
     # @return [String]
     def status_message
-      data.status_message
+      data[:status_message]
     end
 
     # A value between 0 and 100 that indicates the progress of the activity.
     # @return [Integer]
     def progress
-      data.progress
+      data[:progress]
     end
 
     # The details about the activity.
     # @return [String]
     def details
-      data.details
+      data[:details]
     end
 
     # @!endgroup
@@ -120,13 +120,108 @@ module Aws::AutoScaling
       !!@data
     end
 
+    # @deprecated Use [Aws::AutoScaling::Client] #wait_until instead
+    #
+    # Waiter polls an API operation until a resource enters a desired
+    # state.
+    #
+    # @note The waiting operation is performed on a copy. The original resource remains unchanged
+    #
+    # ## Basic Usage
+    #
+    # Waiter will polls until it is successful, it fails by
+    # entering a terminal state, or until a maximum number of attempts
+    # are made.
+    #
+    #     # polls in a loop until condition is true
+    #     resource.wait_until(options) {|resource| condition}
+    #
+    # ## Example
+    #
+    #     instance.wait_until(max_attempts:10, delay:5) {|instance| instance.state.name == 'running' }
+    #
+    # ## Configuration
+    #
+    # You can configure the maximum number of polling attempts, and the
+    # delay (in seconds) between each polling attempt. The waiting condition is set
+    # by passing a block to {#wait_until}:
+    #
+    #     # poll for ~25 seconds
+    #     resource.wait_until(max_attempts:5,delay:5) {|resource|...}
+    #
+    # ## Callbacks
+    #
+    # You can be notified before each polling attempt and before each
+    # delay. If you throw `:success` or `:failure` from these callbacks,
+    # it will terminate the waiter.
+    #
+    #     started_at = Time.now
+    #     # poll for 1 hour, instead of a number of attempts
+    #     proc = Proc.new do |attempts, response|
+    #       throw :failure if Time.now - started_at > 3600
+    #     end
+    #
+    #       # disable max attempts
+    #     instance.wait_until(before_wait:proc, max_attempts:nil) {...}
+    #
+    # ## Handling Errors
+    #
+    # When a waiter is successful, it returns the Resource. When a waiter
+    # fails, it raises an error.
+    #
+    #     begin
+    #       resource.wait_until(...)
+    #     rescue Aws::Waiters::Errors::WaiterFailed
+    #       # resource did not enter the desired state in time
+    #     end
+    #
+    #
+    # @yield param [Resource] resource to be used in the waiting condition
+    #
+    # @raise [Aws::Waiters::Errors::FailureStateError] Raised when the waiter terminates
+    #   because the waiter has entered a state that it will not transition
+    #   out of, preventing success.
+    #
+    #   yet successful.
+    #
+    # @raise [Aws::Waiters::Errors::UnexpectedError] Raised when an error is encountered
+    #   while polling for a resource that is not expected.
+    #
+    # @raise [NotImplementedError] Raised when the resource does not
+    #
+    # @option options [Integer] :max_attempts (10) Maximum number of
+    # attempts
+    # @option options [Integer] :delay (10) Delay between each
+    # attempt in seconds
+    # @option options [Proc] :before_attempt (nil) Callback
+    # invoked before each attempt
+    # @option options [Proc] :before_wait (nil) Callback
+    # invoked before each wait
+    # @return [Resource] if the waiter was successful
+    def wait_until(options = {}, &block)
+      self_copy = self.dup
+      attempts = 0
+      options[:max_attempts] = 10 unless options.key?(:max_attempts)
+      options[:delay] ||= 10
+      options[:poller] = Proc.new do
+        attempts += 1
+        if block.call(self_copy)
+          [:success, self_copy]
+        else
+          self_copy.reload unless attempts == options[:max_attempts]
+          :retry
+        end
+      end
+      Aws::Waiters::Waiter.new(options).wait({})
+    end
+
     # @!group Associations
 
     # @return [AutoScalingGroup, nil]
     def group
-      if data.auto_scaling_group_name
+      if data[:auto_scaling_group_name]
         AutoScalingGroup.new(
-          name: data.auto_scaling_group_name,
+          name: data[:auto_scaling_group_name],
           client: @client
         )
       else

data/lib/aws-sdk-autoscaling/auto_scaling_group.rb

@@ -34,64 +34,64 @@ module Aws::AutoScaling
     # The Amazon Resource Name (ARN) of the group.
     # @return [String]
     def auto_scaling_group_arn
-      data.auto_scaling_group_arn
+      data[:auto_scaling_group_arn]
     end
 
     # The name of the associated launch configuration.
     # @return [String]
     def launch_configuration_name
-      data.launch_configuration_name
+      data[:launch_configuration_name]
     end
 
     # The minimum size of the group.
     # @return [Integer]
     def min_size
-      data.min_size
+      data[:min_size]
     end
 
     # The maximum size of the group.
     # @return [Integer]
     def max_size
-      data.max_size
+      data[:max_size]
     end
 
     # The desired size of the group.
     # @return [Integer]
     def desired_capacity
-      data.desired_capacity
+      data[:desired_capacity]
     end
 
     # The amount of time, in seconds, after a scaling activity completes
     # before another scaling activity can start.
     # @return [Integer]
     def default_cooldown
-      data.default_cooldown
+      data[:default_cooldown]
     end
 
     # One or more Availability Zones for the group.
     # @return [Array<String>]
     def availability_zones
-      data.availability_zones
+      data[:availability_zones]
     end
 
     # One or more load balancers associated with the group.
     # @return [Array<String>]
     def load_balancer_names
-      data.load_balancer_names
+      data[:load_balancer_names]
     end
 
     # The Amazon Resource Names (ARN) of the target groups for your load
     # balancer.
     # @return [Array<String>]
     def target_group_arns
-      data.target_group_arns
+      data[:target_group_arns]
     end
 
     # The service to use for the health checks. The valid values are `EC2`
     # and `ELB`.
     # @return [String]
     def health_check_type
-      data.health_check_type
+      data[:health_check_type]
     end
 
     # The amount of time, in seconds, that Auto Scaling waits before
@@ -99,19 +99,19 @@ module Aws::AutoScaling
     # service.
     # @return [Integer]
     def health_check_grace_period
-      data.health_check_grace_period
+      data[:health_check_grace_period]
     end
 
     # The date and time the group was created.
     # @return [Time]
     def created_time
-      data.created_time
+      data[:created_time]
     end
 
     # The suspended processes associated with the group.
     # @return [Array<Types::SuspendedProcess>]
     def suspended_processes
-      data.suspended_processes
+      data[:suspended_processes]
     end
 
     # The name of the placement group into which you'll launch your
@@ -123,7 +123,7 @@ module Aws::AutoScaling
     # [1]: http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/placement-groups.html
     # @return [String]
     def placement_group
-      data.placement_group
+      data[:placement_group]
     end
 
     # One or more subnet IDs, if applicable, separated by commas.
@@ -133,33 +133,33 @@ module Aws::AutoScaling
     # `AvailabilityZones`.
     # @return [String]
     def vpc_zone_identifier
-      data.vpc_zone_identifier
+      data[:vpc_zone_identifier]
     end
 
     # The metrics enabled for the group.
     # @return [Array<Types::EnabledMetric>]
     def enabled_metrics
-      data.enabled_metrics
+      data[:enabled_metrics]
     end
 
     # The current state of the group when DeleteAutoScalingGroup is in
     # progress.
     # @return [String]
     def status
-      data.status
+      data[:status]
     end
 
     # The termination policies for the group.
     # @return [Array<String>]
     def termination_policies
-      data.termination_policies
+      data[:termination_policies]
     end
 
     # Indicates whether newly launched instances are protected from
     # termination by Auto Scaling when scaling in.
     # @return [Boolean]
     def new_instances_protected_from_scale_in
-      data.new_instances_protected_from_scale_in
+      data[:new_instances_protected_from_scale_in]
     end
 
     # @!endgroup
@@ -262,6 +262,101 @@ module Aws::AutoScaling
       })
     end
 
+    # @deprecated Use [Aws::AutoScaling::Client] #wait_until instead
+    #
+    # Waiter polls an API operation until a resource enters a desired
+    # state.
+    #
+    # @note The waiting operation is performed on a copy. The original resource remains unchanged
+    #
+    # ## Basic Usage
+    #
+    # Waiter will polls until it is successful, it fails by
+    # entering a terminal state, or until a maximum number of attempts
+    # are made.
+    #
+    #     # polls in a loop until condition is true
+    #     resource.wait_until(options) {|resource| condition}
+    #
+    # ## Example
+    #
+    #     instance.wait_until(max_attempts:10, delay:5) {|instance| instance.state.name == 'running' }
+    #
+    # ## Configuration
+    #
+    # You can configure the maximum number of polling attempts, and the
+    # delay (in seconds) between each polling attempt. The waiting condition is set
+    # by passing a block to {#wait_until}:
+    #
+    #     # poll for ~25 seconds
+    #     resource.wait_until(max_attempts:5,delay:5) {|resource|...}
+    #
+    # ## Callbacks
+    #
+    # You can be notified before each polling attempt and before each
+    # delay. If you throw `:success` or `:failure` from these callbacks,
+    # it will terminate the waiter.
+    #
+    #     started_at = Time.now
+    #     # poll for 1 hour, instead of a number of attempts
+    #     proc = Proc.new do |attempts, response|
+    #       throw :failure if Time.now - started_at > 3600
+    #     end
+    #
+    #       # disable max attempts
+    #     instance.wait_until(before_wait:proc, max_attempts:nil) {...}
+    #
+    # ## Handling Errors
+    #
+    # When a waiter is successful, it returns the Resource. When a waiter
+    # fails, it raises an error.
+    #
+    #     begin
+    #       resource.wait_until(...)
+    #     rescue Aws::Waiters::Errors::WaiterFailed
+    #       # resource did not enter the desired state in time
+    #     end
+    #
+    #
+    # @yield param [Resource] resource to be used in the waiting condition
+    #
+    # @raise [Aws::Waiters::Errors::FailureStateError] Raised when the waiter terminates
+    #   because the waiter has entered a state that it will not transition
+    #   out of, preventing success.
+    #
+    #   yet successful.
+    #
+    # @raise [Aws::Waiters::Errors::UnexpectedError] Raised when an error is encountered
+    #   while polling for a resource that is not expected.
+    #
+    # @raise [NotImplementedError] Raised when the resource does not
+    #
+    # @option options [Integer] :max_attempts (10) Maximum number of
+    # attempts
+    # @option options [Integer] :delay (10) Delay between each
+    # attempt in seconds
+    # @option options [Proc] :before_attempt (nil) Callback
+    # invoked before each attempt
+    # @option options [Proc] :before_wait (nil) Callback
+    # invoked before each wait
+    # @return [Resource] if the waiter was successful
+    def wait_until(options = {}, &block)
+      self_copy = self.dup
+      attempts = 0
+      options[:max_attempts] = 10 unless options.key?(:max_attempts)
+      options[:delay] ||= 10
+      options[:poller] = Proc.new do
+        attempts += 1
+        if block.call(self_copy)
+          [:success, self_copy]
+        else
+          self_copy.reload unless attempts == options[:max_attempts]
+          :retry
+        end
+      end
+      Aws::Waiters::Waiter.new(options).wait({})
+    end
+
     # @!group Actions
 
     # @example Request syntax with placeholder values
@@ -793,11 +888,11 @@ module Aws::AutoScaling
     # @return [Instance::Collection]
     def instances
       batch = []
-      data.instances.each do |i|
+      data[:instances].each do |d|
         batch << Instance.new(
           group_name: @name,
-          id: i.instance_id,
-          data: i,
+          id: d[:instance_id],
+          data: d,
           client: @client
         )
       end
@@ -806,9 +901,9 @@ module Aws::AutoScaling
 
     # @return [LaunchConfiguration, nil]
     def launch_configuration
-      if data.launch_configuration_name
+      if data[:launch_configuration_name]
         LaunchConfiguration.new(
-          name: data.launch_configuration_name,
+          name: data[:launch_configuration_name],
           client: @client
         )
       else
@@ -1014,12 +1109,12 @@ module Aws::AutoScaling
     # @return [Tag::Collection]
     def tags
       batch = []
-      data.tags.each do |t|
+      data[:tags].each do |d|
         batch << Tag.new(
-          key: t.key,
-          resource_id: t.resource_id,
-          resource_type: t.resource_type,
-          data: t,
+          key: d[:key],
+          resource_id: d[:resource_id],
+          resource_type: d[:resource_type],
+          data: d,
           client: @client
         )
       end