capistrano-autoscaling 0.0.3 → 0.0.4

data/README.md

@@ -42,7 +42,75 @@ To enable this recipe, add following in your `config/deploy.rb`.
     after "deploy:rollback", "autoscaling:update"
     after "autoscaling:update", "autoscaling:cleanup"
 
-TODO: Write usage instructions here
+The following options are preserved to manage AutoScaling.
+
+### General options:
+
+ * `:autoscaling_region` - The region name of AWS.
+ * `:autoscaling_access_key_id` - The access key of AWS. By default, find one from `:aws_access_key_id` and `ENV["AWS_ACCESS_KEY_ID"]`.
+ * `:autoscaling_secret_access_key` - The secret access key of AWS. By default, find one from `:aws_secret_access_key` and `ENV["AWS_SECRET_ACCESS_KEY"]`.
+ * `:autoscaling_log_level` - The log level for AWS SDK.
+ * `:autoscaling_application` - The basename for AutoScaling configurations. By default, generate from `:application`.
+ * `:autoscaling_availability_zones` - The availability zones which will be used with AutoScaling. By default, use all availability zones within specified region.
+ * `:autoscaling_instance_type` - The instance type which will be used with AutoScaling. By default, use `t1.micro`.
+ * `:autoscaling_security_groups` - The security groups which will be used with AutoScaling. By default, use `%w(default)`.
+ * `:autoscaling_min_size` - The minimal size of AutoScaling cluster. By default, use `1`.
+ * `:autoscaling_max_size` - The maximum size of AutoScaling cluster. By default, use `:autoscaling_min_size`.
+
+### ELB options
+
+ * `:autoscaling_create_elb` - Controls whether create new ELB or not. By defalut, `true`.
+ * `:autoscaling_elb_instance` - The ELB instance. By default, create new ELB instance if `:autoscaling_create_elb` is true.
+ * `:autoscaling_elb_listeners` - A Hash of the listener configuration for ELB. By default, generate from `:autoscaling_elb_port` and `:autoscaling_elb_protocol`.
+ * `:autoscaling_elb_port` - The ELB port. By default, use `80`.
+ * `:autoscaling_elb_protocol` - The ELB protocol. By default, use `:http`.
+ * `:autoscaling_elb_instance_port` - The instance port behind ELB. By default, use `:autoscaling_elb_port`.
+ * `:autoscaling_elb_instance_protocol` - The instance protocol behind ELB. By default, use `:autoscaling_elb_protocol`.
+ * `:autoscaling_elb_healthy_threshold` - The healthy threshold of ELB. By default, use `10`.
+ * `:autoscaling_elb_unhealthy_threshold` - The unhealthy threshold of ELB. By default, use `2`.
+ * `:autoscaling_elb_health_check_interval` - The health check interval of ELB. By default, use `30`.
+ * `:autoscaling_elb_health_check_timeout` - The health check timeout of ELB. By default, use `5`.
+ * `:autoscaling_elb_health_check_target` - The health check target of ELB. By default, generate from first listener in `:autoscaling_elb_listeners`.
+ * `:autoscaling_elb_health_check_target_path` - The health check target path for HTTP services. By default, use `"/"`.
+
+### 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_private_dns_names` - The private DNS name of EC2 instances behind ELB.
+
+### AMI options
+
+ * `:autoscaling_create_image` - Controls whether create new AMI or not. By default, `true`.
+ * `:autoscaling_image` - The AMI of application. By default, create new AMI if `:autoscaling_create_image` is true.
+ * `:autoscaling_image_extra_options` - The extra options for creating new AMIs.
+ * `:autoscaling_keep_images` - How many AMIs do you want to keep on `autoscaling:cleanup` task. By default, keep 2 AMIs.
+
+### LaunchConfiguration options
+
+ * `:autoscaling_create_launch_configuration` - Controls whether create new launch configuration or not.
+ * `:autoscaling_launch_configuration` - The launch configuration of application. By default, create new launch configuration if `:autoscaling_create_launch_configuration` is true.
+ * `:autoscaling_launch_configuration_extra_options` - The extra options for creating new launch configurations.
+
+### AutoScalingGroup options
+
+ * `:autoscaling_create_group` - Controls whether create new group or not. By default, `true`.
+ * `:autoscaling_group` - The group for application. By default, create new group if `:autoscaling_create_group` is true.
+ * `:autoscaling_group_extra_options` - The extra options for creating new group.
+
+### ScalingPolicy options
+
+ * `:autoscaling_create_policy` - Controls whether create new policies or not.
+ * `:autoscaling_expand_policy` - The scale-out policy.
+ * `:autoscaling_shrink_policy` - The scale-in policy.
+ * `:autoscaling_expand_policy_adjustment` - The scale-out adjustment. By defualt, use `1`.
+ * `:autoscaling_shrink_policy_adjustment` - The scale-in adjustment. By default, use `-1`.
+
+### MetricAlarm options
+
+ * `:autoscaling_create_alarm` - Controls whether create new alarms or not.
+ * `:autoscaling_expand_alarm_definitions` - The definition of scale-out alarms.
+ * `:autoscaling_shrink_alarm_definitions` - The definition of scale-in alarms.
 
 
 ## Contributing

data/lib/capistrano-autoscaling.rb

@@ -87,6 +87,7 @@ module Capistrano
           _cset(:autoscaling_application) { autoscaling_name_mangling(application) }
           _cset(:autoscaling_timestamp) { Time.now.strftime("%Y%m%d%H%M%S") }
           _cset(:autoscaling_availability_zones) { autoscaling_ec2_client.availability_zones.to_a.map { |az| az.name } }
+          _cset(:autoscaling_subnets, nil) # VPC only
           _cset(:autoscaling_wait_interval, 1.0)
           _cset(:autoscaling_keep_images, 2)
           _cset(:autoscaling_instance_type, "t1.micro")
@@ -111,22 +112,36 @@ module Capistrano
           _cset(:autoscaling_elb_instance_name_prefix, "elb-")
           _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_port, 80)
+          _cset(:autoscaling_elb_protocol, :http)
           _cset(:autoscaling_elb_listeners) {
             [
               {
-                :port => fetch(:autoscaling_elb_port, 80),
-                :protocol => fetch(:autoscaling_elb_protocol, :http),
-                :instance_port => fetch(:autoscaling_elb_instance_port, 80),
-                :instance_protocol => fetch(:autoscaling_elb_instance_protocol, :http),
+                :port => autoscaling_elb_port,
+                :protocol => autoscaling_elb_protocol,
+                :instance_port => fetch(:autoscaling_elb_instance_port, autoscaling_elb_port),
+                :instance_protocol => fetch(:autoscaling_elb_instance_protocol, autoscaling_elb_protocol),
               },
             ]
           }
           _cset(:autoscaling_elb_availability_zones) { autoscaling_availability_zones }
+          _cset(:autoscaling_elb_subnets) { autoscaling_subnets } # VPC only
+          _cset(:autoscaling_elb_security_groups) { autoscaling_security_groups } # VPC only
+          _cset(:autoscaling_elb_scheme, "internal") # VPC only
           _cset(:autoscaling_elb_instance_options) {
-            {
-              :availability_zones => autoscaling_elb_availability_zones,
+            options = {
               :listeners => autoscaling_elb_listeners,
-            }.merge(fetch(:autoscaling_elb_instance_extra_options, {}))
+            }
+            if autoscaling_elb_subnets and not autoscaling_elb_subnets.empty?
+              # VPC
+              options[:subnets] = autoscaling_elb_subnets
+              options[:security_groups] = autoscaling_elb_security_groups
+              options[:scheme] = autoscaling_elb_scheme
+            else
+              # non-VPC
+              options[:availability_zones] = autoscaling_elb_availability_zones
+            end
+            options.merge(fetch(:autoscaling_elb_instance_extra_options, {}))
           }
           _cset(:autoscaling_elb_health_check_target_path, "/")
           _cset(:autoscaling_elb_health_check_target) {
@@ -188,21 +203,31 @@ module Capistrano
           _cset(:autoscaling_launch_configuration_name_prefix, "lc-")
           _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 }
           _cset(:autoscaling_launch_configuration_options) {
             {
-              :security_groups => fetch(:autoscaling_launch_configuration_security_groups, autoscaling_security_groups),
+              :security_groups => autoscaling_launch_configuration_security_groups,
             }.merge(fetch(:autoscaling_launch_configuration_extra_options, {}))
           }
 
 ## AutoScalingGroup
           _cset(:autoscaling_group_name_prefix, "asg-")
           _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
           _cset(:autoscaling_group_options) {
-            {
-              :availability_zones => fetch(:autoscaling_group_availability_zones, autoscaling_availability_zones),
+            options = {
               :min_size => fetch(:autoscaling_group_min_size, autoscaling_min_size),
               :max_size => fetch(:autoscaling_group_max_size, autoscaling_max_size),
-            }.merge(fetch(:autoscaling_group_extra_options, {}))
+            }
+            if autoscaling_group_subnets and not autoscaling_group_subnets.empty?
+              # VPC
+              options[:subnets] = autoscaling_group_subnets
+            else
+              # non-VPC
+              options[:availability_zones] = autoscaling_group_availability_zones
+            end
+            options.merge(fetch(:autoscaling_group_extra_options, {}))
           }
           _cset(:autoscaling_group) { autoscaling_autoscaling_client.groups[autoscaling_group_name] }
 
@@ -211,11 +236,13 @@ module Capistrano
           _cset(:autoscaling_shrink_policy_name_prefix, "shrink-")
           _cset(:autoscaling_expand_policy_name) { "#{autoscaling_expand_policy_name_prefix}#{autoscaling_application}" }
           _cset(:autoscaling_shrink_policy_name) { "#{autoscaling_shrink_policy_name_prefix}#{autoscaling_application}" }
-          _cset(:autoscaling_expand_policy_options) {{
-            :adjustment => fetch(:autoscaling_expand_policy_adjustment, 1),
-            :cooldown => fetch(:autoscaling_expand_policy_cooldown, 300),
-            :type => fetch(:autoscaling_expand_policy_type, "ChangeInCapacity"),
-          }}
+          _cset(:autoscaling_expand_policy_options) {
+            {
+              :adjustment => fetch(:autoscaling_expand_policy_adjustment, 1),
+              :cooldown => fetch(:autoscaling_expand_policy_cooldown, 300),
+              :type => fetch(:autoscaling_expand_policy_type, "ChangeInCapacity"),
+            }.merge(fetch(:autoscaling_expand_policy_extra_options, {}))
+          }
           _cset(:autoscaling_shrink_policy_options) {
             {
               :adjustment => fetch(:autoscaling_shrink_policy_adjustment, -1),
@@ -264,14 +291,35 @@ module Capistrano
 
           desc("Setup AutoScaling.")
           task(:setup, :roles => :app, :except => { :no_release => true }) {
-            setup_elb
+            update_elb
+          }
+
+          desc("Remove AutoScaling settings.")
+          task(:destroy, :roles => :app, :except => { :no_release => true }) {
+            destroy_alarm
+            destroy_policy
+            destroy_group
+            destroy_elb
+          }
+
+          desc("Register current instance for AutoScaling.")
+          task(:update, :roles => :app, :except => { :no_release => true }) {
+            suspend
+            update_image
+            update_launch_configuration
+            update_group
+            update_policy
+            update_alarm
+            resume
           }
 
-          task(:setup_elb, :roles => :app, :except => { :no_release => true }) {
+          task(:update_elb, :roles => :app, :except => { :no_release => true }) {
             if autoscaling_create_elb
               if autoscaling_elb_instance and autoscaling_elb_instance.exists?
                 logger.debug("Found ELB: #{autoscaling_elb_instance.name}")
-                autoscaling_elb_instance.availability_zones.enable(*autoscaling_elb_availability_zones)
+                if autoscaling_elb_instance_options.has_key?(:availability_zones)
+                  autoscaling_elb_instance.availability_zones.enable(*autoscaling_elb_instance_options[:availability_zones])
+                end
                 autoscaling_elb_listeners.each do |listener|
                   autoscaling_elb_instance.listeners.create(listener)
                 end
@@ -290,19 +338,15 @@ module Capistrano
             end
           }
 
-          desc("Remove AutoScaling settings.")
-          task(:destroy, :roles => :app, :except => { :no_release => true }) {
-            abort("FIXME: Not yet implemented.")
-          }
-
-          desc("Register current instance for AutoScaling.")
-          task(:update, :roles => :app, :except => { :no_release => true }) {
-            suspend
-            update_image
-            update_launch_configuration
-            update_group
-            update_policy
-            resume
+          task(:destroy_elb, :roles => :app, :except => { :no_release => true }) {
+            if autoscaling_elb_instance and autoscaling_elb_instance.exists?
+              if 0 < autoscaling_elb_instance.length
+                abort("ELB is not empty.")
+              end
+              logger.debug("Deleting ELB: #{autoscaling_elb_instance.name}")
+              autoscaling_elb_instance.delete()
+              logger.debug("Deleted ELB: #{autoscaling_elb_instance.name}")
+            end
           }
 
           task(:update_image, :roles => :app, :except => { :no_release => true }) {
@@ -373,6 +417,17 @@ module Capistrano
             end
           }
 
+          task(:destroy_group, :roles => :app, :except => { :no_release => true }) {
+            if autoscaling_group and autoscaling_group.exists?
+              if 0 < autoscaling_elb_instance.instances.length
+                abort("AutoScalingGroup is not empty.")
+              end
+              logger.debug("Deleting AutoScalingGroup: #{autoscaling_group.name} (#{autoscaling_group.launch_configuration_name})")
+              autoscaling_group.delete()
+              logger.debug("Deleted AutoScalingGroup: #{autoscaling_group.name} (#{autoscaling_group.launch_configuration_name})")
+            end
+          }
+
           task(:update_policy, :roles => :app, :except => { :no_release => true }) {
             if autoscaling_create_policy
               if autoscaling_expand_policy and autoscaling_expand_policy.exists?
@@ -403,6 +458,20 @@ module Capistrano
             end
           }
 
+          task(:destroy_policy, :roles => :app, :except => { :no_release => true }) {
+            if autoscaling_expand_policy and autoscaling_expand_policy.exists?
+              logger.debug("Deleting ScalingPolicy for expansion: #{autoscaling_expand_policy.name}")
+              autoscaling_expand_policy.delete()
+              logger.debug("Deleted ScalingPolicy for expansion: #{autoscaling_expand_policy.name}")
+            end
+
+            if autoscaling_shrink_policy and autoscaling_shrink_policy.exists?
+              logger.debug("Deleting ScalingPolicy for shrinking: #{autoscaling_shrink_policy.name}")
+              autoscaling_shrink_policy.delete()
+              logger.debug("Deleted ScalingPolicy for shrinking: #{autoscaling_shrink_policy.name}")
+            end
+          }
+
           def autoscaling_default_alarm_dimensions(namespace)
             case namespace
             when %r{AWS/EC2}i
@@ -452,6 +521,26 @@ module Capistrano
             end
           }
 
+          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]
+              if alarm and alarm.exists?
+                logger.debug("Deleting Alarm for expansion: #{alarm.name}")
+                alarm.delete()
+                logger.debug("Deleted Alarm for expansion: #{alarm.name}")
+              end
+            end
+
+            autoscaling_shrink_alarm_definitions.each do |alarm_name, alarm_options|
+              alarm = autoscaling_cloudwatch_client.alarms[alarm_name]
+              if alarm and alarm.exists?
+                logger.debug("Deleting Alarm for shrinking: #{alarm.name}")
+                alarm.delete()
+                logger.debug("Deleted Alarm for shrinking: #{alarm.name}")
+              end
+            end
+          }
+
           desc("Suspend AutoScaling processes.")
           task(:suspend, :roles => :app, :except => { :no_release => true }) {
             if autoscaling_group and autoscaling_group.exists?

data/lib/capistrano-autoscaling/version.rb

@@ -1,5 +1,5 @@
 module Capistrano
   module AutoScaling
-    VERSION = "0.0.3"
+    VERSION = "0.0.4"
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: capistrano-autoscaling
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.4
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-11-27 00:00:00.000000000 Z
+date: 2012-12-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: capistrano