ec2-blackout 0.0.6 → 0.0.7

data/Gemfile

@@ -2,3 +2,5 @@ source 'https://rubygems.org'
 
 # Specify your gem's dependencies in ec2-sleeper.gemspec
 gemspec
+
+gem "rspec"

data/README.md

@@ -6,13 +6,15 @@ Do you stop EC2 instances out of business hours?
 
 If you don't, `ec2-blackout` could save you money
 
-`ec2-blackout` is a command-line tool to stop running EC2 instances.
+`ec2-blackout` is a command-line tool to stop running EC2 instances and Auto Scaling Groups.
 
 Use ec2-blackout to shutdown EC2 instances when they are idle, for example when you are not in the office.
 
 If an instance has an Elastic IP address, `ec2-blackout` will reassociate the EIP when the instance is started.
 Note: When an instance with an EIP is stopped AWS will automatically disassociate the EIP. AWS charge a small hourly fee for an unattached EIP.
 
+Instances within Auto Scaling Groups are stopped by setting the group's "desired capacity" to zero, which causes all running instances to be terminated.
+
 Certinaly not suitable for production instances but development and test instances can generally be shutdown overnight to save money.
 
 ## Installation
@@ -23,13 +25,24 @@ It is recommended you create an access policy using Amazon IAM
 
 1. Sign in to your AWS management console and go to the IAM section
 2. Create a group and paste in the following policy
-
+```json
     {
       "Statement": [
+        {
+          "Action": [
+            "autoscaling:CreateOrUpdateTags",
+            "autoscaling:DeleteTags",
+            "autoscaling:DescribeAutoScalingGroups",
+            "autoscaling:SetDesiredCapacity"
+          ],
+          "Effect": "Allow",
+          "Resource": "*"
+        },
         {
           "Action": [
             "ec2:StartInstances",
             "ec2:StopInstances",
+            "ec2:DescribeTags",
             "ec2:CreateTags",
             "ec2:DeleteTags",
             "ec2:DescribeInstances",
@@ -38,10 +51,11 @@ It is recommended you create an access policy using Amazon IAM
             "ec2:AssociateAddress"
           ],
           "Effect": "Allow",
-          "Resource": "\*"
+          "Resource": "*"
         }
       ]
     }
+```
 
 3. Create a user account and download the access key.
 4. Add the user to the previously created group.
@@ -52,8 +66,16 @@ Once installed you need to export your AWS credentials
     export AWS_ACCESS_KEY_ID=YOUR_ACCESS_KEY
     export AWS_SECRET_ACCESS_KEY=YOUR_SECREY_KEY
 
+## Stopping Auto Scaling Groups
+
+EC2 blackout will try to stop instances that are running within auto scaling groups, as well as normal standalone instances. It accomplishes this by setting the "desired capacity" of the auto scaling group to zero, and then restoring it to its previous value when starting up again. It is important to note that you can't actually stop an auto scaled instance - they can only be terminated.
+
+In order for auto scaled instances to be shut down, the "min size" attribute of the auto scaling group must be set to zero. If it is not, no instances within the group will be shut down.
+
 ## Usage
 
+To get help on the commands available:
+
     $ ec2-blackout --help
 
 To run a blackout across all AWS regions:
@@ -64,15 +86,38 @@ To run a blackout across a subset of AWS regions:
 
     $ ec2-blackout on --regions us-east-1,us-west-1
 
-To run a blackout but exclude instances that have been tagged:
+You can exclude instances from the blackout based on their EC2 tags as well. For instances that belong to an auto scaling group, the tags are matched against the Auto Scaling Group's tags, NOT the tags of the instances themselves. The name of the auto scaling group is treated as if it were a tag with key "Name". Tags are matched using regular expressions.
+
+    # Exclude instances that have a tag with key "no_blackout"
+    $ ec2-blackout on --exclude-by-tag no_blackout
+
+    # Exclude instances whose "environment" tag "preprod"
+    $ ec2-blackout on --exclude-by-tag 'environment=preprod'
+
+    # Exclude instances whose "environment" tag is either "preprod" OR "integration"
+    $ ec2-blackout on --exclude-by-tag 'environment=preprod|integration'
+
+    # Exclude instances whose "Name" tag starts with "myapp".
+    $ ec2-blackout on --exclude-by-tag 'Name=myapp.*'
+
+    # Exclude instances whose "Name" tag starts with "myapp" AND whose "environment" tag is "preprod" or "integration"
+    $ ec2-blackout on --exclude-by-tag 'Name=myapp.*,environment=preprod|integration'
+
+Similarly, you can also specifically *include* instances in the blackout based on their tags. If this option is used, only matching instances will be stopped. The syntax is the same as for exclude tags.
+
+    # Stop only those instances whose "Name" tag starts with "myapp" AND whose "environment" tag is "test"
+    $ ec2-blackout on --include-by-tag 'Name=myapp.*,environment=test'
+
+Excludes and includes can be used together if you like:
 
-    $ ec2-blackout on --exclude-by-tag do_not_blackout
+    # Stop all instances whose name starts with "myapp" except those whose "environment" is "preprod"
+    $ ec2-blackout on --include-by-tag 'Name=myapp.*' --exclude-by-tag 'environment=preprod'
 
 To leave a blackout and start the instances that were previously stopped:
 
     $ ec2-blackout off
 
-`ec2-blackout` also provides a dry-run using the `--dry-run` option.
+`ec2-blackout` also provides a dry-run using the `--dry-run` option. This option shows you what will be done, but without actually doing it.
 
 
 ## Contributing

data/ec2-blackout.gemspec

@@ -2,13 +2,14 @@
 require File.expand_path('../lib/ec2-blackout/version', __FILE__)
 
 Gem::Specification.new do |gem|
-  gem.authors       = ["Stephen Bartlett"]
+  gem.authors       = ["Stephen Bartlett", "Charles Blaxland"]
   gem.email         = ["stephenb@rtlett.org"]
   gem.description   = Ec2::Blackout.description
   gem.summary       = Ec2::Blackout.summary
   gem.homepage      = "https://github.com/srbartlett/ec2-blackout"
   gem.add_dependency 'commander'
   gem.add_dependency 'aws-sdk'
+  gem.add_dependency 'colorize'
   gem.files         = `git ls-files`.split($\)
   gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
   gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})

data/lib/ec2-blackout.rb

@@ -1,6 +1,9 @@
 require "ec2-blackout/version"
 require 'commander'
 require 'aws-sdk'
-require 'ec2-blackout/shutdown'
+require 'ec2-blackout/options'
+require 'ec2-blackout/auto_scaling_group'
+require 'ec2-blackout/ec2_instance'
 require 'ec2-blackout/startup'
+require 'ec2-blackout/shutdown'
 

data/lib/ec2-blackout/auto_scaling_group.rb

@@ -0,0 +1,94 @@
+require 'logger'
+
+class Ec2::Blackout::AutoScalingGroup
+  TIMESTAMP_TAG_NAME = 'ec2:blackout:on'
+  DESIRED_CAPACITY_TAG_NAME = 'ec2:blackout:desired_capacity'
+
+  def self.groups(region, options)
+    AWS::AutoScaling.new(:region => region).groups.map do |group|
+      Ec2::Blackout::AutoScalingGroup.new(group, options)
+    end
+  end
+
+  def initialize(group, options)
+    @group, @options = group, options
+  end
+
+  def stop
+    tag
+    zero_desired_capacity
+  end
+
+  def start
+    restore_desired_capacity
+    untag
+  end
+
+  def stoppable?
+    AWS.memoize do
+      if @options.matches_exclude_tags?(tags)
+        [false, "matches exclude tags"]
+      elsif !@options.matches_include_tags?(tags)
+        [false, "does not match include tags"]
+      elsif @group.desired_capacity == 0
+        [false, "group has already been stopped"]
+      elsif @group.min_size > 0
+        [false, "minimum ASG size is greater than zero - set min_size to 0 if you want to be able to stop this AutoScalingGroup"]
+      else
+        true
+      end
+    end
+  end
+
+  def startable?
+    if @group.max_size == 0
+      [false, "maximum ASG size is zero"]
+    elsif @options.force
+      true
+    elsif !tags[TIMESTAMP_TAG_NAME]
+      [false, "instance was not originally stopped by ec2-blackout"]
+    else
+      true
+    end
+  end
+
+  def to_s
+    "autoscaling group #{@group.name}"
+  end
+
+
+  private
+
+  def tag
+    @group.update(:tags => [
+      { :key => TIMESTAMP_TAG_NAME, :value => Time.now.utc.to_s, :propagate_at_launch => false },
+      { :key => DESIRED_CAPACITY_TAG_NAME, :value => @group.desired_capacity.to_s, :propagate_at_launch => false }
+    ])
+  end
+
+  def untag
+    @group.delete_tags([
+      { :key => TIMESTAMP_TAG_NAME, :value => tags[TIMESTAMP_TAG_NAME], :propagate_at_launch => false },
+      { :key => DESIRED_CAPACITY_TAG_NAME, :value => tags[DESIRED_CAPACITY_TAG_NAME], :propagate_at_launch => false }
+    ])
+  end
+
+  def zero_desired_capacity
+    @group.set_desired_capacity(0)
+  end
+
+  def restore_desired_capacity
+    previous_desired_capacity = tags[DESIRED_CAPACITY_TAG_NAME].to_i
+    previous_desired_capacity = @group.min_size if previous_desired_capacity == 0
+    @group.set_desired_capacity(previous_desired_capacity)
+  end
+
+  def tags
+    @tags ||= begin
+      tags_array = @group.tags.map { |tag| [tag[:key], tag[:value]] }
+      tags_hash = Hash[tags_array]
+      {"Name" => @group.name}.merge(tags_hash)
+    end
+  end
+
+end

data/lib/ec2-blackout/commands.rb

@@ -7,26 +7,18 @@ program :description, Ec2::Blackout.summary
 
 default_command :help
 
-def aws
-  AWS::EC2.new(:access_key_id => ENV['AWS_ACCESS_KEY_ID'],
-     :secret_access_key => ENV['AWS_SECRET_ACCESS_KEY'])
-end
-
-DEFAULT_REGIONS = ['us-east-1', 'us-west-1', 'us-west-2', 'eu-west-1', 'ap-southeast-1', 'ap-southeast-2',
-      'ap-northeast-1', 'sa-east-1'].join(',')
-
 command "on" do |c|
   c.syntax      = '[options]'
   c.summary     = 'Shutdown EC2 instances'
   c.description = 'For each AWS Region, find running EC2 instances and shut them down.'
 
-  c.option '-r', '--regions STRING', 'Comma separated list of regions to search. Defaults to all regions'
-  c.option '-x', '--exclude-by-tag STRING', 'Exclude instances with the specified tag.'
+  c.option '-r', '--regions region1,region2', Array, 'Comma separated list of regions to search. Defaults to all regions'
+  c.option '-x', '--exclude-by-tag tagname1=value,tagname2', Array, 'Comma separated list of name-value tags to exclude from the blackout'
+  c.option '-i', '--include-by-tag tagname1=value,tagname2', Array, 'Comma separated list of name-value tags to include in the blackout'
   c.option '-d', '--dry-run', 'Find instances without stopping them'
 
   c.action do |args, options|
-    options.default :regions => DEFAULT_REGIONS
-    Ec2::Blackout::Shutdown.new(self, aws, options.__hash__).execute
+    Ec2::Blackout::Shutdown.new(self, Ec2::Blackout::Options.new(options.__hash__)).execute
   end
 end
 
@@ -35,12 +27,11 @@ command "off" do |c|
   c.summary     = 'Start up EC2 instances'
   c.description = 'For each AWS Region, find EC2 instances previously shutdown by ec2-blackout and start them up.'
 
-  c.option '-r', '--regions STRING', 'Comma separated list of regions to search. Defaults to all regions'
+  c.option '-r', '--regions region1,region2', Array, 'Comma separated list of regions to search. Defaults to all regions'
   c.option '-f', '--force', 'Force start up regardless of who shut them dowm'
   c.option '-d', '--dry-run', 'Find instances without starting them'
 
   c.action do |args, options|
-    options.default :regions => DEFAULT_REGIONS
-    Ec2::Blackout::Startup.new(self, aws, options.__hash__).execute
+    Ec2::Blackout::Startup.new(self, Ec2::Blackout::Options.new(options.__hash__)).execute
   end
 end

data/lib/ec2-blackout/ec2_instance.rb

@@ -0,0 +1,107 @@
+require "logger"
+
+class Ec2::Blackout::Ec2Instance
+
+  TIMESTAMP_TAG_NAME = 'ec2:blackout:on'
+  EIP_TAG_NAME = 'ec2:blackout:eip'
+
+  def self.running_instances(region, options)
+    instances(region, options, 'running')
+  end
+
+  def self.stopped_instances(region, options)
+    instances(region, options, 'stopped')
+  end
+
+
+  attr_accessor :eip_retry_delay_seconds
+
+  def initialize(instance, options)
+    @instance, @options = instance, options
+    @eip_retry_delay_seconds = 5
+  end
+
+  def stop
+    tag
+    @instance.stop
+  end
+
+  def start
+    @instance.start
+    associate_eip
+    untag
+  end
+
+  def stoppable?
+    if tags['aws:autoscaling:groupName']
+      [false, "instance is part of an autoscaling group"]
+    elsif @instance.status != :running
+      [false, "instance is not in running state"]
+    elsif @options.matches_exclude_tags?(tags)
+      [false, "matches exclude tags"]
+    elsif !@options.matches_include_tags?(tags)
+      [false, "does not match include tags"]
+    else
+      true
+    end
+  end
+
+  def startable?
+    if @instance.status != :stopped
+      [false, "instance is not in stopped state"]
+    elsif @options.force
+      true
+    elsif !tags[TIMESTAMP_TAG_NAME]
+      [false, "instance was not originally stopped by ec2-blackout"]
+    else
+      true
+    end
+  end
+
+  def to_s
+    s = "instance #{@instance.id}"
+    s += " (#{tags['Name']})" if tags['Name']
+    s
+  end
+
+
+  private
+
+  def self.instances(region, options, instance_status)
+    AWS::EC2.new(:region => region).instances.filter('instance-state-name', instance_status).map do |instance|
+      Ec2::Blackout::Ec2Instance.new(instance, options)
+    end
+  end
+
+
+  def tag
+    @instance.add_tag(TIMESTAMP_TAG_NAME, :value => Time.now.utc)
+    if @instance.has_elastic_ip?
+      @instance.add_tag(EIP_TAG_NAME, :value => @instance.elastic_ip.allocation_id)
+    end
+  end
+
+  def untag
+    @instance.tags.delete(TIMESTAMP_TAG_NAME)
+    @instance.tags.delete(EIP_TAG_NAME)
+  end
+
+  def tags
+    @tags ||= @instance.tags.to_h
+  end
+
+  def associate_eip
+    eip = @instance.tags[EIP_TAG_NAME]
+    if eip
+      attempts = 0
+      begin
+        @instance.associate_elastic_ip(eip)
+      rescue
+        sleep eip_retry_delay_seconds
+        attempts += 1
+        retry if attempts * eip_retry_delay_seconds < 5*60 # 5 mins
+      end
+    end
+  end
+
+end

data/lib/ec2-blackout/options.rb

@@ -0,0 +1,55 @@
+
+class Ec2::Blackout::Options
+
+  DEFAULT_REGIONS = ['us-east-1', 'us-west-1', 'us-west-2', 'eu-west-1', 'ap-southeast-1', 'ap-southeast-2', 'ap-northeast-1', 'sa-east-1']
+
+  def initialize(options = {})
+    @options = options
+    @options[:regions] = DEFAULT_REGIONS unless @options[:regions]
+  end
+
+  def include_tags
+    @include_tags ||= key_value_hash(@options[:include_by_tag])
+  end
+
+  def exclude_tags
+    @exclude_tags ||= key_value_hash(@options[:exclude_by_tag])
+  end
+
+  def matches_include_tags?(tags)
+    return true unless include_tags
+    matches_tags?(include_tags, tags)
+  end
+
+  def matches_exclude_tags?(tags)
+    return false unless exclude_tags
+    matches_tags?(exclude_tags, tags)
+  end
+
+  def regions
+    @options[:regions]
+  end
+
+  def dry_run
+    @options[:dry_run]
+  end
+
+  def force
+    @options[:force]
+  end
+
+
+  private
+
+  def matches_tags?(tags_to_match, tags)
+    tags_to_match.each do |tag_name, tag_value|
+      return false unless tags[tag_name] =~ /#{tag_value}/
+    end
+    true
+  end
+
+  def key_value_hash(options)
+    options ? Hash[options.map { |opt| opt.split("=", 2).map(&:strip) }] : nil
+  end
+
+end

data/lib/ec2-blackout/shutdown.rb

@@ -1,53 +1,34 @@
+require 'colorize'
 
 class Ec2::Blackout::Shutdown
 
-  def initialize(ui, aws, options)
-    @ui, @aws, @options = ui, aws, options
+  def initialize(ui, options)
+    @ui, @options = ui, options
   end
 
   def execute
-    regions.each do |region|
-      @ui.say "Checking region: #{region}"
-      AWS.memoize do
-        @aws.regions[region].instances.each do |instance|
-          if stoppable? instance
-            @ui.say "-> Stopping instance: #{instance.id}, name: #{instance.tags['Name']}"
-            unless dry_run?
-              tag(instance)
-              instance.stop
-            end
-          elsif instance.status == :running
-            @ui.say "-> Skipping instance: #{instance.id}, name: #{instance.tags['Name']}, region: #{region}"
-          end
-        end
-      end
+    @ui.say 'Dry run specified - no instances will be stopped'.bold
+    @ui.say "Stopping instances"
+    @options.regions.each do |region|
+      @ui.say "Checking region #{region}"
+      shutdown(Ec2::Blackout::AutoScalingGroup.groups(region, @options))
+      shutdown(Ec2::Blackout::Ec2Instance.running_instances(region, @options))
     end
     @ui.say 'Done!'
   end
 
   private
 
-  def regions
-    @options[:regions] ? @options[:regions].split(',') : Ec2::Blackout.regions
-  end
-
-  def stoppable? instance
-    (instance.status == :running && exclude_tag && !instance.tags.to_h.key?(exclude_tag)) or
-      (instance.status == :running && exclude_tag.nil?)
-  end
-
-  def exclude_tag
-    @options[:exclude_by_tag]
-  end
-
-  def dry_run?
-    @options[:dry_run]
-  end
-
-  def tag instance
-    instance.add_tag('ec2:blackout:on', :value => Time.now.utc)
-    if instance.has_elastic_ip?
-      instance.add_tag('ec2:blackout:eip', :value => instance.elastic_ip)
+  def shutdown(resources)
+    resources.each do |resource|
+      stoppable, reason = resource.stoppable?
+      if stoppable
+        @ui.say "-> Stopping #{resource}".yellow
+        resource.stop unless @options.dry_run
+      else
+        @ui.say "-> Skipping #{resource}: #{reason}"
+      end
     end
   end
+
 end

data/lib/ec2-blackout/startup.rb

@@ -1,59 +1,34 @@
+require 'colorize'
 
 class Ec2::Blackout::Startup
 
-  def initialize(ui, aws, options)
-    @ui, @aws, @options = ui, aws, options
+  def initialize(ui, options)
+    @ui, @options = ui, options
   end
 
   def execute
-    regions.each do |region|
-      @ui.say "Checking region: #{region}"
-      AWS.memoize do
-        @aws.regions[region].instances.each do |instance|
-          if startable? instance
-            @ui.say "-> Starting instance: #{instance.id}, name: #{instance.tags['Name']}."
-            unless dry_run?
-              instance.tags.delete('ec2:blackout:on')
-              instance.start
-              associate_eip(instance)
-            end
-          elsif instance.status == :stopped
-            @ui.say "-> Skipping instance: #{instance.id}, name: #{instance.tags['Name'] || 'N/A'}"
-          end
-        end
-      end
+    @ui.say 'Dry run specified - no instances will be started'.bold
+    @ui.say "Starting instances"
+    @options.regions.each do |region|
+      @ui.say "Checking region #{region}"
+      startup(Ec2::Blackout::AutoScalingGroup.groups(region, @options))
+      startup(Ec2::Blackout::Ec2Instance.stopped_instances(region, @options))
     end
     @ui.say 'Done!'
   end
 
   private
 
-  def regions
-    @options[:regions] ? @options[:regions].split(',') : Ec2::Blackout.regions
-  end
-
-  def startable? instance
-    (instance.status == :stopped && instance.tags.to_h.key?('ec2:blackout:on')) or
-      (instance.status == :stopped && @options[:force])
-  end
-
-  def dry_run?
-    @options[:dry_run]
-  end
-
-  def associate_eip instance
-    eip = instance.tags['ec2:blackout:eip']
-    if eip
-      @ui.say("Associating Elastic IP #{eip} to #{instance.id}")
-      attempts = 0
-      begin
-        instance.associate_elastic_ip(eip)
-      rescue
-        sleep 5
-        attempts += 1
-        retry if attempts < 60 # 5 mins
+  def startup(resources)
+    resources.each do |resource|
+      startable, reason = resource.startable?
+      if startable
+        @ui.say "-> Starting #{resource}".green
+        resource.start unless @options.dry_run
+      else
+        @ui.say "-> Skipping #{resource}: #{reason}"
       end
-      instance.tags.delete('ec2:blackout:eip')
     end
   end
+
 end

data/lib/ec2-blackout/version.rb

@@ -1,6 +1,6 @@
 module Ec2
   module Blackout
-    VERSION = "0.0.6"
+    VERSION = "0.0.7"
 
     def self.name
       'ec2-blackout'

data/spec/ec2-blackout/auto_scaling_group_spec.rb

@@ -0,0 +1,196 @@
+require 'spec_helper'
+
+module Ec2::Blackout
+  describe AutoScalingGroup do
+
+    describe ".groups" do
+
+      it "returns all groups in the region" do
+        auto_scaling_stub = double("autoscaling")
+        auto_scaling_stub.should_receive(:groups).and_return([double, double])
+        AWS::AutoScaling.should_receive(:new).with(:region => "ap-southeast-2").and_return(auto_scaling_stub)
+        groups = AutoScalingGroup.groups("ap-southeast-2", Options.new)
+        expect(groups.size).to eq 2
+      end
+
+    end
+
+
+    describe "#stop" do
+      let!(:aws_group) { double("autoscaling group") }
+      let!(:group) { stubbed_stoppable_auto_scaling_group(aws_group) }
+
+      it "sets desired capacity to zero" do
+        aws_group.should_receive(:set_desired_capacity).with(0)
+        group.stop
+      end
+
+      it "tags the instance with timestamp and original desired capacity" do
+        aws_group.stub(:desired_capacity).and_return(3)
+        aws_group.should_receive(:update).with do |attributes|
+          expect_ec2_blackout_tags(attributes[:tags], Time.now, 3)
+        end
+
+        group.stop
+      end
+
+    end
+
+
+    describe "#start" do
+      let!(:aws_group) { double("autoscaling group") }
+      let!(:group) { stubbed_startable_auto_scaling_group(aws_group) }
+
+      it "restores desired capacity to its previous setting" do
+        aws_group.should_receive(:tags).and_return(ec2_blackout_tags("2014-02-10 11:44:58 UTC", 3))
+        aws_group.should_receive(:set_desired_capacity).with(3)
+        group.start
+      end
+
+      it "removes the ec2 blackout tags from the autoscaling group" do
+        tags = ec2_blackout_tags("2014-02-10 12s:44:58 UTC", 2)
+        aws_group.stub(:tags).and_return(tags)
+        aws_group.should_receive(:delete_tags).with(tags)
+        group.start
+      end
+
+      it "sets desired capacity to min capacity if there is no desired capacity tag" do
+        tags = ec2_blackout_tags("2014-02-10 11:44:58 UTC", nil)
+        aws_group.stub(:tags).and_return(tags)
+        aws_group.stub(:min_size).and_return(4)
+        aws_group.should_receive(:set_desired_capacity).with(4)
+        group.start
+      end
+
+    end
+
+
+    describe("#stoppable?") do
+
+      let!(:aws_group) { double("autoscaling group") }
+      let!(:group) { stubbed_stoppable_auto_scaling_group(aws_group) }
+
+      it "returns true if the group meets all the stoppable conditions" do
+        stoppable, reason = group.stoppable?
+        expect(stoppable).to be_true
+      end
+
+      it "returns false if the tags match the exclude tag options" do
+        options = Ec2::Blackout::Options.new(:exclude_by_tag =>  ["foo=bar"])
+        group = stubbed_stoppable_auto_scaling_group(aws_group, options)
+        aws_group.stub(:tags).and_return(asg_tags("foo" => "bar"))
+
+        stoppable, reason = group.stoppable?
+        expect(stoppable).to be_false
+      end
+
+      it "returns false if the tags do not match the include tag options" do
+        options = Ec2::Blackout::Options.new(:include_by_tag =>  ["foo=bar"])
+        group = stubbed_stoppable_auto_scaling_group(aws_group, options)
+        aws_group.stub(:tags).and_return(asg_tags("foo" => "baz"))
+
+        stoppable, reason = group.stoppable?
+        expect(stoppable).to be_false
+      end
+
+      it "returns false if the desired capacity is zero" do
+        aws_group.stub(:desired_capacity).and_return(0)
+        stoppable, reason = group.stoppable?
+        expect(stoppable).to be_false
+      end
+
+      it "returns false if min size is greater than zero" do
+        aws_group.stub(:min_size).and_return(1)
+        stoppable, reason = group.stoppable?
+        expect(stoppable).to be_false
+      end
+
+      it "treats the name of the ASG as a tag with key 'Name'" do
+        options = Ec2::Blackout::Options.new(:include_by_tag =>  ["Name=My ASG"])
+        group = stubbed_stoppable_auto_scaling_group(aws_group, options)
+        aws_group.stub(:name).and_return("My ASG")
+
+        stoppable, reason = group.stoppable?
+        expect(stoppable).to be_true
+      end
+
+    end
+
+
+    describe("#startable?") do
+
+      let!(:aws_group) { double("autoscaling group") }
+      let!(:group) { stubbed_startable_auto_scaling_group(aws_group) }
+
+      it "returns true if the instance was previously stopped with ec2 blackout" do
+        startable, reason = group.startable?
+        expect(startable).to be_true
+      end
+
+      it "returns false if there is no ec2 blackout timestamp tag" do
+        aws_group.stub(:tags).and_return([])
+        startable, reason = group.startable?
+        expect(startable).to be_false
+      end
+
+      it "returns true if the force option was specified, even if there is no ec2 blackout timestamp tag" do
+        options = Ec2::Blackout::Options.new(:force => true)
+        aws_group = double("autoscaling group")
+        group = stubbed_startable_auto_scaling_group(aws_group, options)
+        aws_group.stub(:tags).and_return([])
+        startable, reason = group.startable?
+        expect(startable).to be_true
+      end
+
+      it "returns false if max size is zero" do
+        aws_group.stub(:max_size).and_return(0)
+        startable, reason = group.startable?
+        expect(startable).to be_false
+      end
+
+    end
+
+
+    def stubbed_stoppable_auto_scaling_group(underlying_aws_stub, options = Options.new)
+      underlying_aws_stub.stub(:name).and_return("Test AutoScaling Group")
+      underlying_aws_stub.stub(:desired_capacity).and_return(1)
+      underlying_aws_stub.stub(:min_size).and_return(0)
+      underlying_aws_stub.stub(:tags).and_return([])
+      underlying_aws_stub.stub(:update)
+      underlying_aws_stub.stub(:set_desired_capacity)
+      AutoScalingGroup.new(underlying_aws_stub, options)
+    end
+
+    def stubbed_startable_auto_scaling_group(underlying_aws_stub, options = Options.new)
+      underlying_aws_stub.stub(:name).and_return("Test AutoScaling Group")
+      underlying_aws_stub.stub(:tags).and_return(ec2_blackout_tags("2014-02-10 11:44:58 UTC", 1))
+      underlying_aws_stub.stub(:max_size).and_return(10)
+      underlying_aws_stub.stub(:delete_tags)
+      underlying_aws_stub.stub(:set_desired_capacity)
+      AutoScalingGroup.new(underlying_aws_stub, options)
+    end
+
+    def ec2_blackout_tags(timestamp, desired_capacity)
+      tags = asg_tags(AutoScalingGroup::TIMESTAMP_TAG_NAME => timestamp)
+      if desired_capacity
+        tags += asg_tags(AutoScalingGroup::DESIRED_CAPACITY_TAG_NAME => desired_capacity.to_s)
+      end
+      tags
+    end
+
+    def asg_tags(tags_hash)
+      tags_hash.map {|k,v| {key: k, value: v, propagate_at_launch: false} }
+    end
+
+    def expect_ec2_blackout_tags(tags, timestamp, desired_capacity)
+      timestamp_tag = tags.find { |tag| tag[:key] == AutoScalingGroup::TIMESTAMP_TAG_NAME }
+      expect(Date.parse(timestamp_tag[:value]).to_time - timestamp).to be < 1
+      expect(timestamp_tag[:propagate_at_launch]).to be_false
+
+      desired_capacity_tag = tags.find { |tag| tag[:key] == AutoScalingGroup::DESIRED_CAPACITY_TAG_NAME }
+      expect(desired_capacity_tag[:value]).to eq desired_capacity.to_s
+      expect(desired_capacity_tag[:propagate_at_launch]).to be_false
+    end
+
+  end
+end

data/spec/ec2-blackout/ec2_instance_spec.rb

@@ -0,0 +1,185 @@
+require 'spec_helper'
+
+module Ec2::Blackout
+
+  describe Ec2Instance do
+
+    describe ".running_instances" do
+      it "returns a list of instances that are in the running state" do
+        expect_instance_filter('running', 'ap-southeast-2')
+        Ec2Instance.running_instances("ap-southeast-2", Options.new)
+      end
+    end
+
+    describe ".stopped_instances" do
+      it "returns a list of instances that are in the stopped state" do
+        expect_instance_filter('stopped', 'ap-southeast-2')
+        Ec2Instance.stopped_instances("ap-southeast-2", Options.new)
+      end
+    end
+
+    describe "#stop" do
+      let!(:aws_instance) { double("ec2 instance") }
+      let!(:instance) { stubbed_stoppable_instance(aws_instance) }
+
+      it "stops the instance" do
+        aws_instance.should_receive(:stop)
+        instance.stop
+      end
+
+      it "tags the instance with a timestamp indicating when it was stopped" do
+        aws_instance.should_receive(:add_tag).with do |tag_name, tag_attributes|
+          expect(tag_name).to eq Ec2Instance::TIMESTAMP_TAG_NAME
+          expect(Time.now - tag_attributes[:value]).to be < 1
+        end
+
+        instance.stop
+      end
+
+      it "saves the associated elastic IP as a tag" do
+        aws_instance.stub(:has_elastic_ip?).and_return(true)
+        eip = double(:allocation_id => "eipalloc-eab23c0d")
+        aws_instance.stub(:elastic_ip).and_return(eip)
+        aws_instance.should_receive(:add_tag).with(Ec2Instance::EIP_TAG_NAME, :value => "eipalloc-eab23c0d")
+        instance.stop
+      end
+
+    end
+
+    describe "#start" do
+      let!(:aws_instance) { double("ec2 instance") }
+      let!(:instance) { stubbed_startable_instance(aws_instance) }
+
+      it "starts the instance" do
+        aws_instance.should_receive(:start)
+        instance.start
+      end
+
+      it "remove ec2 blackout tags from the instance" do
+        tags = ec2_tags(Ec2Instance::TIMESTAMP_TAG_NAME => '2014-02-12 02:35:52 UTC', Ec2Instance::EIP_TAG_NAME => 'eipalloc-eab23c0d')
+        aws_instance.stub(:tags).and_return(tags)
+        tags.should_receive(:delete).with(Ec2Instance::TIMESTAMP_TAG_NAME)
+        tags.should_receive(:delete).with(Ec2Instance::EIP_TAG_NAME)
+        instance.start
+      end
+
+      it "reattaches the previous elastic IP" do
+        tags = ec2_tags(Ec2Instance::TIMESTAMP_TAG_NAME => '2014-02-12 02:35:52 UTC', Ec2Instance::EIP_TAG_NAME => 'eipalloc-eab23c0d')
+        aws_instance.stub(:tags).and_return(tags)
+        aws_instance.should_receive(:associate_elastic_ip).with("eipalloc-eab23c0d")
+        instance.start
+      end
+
+      it "should retry attaching the elastic IP if it fails" do
+        tags = ec2_tags(Ec2Instance::TIMESTAMP_TAG_NAME => '2014-02-12 02:35:52 UTC', Ec2Instance::EIP_TAG_NAME => 'eipalloc-eab23c0d')
+        aws_instance.stub(:tags).and_return(tags)
+        aws_instance.should_receive(:associate_elastic_ip).and_raise(:error)
+        aws_instance.should_receive(:associate_elastic_ip)
+        instance.eip_retry_delay_seconds = 0
+        instance.start
+      end
+    end
+
+    describe "#stoppable?" do
+      let!(:aws_instance) { double("ec2 instance") }
+      let!(:instance) { stubbed_stoppable_instance(aws_instance) }
+
+      it "returns true if the instance meets all conditions for being stoppable" do
+        stoppable, reason = instance.stoppable?
+        expect(stoppable).to be_true
+      end
+
+      it "returns false if the instance is not running" do
+        aws_instance.stub(:status).and_return(:stopped)
+        stoppable, reason = instance.stoppable?
+        expect(stoppable).to be_false
+      end
+
+      it "returns false if the instance belongs to an autoscaling group" do
+        aws_instance.stub(:tags).and_return(ec2_tags('aws:autoscaling:groupName' => 'foobar'))
+        stoppable, reason = instance.stoppable?
+        expect(stoppable).to be_false
+      end
+
+      it "returns false if the instance matches the exclude tags specified in the options" do
+        options = Ec2::Blackout::Options.new(:exclude_by_tag =>  ["foo=bar"])
+        instance = stubbed_stoppable_instance(aws_instance, options)
+        aws_instance.stub(:tags).and_return(ec2_tags("foo" => "bar"))
+        stoppable, reason = instance.stoppable?
+        expect(stoppable).to be_false
+      end
+
+      it "returns false if the instance does not match the include tags specified in the options" do
+        options = Ec2::Blackout::Options.new(:include_by_tag =>  ["foo=bar"])
+        instance = stubbed_stoppable_instance(aws_instance, options)
+        aws_instance.stub(:tags).and_return(ec2_tags("foo" => "baz"))
+        stoppable, reason = instance.stoppable?
+        expect(stoppable).to be_false
+      end
+    end
+
+    describe "#startable?" do
+      let!(:aws_instance) { double("ec2 instance") }
+      let!(:instance) { stubbed_startable_instance(aws_instance) }
+
+      it "returns true if the instance meets all conditions for being startable" do
+        startable, reason = instance.startable?
+        expect(startable).to be_true
+      end
+
+      it "returns false if the instance does not have the ec2 blackout timestamp tag" do
+        aws_instance.stub(:tags).and_return(ec2_tags({}))
+        startable, reason = instance.startable?
+        expect(startable).to be_false
+      end
+
+      it "returns true if the force tag was specified even if the instance does not have the ec2 blackout timestamp tag" do
+        options = Ec2::Blackout::Options.new(:force => true)
+        instance = stubbed_startable_instance(aws_instance, options)
+        aws_instance.stub(:tags).and_return(ec2_tags({}))
+        startable, reason = instance.startable?
+        expect(startable).to be_true
+      end
+    end
+
+
+    def stubbed_stoppable_instance(underlying_aws_stub, options = Options.new)
+      underlying_aws_stub.stub(:status).and_return(:running)
+      underlying_aws_stub.stub(:has_elastic_ip?).and_return(false)
+      underlying_aws_stub.stub(:tags).and_return(ec2_tags({}))
+      underlying_aws_stub.stub(:add_tag)
+      underlying_aws_stub.stub(:stop)
+      Ec2Instance.new(underlying_aws_stub, options)
+    end
+
+    def stubbed_startable_instance(underlying_aws_stub, options = Options.new)
+      underlying_aws_stub.stub(:status).and_return(:stopped)
+      underlying_aws_stub.stub(:has_elastic_ip?).and_return(false)
+      underlying_aws_stub.stub(:tags).and_return(ec2_tags(Ec2Instance::TIMESTAMP_TAG_NAME => '2014-02-13 02:35:52 UTC'))
+      underlying_aws_stub.stub(:associate_elastic_ip)
+      underlying_aws_stub.stub(:start)
+      Ec2Instance.new(underlying_aws_stub, options)
+    end
+
+    def expect_instance_filter(state, region)
+      instances_stub = double("instances")
+      ec2_stub = double("ec2 instance", :instances => instances_stub)
+      AWS::EC2.should_receive(:new).with(:region => region).and_return(ec2_stub)
+      instances_stub.should_receive(:filter).with('instance-state-name', state).and_return([double, double])
+    end
+
+    def ec2_tags(tags_hash)
+      # Hack to add a "to_h" method to hash instance (ruby 1.9 doesn't have it, but 2.0 does).
+      # This lets us use a simple hash instead of an instance of AWS::EC2::ResourceTagCollection to
+      # represent the instance tags.
+      if !tags_hash.respond_to?(:to_h)
+        def tags_hash.to_h
+          self
+        end
+      end
+      tags_hash
+    end
+
+  end
+
+end

data/spec/ec2-blackout/options_spec.rb

@@ -0,0 +1,99 @@
+require 'spec_helper'
+
+describe Ec2::Blackout::Options do
+
+  describe "#exclude_tags" do
+
+    it "converts exclude tags into a hash" do
+      options = Ec2::Blackout::Options.new :exclude_by_tag => ["Name=foo.*", " Owner = joe ", "Stopped", "Foo="]
+      expect(options.exclude_tags).to eq({"Name" => "foo.*", "Owner" => "joe", "Stopped" => nil, "Foo" => ""})
+    end
+
+  end
+
+
+  describe "#matches_exclude_tags" do
+
+    it "matches by regular expression" do
+      regex_options = Ec2::Blackout::Options.new(:exclude_by_tag =>  ["Name=foo.*"])
+      expect(regex_options.matches_exclude_tags?({"Name" => "foobar"})).to be_true
+    end
+
+    it "matches by tag name only if no value is given in the options" do
+      tag_name_only_options = Ec2::Blackout::Options.new(:exclude_by_tag =>  ["Name"])
+      expect(tag_name_only_options.matches_exclude_tags?("Name" => "foobar")).to be_true
+      expect(tag_name_only_options.matches_exclude_tags?("Owner" => "bill")).to be_false
+    end
+
+    it "returns true only if all tags match" do
+      multiple_tag_options = Ec2::Blackout::Options.new(:exclude_by_tag =>  ["Name=foo.*", "Owner=joe"])
+      expect(multiple_tag_options.matches_exclude_tags?("Name" => "foobar", "Owner" => "joe")).to be_true
+      expect(multiple_tag_options.matches_exclude_tags?("Name" => "foobar", "Owner" => "bill")).to be_false
+    end
+
+    it "returns false if there are no exclude tags specified" do
+      empty_options = Ec2::Blackout::Options.new
+      expect(empty_options.matches_exclude_tags?("Name" => "foobar")).to be_false
+    end
+
+    it "returns false if no tags match" do
+      regex_options = Ec2::Blackout::Options.new(:exclude_by_tag =>  ["Name=foobar"])
+      expect(regex_options.matches_exclude_tags?({"Name" => "blerk"})).to be_false
+    end
+
+    it "handles equals signs in the value" do
+      equals_options = Ec2::Blackout::Options.new(:exclude_by_tag =>  ["Name=foo=bar"])
+      expect(equals_options.matches_exclude_tags?("Name" => "foo=bar")).to be_true
+    end
+
+  end
+
+
+  describe "#matches_include_tags" do
+
+    it "matches by regular expression" do
+      regex_options = Ec2::Blackout::Options.new(:include_by_tag =>  ["Name=foo.*"])
+      expect(regex_options.matches_include_tags?({"Name" => "foobar"})).to be_true
+    end
+
+    it "matches by tag name only if no value is given in the options" do
+      tag_name_only_options = Ec2::Blackout::Options.new(:include_by_tag =>  ["Name"])
+      expect(tag_name_only_options.matches_include_tags?("Name" => "foobar")).to be_true
+      expect(tag_name_only_options.matches_include_tags?("Owner" => "bill")).to be_false
+    end
+
+    it "returns true only if all tags match" do
+      multiple_tag_options = Ec2::Blackout::Options.new(:include_by_tag =>  ["Name=foo.*", "Owner=joe"])
+      expect(multiple_tag_options.matches_include_tags?("Name" => "foobar", "Owner" => "joe")).to be_true
+      expect(multiple_tag_options.matches_include_tags?("Name" => "foobar", "Owner" => "bill")).to be_false
+    end
+
+    it "returns true if there are no include tags specified" do
+      empty_options = Ec2::Blackout::Options.new
+      expect(empty_options.matches_include_tags?("Name" => "foobar")).to be_true
+    end
+
+    it "returns false if no tags match" do
+      regex_options = Ec2::Blackout::Options.new(:include_by_tag =>  ["Name=foo.*"])
+      expect(regex_options.matches_include_tags?({"Name" => "blerk"})).to be_false
+    end
+
+    it "handles equals signs in the value" do
+      equals_options = Ec2::Blackout::Options.new(:include_by_tag =>  ["Name=foo=bar"])
+      expect(equals_options.matches_include_tags?("Name" => "foo=bar")).to be_true
+    end
+
+  end
+
+
+  describe "#regions" do
+
+    it "provides default regions if none are specified" do
+      options = Ec2::Blackout::Options.new
+      expect(options.regions).to eq Ec2::Blackout::Options::DEFAULT_REGIONS
+    end
+
+  end
+
+
+end

data/spec/ec2-blackout/shutdown_spec.rb

@@ -0,0 +1,74 @@
+require 'spec_helper'
+
+describe Ec2::Blackout::Shutdown do
+
+  describe "#execute" do
+
+    it "should shut down only stoppable resources" do
+      stoppable_group = stoppable_resource(Ec2::Blackout::AutoScalingGroup)
+      stoppable_group.should_receive(:stop)
+
+      unstoppable_group = unstoppable_resource(Ec2::Blackout::AutoScalingGroup)
+      unstoppable_group.should_not_receive(:stop)
+
+      stoppable_instance = stoppable_resource(Ec2::Blackout::Ec2Instance)
+      stoppable_instance.should_receive(:stop)
+
+      unstoppable_instance = unstoppable_resource(Ec2::Blackout::Ec2Instance)
+      unstoppable_instance.should_not_receive(:stop)
+
+      groups = [stoppable_group, unstoppable_group]
+      instances = [stoppable_instance, unstoppable_instance]
+
+      Ec2::Blackout::AutoScalingGroup.stub(:groups).and_return(groups)
+      Ec2::Blackout::Ec2Instance.stub(:running_instances).and_return(instances)
+
+      shutdown = Ec2::Blackout::Shutdown.new(double, Ec2::Blackout::Options.new(:regions => ["ap-southeast-2"]))
+      shutdown.execute
+    end
+
+    it "should shut down instances in all regions given by the options" do
+      options = Ec2::Blackout::Options.new(:regions => ["ap-southeast-1", "ap-southeast-2"])
+
+      Ec2::Blackout::AutoScalingGroup.should_receive(:groups).with("ap-southeast-1", anything).and_return([])
+      Ec2::Blackout::AutoScalingGroup.should_receive(:groups).with("ap-southeast-2", anything).and_return([])
+      Ec2::Blackout::Ec2Instance.should_receive(:running_instances).with("ap-southeast-1", anything).and_return([])
+      Ec2::Blackout::Ec2Instance.should_receive(:running_instances).with("ap-southeast-2", anything).and_return([])
+
+      shutdown = Ec2::Blackout::Shutdown.new(double, options)
+      shutdown.execute
+    end
+
+    it "should not stop instances if the dry run option has been specified" do
+      options = Ec2::Blackout::Options.new(:dry_run => true, :regions => ["ap-southeast-2"])
+      stoppable_group = stoppable_resource(Ec2::Blackout::AutoScalingGroup)
+      stoppable_group.should_not_receive(:stop)
+
+      stoppable_instance = stoppable_resource(Ec2::Blackout::Ec2Instance)
+      stoppable_instance.should_not_receive(:stop)
+
+      Ec2::Blackout::AutoScalingGroup.stub(:groups).and_return([stoppable_group])
+      Ec2::Blackout::Ec2Instance.stub(:running_instances).and_return([stoppable_instance])
+
+      shutdown = Ec2::Blackout::Shutdown.new(double, options)
+      shutdown.execute
+    end
+
+  end
+
+
+  def stoppable_resource(type)
+    resource(type, true)
+  end
+
+  def unstoppable_resource(type)
+    resource(type, false)
+  end
+
+  def resource(type, stoppable)
+    resource = double(type)
+    resource.should_receive(:stoppable?).and_return(stoppable)
+    resource
+  end
+
+end

data/spec/ec2-blackout/startup_spec.rb

@@ -0,0 +1,74 @@
+require 'spec_helper'
+
+describe Ec2::Blackout::Startup do
+
+  describe "#execute" do
+
+    it "should start up only startable resources" do
+      startable_group = startable_resource(Ec2::Blackout::AutoScalingGroup)
+      startable_group.should_receive(:start)
+
+      unstartable_group = unstartable_resource(Ec2::Blackout::AutoScalingGroup)
+      unstartable_group.should_not_receive(:start)
+
+      startable_instance = startable_resource(Ec2::Blackout::Ec2Instance)
+      startable_instance.should_receive(:start)
+
+      unstartable_instance = unstartable_resource(Ec2::Blackout::Ec2Instance)
+      unstartable_instance.should_not_receive(:start)
+
+      groups = [startable_group, unstartable_group]
+      instances = [startable_instance, unstartable_instance]
+
+      Ec2::Blackout::AutoScalingGroup.stub(:groups).and_return(groups)
+      Ec2::Blackout::Ec2Instance.stub(:stopped_instances).and_return(instances)
+
+      startup = Ec2::Blackout::Startup.new(double, Ec2::Blackout::Options.new(:regions => ["ap-southeast-2"]))
+      startup.execute
+    end
+
+    it "should start up instances in all regions given by the options" do
+      options = Ec2::Blackout::Options.new(:regions => ["ap-southeast-1", "ap-southeast-2"])
+
+      Ec2::Blackout::AutoScalingGroup.should_receive(:groups).with("ap-southeast-1", anything).and_return([])
+      Ec2::Blackout::AutoScalingGroup.should_receive(:groups).with("ap-southeast-2", anything).and_return([])
+      Ec2::Blackout::Ec2Instance.should_receive(:stopped_instances).with("ap-southeast-1", anything).and_return([])
+      Ec2::Blackout::Ec2Instance.should_receive(:stopped_instances).with("ap-southeast-2", anything).and_return([])
+
+      startup = Ec2::Blackout::Startup.new(double, options)
+      startup.execute
+    end
+
+    it "should not start instances if the dry run option has been specified" do
+      options = Ec2::Blackout::Options.new(:dry_run => true, :regions => ["ap-southeast-2"])
+      startable_group = startable_resource(Ec2::Blackout::AutoScalingGroup)
+      startable_group.should_not_receive(:start)
+
+      startable_instance = startable_resource(Ec2::Blackout::Ec2Instance)
+      startable_instance.should_not_receive(:start)
+
+      Ec2::Blackout::AutoScalingGroup.stub(:groups).and_return([startable_group])
+      Ec2::Blackout::Ec2Instance.stub(:stopped_instances).and_return([startable_instance])
+
+      startup = Ec2::Blackout::Startup.new(double, options)
+      startup.execute
+    end
+
+  end
+
+
+  def startable_resource(type)
+    resource(type, true)
+  end
+
+  def unstartable_resource(type)
+    resource(type, false)
+  end
+
+  def resource(type, startable)
+    resource = double(type)
+    resource.should_receive(:startable?).and_return(startable)
+    resource
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,4 @@
+require 'ec2-blackout'
+
+# Make sure we don't accidentally hit a real AWS service
+AWS.stub!

metadata

@@ -1,15 +1,16 @@
 --- !ruby/object:Gem::Specification
 name: ec2-blackout
 version: !ruby/object:Gem::Version
-  version: 0.0.6
+  version: 0.0.7
   prerelease: 
 platform: ruby
 authors:
 - Stephen Bartlett
+- Charles Blaxland
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-08-14 00:00:00.000000000 Z
+date: 2014-02-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: commander
@@ -43,6 +44,22 @@ dependencies:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: colorize
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 description: ! "\n        ec2-blackout is a command line tool to shutdown EC2 instances.\n\n
   \       It's main purpose is to save you money by stopping EC2 instances during\n
   \       out of office hours.\n      "
@@ -61,10 +78,19 @@ files:
 - bin/ec2-blackout
 - ec2-blackout.gemspec
 - lib/ec2-blackout.rb
+- lib/ec2-blackout/auto_scaling_group.rb
 - lib/ec2-blackout/commands.rb
+- lib/ec2-blackout/ec2_instance.rb
+- lib/ec2-blackout/options.rb
 - lib/ec2-blackout/shutdown.rb
 - lib/ec2-blackout/startup.rb
 - lib/ec2-blackout/version.rb
+- spec/ec2-blackout/auto_scaling_group_spec.rb
+- spec/ec2-blackout/ec2_instance_spec.rb
+- spec/ec2-blackout/options_spec.rb
+- spec/ec2-blackout/shutdown_spec.rb
+- spec/ec2-blackout/startup_spec.rb
+- spec/spec_helper.rb
 homepage: https://github.com/srbartlett/ec2-blackout
 licenses: []
 post_install_message: 
@@ -89,4 +115,10 @@ rubygems_version: 1.8.23
 signing_key: 
 specification_version: 3
 summary: A command-line tool to shutdown EC2 instances.
-test_files: []
+test_files:
+- spec/ec2-blackout/auto_scaling_group_spec.rb
+- spec/ec2-blackout/ec2_instance_spec.rb
+- spec/ec2-blackout/options_spec.rb
+- spec/ec2-blackout/shutdown_spec.rb
+- spec/ec2-blackout/startup_spec.rb
+- spec/spec_helper.rb