aws-asg-fleet 0.0.1

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in asg-fleet.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Zach Wily
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,140 @@
+# AWS Auto Scaling Fleet
+
+Helps manage several Auto-Scaling Groups that share common
+configuration.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'aws-asg-fleet'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install aws-asg-fleet
+
+## Usage
+
+Initialize:
+
+```ruby
+require 'aws/auto_scaling/fleets'
+
+auto_scaling = AWS::AutoScaling.new(
+  :access_key_id => 'YOUR_ACCESS_KEY_ID',
+  :secret_access_key => 'YOUR_SECRET_ACCESS_KEY')
+```
+
+First create an Auto Scaling group (with a Launch Configuration, Scaling
+Policy, and an Alarm to trigger the Policy.) This ASG (and related
+objects) will act as a template for future additions to the fleet:
+
+```ruby
+launch_config = auto_scaling.launch_configurations.create(
+  'my-launch-config',
+  'ami-123456',
+  't1.micro')
+
+group = auto_scaling.groups.create('my-group',
+  :launch_configuration => launch_config,
+  :availability_zones => [ 'us-east-1a' ],
+  :min_size => 1,
+  :max_size => 4,
+  :load_balancers => [ 'my-main-elb' ])
+
+up_policy = group.scaling_policies.create('my-scaleup-policy',
+  :adjustment_type => 'ChangeInCapacity',
+  :scaling_adjustment => 1)
+
+down_policy => group.scaling_policies.create('my-scaledown-policy',
+  :adjustment_type => 'ChangeInCapacity',
+  :scaling_adjustment => -1)
+
+cloudwatch = AWS::CloudWatch.new
+up_alarm = cloudwatch.alarms.create('cpu-high-alarm',
+  :namespace => "AWS/EC2",
+  :metric_name => "CPUUtilization",
+  :dimensions => [{
+    :name => "AutoScalingGroupName",
+    :value => group.name
+  }],
+  :comparison_operator => "GreaterThanOrEqualToThreshold",
+  :evaluation_periods => 2,
+  :period => 120,
+  :statistic => "Average",
+  :threshold => 80,
+  :alarm_actions => [ up_policy.arn ])
+
+down_alarm = cloudwatch.alarms.create('cpu-low-alarm',
+  :namespace => "AWS/EC2",
+  :metric_name => "CPUUtilization",
+  :dimensions => [{
+    :name => "AutoScalingGroupName",
+    :value => group.name
+  }],
+  :comparison_operator => "LessThanOrEqualToThreshold",
+  :evaluation_periods => 2,
+  :period => 300,
+  :statistic => "Average",
+  :threshold => 40,
+  :alarm_actions => [ down_policy.arn ])
+```
+
+Phew - that was a lot of stuff. But we now have a configured Auto
+Scaling group we can use in our fleet.
+
+Create the fleet:
+
+```ruby
+fleet = auto_scaling.fleets.create('my-fleet', group)
+```
+
+Add another group to the fleet:
+
+```ruby
+# (creation of other_group not shown)
+fleet.groups << other_group
+```
+
+Now that you have a fleet with multiple groups you can perform actions
+across the fleet.
+
+Suspend and resume scaling activities across all groups:
+
+```ruby
+fleet.suspend_all_processes
+# do stuff where you don't want scaling activities
+fleet.resume_all_processes
+```
+
+Update the launch configuration for all groups:
+
+```ruby
+fleet.update_launch_configuration('new-launch-config',
+  :image_id => 'ami-8765432')
+```
+
+That will create a new launch configuration, and add it to all the
+groups, replacing the old one.
+
+Above, we showed how to add a group you've already created to the fleet.
+You can also create a group *based on the existing template group*. This
+method will create a new group using options you pass in, but any
+options you don't specify will be pulled from the template group. Policies
+and alarms also get duplicated for the new group:
+
+```ruby
+fleet.groups.create('yet-another-group',
+  :load_balancers => [ 'my-other-elb' ])
+```
+
+## How It Works
+
+Fleets are identified using tags on Auto Scaling groups. When you create
+a new fleet 'my-fleet', it adds the tag key "asgfleet:my-fleet" with
+value "template". Other groups added to the fleet get tagged with key
+"asgfleet:my-fleet" and value "member".

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/asg-fleet.gemspec

@@ -0,0 +1,25 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+#require 'asg/fleet/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "aws-asg-fleet"
+  spec.version       = "0.0.1"
+  spec.authors       = ["Zach Wily"]
+  spec.email         = ["zach@zwily.com"]
+  spec.description   = %q{AWS Auto Scaling Fleets}
+  spec.summary       = %q{Provides a mechanism to group together Auto Scaling groups and perform actions on them in bulk.}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "aws-sdk", "1.11.3"
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+end

data/lib/aws/auto_scaling/fleet.rb

@@ -0,0 +1,88 @@
+module AWS
+  class AutoScaling
+    class Fleet < Core::Resource
+
+      def initialize name, options = {}
+        @name = name
+        super
+      end
+
+      # @return [String]
+      attr_reader :name
+
+      # @return [Group]
+      def template_group
+        tag = TagCollection.new(:config => config)
+          .filter(:key, "asgfleet:#{name}")
+          .filter(:value, "template")
+          .first
+        return nil unless tag
+        tag.resource
+      end
+
+      def exists?
+        !template_group.nil?
+      end
+
+      def groups
+        FleetGroupCollection.new(self)
+      end
+      
+      # Suspends all scaling processes in all Auto Scaling groups in the
+      # fleet.
+      def suspend_all_processes
+        groups.each do |group|
+          group.suspend_all_processes
+        end
+      end
+
+      # Resumes all scaling processes in all Auto Scaling groups in the
+      # fleet.
+      def resume_all_processes
+        groups.each do |group|
+          group.resume_all_processes
+        end
+      end
+
+      # Creates a new launch configuration and applies it to all the
+      # Auto Scaling groups in the fleet. Any options not specified will
+      # be pulled from the Launch Configuration currently attached to
+      # the template Auto Scaling group.
+      #
+      # @param [String] name The name of the new launch configuration
+      #
+      # @param [Hash] options Options for the new launch configuration.
+      #   Any options not specified in this hash will be pulled from the
+      #   existing launch configuration on the template scaling group.
+      #
+      def update_launch_configuration name, options = {}
+        old_lc = template_group.launch_configuration
+        image_id = options[:image_id] || old_lc.image_id
+        instance_type = options[:instance_type] || old_lc.instance_type
+        [ :block_device_mappings, :detailed_instance_monitoring, :kernel_id,
+          :key_pair, :ramdisk_id, :security_groups, :user_data,
+          :iam_instance_profile, :spot_price ].each do |k|
+          existing_value = old_lc.send(k)
+          next if existing_value == nil || existing_value == []
+          options[k] ||= existing_value
+        end
+
+        launch_configurations = LaunchConfigurationCollection.new(:config => config)
+        puts options
+        new_lc = launch_configurations.create(name, image_id, instance_type, options)
+
+        groups.each do |group|
+          group.update(:launch_configuration => new_lc)
+        end
+
+        new_lc
+      end
+
+      protected
+
+      def resource_identifiers
+        [[:name, name]]
+      end
+    end
+  end
+end

data/lib/aws/auto_scaling/fleet_collection.rb

@@ -0,0 +1,50 @@
+module AWS
+  class AutoScaling
+    class FleetCollection
+
+      include Core::Collection::Simple
+
+      # Create an ASG Fleet.
+      #
+      # To create a Fleet, you must supply an already-constructed
+      # Auto Scaling group to be used as the template for new groups
+      # added to the fleet.
+      #
+      #     fleet = auto_scaling.fleets.create('fleet-name',
+      #         auto_scaling.groups['my-asg-group'])
+      #
+      # @param [String] name The name of the new fleet to create.
+      #   Must be unique in your account.
+      #
+      # @param [Group] group The group to be used as a template
+      #   for future groups and fleet changes.
+      #
+      # @return [Fleet]
+      #
+      def create name, template_group
+        raise ArgumentError, "Fleet #{name} already exists" if self[name].exists?
+        raise ArgumentError, "Group is already in a fleet" if template_group.fleet
+
+        template_group.set_fleet(name, "template")
+        self[name]
+      end
+
+      # @param [String] name The name of the ASG fleet.
+      # @return [Fleet]
+      def [] name
+        Fleet.new(name, :config => config)
+      end
+
+      protected
+
+      def _each_item options
+        TagCollection.new(:config => config).filter(:value, "template").each do |tag|
+          if tag[:key] =~ /^asgfleet:/
+            name = tag[:key].split(':', 2)[1]
+            yield Fleet.new(name, :config => config)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/aws/auto_scaling/fleet_group_collection.rb

@@ -0,0 +1,145 @@
+module AWS
+  class AutoScaling
+    class FleetGroupCollection
+
+      include Core::Collection::Simple
+
+      def initialize fleet, options = {}
+        @fleet = fleet
+        super
+      end
+
+      # @return [Fleet]
+      attr_reader :fleet
+
+      # Add an existing group to a Fleet.
+      #
+      # @param [Group] The group to add.
+      def << group
+        group.set_fleet @fleet.name
+      end
+
+      # Create a group within a Fleet.
+      #
+      # To create a group you supply a name, and any desired Auto
+      # Scaling group options. Any options not specified will be pulled
+      # from the template group for the fleet. Scaling policies and
+      # alarms will also be created for the new Group, based on those
+      # associated with the template.
+      #
+      # @param [String] name The name of the new group to create in the
+      #   fleet. Must be unique in your account.
+      #
+      # @param [Hash] options
+      #
+      # @option (see GroupOptions#group_options)
+      #
+      # @return [Group]
+      def create name, options = {}
+        ## Clone the group
+        template_group = @fleet.template_group
+
+        options = options_from(template_group,
+          :load_balancers, :min_size, :max_size, :launch_configuration,
+          :availability_zones, :default_cooldown, :desired_capacity,
+          :health_check_grace_period, :health_check_type, :placement_group,
+          :termination_policies, :subnets).merge(options)
+
+        # merge together tags from options and the template
+        new_tags = template_group.tags.to_a.map do |t|
+          {
+            :key => t[:key],
+            :value => t[:value],
+            :propagate_at_launch => t[:propagate_at_launch]
+          }
+        end
+        if options[:tags]
+          options[:tags].each do |tag|
+            existing_tag = new_tags.find {|t| t[:key] == tag[:key] }
+            if existing_tag
+              existing_tag.merge! tag
+            else
+              new_tags << tag
+            end
+          end
+        end
+        # change the fleet tag value from "template" to "member"
+        fleet_tag = new_tags.find {|t| t[:key] == "asgfleet:#{@fleet.name}" }
+        fleet_tag[:value] = "member"
+        options[:tags] = new_tags
+
+        group = GroupCollection.new(:config => config).create name, options
+
+        ## Clone the scaling policies and alarms from the group
+        cloudwatch = AWS::CloudWatch.new(:config => config)
+        template_group.scaling_policies.each do |template_policy|
+          policy_options = options_from(template_policy,
+            :adjustment_type, :scaling_adjustment, :cooldown, :min_adjustment_step)
+
+          policy = group.scaling_policies.create template_policy.name, policy_options
+
+          template_policy.alarms.keys.each do |template_alarm_name|
+            template_alarm = cloudwatch.alarms[template_alarm_name]
+            alarm_name = "#{template_alarm.name}-#{group.name}"
+            alarm_options = options_from(template_alarm,
+              :namespace, :metric_name, :comparison_operator, :evaluation_periods,
+              :period, :statistic, :threshold, :actions_enabled, :alarm_description,
+              :unit)
+
+            # For dimensions, copy them all except for the one
+            # referencing the ASG - replace that with the right group.
+            alarm_options[:dimensions] = template_alarm.dimensions.map do |dimension|
+              if dimension[:name] == "AutoScalingGroupName"
+                { :name => "AutoScalingGroupName", :value => group.name }
+              else
+                dimension
+              end
+            end
+
+            # For actions, we want to go through them all, replacing any
+            # ARNs referencing the template_policy with ones pointing to
+            # our new policy. For ARNs we don't recognize, we just copy
+            # them, assuming the user wants those ARNs to continue to
+            # fire.
+            [ :insufficient_data_actions, :ok_actions, :alarm_actions ].each do |key|
+              new_actions = template_alarm.send(key).map do |arn|
+                if arn == template_policy.arn
+                  policy.arn
+                else
+                  arn
+                end
+              end
+
+              unless new_actions.empty?
+                alarm_options[key] = new_actions
+              end
+            end
+
+            cloudwatch.alarms.create alarm_name, alarm_options
+          end
+        end
+
+        group
+      end
+
+      protected
+
+      def _each_item options
+        TagCollection.new(:config => config).filter(:key, "asgfleet:#{@fleet.name}").each do |tag|
+          yield tag.resource
+        end
+      end
+
+      def options_from(obj, *attributes)
+        opts = {}
+        attributes.each do |key|
+          value = obj.send(key)
+          next if value.nil? || (value.respond_to?(:empty?) && value.empty?)
+          value = value.to_a if value.is_a? Array
+          opts[key] ||= value
+        end
+        opts
+      end
+    end
+  end
+end

data/lib/aws/auto_scaling/fleets.rb

@@ -0,0 +1,49 @@
+require 'aws/auto_scaling'
+require 'aws/version'
+
+module AWS
+  class AutoScaling
+
+    autoload :Fleet, 'aws/auto_scaling/fleet'
+    autoload :FleetCollection, 'aws/auto_scaling/fleet_collection'
+    autoload :FleetGroupCollection, 'aws/auto_scaling/fleet_group_collection'
+
+    # @return [FleetCollection]
+    def fleets
+      FleetCollection.new(:config => config)
+    end
+
+    class Group
+      # stupid hack to get an attribute added to Group. It'll be fixed in
+      # 1.11.4, so remove this and set 1.11.4 as the required version when
+      # released.
+      if AWS::VERSION == '1.11.3'
+        attribute :termination_policies
+      end
+
+      def fleet
+        fleet_tag = tags.find {|t| t[:key] =~ /^asgfleet:/ }
+        return nil unless fleet_tag
+
+        fleet_name = fleet_tag[:key].split(':', 2)[1]
+        Fleet.new(fleet_name, :config => config)
+      end
+
+      def set_fleet fleet, role = "member"
+        if fleet && self.fleet
+          raise ArgumentError, "Group already belongs to a fleet"
+        end
+
+        if fleet.nil?
+          tags.find {|t| t[:key] =~ /^asgfleet:/ }.delete
+        else
+          self.update(:tags => [{
+            :key => "asgfleet:#{fleet.is_a?(Fleet) ? fleet.name : fleet}",
+            :value => role,
+            :propagate_at_launch => false
+          }])
+        end
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,106 @@
+--- !ruby/object:Gem::Specification
+name: aws-asg-fleet
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Zach Wily
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-06-29 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: aws-sdk
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.11.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.11.3
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: AWS Auto Scaling Fleets
+email:
+- zach@zwily.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- asg-fleet.gemspec
+- lib/aws/auto_scaling/fleet.rb
+- lib/aws/auto_scaling/fleet_collection.rb
+- lib/aws/auto_scaling/fleet_group_collection.rb
+- lib/aws/auto_scaling/fleets.rb
+homepage: ''
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: Provides a mechanism to group together Auto Scaling groups and perform actions
+  on them in bulk.
+test_files: []
+has_rdoc: