slugforge 4.0.0

data/lib/slugforge/build/package.rb

@@ -0,0 +1,63 @@
+module Slugforge
+  module Build
+    class Package < Slugforge::BuildCommand
+      desc :package, 'package the project'
+      def call
+        existing = Dir.glob('*.slug')
+
+        if options[:clean]
+          existing.each do |path|
+            logger.say_status :clean, path, :red
+            File.delete(path)
+          end
+        end
+
+        logger.say_status :execute, "fpm #{package_file_name}"
+        execute(fpm_command)
+
+        if options[:deploy]
+          invoke Slugforge::Commands::Deploy, [:file, package_file_name, options[:deploy]], []
+        end
+      end
+      default_task :call
+
+      private
+      def fpm_command
+        command = ['fpm']
+        command << '--verbose'
+        command << "--package #{package_file_name}"
+        command << "--maintainer=#{`whoami`.chomp}"
+        command << "-C #{project_root}"
+        command << '-s dir'
+        command << '-t sh'
+        command << "-n #{project_name}"
+        command << "-v #{date_stamp}"
+        command << '--template-scripts'
+        command << post_install_template_variables
+        command << "--after-install #{post_install_script_path}"
+        unless options[:'with-git']
+          command << "--exclude '.git'"
+          command << "--exclude '.git/**'"
+        end
+        command << "--exclude '*.slug'"
+        command << "--exclude 'log/**'"
+        command << "--exclude 'tmp/**'"
+        command << "--exclude 'vendor/bundle/ruby/1.9.1/cache/*'"
+        command << "." # package all the things
+        command.join(' ')
+      end
+
+      def post_install_script_path
+        scripts_dir('post-install.sh')
+      end
+
+      def post_install_template_variables
+        variables = {
+          'release_id' => File.basename(package_file_name, ".*")
+        }.map do |key, value|
+          "--template-value #{key}=#{value}"
+        end.join(' ')
+      end
+    end
+  end
+end

data/lib/slugforge/cli.rb

@@ -0,0 +1,125 @@
+require 'thor'
+require 'slugforge/helper'
+require 'slugforge/commands'
+
+# Don't display warnings to the user
+$VERBOSE = nil
+
+$stdout.sync = true
+
+module Slugforge
+  class Cli < Slugforge::Command
+
+    desc 'version', 'display the current version'
+    def version
+      logger.say_json :slugforge => Slugforge::VERSION
+      logger.say "slugforge #{Slugforge::VERSION}"
+    end
+
+    desc 'build [ARGS]', 'build a new slug (`slugforge build` for more help)'
+    option :ruby, :type => :string, :aliases => '-r',
+      :desc => 'Ruby version this package requires'
+    option :path, :type => :string, :default => Dir.pwd,
+      :desc => 'The path to the files being packaged'
+    option :clean, :type => :boolean,
+      :desc => 'Clean existing slugs from current directory before build'
+    option :deploy, :type => :string,
+      :desc => 'Deploy the slug if the build was successful'
+    option :'with-git', :type => :boolean,
+      :desc => 'include the .git folder in the slug'
+    def build
+      verify_procfile_exists!
+      invoke Slugforge::Commands::Build
+    end
+
+    desc 'deploy <command> [ARGS]', 'deploy a slug to a host (`slugforge deploy` for more help)'
+    subcommand 'deploy', Slugforge::Commands::Deploy
+
+    desc 'project <command> [ARGS]', 'manage projects (`slugforge project` for more help)'
+    subcommand 'project', Slugforge::Commands::Project
+
+    desc 'tag <command> [ARGS]', 'manage project tags (`slugforge tag` for more help)'
+    subcommand 'tag', Slugforge::Commands::Tag
+
+    desc 'wrangler <command> [ARGS]', 'list, push and delete slugs (`slugforge wrangler` for more help)'
+    subcommand 'wrangler', Slugforge::Commands::Wrangler
+
+    # subcommand method name is configuration to not conflict with the config method on all commands
+    desc 'config <command> [ARGS]', 'configure slugforge (`slugforge config` for more help)'
+    subcommand 'configuration', Slugforge::Commands::Config
+
+    def help(command = nil, subcommand = nil)
+      return super if command
+
+      self.class.help(shell, subcommand)
+
+      logger.say <<-HELP
+Project Naming
+
+  The easiest way to name a project is to name it after a repository. The only reason you may have to use a different
+  name is for testing of some kind. That said, once you've named your project there are a few ways for slugforge to
+  determine what project you are attempting to run project-specific commands (such as build) against. There are two
+  basic ways of telling slugforge which project you are working with:
+
+    1. With the provided configuration option (through a CLI flag, environment variable or config file)
+    2. By running the slugforge command from inside the project's repository. slugforge will use the name of the
+       project's root folder (as defined by the location of .git), which generally matches the name of the repository
+       which should be the name of the project in slugforge.
+
+Configuring the CLI
+
+  The configuration options above can all be configured through several candidate configuration files, environment
+  variables or the flags as shown. Precedence is by proximity to the command: flags trump environment, which trumps
+  configuration files. Slugforge will attempt to load configuration files in the following locations, listed in order
+  of priority highest to lowest:
+
+    .slugforge
+    ~/.slugforge
+    /etc/slugforge
+
+  Configuration files are written in yaml for simplicity. Below is a list of each option and the keys expected for each
+  type. File keys should be split on periods and expanded into hashes. AWS buckets accepts a comma seperated list,
+  which will be tried from first to last. There is an example config at the end of this screen.
+
+      HELP
+
+      rows = []
+      rows << %w(CLI Environment File)
+      Slugforge::Configuration.options.each do |name, config|
+        rows << [config[:option], config[:env], config[:key]]
+
+        unless rows.last.first.nil?
+          rows.last[0] = "--#{rows.last.first}"
+        end
+      end
+      print_table(rows, :indent => 4)
+
+      logger.say <<-HELP
+
+Example configuration file
+
+    aws:
+      access_key: hashhashhashhashhash
+      secret_key: hashhashhashhashhashhashhashhashhashhash
+
+      HELP
+    end
+
+    if binding.respond_to?(:pry)
+      desc 'pry', 'start a pry session inside of a Thor command', :hide => true
+      option :path, :type => :string, :default => Dir.pwd,
+        :desc => 'The path to the files being packaged'
+      def pry
+        binding.pry
+      end
+    end
+
+    desc 'debug', 'run a test command inside slugforge', :hide => true
+    option :path, :type => :string, :default => Dir.pwd,
+      :desc => 'The path to the files being packaged'
+    def debug(cmd)
+      eval(cmd)
+    end
+  end
+end
+

data/lib/slugforge/commands.rb

@@ -0,0 +1,130 @@
+module Slugforge
+  module Commands
+    autoload :Build,    'slugforge/commands/build'
+    autoload :Config,   'slugforge/commands/config'
+    autoload :Deploy,   'slugforge/commands/deploy'
+    autoload :Project,  'slugforge/commands/project'
+    autoload :Tag,      'slugforge/commands/tag'
+    autoload :Tjs,      'slugforge/commands/tjs'
+    autoload :Wrangler, 'slugforge/commands/wrangler'
+  end
+
+  class JsonError < Thor::Error
+    def initialize(message)
+      super({error: message}.to_json)
+    end
+  end
+
+  class Command < Thor
+    include Thor::Actions
+    include Slugforge::Helper
+
+    check_unknown_options!
+
+    # Add Thor::Actions options
+    add_runtime_options!
+
+
+    class << self
+      # Parses the command and options from the given args, instantiate the class
+      # and invoke the command. This method is used when the arguments must be parsed
+      # from an array. If you are inside Ruby and want to use a Thor class, you
+      # can simply initialize it:
+      #
+      #   script = MyScript.new(args, options, config)
+      #   script.invoke(:command, first_arg, second_arg, third_arg)
+      #
+      def start(given_args=ARGV, config={})
+        # Loads enabled slugins. This must be done before the CLI is instantiated so that new commands
+        # will be found. Activation of slugins must be delayed until the command line options are parsed
+        # so that the full config will be available.
+        Configuration.new
+        super
+      end
+    end
+
+    # ==== Parameters
+    # args<Array[Object]>:: An array of objects. The objects are applied to their
+    #                       respective accessors declared with <tt>argument</tt>.
+    #
+    # options<Hash>:: Either an array of command-line options requiring parsing or
+    #                 a hash of pre-parsed options.
+    #
+    # config<Hash>:: Configuration for this Thor class.
+    #
+    def initialize(args=[], options=[], config={})
+      @command_start_time = Time.now()
+
+      super
+
+      # Configuration must be
+      #  - created after command line is parsed (so not in #start)
+      #  - inherited from parent commands
+      if config[:invoked_via_subcommand]
+        @config = config[:shell].base.config
+      else
+        @config = Configuration.new(self.options)
+        @config.activate_slugins
+      end
+    end
+
+    protected
+
+    def config
+      @config
+    end
+
+    def self.exit_on_failure?
+      true
+    end
+
+    def self.inherited(base)
+      base.source_root templates_dir
+    end
+
+    def publish(event, *args)
+      ActiveSupport::Notifications.publish(event, self, *args) if notifications_enabled?
+    rescue => e
+      clean_trace = e.backtrace.reject { |l| l =~ /active_support|thor|bin\/slugforge/ } # reject parts of the stack containing active_support, thor, or bin/slugforge
+      logger.say_status :error, "[notification #{args.first}] #{e.message}\n" + clean_trace.join("\n"), :red
+    end
+  end
+
+  # This class overrides #banner, forcing the subcommand parameter to be true by default. This gets around a bug in
+  # Thor, and causes subcommands to properly display their parent command in the help text for the subcommand.
+  class SubCommand < Command
+    def self.banner(command, namespace = nil, subcommand = true)
+      super
+    end
+  end
+
+  class BuildCommand < Command
+    class_option :ruby, :type => :string, :aliases => '-r',
+      :desc => 'Ruby version this package requires'
+    class_option :path, :type => :string, :default => Dir.pwd,
+      :desc => 'The path to the files being packaged'
+    class_option :clean, :type => :boolean,
+      :desc => 'Clean existing slugs from current directory before build'
+    class_option :deploy, :type => :string,
+      :desc => 'Deploy the slug if the build was successful'
+    class_option :'with-git', :type => :boolean,
+      :desc => 'include the .git folder in the slug'
+
+    def self.inherited(base)
+      base.source_root templates_dir
+    end
+  end
+
+  class Group < Thor::Group
+    include Thor::Actions
+    include Slugforge::Helper
+
+    # Add Thor::Actions options
+    add_runtime_options!
+
+    def self.inherited(base)
+      base.source_root templates_dir
+    end
+  end
+end
+

data/lib/slugforge/commands/build.rb

@@ -0,0 +1,20 @@
+require 'slugforge/build'
+
+module Slugforge
+  module Commands
+    class Build < Slugforge::Group
+      def build_project
+        invoke Slugforge::Build::BuildProject
+      end
+
+      def export_upstart
+        invoke Slugforge::Build::ExportUpstart
+      end
+
+      def package
+        invoke Slugforge::Build::Package
+      end
+    end
+  end
+end
+

data/lib/slugforge/commands/config.rb

@@ -0,0 +1,24 @@
+module Slugforge
+  module Commands
+    class Config < Slugforge::SubCommand
+      desc 'show', 'Print current configuration options'
+      def show
+        if json?
+          logger.say_json config.values
+        else
+          logger.say "The following configuration options are in use:"
+          rows = config.values.map { |name, value| [name, value] }
+          print_table(rows, :indent => 4)
+
+          unless config.slugins.empty?
+            logger.say "Slugins detected:"
+            rows = config.slugins.map do |(name, slugin)|
+              [name, slugin.spec.version, slugin.enabled ? 'enabled' : 'disabled']
+            end
+            print_table(rows, :indent => 4)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/slugforge/commands/deploy.rb

@@ -0,0 +1,383 @@
+require 'slugforge/models/host'
+require 'slugforge/models/host_group'
+
+module Slugforge
+  module Commands
+    class Deploy < Slugforge::SubCommand
+      class_option :identity, :type => :string, :aliases => '-i',
+        :desc => 'The identify (.pem) file to use for authentication'
+      class_option :deploy_dir, :type => :string, :aliases => '-d',
+        :desc => 'The directory to deploy to on the server'
+      class_option :owner, :type => :string, :aliases => '-o',
+        :desc => 'Account that the application will run with when deployed'
+      class_option :env, :type => :string, :aliases => '-e',
+        :desc => 'A quoted, space-delimited list of environment variables and values'
+      class_option :count, :type => :numeric, :aliases => '-c',
+        :desc => 'Only deploy to the specified number hosts in the expanded list'
+      class_option :percent, :type => :numeric,
+        :desc => 'Only deploy to the specified percent in the expanded list'
+      # AWS may throttle simultaneous downloads to a file
+      class_option :'batch-size', :type => :numeric, :default => 85,
+        :desc => 'Set the number of hosts per deployment batch to help slow your roll'
+      class_option :'batch-count', :type => :numeric,
+        :desc => 'Set the number of deployment batches to help slow your roll'
+      class_option :'batch-pause', :type => :numeric,
+        :desc => 'Set the amount of time (in seconds) to pause between deployment batches, to further slow your roll'
+      class_option :'no-stage', :type => :boolean, :default => false,
+        :desc => "Don't stage the slug files on the host group members that were not targeted for the deploy"
+      class_option :'yes', :type => :boolean, :default => false,
+        :desc => "Do not prompt to proceed with deploy (a more gentle --force)"
+
+      desc 'file <filename> <hosts...> [ARGS]', 'deploy a slug file to host(s)'
+      option :path, :copy_type => :string, :default => Dir.pwd,
+        :desc => 'The path to the files being packaged'
+      def file(filename, *hosts)
+        logger.say_status :deploy, "deploying local slug #{filename}", :green
+        slug_name = File.basename(filename)
+
+        deploy(hosts, slug_name, deploy_options(:copy_type => :scp, :filename => filename))
+      end
+
+      desc 'name <name_part> <hosts...> [ARGS]', 'deploy an S3 stored slug by name to host(s) (use `wrangler list` for slug names)'
+      def name(name_part, *hosts)
+        slug = find_slug(name_part)
+        slug_name = File.basename(slug.key)
+        logger.say_status :deploy, "deploying slug #{slug_name} from s3", :green
+
+        url = expiring_url(slug)
+        deploy(hosts, slug_name, deploy_options(:copy_type => :aws_cmd, :url => url, :aws_session => aws_session, :s3_url => "s3://#{aws_bucket}/#{slug.key}"))
+      end
+
+      desc 'rollback <tag> <hosts...> [ARGS]', 'deploy the previous slug for a tag to host(s)'
+      def rollback(tag, *hosts)
+        raise error_class, "There is no project found named '#{project_name}'. Try setting the project name with --project" unless tag_manager.projects.include?(project_name)
+        data = tag_manager.rollback_slug_for_tag(project_name, tag)
+        if data.nil?
+          raise error_class, "could not find tag '#{tag}' for project '#{project_name}'"
+        else
+          logger.say_status :deploy, "deploying slug #{data}", :green
+          slug = find_slug(data)
+          slug_name = File.basename(data)
+          url = expiring_url(slug)
+        end
+
+        raise error_class, "could not determine URL for tag" unless url
+        deploy(hosts, slug_name, deploy_options(:copy_type => :aws_cmd, :url => url, :aws_session => aws_session, :s3_url => "s3://#{aws_bucket}/#{data}"))
+      end
+
+      desc 'tag <tag> <hosts...> [ARGS]', 'deploy a slug by tag to host(s)'
+      def tag(tag, *hosts)
+        raise error_class, "There is no project found named '#{project_name}'. Try setting the project name with --project" unless tag_manager.projects.include?(project_name)
+        data = tag_manager.slug_for_tag(project_name, tag)
+        if data.nil?
+          raise error_class, "could not find tag '#{tag}' for project '#{project_name}'"
+        else
+          logger.say_status :deploy, "deploying slug #{data}", :green
+          slug = find_slug(data)
+          slug_name = File.basename(data)
+          url = expiring_url(slug)
+        end
+
+        raise error_class, "could not determine URL for tag" unless url
+
+        deploy(hosts, slug_name, deploy_options(:copy_type => :aws_cmd, :url => url, :aws_session => aws_session, :s3_url => "s3://#{aws_bucket}/#{data}"))
+      end
+
+      desc 'ssh <hosts...> [ARGS]', 'log in to a box for testing', :hide => true
+      def ssh(*hosts)
+        deploy hosts, nil, deploy_options(:copy_type => :ssh)
+      end
+
+      private
+      def deploy_options(opts={})
+        {
+          :username   => config.ssh_username,
+          :deploy_dir => options[:deploy_dir] || self.deploy_dir,
+          :owner      => options[:owner],
+          :identity   => options[:identity],
+          :env        => options[:env],
+          :force      => force?,
+          :pretend    => pretend?
+        }.merge(opts)
+      end
+
+      def deploy(host_patterns, slug_name, deploy_opts)
+        host_groups = determine_host_groups(host_patterns)
+        return unless confirm_deployment_start?(host_groups)
+
+        # Stage file on all other hosts in facets, unless told otherwise
+        unless options[:'no-stage']
+          host_groups.each do |group|
+            group.hosts.each { |host| host.add_action(:stage) unless host.install? }
+          end
+        end
+
+        logger.say_status :deploy, "beginning deployment", :green
+
+        # Organize the list of hosts to more evenly spread load across impacted facets
+        hosts = order_deploy(unique_hosts(host_groups))
+        batches = (batch_size(hosts.count) == 0) ? [hosts] : hosts.each_slice(batch_size(hosts.count)).to_a
+
+        partial_deploy_type = [:count, :percent].detect{ |s| options[s] }
+
+        publish('deploy.started', {
+          :partial_deploy_method => partial_deploy_type,
+          :partial_deploy_limit  => options[partial_deploy_type],
+          :host_groups           => host_groups,
+          :batch_size            => batch_size(hosts.count),
+          :project               => project_name,
+          :slug_name             => slug_name
+        })
+
+        deploy_in_batches(batches, slug_name, deploy_opts)
+
+        logger.say_status :deploy, "deployment complete!", :green
+        say_deploy_status(host_groups, slug_name)
+
+
+        publish('deploy.finished', {
+          :success               => hosts.all?(&:success?),
+          :partial_deploy_method => partial_deploy_type,
+          :partial_deploy_limit  => options[:count] || options[:percent],
+          :host_groups           => host_groups,
+          :batch_size            => batch_size(hosts.count),
+          :project               => project_name,
+          :slug_name             => slug_name
+        })
+
+        host_groups
+      end
+
+      def deploy_in_batches(batches, slug_name, deploy_opts)
+        pause = options[:'batch-pause'].to_i
+        batches.each.with_index(1) do |batch, i|
+          logger.say "deploying batch #{i} of #{batches.count}", :magenta if batches.count > 1
+          threads = {}
+          batch.each do |host|
+            thread = Thread.new do
+              host.deploy(slug_name, logger, deploy_opts)
+            end
+            threads[host.ip] = thread
+          end
+          join_batch_threads(threads, batch, logger)
+          unless (batches.length == i || pause == 0)
+            logger.say "batch #{i} complete; pausing for #{pause} seconds", :magenta
+            sleep pause
+          end
+        end
+      end
+
+      def say_deploy_status(host_groups, slug_name)
+        return nil if host_groups.nil?
+        hosts = unique_hosts(host_groups)
+        return nil if hosts.empty?
+        total_count = hosts.count
+        successful = hosts.select { |h| h.success? }.count
+        overall_success = (total_count == successful)
+
+        if json?
+          logger.say_json :hosts => hosts.map(&:to_status), :success => overall_success
+        else
+          status_color = overall_success ? :green : :red
+          logger.say "\n#{'-'*22}\n| Deployment Summary |\n#{'-'*22}", status_color
+          logger.say "Deployed #{slug_name} to "
+          logger.say "#{successful} ", status_color
+          logger.say "of "
+          logger.say "#{total_count} ", status_color
+          logger.say "hosts in "
+          logger.say "#{elapsed_time}", :yellow
+
+          unless overall_success
+            indent = Math.log10(total_count - successful).round + 4
+            logger.say "\nFailures:", :red
+            count = 0
+            hosts.each do |host|
+              unless host.success?
+                logger.say ""
+                logger.say "%#{indent}s" % "#{count += 1}) ", :red
+                logger.say "#{host.name}", :red
+                print_wrapped host.output.join("\n"), :indent => indent
+              end
+            end
+          end
+          log_rollout_status(host_groups)
+        end
+      end
+
+      def determine_host_groups(host_patterns)
+        say_option_status host_patterns
+        logger.say_status :deploy, "determining deployment targets", :green
+        host_groups = partial_install_groups(host_groups_for_patterns(host_patterns))
+      end
+
+      def confirm_deployment_start?(host_groups)
+        say_predeploy_status(host_groups)
+        if !(force? || json? || options[:yes]) && (ask("Are you sure you wish to deploy? [yN]").downcase != 'y')
+          logger.say_status :deploy, "deployment aborted!", :red
+          return false
+        end
+        # Reset the start time for more useful reporting
+        @command_start_time = Time.now()
+        true
+      end
+
+      def unique_hosts(host_groups)
+        # If we're not staging the slug, return just the hosts being installed to
+        options[:'no-stage'] ? host_groups.collect {|host_group| host_group.hosts_for_action(:install)}.flatten.uniq { |h| h.name } : host_groups.map(&:hosts).flatten.uniq { |h| h.name }
+      end
+
+      def order_deploy(hosts)
+        # Percolate installations to the top, then stripe across batches
+        hosts.sort! {|a,b| a.install? ? -1 : 1}
+        results=[]
+        batches = hosts.count / batch_size(hosts.count)
+        hosts.each.with_index {|item, index| results[index % batches].nil? ? results[index % batches] = [item] : results[index % batches] << item }
+        results.flatten
+      end
+
+      def join_batch_threads(threads, hosts, logger)
+        joined = false
+        while !joined
+          begin
+            threads.map { |ip,thread| thread }.map(&:join)
+            joined = true
+          rescue Interrupt  # Ctrl+C
+            logger.say "\nWe are #{elapsed_time} in. Stragglers for this batch:", :magenta
+            hosts.reject { |host| host.complete? }.each_with_index do |host, stripe|
+              logger.say "  #{host.name} (Timeline: #{host.timeline})", stripe.odd? ? :cyan : :yellow
+            end
+            logger.say "Maybe you should give 'em them the clamps?", :magenta
+            case ask("(T)erminate stragglers, (F)ail stragglers, (?) for help, or anything else to keep waiting:").downcase
+            when 'f'
+              break
+            when 't'
+              logger.say "Gee, you think? You think that maybe I should use these clamps that I use every day at every opportunity? You're a freakin' genius, you idiot!", :magenta
+              hosts.each_with_index do |host, index|
+                next if host.complete?
+                if host.id.nil? || !host.is_autoscaled?
+                  logger.say "Can't terminate #{host.name} as it is not part of an autoscaler"
+                else
+                  logger.say "Terminating #{host.name} (#{['Clamp.','Clamp!','Clampity Clamp!'][index%3]})", index.odd? ? :cyan : :yellow
+                  threads[host.ip].terminate
+                  host.record_event(:terminated)
+                  autoscaling.terminate_instance_in_auto_scaling_group(host.id, false)
+                end
+              end
+            when '?'
+              straggler_help
+            end
+          end
+        end
+      end
+
+      def straggler_help
+        logger.say <<-EOF
+
+T) Attempt to terminate the stragglers and let their autoscaling group create new instances. The deploy will end if everyone who had not completed could be terminated.
+F) Mark the remaining stragglers are failed and end the deployment
+?) Display this help and resume the deploy
+EOF
+      end
+
+      def say_option_status(host_patterns)
+        subset_name = if options[:count]
+          "#{options[:count]} server#{(options[:count] == 1) ? '' : 's'}"
+        elsif options[:percent]
+          "#{options[:percent]}% of servers"
+        else
+          "all servers"
+        end
+        logger.say_status :deploy, "targeting #{subset_name} for: #{host_patterns.join(', ')}", :green
+      end
+
+      def say_predeploy_status(host_groups)
+        total_count = host_groups.inject(0) { |sum, host_group| sum += host_group.hosts.count }
+        install_count = 0
+        host_groups.each_with_index do |host_group, stripe|
+          raise error_class, "Host group #{host_group.name} was empty!" if host_group.hosts.nil?
+          install_hosts = host_group.hosts_for_action(:install)
+          install_count += install_hosts.count
+          install_hosts.each do |host|
+            unless json?
+              logger.say  # Add a newline for cleaner paste into Flowdock
+              logger.say "#{host_group.name}: ", stripe.odd? ? :cyan : :yellow
+              logger.say "#{host.name}"
+            end
+          end
+        end
+        logger.say  # Add a newline for cleaner paste into Flowdock
+        logger.say_status :deploy, "#{with_units(install_count, 'host')} targeted for installation out of #{with_units(total_count, 'host')} total", :green
+
+        batch_host_count = options[:'no-stage'] ? host_groups.inject(0) { |sum, host_group| sum += host_group.hosts_for_action(:install).count } : total_count
+        batches = (batch_host_count/batch_size(batch_host_count).to_f).ceil
+        logger.say_status :deploy, "using #{batches} batch#{batches == 1 ? '' : 'es'} of #{with_units(batch_size(batch_host_count), 'host')} for installation #{options[:'no-stage'] ? '' : 'and staging'} ", :green
+      end
+
+      def with_units(value, unit)
+        "#{value} #{unit}#{(value == 1) ? '' : 's'}"
+      end
+
+      def log_rollout_status(host_groups)
+        return if host_groups.nil?
+        result = { :environment => overall_status, :hostgroups => [] }
+        host_groups.each do |host_group|
+          host_group.hosts.each do |host|
+            result[:hostgroups] << { :group => host_group.name }.merge(host.to_status)
+          end
+        end
+        filename = "slugforge_status-#{date_stamp}.json"
+        logger.say "Writing full status report to #{filename}"
+        File.open(filename, "w") do |f|
+          f.write(JSON.pretty_generate(result))
+        end
+        purge_old_files 'slugforge_status-*.json'
+      end
+
+      def overall_status
+        {
+          :command_line   => "#{$0} #{$*.join(' ')}",
+          :options        => @options,
+          :ruby_version   => RUBY_VERSION,
+          :ec2_access_key => @ec2_access_key,
+          :s3_access_key  => @s3_access_key,
+          :git_info       => git_info,
+        }
+      end
+
+      def purge_old_files(file_mask, keep_count = 10)
+        old_files = Dir.glob(file_mask).sort_by{ |f| File.ctime(f) }.reverse.slice(keep_count..-1)
+        File.delete(*old_files)
+      end
+
+      def host_groups_for_patterns(host_patterns)
+        host_groups = HostGroup.discover(host_patterns, compute)
+        raise error_class, "Unable to determine what host or group of hosts you meant with '#{pattern}'." unless host_groups
+        # determine unique hosts in each list, then sort by IP (alphabetically) to make partial deploys essentially deterministic
+        host_groups
+      end
+
+      def partial_install_groups(host_groups)
+        if options[:percent]
+          return host_groups.each { |host_group| host_group.install_percent_of_hosts(options[:percent]) }
+        elsif options[:count]
+          return host_groups.each { |host_group| host_group.install_number_of_hosts(options[:count]) }
+        end
+        host_groups.each { |host_group| host_group.install_all }
+      end
+
+      private
+      def batch_size(host_count = 1)
+        if options[:'batch-count'] && host_count >= options[:'batch-count'].to_i
+          batch_count = options[:'batch-count'] < 1 ? 1 : options[:'batch-count']
+          (host_count / batch_count.to_f).ceil
+        elsif options[:'batch-size'] && host_count > options[:'batch-size'].to_i
+          batch_size = options[:'batch-size'].to_i
+          batch_size = batch_size < 1 ? host_count : batch_size
+        else
+          host_count > 1 ? host_count : 1
+        end
+      end
+    end
+  end
+end
+