class Aws::RDS::AccountQuota

def client

Returns:
  • (Client) - 
def client
  @client
end

def data

Returns:
  • (Types::AccountQuota) -

Raises:
  • (NotImplementedError) - Raises when {#data_loaded?} is `false`. 
def data
  load unless @data
  @data
end

def data_loaded?

Returns:
  • (Boolean) - 
def data_loaded?
  !!@data
end

def extract_name(args, options) 

def extract_name(args, options)
  value = args[0] || options.delete(:name)
  case value
  when String then value
  when nil then raise ArgumentError, "missing required option :name"
  else
    msg = "expected :name to be a String, got #{value.class}"
    raise ArgumentError, msg
  end
end

def identifiers

Other tags:
    Api: - private

Deprecated:
def identifiers
  { name: @name }
end

def initialize(*args)

Options Hash: (**options)
  • :client (Client) --
  • :name (required, String) --
  • :client (Client) --

Overloads:
  • def initialize(options = {})
  • def initialize(name, options = {})

Parameters:
  • name (String) -- 
def initialize(*args)
  options = Hash === args.last ? args.pop.dup : {}
  @name = extract_name(args, options)
  @data = options.delete(:data)
  @client = options.delete(:client) || Client.new(options)
  @waiter_block_warned = false
end

def load

Other tags:
    Api: - private

Raises:
  • (NotImplementedError) - 
def load
  msg = "#load is not implemented, data only available via enumeration"
  raise NotImplementedError, msg
end

def max

Returns:
  • (Integer) - 
def max
  data[:max]
end

def name

Returns:
  • (String) - 
def name
  @name
end

def used

Returns:
  • (Integer) - 
def used
  data[:used]
end

def wait_until(options = {}, &block)

Returns:
  • (Resource) - if the waiter was successful

Options Hash: (**options)
  • :before_wait (Proc) -- Callback
  • :before_attempt (Proc) -- Callback
  • :delay (Integer) -- Delay between each
  • :max_attempts (Integer) -- Maximum number of

Raises:
  • (NotImplementedError) - Raised when the resource does not
  • (Aws::Waiters::Errors::UnexpectedError) - Raised when an error is
  • (Aws::Waiters::Errors::FailureStateError) - Raised when the waiter

Other tags:
    Yieldparam: resource - to be used in the waiting condition.

Other tags:
    Note: - The waiting operation is performed on a copy. The original resource

Deprecated:
  • Use [Aws::RDS::Client] #wait_until instead
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::Plugins::UserAgent.feature('resource') do
    Aws::Waiters::Waiter.new(options).wait({})
  end
end