Class: Hashicorptools::AutoScalingGroup

Inherits:
Object
  • Object
show all
Defined in:
lib/hashicorptools/auto_scaling_group.rb

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(attrs = {}) ⇒ AutoScalingGroup

Returns a new instance of AutoScalingGroup.



7
8
9
10
11
12
13
 
# File 'lib/hashicorptools/auto_scaling_group.rb', line 7

def initialize(attrs = {})
  attrs.each do |key,value|
    if self.respond_to?("#{key}=")
      self.send("#{key}=", value)
    end
  end
end

Instance Attribute Details

#name ⇒ Object

Returns the value of attribute name.



5
6
7
 
# File 'lib/hashicorptools/auto_scaling_group.rb', line 5

def name
  @name
end

#region ⇒ Object

Returns the value of attribute region.



5
6
7
 
# File 'lib/hashicorptools/auto_scaling_group.rb', line 5

def region
  @region
end

Instance Method Details

#all_load_balancers_at_full_health? ⇒ Boolean

Returns:

  • (Boolean) 


67
68
69
70
71
72
73
74
75
76
77
 
# File 'lib/hashicorptools/auto_scaling_group.rb', line 67

def all_load_balancers_at_full_health?
  names = group.load_balancer_names
  names.each do |lb_name|
    puts "checking health of instances in #{lb_name}"
    inst_health = elb.describe_instance_health({load_balancer_name: lb_name})
    unless inst_health.instance_states.all?{|inst| inst.state == 'InService'}
      return false
    end
  end
  return true
end

#delete! ⇒ Object 



79
80
81
82
83
84
85
86
87
88
89
90
91
 
# File 'lib/hashicorptools/auto_scaling_group.rb', line 79

def delete!
  groups.each do |group|
    wait_for_instances_to_delete(group)

    autoscaling.delete_auto_scaling_group(auto_scaling_group_name: group.auto_scaling_group_name)
    puts "waiting for #{group.auto_scaling_group_name} to delete"

    wait_until do
      autoscaling.describe_auto_scaling_groups(auto_scaling_group_names: [group.auto_scaling_group_name]).auto_scaling_groups.empty?
    end
    autoscaling.delete_launch_configuration(launch_configuration_name: group.launch_configuration_name)
  end
end

#group ⇒ Object 



63
64
65
 
# File 'lib/hashicorptools/auto_scaling_group.rb', line 63

def group
  groups.first
end

#set_desired_instances(desired_instances) ⇒ Object 



15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
 
# File 'lib/hashicorptools/auto_scaling_group.rb', line 15

def set_desired_instances(desired_instances)
  puts "updating size of #{name} to #{desired_instances}"
  autoscaling.set_desired_capacity({auto_scaling_group_name: name, desired_capacity: desired_instances, honor_cooldown: false })

  # wait for the instance count to be correct.
  wait_until do
    current_size = group.instances.size
    puts "asg currently has #{current_size} instances"
    current_size == desired_instances
  end

  puts "waiting for scaling events to finish"
  wait_for_activities_to_complete(group)
  puts "all scaling activities finished."

  if desired_instances > 0
    wait_until_instances_ready
    puts "all #{desired_instances} instances ready."
  end
end

#verify_all_instances_using_correct_ami ⇒ Object 



93
94
95
96
97
98
99
100
 
# File 'lib/hashicorptools/auto_scaling_group.rb', line 93

def verify_all_instances_using_correct_ami
  launch_configuration = Aws::AutoScaling::LaunchConfiguration.new(name: group.launch_configuration_name, client: autoscaling)
  image_id = launch_configuration.image_id
  group.instances.each do |i|
    instance = Aws::EC2::Instance.new(i.instance_id, client: ec2)
    raise "#{i.instance_id} has the incorrect AMI, not #{image_id} from current LaunchConfig" if instance.image_id != image_id
  end
end

#wait_until_instances_ready ⇒ Object 



36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
 
# File 'lib/hashicorptools/auto_scaling_group.rb', line 36

def wait_until_instances_ready
  wait_until do
    group.instances.any?
  end

  pending_instance_ids = group.instances.find_all{|i| ['Pending', 'Pending:Wait', 'Pending:Proceed'].include?(i.lifecycle_state) }.collect{|i| i.instance_id}
  shutting_down_ids =  group.instances.find_all{|i| ['Terminating', 'Terminating:Wait', 'Terminating:Proceed'].include?(i.lifecycle_state) }.collect{|i| i.instance_id}

  ec2.wait_until(:instance_running, instance_ids: pending_instance_ids) if pending_instance_ids.any?
  ec2.wait_until(:instance_terminated, instance_ids: shutting_down_ids)  if shutting_down_ids.any?

  # now that all of the instances starting up / shutting down have settled, we can verify that running instances are healthy.
  puts "waiting for instance status checks to pass.."
  wait_until do
    puts "checking instance statuses"
    resp = ec2.describe_instance_status(instance_ids: group.instances.collect{|i| i.instance_id})
    resp.instance_statuses.all?{|s| s.system_status.status == 'ok'}
  end

  puts "waiting for ELB health checks to pass..."
  wait_until do
    all_load_balancers_at_full_health?
  end

  wait_for_activities_to_complete(group)
end