aws-sdk-rds 1.1.0 → 1.2.0

data/lib/aws-sdk-rds/option_group_option.rb

@@ -33,50 +33,50 @@ module Aws::RDS
     # The description of the option.
     # @return [String]
     def description
-      data.description
+      data[:description]
     end
 
     # The name of the engine that this option can be applied to.
     # @return [String]
     def engine_name
-      data.engine_name
+      data[:engine_name]
     end
 
     # Indicates the major engine version that the option is available for.
     # @return [String]
     def major_engine_version
-      data.major_engine_version
+      data[:major_engine_version]
     end
 
     # The minimum required engine version for the option to be applied.
     # @return [String]
     def minimum_required_minor_engine_version
-      data.minimum_required_minor_engine_version
+      data[:minimum_required_minor_engine_version]
     end
 
     # Specifies whether the option requires a port.
     # @return [Boolean]
     def port_required
-      data.port_required
+      data[:port_required]
     end
 
     # If the option requires a port, specifies the default port for the
     # option.
     # @return [Integer]
     def default_port
-      data.default_port
+      data[:default_port]
     end
 
     # The options that are prerequisites for this option.
     # @return [Array<String>]
     def options_depended_on
-      data.options_depended_on
+      data[:options_depended_on]
     end
 
     # The options that conflict with this option.
     # @return [Array<String>]
     def options_conflicts_with
-      data.options_conflicts_with
+      data[:options_conflicts_with]
     end
 
     # Persistent options can't be removed from an option group while DB
@@ -85,7 +85,7 @@ module Aws::RDS
     # option from the option group.
     # @return [Boolean]
     def persistent
-      data.persistent
+      data[:persistent]
     end
 
     # Permanent options can never be removed from an option group. An option
@@ -93,7 +93,7 @@ module Aws::RDS
     # instance.
     # @return [Boolean]
     def permanent
-      data.permanent
+      data[:permanent]
     end
 
     # If true, you must enable the Auto Minor Version Upgrade setting for
@@ -102,14 +102,14 @@ module Aws::RDS
     # modifying your DB instance later.
     # @return [Boolean]
     def requires_auto_minor_engine_version_upgrade
-      data.requires_auto_minor_engine_version_upgrade
+      data[:requires_auto_minor_engine_version_upgrade]
     end
 
     # If true, you can only use this option with a DB instance that is in a
     # VPC.
     # @return [Boolean]
     def vpc_only
-      data.vpc_only
+      data[:vpc_only]
     end
 
     # If true, you can change the option to an earlier version of the
@@ -117,20 +117,20 @@ module Aws::RDS
     # available.
     # @return [Boolean]
     def supports_option_version_downgrade
-      data.supports_option_version_downgrade
+      data[:supports_option_version_downgrade]
     end
 
     # The option settings that are available (and the default value) for
     # each option in an option group.
     # @return [Array<Types::OptionGroupOptionSetting>]
     def option_group_option_settings
-      data.option_group_option_settings
+      data[:option_group_option_settings]
     end
 
     # The versions that are available for the option.
     # @return [Array<Types::OptionVersion>]
     def option_group_option_versions
-      data.option_group_option_versions
+      data[:option_group_option_versions]
     end
 
     # @!endgroup
@@ -163,6 +163,101 @@ module Aws::RDS
       !!@data
     end
 
+    # @deprecated Use [Aws::RDS::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
+
     # @deprecated
     # @api private
     def identifiers

data/lib/aws-sdk-rds/parameter.rb

@@ -34,37 +34,37 @@ module Aws::RDS
     # Specifies the value of the parameter.
     # @return [String]
     def parameter_value
-      data.parameter_value
+      data[:parameter_value]
     end
 
     # Provides a description of the parameter.
     # @return [String]
     def description
-      data.description
+      data[:description]
     end
 
     # Indicates the source of the parameter value.
     # @return [String]
     def source
-      data.source
+      data[:source]
     end
 
     # Specifies the engine specific parameters type.
     # @return [String]
     def apply_type
-      data.apply_type
+      data[:apply_type]
     end
 
     # Specifies the valid data type for the parameter.
     # @return [String]
     def data_type
-      data.data_type
+      data[:data_type]
     end
 
     # Specifies the valid range of values for the parameter.
     # @return [String]
     def allowed_values
-      data.allowed_values
+      data[:allowed_values]
     end
 
     # Indicates whether (`true`) or not (`false`) the parameter can be
@@ -72,19 +72,19 @@ module Aws::RDS
     # that prevent them from being changed.
     # @return [Boolean]
     def is_modifiable
-      data.is_modifiable
+      data[:is_modifiable]
     end
 
     # The earliest engine version to which the parameter can apply.
     # @return [String]
     def minimum_engine_version
-      data.minimum_engine_version
+      data[:minimum_engine_version]
     end
 
     # Indicates when to apply parameter updates.
     # @return [String]
     def apply_method
-      data.apply_method
+      data[:apply_method]
     end
 
     # @!endgroup
@@ -117,6 +117,101 @@ module Aws::RDS
       !!@data
     end
 
+    # @deprecated Use [Aws::RDS::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
+
     # @deprecated
     # @api private
     def identifiers

data/lib/aws-sdk-rds/pending_maintenance_action.rb

@@ -45,7 +45,7 @@ module Aws::RDS
     # any `next-maintenance` opt-in requests are ignored.
     # @return [Time]
     def auto_applied_after_date
-      data.auto_applied_after_date
+      data[:auto_applied_after_date]
     end
 
     # The date when the maintenance action will be automatically applied.
@@ -54,14 +54,14 @@ module Aws::RDS
     # specified, any `immediate` opt-in requests are ignored.
     # @return [Time]
     def forced_apply_date
-      data.forced_apply_date
+      data[:forced_apply_date]
     end
 
     # Indicates the type of opt-in request that has been received for the
     # resource.
     # @return [String]
     def opt_in_status
-      data.opt_in_status
+      data[:opt_in_status]
     end
 
     # The effective date when the pending maintenance action will be applied
@@ -72,13 +72,13 @@ module Aws::RDS
     # specified as `AutoAppliedAfterDate` or `ForcedApplyDate`.
     # @return [Time]
     def current_apply_date
-      data.current_apply_date
+      data[:current_apply_date]
     end
 
     # A description providing more detail about the maintenance action.
     # @return [String]
     def description
-      data.description
+      data[:description]
     end
 
     # @!endgroup
@@ -111,6 +111,101 @@ module Aws::RDS
       !!@data
     end
 
+    # @deprecated Use [Aws::RDS::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