capistrano-autoscaling 0.0.5 → 0.0.6

data/README.md

@@ -76,8 +76,10 @@ The following options are preserved to manage AutoScaling.
 ### EC2 options
 
  * `:autoscaling_ec2_instances` - The EC2 instances behind ELB.
- * `:autoscaling_ec2_instance_dns_names` - The DNS name of EC2 instances behind ELB.
+ * `:autoscaling_ec2_instance_public_dns_names` - The DNS name of EC2 instances behind ELB.
+ * `:autoscaling_ec2_instance_public_ip_addresses` - The IP address of EC2 instances behind ELB.
  * `:autoscaling_ec2_instance_private_dns_names` - The private DNS name of EC2 instances behind ELB.
+ * `:autoscaling_ec2_instance_private_ip_addresses` - The private IP address of EC2 instances behind ELB.
 
 ### AMI options
 

data/lib/capistrano-autoscaling.rb

@@ -109,9 +109,9 @@ module Capistrano
           _cset(:autoscaling_create_alarm) { autoscaling_create_policy }
 
 ## ELB
-          _cset(:autoscaling_elb_instance_name_prefix, "elb-")
+          _cset(:autoscaling_elb_instance_name_prefix, "")
           _cset(:autoscaling_elb_instance_name) { "#{autoscaling_elb_instance_name_prefix}#{autoscaling_application}" }
-          _cset(:autoscaling_elb_instance) { autoscaling_elb_client.load_balancers[autoscaling_elb_instance_name] }
+          _cset(:autoscaling_elb_instance) { autoscaling_elb_client.load_balancers[autoscaling_elb_instance_name] rescue nil }
           _cset(:autoscaling_elb_port, 80)
           _cset(:autoscaling_elb_protocol, :http)
           _cset(:autoscaling_elb_listeners) {
@@ -174,6 +174,10 @@ module Capistrano
           }
           _cset(:autoscaling_ec2_instance_dns_names) { autoscaling_ec2_instances.map { |instance| instance.dns_name } }
           _cset(:autoscaling_ec2_instance_private_dns_names) { autoscaling_ec2_instances.map { |instance| instance.private_dns_name } }
+          _cset(:autoscaling_ec2_instance_public_dns_names) { autoscaling_ec2_instances.map { |instance| instance.public_dns_name } }
+          _cset(:autoscaling_ec2_instance_ip_addresses) { autoscaling_ec2_instances.map { |instance| instance.ip_address } }
+          _cset(:autoscaling_ec2_instance_private_ip_addresses) { autoscaling_ec2_instances.map { |instance| instance.private_ip_address } }
+          _cset(:autoscaling_ec2_instance_public_ip_addresses) { autoscaling_ec2_instances.map { |instance| instance.public_ip_address } }
 
 ## AMI
           _cset(:autoscaling_image_name_prefix) { "#{autoscaling_application}/" }
@@ -198,9 +202,9 @@ module Capistrano
 
 ## LaunchConfiguration
           _cset(:autoscaling_launch_configuration) {
-            autoscaling_autoscaling_client.launch_configurations[autoscaling_launch_configuration_name]
+            autoscaling_autoscaling_client.launch_configurations[autoscaling_launch_configuration_name] rescue nil
           }
-          _cset(:autoscaling_launch_configuration_name_prefix, "lc-")
+          _cset(:autoscaling_launch_configuration_name_prefix, "")
           _cset(:autoscaling_launch_configuration_name) { "#{autoscaling_launch_configuration_name_prefix}#{autoscaling_image_name}" }
           _cset(:autoscaling_launch_configuration_instance_type) { autoscaling_instance_type }
           _cset(:autoscaling_launch_configuration_security_groups) { autoscaling_security_groups }
@@ -211,7 +215,7 @@ module Capistrano
           }
 
 ## AutoScalingGroup
-          _cset(:autoscaling_group_name_prefix, "asg-")
+          _cset(:autoscaling_group_name_prefix, "")
           _cset(:autoscaling_group_name) { "#{autoscaling_group_name_prefix}#{autoscaling_application}" }
           _cset(:autoscaling_group_availability_zones) { autoscaling_availability_zones }
           _cset(:autoscaling_group_subnets) { autoscaling_subnets } # VPC only
@@ -229,7 +233,7 @@ module Capistrano
             end
             options.merge(fetch(:autoscaling_group_extra_options, {}))
           }
-          _cset(:autoscaling_group) { autoscaling_autoscaling_client.groups[autoscaling_group_name] }
+          _cset(:autoscaling_group) { autoscaling_autoscaling_client.groups[autoscaling_group_name] rescue nil }
 
 ## ScalingPolicy
           _cset(:autoscaling_expand_policy_name_prefix, "expand-")
@@ -250,8 +254,8 @@ module Capistrano
               :type => fetch(:autoscaling_shrink_policy_type, "ChangeInCapacity"),
             }.merge(fetch(:autoscaling_shrink_policy_extra_options, {}))
           }
-          _cset(:autoscaling_expand_policy) { autoscaling_group.scaling_policies[autoscaling_expand_policy_name] }
-          _cset(:autoscaling_shrink_policy) { autoscaling_group.scaling_policies[autoscaling_shrink_policy_name] }
+          _cset(:autoscaling_expand_policy) { autoscaling_group.scaling_policies[autoscaling_expand_policy_name] rescue nil }
+          _cset(:autoscaling_shrink_policy) { autoscaling_group.scaling_policies[autoscaling_shrink_policy_name] rescue nil }
 
 ## Alarm
           _cset(:autoscaling_expand_alarm_options) {
@@ -275,8 +279,8 @@ module Capistrano
               :statistic => fetch(:autoscaling_expand_alarm_evaluation_statistic, "Average"),
               :namespace => fetch(:autoscaling_expand_alarm_namespace, "AWS/EC2"),
               :metric_name => fetch(:autoscaling_expand_alarm_metric_name, "CPUUtilization"),
-              :comparison_operator => fetch(:autoscaling_expand_alarm_comparison_operator, "LessThanThreshold"),
-              :threshold => fetch(:autoscaling_expand_alarm_threshold, 30),
+              :comparison_operator => fetch(:autoscaling_expand_alarm_comparison_operator, "GreaterThanThreshold"),
+              :threshold => fetch(:autoscaling_expand_alarm_threshold, 60),
             },
           }}
           _cset(:autoscaling_shrink_alarm_definitions) {{
@@ -325,7 +329,7 @@ module Capistrano
                 end
               else
                 logger.debug("Creating ELB instance: #{autoscaling_elb_instance_name}")
-                set(:autoscaling_elb_instance, autoscling_elb_client.load_balancers.create(
+                set(:autoscaling_elb_instance, autoscaling_elb_client.load_balancers.create(
                   autoscaling_elb_instance_name, autoscaling_elb_instance_options))
                 sleep(autoscaling_wait_interval) unless autoscaling_elb_instance.exists?
                 logger.debug("Created ELB instance: #{autoscaling_elb_instance.name}")
@@ -340,7 +344,7 @@ module Capistrano
 
           task(:destroy_elb, :roles => :app, :except => { :no_release => true }) {
             if autoscaling_elb_instance and autoscaling_elb_instance.exists?
-              if 0 < autoscaling_elb_instance.length
+              if 0 < autoscaling_elb_instance.instances.length
                 abort("ELB is not empty.")
               end
               logger.debug("Deleting ELB: #{autoscaling_elb_instance.name}")
@@ -486,7 +490,7 @@ module Capistrano
           task(:update_alarm, :roles => :app, :except => { :no_release => true }) {
             if autoscaling_create_alarm
               autoscaling_expand_alarm_definitions.each do |alarm_name, alarm_options|
-                alarm = autoscaling_cloudwatch_client.alarms[alarm_name]
+                alarm = ( autoscaling_cloudwatch_client.alarms[alarm_name] rescue nil )
                 if alarm and alarm.exists?
                   logger.debug("Found Alarm for expansion: #{alarm.name}")
                 else
@@ -504,7 +508,7 @@ module Capistrano
 
             if autoscaling_create_alarm
               autoscaling_shrink_alarm_definitions.each do |alarm_name, alarm_options|
-                alarm = autoscaling_cloudwatch_client.alarms[alarm_name]
+                alarm = ( autoscaling_cloudwatch_client.alarms[alarm_name] rescue nil )
                 if alarm and alarm.exists?
                   logger.debug("Found Alarm for shrinking: #{alarm.name}")
                 else
@@ -523,7 +527,7 @@ module Capistrano
 
           task(:destroy_alarm, :roles => :app, :except => { :no_release => true }) {
             autoscaling_expand_alarm_definitions.each do |alarm_name, alarm_options|
-              alarm = autoscaling_cloudwatch_client.alarms[alarm_name]
+              alarm = ( autoscaling_cloudwatch_client.alarms[alarm_name] rescue nil)
               if alarm and alarm.exists?
                 logger.debug("Deleting Alarm for expansion: #{alarm.name}")
                 alarm.delete()
@@ -532,7 +536,7 @@ module Capistrano
             end
 
             autoscaling_shrink_alarm_definitions.each do |alarm_name, alarm_options|
-              alarm = autoscaling_cloudwatch_client.alarms[alarm_name]
+              alarm = ( autoscaling_cloudwatch_client.alarms[alarm_name] rescue nil )
               if alarm and alarm.exists?
                 logger.debug("Deleting Alarm for shrinking: #{alarm.name}")
                 alarm.delete()
@@ -563,61 +567,86 @@ module Capistrano
 
           desc("Show AutoScaling status.")
           task(:status, :roles => :app, :except => { :no_release => true }) {
+            status = {}
+
+            if autoscaling_group and autoscaling_group.exists?
+              status[:name] = autoscaling_group.name
+              status[:availability_zone_names] = autoscaling_group.availability_zone_names.to_a
+              status[:desired_capacity] = autoscaling_group.desired_capacity
+              status[:max_size] = autoscaling_group.max_size
+              status[:min_size] = autoscaling_group.min_size
+            end
+
+            launch_configuration = nil
+            if autoscaling_group and autoscaling_group.exists?
+              launch_configuration = autoscaling_gruop.launch_configuration
+            elsif autoscaling_launch_configuration and autoscaling_launch_configuration.exists?
+              launch_configuration = autoscaling_launch_configuration
+            end
+            if launch_configuration
+               status[:launch_configuration] = {
+                :name => launch_configuration.name,
+                :iam_instance_profile => launch_configuration.iam_instance_profile,
+                :instance_type => launch_configuration.instance_type,
+                :security_groups => launch_configuration.security_groups.map { |sg| sg.name },
+                :image => {
+                  :id => launch_configuration.image.id,
+                  :name => launch_configuration.image.name,
+                  :state => launch_configuration.image.state,
+                }
+              }
+           end
+
+            load_balancers = nil
             if autoscaling_group and autoscaling_group.exists?
-              STDOUT.puts({
-                :name => autoscaling_group.name,
-                :availability_zone_names => autoscaling_group.availability_zone_names.to_a,
-                :desired_capacity => autoscaling_group.desired_capacity,
-                :max_size => autoscaling_group.max_size,
-                :min_size => autoscaling_group.min_size,
-                :launch_configuration => {
-                  :name => autoscaling_group.launch_configuration.name,
-                  :iam_instance_profile => autoscaling_group.launch_configuration.iam_instance_profile,
-                  :instance_type => autoscaling_group.launch_configuration.instance_type,
-                  :security_groups => autoscaling_group.launch_configuration.security_groups.map { |sg| sg.name },
-                  :image => {
-                    :id => autoscaling_group.launch_configuration.image.id,
-                    :name => autoscaling_group.launch_configuration.image.name,
-                    :state => autoscaling_group.launch_configuration.image.state,
+              load_balancers = autoscaling_group.load_balancers.to_a
+            elsif autoscaling_elb_instance and autoscaling_elb_instance.exists?
+              load_balancers = [ autoscaling_elb_instance ]
+            end
+            if load_balancers
+              status[:load_balancers] = load_balancers.map { |lb|
+                {
+                  :name => lb.name,
+                  :availability_zone_names => lb.availability_zone_names.to_a,
+                  :dns_name => lb.dns_name,
+                  :instances => lb.instances.map { |i|
+                    {
+                      :id => i.id,
+                      :private_ip_address => i.private_ip_address,
+                      :private_dns_name => i.private_dns_name,
+                      :public_ip_address => i.public_ip_address,
+                      :public_dns_name => i.public_dns_name,
+                      :status => i.status,
+                    }
                   },
-                },
-                :load_balancers => autoscaling_group.load_balancers.to_a.map { |lb|
-                  {
-                    :name => lb.name,
-                    :availability_zone_names => lb.availability_zone_names.to_a,
-                    :dns_name => lb.dns_name,
-                    :instances => lb.instances.map { |i|
-                      {
-                        :id => i.id,
-                        :dns_name => i.dns_name,
-                        :private_dns_name => i.private_dns_name,
-                        :status => i.status,
-                      }
-                    },
-                  }
-                },
-                :scaling_policies => autoscaling_group.scaling_policies.map { |policy|
-                  {
-                    :name => policy.name,
-                    :adjustment_type => policy.adjustment_type,
-                    :alarms => policy.alarms.to_hash.keys,
-                    :cooldown => policy.cooldown,
-                    :scaling_adjustment => policy.scaling_adjustment,
-                  }
-                },
-                :scheduled_actions => autoscaling_group.scheduled_actions.map { |action|
-                  {
-                    :name => action.name,
-                    :desired_capacity => action.desired_capacity,
-                    :end_time => action.end_time,
-                    :max_size => action.max_size,
-                    :min_size => action.min_size,
-                    :start_time => action.start_time,
-                  }
-                },
-                :suspended_processes => autoscaling_group.suspended_processes.to_hash,
-              }.to_yaml)
+                }
+              }
+            end
+
+            if autoscaling_group and autoscaling_group.exists?
+              status[:scaling_policies] = autoscaling_group.scaling_policies.map { |policy|
+                {
+                  :name => policy.name,
+                  :adjustment_type => policy.adjustment_type,
+                  :alarms => policy.alarms.to_hash.keys,
+                  :cooldown => policy.cooldown,
+                  :scaling_adjustment => policy.scaling_adjustment,
+                }
+              }
+              status[:scheduled_actions] = autoscaling_group.scheduled_actions.map { |action|
+                {
+                  :name => action.name,
+                  :desired_capacity => action.desired_capacity,
+                  :end_time => action.end_time,
+                  :max_size => action.max_size,
+                  :min_size => action.min_size,
+                  :start_time => action.start_time,
+                }
+              }
+              status[:suspended_processes] = autoscaling_group.suspended_processes.to_hash
             end
+
+            STDOUT.puts(status.to_yaml)
           }
 
           desc("Show AutoScaling history.")
@@ -625,14 +654,16 @@ module Capistrano
             if autoscaling_group and autoscaling_group.exists?
               autoscaling_group.scaling_policies.each do |policy|
                 policy.alarms.each do |alarm_name, alarm_arn|
-                  alarm = autoscaling_cloudwatch_client.alarms[alarm_name]
-                  start_date = Time.now - fetch(:autoscaling_history_days, 3) * 86400
-                  history_items = alarm.history_items.with_start_date(start_date)
-
-                  STDOUT.puts("--")
-                  STDOUT.puts("Alarm: #{alarm_name} (ScalingPolicy: #{policy.name})")
-                  history_items.each do |hi|
-                    STDOUT.puts("#{hi.timestamp}: #{hi.type}: #{hi.summary}")
+                  alarm = ( autoscaling_cloudwatch_client.alarms[alarm_name] rescue nil )
+                  if alarm and alarm.exists?
+                    start_date = Time.now - fetch(:autoscaling_history_days, 3) * 86400
+                    history_items = alarm.history_items.with_start_date(start_date)
+
+                    STDOUT.puts("--")
+                    STDOUT.puts("Alarm: #{alarm_name} (ScalingPolicy: #{policy.name})")
+                    history_items.each do |hi|
+                      STDOUT.puts("#{hi.timestamp}: #{hi.type}: #{hi.summary}")
+                    end
                   end
                 end
               end

data/lib/capistrano-autoscaling/version.rb

@@ -1,5 +1,5 @@
 module Capistrano
   module AutoScaling
-    VERSION = "0.0.5"
+    VERSION = "0.0.6"
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: capistrano-autoscaling
 version: !ruby/object:Gem::Version
-  version: 0.0.5
+  version: 0.0.6
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-12-04 00:00:00.000000000 Z
+date: 2013-01-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: capistrano
@@ -85,3 +85,4 @@ specification_version: 3
 summary: A Capistrano recipe that configures AutoScaling on Amazon Web Services infrastructure
   for your application.
 test_files: []
+has_rdoc: