Class: Aws::AutoScaling::LifecycleHook

Inherits:
Object
  • Object
show all
Extended by:
Deprecations
Defined in:
lib/aws-sdk-autoscaling/lifecycle_hook.rb

Defined Under Namespace

Classes: Collection

Read-Only Attributes collapse

Actions collapse

Associations collapse

Instance Method Summary collapse

Constructor Details

#initialize(group_name, name, options = {}) ⇒ LifecycleHook #initialize(options = {}) ⇒ LifecycleHook

Returns a new instance of LifecycleHook.

Overloads:

  • #initialize(group_name, name, options = {}) ⇒ LifecycleHook

    Parameters:

    • group_name (String)
    • name (String)

    Options Hash (options):

  • #initialize(options = {}) ⇒ LifecycleHook

    Options Hash (options):

    • :group_name (required, String)
    • :name (required, String)
    • :client (Client) 


24
25
26
27
28
29
30
31
 
# File 'lib/aws-sdk-autoscaling/lifecycle_hook.rb', line 24

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

Instance Method Details

#client ⇒ Client

Returns:



107
108
109
 
# File 'lib/aws-sdk-autoscaling/lifecycle_hook.rb', line 107

def client
  @client
end

#complete(options = {}) ⇒ Types::CompleteLifecycleActionAnswer

Examples:

Request syntax with placeholder values


lifecycle_hook.complete({
  lifecycle_action_token: "LifecycleActionToken",
  lifecycle_action_result: "LifecycleActionResult", # required
  instance_id: "XmlStringMaxLen19",
})

Parameters:

  • options (Hash) (defaults to: {}) —

    ({})

Options Hash (options):

  • :lifecycle_action_token (String) —

    A universally unique identifier (UUID) that identifies a specific lifecycle action associated with an instance. Amazon EC2 Auto Scaling sends this token to the notification target you specified when you created the lifecycle hook.

  • :lifecycle_action_result (required, String) —

    The action for the group to take. You can specify either ‘CONTINUE` or `ABANDON`.

  • :instance_id (String) —

    The ID of the instance.

Returns:



264
265
266
267
268
269
270
271
272
273
 
# File 'lib/aws-sdk-autoscaling/lifecycle_hook.rb', line 264

def complete(options = {})
  options = options.merge(
    auto_scaling_group_name: @group_name,
    lifecycle_hook_name: @name
  )
  resp = Aws::Plugins::UserAgent.metric('RESOURCE_MODEL') do
    @client.complete_lifecycle_action(options)
  end
  resp.data
end

#data ⇒ Types::LifecycleHook

Returns the data for this Aws::AutoScaling::LifecycleHook. Calls Client#describe_lifecycle_hooks if #data_loaded? is ‘false`.

Returns:



132
133
134
135
 
# File 'lib/aws-sdk-autoscaling/lifecycle_hook.rb', line 132

def data
  load unless @data
  @data
end

#data_loaded? ⇒ Boolean

Returns ‘true` if this resource is loaded. Accessing attributes or #data on an unloaded resource will trigger a call to #load.

Returns:

  • (Boolean) —

    Returns ‘true` if this resource is loaded. Accessing attributes or #data on an unloaded resource will trigger a call to #load.



140
141
142
 
# File 'lib/aws-sdk-autoscaling/lifecycle_hook.rb', line 140

def data_loaded?
  !!@data
end

#default_result ⇒ String

The action the Auto Scaling group takes when the lifecycle hook timeout elapses or if an unexpected failure occurs.

Valid values: ‘CONTINUE` | `ABANDON`

Returns:

  • (String) 


100
101
102
 
# File 'lib/aws-sdk-autoscaling/lifecycle_hook.rb', line 100

def default_result
  data[:default_result]
end

#delete(options = {}) ⇒ Types::DeleteLifecycleHookAnswer

Examples:

Request syntax with placeholder values


lifecycle_hook.delete()

Parameters:

  • options (Hash) (defaults to: {}) —

    ({})

Returns:



280
281
282
283
284
285
286
287
288
289
 
# File 'lib/aws-sdk-autoscaling/lifecycle_hook.rb', line 280

def delete(options = {})
  options = options.merge(
    auto_scaling_group_name: @group_name,
    lifecycle_hook_name: @name
  )
  resp = Aws::Plugins::UserAgent.metric('RESOURCE_MODEL') do
    @client.delete_lifecycle_hook(options)
  end
  resp.data
end

#global_timeout ⇒ Integer

The maximum time, in seconds, that an instance can remain in a wait state. The maximum is 172800 seconds (48 hours) or 100 times ‘HeartbeatTimeout`, whichever is smaller.

Returns:

  • (Integer) 


91
92
93
 
# File 'lib/aws-sdk-autoscaling/lifecycle_hook.rb', line 91

def global_timeout
  data[:global_timeout]
end

#group ⇒ AutoScalingGroup

Returns:



390
391
392
393
394
395
 
# File 'lib/aws-sdk-autoscaling/lifecycle_hook.rb', line 390

def group
  AutoScalingGroup.new(
    name: @group_name,
    client: @client
  )
end

#group_name ⇒ String Also known as: auto_scaling_group_name

Returns:

  • (String) 


36
37
38
 
# File 'lib/aws-sdk-autoscaling/lifecycle_hook.rb', line 36

def group_name
  @group_name
end

#heartbeat_timeout ⇒ Integer

The maximum time, in seconds, that can elapse before the lifecycle hook times out. If the lifecycle hook times out, Amazon EC2 Auto Scaling performs the action that you specified in the ‘DefaultResult` property.

Returns:

  • (Integer) 


83
84
85
 
# File 'lib/aws-sdk-autoscaling/lifecycle_hook.rb', line 83

def heartbeat_timeout
  data[:heartbeat_timeout]
end

#identifiers ⇒ Object

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Deprecated. 


399
400
401
402
403
404
 
# File 'lib/aws-sdk-autoscaling/lifecycle_hook.rb', line 399

def identifiers
  {
    group_name: @group_name,
    name: @name
  }
end

#lifecycle_transition ⇒ String

The lifecycle transition.

Valid values: ‘autoscaling:EC2_INSTANCE_LAUNCHING` | `autoscaling:EC2_INSTANCE_TERMINATING`

Returns:

  • (String) 


52
53
54
 
# File 'lib/aws-sdk-autoscaling/lifecycle_hook.rb', line 52

def lifecycle_transition
  data[:lifecycle_transition]
end

#load ⇒ self Also known as: reload

Loads, or reloads #data for the current Aws::AutoScaling::LifecycleHook. Returns ‘self` making it possible to chain methods.

lifecycle_hook.reload.data

Returns:

  • (self) 


117
118
119
120
121
122
123
124
125
126
 
# File 'lib/aws-sdk-autoscaling/lifecycle_hook.rb', line 117

def load
  resp = Aws::Plugins::UserAgent.metric('RESOURCE_MODEL') do
    @client.describe_lifecycle_hooks(
    auto_scaling_group_name: @group_name,
    lifecycle_hook_names: [@name]
  )
  end
  @data = resp.lifecycle_hooks[0]
  self
end

#name ⇒ String Also known as: lifecycle_hook_name

Returns:

  • (String) 


42
43
44
 
# File 'lib/aws-sdk-autoscaling/lifecycle_hook.rb', line 42

def name
  @name
end

#notification_metadata ⇒ String

Additional information that is included any time Amazon EC2 Auto Scaling sends a message to the notification target.

Returns:

  • (String) 


74
75
76
 
# File 'lib/aws-sdk-autoscaling/lifecycle_hook.rb', line 74

def notification_metadata
  data[:notification_metadata]
end

#notification_target_arn ⇒ String

The ARN of the target that Amazon EC2 Auto Scaling sends notifications to when an instance is in a wait state for the lifecycle hook.

Returns:

  • (String) 


59
60
61
 
# File 'lib/aws-sdk-autoscaling/lifecycle_hook.rb', line 59

def notification_target_arn
  data[:notification_target_arn]
end

#put(options = {}) ⇒ Types::PutLifecycleHookAnswer

Examples:

Request syntax with placeholder values


lifecycle_hook.put({
  lifecycle_transition: "LifecycleTransition",
  role_arn: "XmlStringMaxLen255",
  notification_target_arn: "NotificationTargetResourceName",
  notification_metadata: "AnyPrintableAsciiStringMaxLen4000",
  heartbeat_timeout: 1,
  default_result: "LifecycleActionResult",
})

Parameters:

  • options (Hash) (defaults to: {}) —

    ({})

Options Hash (options):

  • :lifecycle_transition (String) —

    The lifecycle transition. For Auto Scaling groups, there are two major lifecycle transitions.

    • To create a lifecycle hook for scale-out events, specify ‘autoscaling:EC2_INSTANCE_LAUNCHING`.

    • To create a lifecycle hook for scale-in events, specify ‘autoscaling:EC2_INSTANCE_TERMINATING`.

    Required for new lifecycle hooks, but optional when updating existing hooks.

  • :role_arn (String) —

    The ARN of the IAM role that allows the Auto Scaling group to publish to the specified notification target.

    Valid only if the notification target is an Amazon SNS topic or an Amazon SQS queue. Required for new lifecycle hooks, but optional when updating existing hooks.

  • :notification_target_arn (String) —

    The Amazon Resource Name (ARN) of the notification target that Amazon EC2 Auto Scaling uses to notify you when an instance is in a wait state for the lifecycle hook. You can specify either an Amazon SNS topic or an Amazon SQS queue.

    If you specify an empty string, this overrides the current ARN.

    This operation uses the JSON format when sending notifications to an Amazon SQS queue, and an email key-value pair format when sending notifications to an Amazon SNS topic.

    When you specify a notification target, Amazon EC2 Auto Scaling sends it a test message. Test messages contain the following additional key-value pair: ‘“Event”: “autoscaling:TEST_NOTIFICATION”`.

  • :notification_metadata (String) —

    Additional information that you want to include any time Amazon EC2 Auto Scaling sends a message to the notification target.

  • :heartbeat_timeout (Integer) —

    The maximum time, in seconds, that can elapse before the lifecycle hook times out. The range is from ‘30` to `7200` seconds. The default value is `3600` seconds (1 hour).

  • :default_result (String) —

    The action the Auto Scaling group takes when the lifecycle hook timeout elapses or if an unexpected failure occurs. The default value is ‘ABANDON`.

    Valid values: ‘CONTINUE` | `ABANDON`

Returns:



350
351
352
353
354
355
356
357
358
359
 
# File 'lib/aws-sdk-autoscaling/lifecycle_hook.rb', line 350

def put(options = {})
  options = options.merge(
    auto_scaling_group_name: @group_name,
    lifecycle_hook_name: @name
  )
  resp = Aws::Plugins::UserAgent.metric('RESOURCE_MODEL') do
    @client.put_lifecycle_hook(options)
  end
  resp.data
end

#record_heartbeat(options = {}) ⇒ Types::RecordLifecycleActionHeartbeatAnswer

Examples:

Request syntax with placeholder values


lifecycle_hook.record_heartbeat({
  lifecycle_action_token: "LifecycleActionToken",
  instance_id: "XmlStringMaxLen19",
})

Parameters:

  • options (Hash) (defaults to: {}) —

    ({})

Options Hash (options):

  • :lifecycle_action_token (String) —

    A token that uniquely identifies a specific lifecycle action associated with an instance. Amazon EC2 Auto Scaling sends this token to the notification target that you specified when you created the lifecycle hook.

  • :instance_id (String) —

    The ID of the instance.

Returns:



376
377
378
379
380
381
382
383
384
385
 
# File 'lib/aws-sdk-autoscaling/lifecycle_hook.rb', line 376

def record_heartbeat(options = {})
  options = options.merge(
    auto_scaling_group_name: @group_name,
    lifecycle_hook_name: @name
  )
  resp = Aws::Plugins::UserAgent.metric('RESOURCE_MODEL') do
    @client.record_lifecycle_action_heartbeat(options)
  end
  resp.data
end

#role_arn ⇒ String

The ARN of the IAM role that allows the Auto Scaling group to publish to the specified notification target (an Amazon SNS topic or an Amazon SQS queue).

Returns:

  • (String) 


67
68
69
 
# File 'lib/aws-sdk-autoscaling/lifecycle_hook.rb', line 67

def role_arn
  data[:role_arn]
end

#wait_until(options = {}) {|resource| ... } ⇒ Resource

Deprecated.

Use [Aws::AutoScaling::Client] #wait_until instead

Note:

The waiting operation is performed on a copy. The original resource remains unchanged.

Waiter polls an API operation until a resource enters a desired state.

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

attempts attempt in seconds invoked before each attempt invoked before each wait

Parameters:

  • options (Hash) (defaults to: {}) —

    a customizable set of options

Options Hash (options):

  • :max_attempts (Integer) — default: 10 —

    Maximum number of

  • :delay (Integer) — default: 10 —

    Delay between each

  • :before_attempt (Proc) — default: nil —

    Callback

  • :before_wait (Proc) — default: nil —

    Callback

Yield Parameters:

  • resource (Resource) —

    to be used in the waiting condition.

Returns:

  • (Resource) —

    if the waiter was successful

Raises:

  • (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.

  • (Aws::Waiters::Errors::UnexpectedError) —

    Raised when an error is encountered while polling for a resource that is not expected.

  • (NotImplementedError) —

    Raised when the resource does not



224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
 
# File 'lib/aws-sdk-autoscaling/lifecycle_hook.rb', line 224

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.metric('RESOURCE_MODEL') do
    Aws::Waiters::Waiter.new(options).wait({})
  end
end