class Aws::AutoScaling::Instance

Public Class Methods

new(*args) click to toggle source

@overload def initialize(group_name, id, options = {})

@param [String] group_name
@param [String] id
@option options [Client] :client

@overload def initialize(options = {})

@option options [required, String] :group_name
@option options [required, String] :id
@option options [Client] :client
# File lib/aws-sdk-autoscaling/instance.rb, line 24
def initialize(*args)
  options = Hash === args.last ? args.pop.dup : {}
  @group_name = extract_group_name(args, options)
  @id = extract_id(args, options)
  @data = options.delete(:data)
  @client = options.delete(:client) || Client.new(options)
  @waiter_block_warned = false
end

Public Instance Methods

attach(options = {}) click to toggle source

@example Request syntax with placeholder values

instance.attach()

@param [Hash] options ({}) @return [EmptyStructure]

# File lib/aws-sdk-autoscaling/instance.rb, line 257
def attach(options = {})
  options = Aws::Util.deep_merge(options,
    auto_scaling_group_name: @group_name,
    instance_ids: [@id]
  )
  resp = @client.attach_instances(options)
  resp.data
end
auto_scaling_group_name()
Alias for: group_name
availability_zone() click to toggle source

The Availability Zone for the instance. @return [String]

# File lib/aws-sdk-autoscaling/instance.rb, line 55
def availability_zone
  data[:availability_zone]
end
client() click to toggle source

@return [Client]

# File lib/aws-sdk-autoscaling/instance.rb, line 121
def client
  @client
end
data() click to toggle source

@return [Types::AutoScalingInstanceDetails]

Returns the data for this {Instance}. Calls
{Client#describe_auto_scaling_instances} if {#data_loaded?} is `false`.
# File lib/aws-sdk-autoscaling/instance.rb, line 141
def data
  load unless @data
  @data
end
data_loaded?() click to toggle source

@return [Boolean]

Returns `true` if this resource is loaded.  Accessing attributes or
{#data} on an unloaded resource will trigger a call to {#load}.
# File lib/aws-sdk-autoscaling/instance.rb, line 149
def data_loaded?
  !!@data
end
detach(options = {}) click to toggle source

@example Request syntax with placeholder values

activity = instance.detach({
  should_decrement_desired_capacity: false, # required
})

@param [Hash] options ({}) @option options [required, Boolean] :should_decrement_desired_capacity

Indicates whether the Auto Scaling group decrements the desired
capacity value by the number of instances detached.

@return [Activity::Collection]

# File lib/aws-sdk-autoscaling/instance.rb, line 276
def detach(options = {})
  batch = []
  options = Aws::Util.deep_merge(options,
    auto_scaling_group_name: @group_name,
    instance_ids: [@id]
  )
  resp = @client.detach_instances(options)
  resp.data.activities.each do |a|
    batch << Activity.new(
      id: a.activity_id,
      data: a,
      client: @client
    )
  end
  Activity::Collection.new([batch], size: batch.size)
end
enter_standby(options = {}) click to toggle source

@example Request syntax with placeholder values

activity = instance.enter_standby({
  should_decrement_desired_capacity: false, # required
})

@param [Hash] options ({}) @option options [required, Boolean] :should_decrement_desired_capacity

Indicates whether to decrement the desired capacity of the Auto
Scaling group by the number of instances moved to `Standby` mode.

@return [Activity::Collection]

# File lib/aws-sdk-autoscaling/instance.rb, line 303
def enter_standby(options = {})
  batch = []
  options = Aws::Util.deep_merge(options,
    auto_scaling_group_name: @group_name,
    instance_ids: [@id]
  )
  resp = @client.enter_standby(options)
  resp.data.activities.each do |a|
    batch << Activity.new(
      id: a.activity_id,
      data: a,
      client: @client
    )
  end
  Activity::Collection.new([batch], size: batch.size)
end
exit_standby(options = {}) click to toggle source

@example Request syntax with placeholder values

instance.exit_standby()

@param [Hash] options ({}) @return [Activity::Collection]

# File lib/aws-sdk-autoscaling/instance.rb, line 325
def exit_standby(options = {})
  batch = []
  options = Aws::Util.deep_merge(options,
    auto_scaling_group_name: @group_name,
    instance_ids: [@id]
  )
  resp = @client.exit_standby(options)
  resp.data.activities.each do |a|
    batch << Activity.new(
      id: a.activity_id,
      data: a,
      client: @client
    )
  end
  Activity::Collection.new([batch], size: batch.size)
end
group() click to toggle source

@return [AutoScalingGroup]

# File lib/aws-sdk-autoscaling/instance.rb, line 397
def group
  AutoScalingGroup.new(
    name: @group_name,
    client: @client
  )
end
group_name() click to toggle source

@return [String]

# File lib/aws-sdk-autoscaling/instance.rb, line 36
def group_name
  @group_name
end
Also aliased as: auto_scaling_group_name
health_status() click to toggle source

The last reported health status of this instance. “Healthy” means that the instance is healthy and should remain in service. “Unhealthy” means that the instance is unhealthy and Amazon EC2 Auto Scaling should terminate and replace it. @return [String]

# File lib/aws-sdk-autoscaling/instance.rb, line 85
def health_status
  data[:health_status]
end
id() click to toggle source

@return [String]

# File lib/aws-sdk-autoscaling/instance.rb, line 42
def id
  @id
end
Also aliased as: instance_id
identifiers() click to toggle source

@deprecated @api private

# File lib/aws-sdk-autoscaling/instance.rb, line 418
def identifiers
  {
    group_name: @group_name,
    id: @id
  }
end
instance_id()
Alias for: id
instance_type() click to toggle source

The instance type of the EC2 instance. @return [String]

# File lib/aws-sdk-autoscaling/instance.rb, line 49
def instance_type
  data[:instance_type]
end
launch_configuration() click to toggle source

@return [LaunchConfiguration, nil]

# File lib/aws-sdk-autoscaling/instance.rb, line 405
def launch_configuration
  if data[:launch_configuration_name]
    LaunchConfiguration.new(
      name: data[:launch_configuration_name],
      client: @client
    )
  else
    nil
  end
end
launch_configuration_name() click to toggle source

The launch configuration used to launch the instance. This value is not available if you attached the instance to the Auto Scaling group. @return [String]

# File lib/aws-sdk-autoscaling/instance.rb, line 92
def launch_configuration_name
  data[:launch_configuration_name]
end
launch_template() click to toggle source

The launch template for the instance. @return [Types::LaunchTemplateSpecification]

# File lib/aws-sdk-autoscaling/instance.rb, line 98
def launch_template
  data[:launch_template]
end
lifecycle_state() click to toggle source

The lifecycle state for the instance. The `Quarantined` state is not used. For information about lifecycle states, see [Instance lifecycle] in the *Amazon EC2 Auto Scaling User Guide*.

Valid Values: `Pending` | `Pending:Wait` | `Pending:Proceed` | `Quarantined` | `InService` | `Terminating` | `Terminating:Wait` | `Terminating:Proceed` | `Terminated` | `Detaching` | `Detached` | `EnteringStandby` | `Standby` | `Warmed:Pending` | `Warmed:Pending:Wait` | `Warmed:Pending:Proceed` | `Warmed:Terminating` | `Warmed:Terminating:Wait` | `Warmed:Terminating:Proceed` | `Warmed:Terminated` | `Warmed:Stopped` | `Warmed:Running`

[1]: docs.aws.amazon.com/autoscaling/ec2/userguide/AutoScalingGroupLifecycle.html @return [String]

# File lib/aws-sdk-autoscaling/instance.rb, line 76
def lifecycle_state
  data[:lifecycle_state]
end
load() click to toggle source

Loads, or reloads {#data} for the current {Instance}. Returns `self` making it possible to chain methods.

instance.reload.data

@return [self]

# File lib/aws-sdk-autoscaling/instance.rb, line 131
def load
  resp = @client.describe_auto_scaling_instances(instance_ids: [@id])
  @data = resp.auto_scaling_instances[0]
  self
end
Also aliased as: reload
protected_from_scale_in() click to toggle source

Indicates whether the instance is protected from termination by Amazon EC2 Auto Scaling when scaling in. @return [Boolean]

# File lib/aws-sdk-autoscaling/instance.rb, line 105
def protected_from_scale_in
  data[:protected_from_scale_in]
end
reload()
Alias for: load
set_health(options = {}) click to toggle source

@example Request syntax with placeholder values

instance.set_health({
  health_status: "XmlStringMaxLen32", # required
  should_respect_grace_period: false,
})

@param [Hash] options ({}) @option options [required, String] :health_status

The health status of the instance. Set to `Healthy` to have the
instance remain in service. Set to `Unhealthy` to have the instance be
out of service. Amazon EC2 Auto Scaling terminates and replaces the
unhealthy instance.

@option options [Boolean] :should_respect_grace_period

If the Auto Scaling group of the specified instance has a
`HealthCheckGracePeriod` specified for the group, by default, this
call respects the grace period. Set this to `False`, to have the call
not respect the grace period associated with the group.

For more information about the health check grace period, see
[CreateAutoScalingGroup][1] in the *Amazon EC2 Auto Scaling API
Reference*.

[1]: https://docs.aws.amazon.com/autoscaling/ec2/APIReference/API_CreateAutoScalingGroup.html

@return [EmptyStructure]

# File lib/aws-sdk-autoscaling/instance.rb, line 368
def set_health(options = {})
  options = options.merge(instance_id: @id)
  resp = @client.set_instance_health(options)
  resp.data
end
terminate(options = {}) click to toggle source

@example Request syntax with placeholder values

activity = instance.terminate({
  should_decrement_desired_capacity: false, # required
})

@param [Hash] options ({}) @option options [required, Boolean] :should_decrement_desired_capacity

Indicates whether terminating the instance also decrements the size of
the Auto Scaling group.

@return [Activity]

# File lib/aws-sdk-autoscaling/instance.rb, line 384
def terminate(options = {})
  options = options.merge(instance_id: @id)
  resp = @client.terminate_instance_in_auto_scaling_group(options)
  Activity.new(
    id: resp.data.activity.activity_id,
    data: resp.data.activity,
    client: @client
  )
end
wait_until(options = {}, &block) click to toggle source

@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) do |instance|
  instance.state.name == 'running'
end

## 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

@yieldparam [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

# File lib/aws-sdk-autoscaling/instance.rb, line 233
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
weighted_capacity() click to toggle source

The number of capacity units contributed by the instance based on its instance type.

Valid Range: Minimum value of 1. Maximum value of 999. @return [String]

# File lib/aws-sdk-autoscaling/instance.rb, line 114
def weighted_capacity
  data[:weighted_capacity]
end

Private Instance Methods

extract_group_name(args, options) click to toggle source
# File lib/aws-sdk-autoscaling/instance.rb, line 428
def extract_group_name(args, options)
  value = args[0] || options.delete(:group_name)
  case value
  when String then value
  when nil then raise ArgumentError, "missing required option :group_name"
  else
    msg = "expected :group_name to be a String, got #{value.class}"
    raise ArgumentError, msg
  end
end
extract_id(args, options) click to toggle source
# File lib/aws-sdk-autoscaling/instance.rb, line 439
def extract_id(args, options)
  value = args[1] || options.delete(:id)
  case value
  when String then value
  when nil then raise ArgumentError, "missing required option :id"
  else
    msg = "expected :id to be a String, got #{value.class}"
    raise ArgumentError, msg
  end
end