iron_chef 0.0.10

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    MzczZmZjMTgxNjNlMWQwOGViOGMzNjkxOWFmNmMyNTMyM2FiNTQ3Mw==
+  data.tar.gz: !binary |-
+    MmQ2MzQ0ZWIwMjE5YmE3MTYxY2YyMDVjYTQ5OTQ4NDk4Y2IwN2QzMw==
+!binary "U0hBNTEy":
+  metadata.gz: !binary |-
+    YWUxNjA3OTUyYWI5NGZjYTc2ODhkMzJiZDQ3NDgwM2MyNDY5MDNkYWNmNTVl
+    YzAyZTZmNmVkM2RkYmVhODc4NGEyZWVhOGM1NDRhODJlYTgxOWJlNjllYWYw
+    OGUxZjQ5MTczOTU2ZTQ5NTBjMWRmM2ZhZTgwYTY0YWNiNWMyZjU=
+  data.tar.gz: !binary |-
+    ZmUxNzA0ZDdhNGMxODdmYWYzMjVlYTJmNzZjMDU5MWVhN2ZhZDI1MzA0ODAz
+    YWZlOWI3YmE3OGI1ZTkwOGZiNjYyOGUzOTQ4ZjkxMmNkZTk0NmIzMzdiMDFl
+    NmJiZWJiMjJhZDI4YTc0M2Y1Y2MxYTYxODI0MDAyMzU3ZThmYzU=

data/Gemfile

@@ -0,0 +1,7 @@
+source 'https://rubygems.org'
+
+group :test do
+  gem 'rake'
+end
+
+gemspec

data/Gemfile.lock

@@ -0,0 +1,33 @@
+PATH
+  remote: .
+  specs:
+    iron_chef (0.0.10)
+      capistrano (>= 2.15.4)
+      json
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    capistrano (2.15.4)
+      highline
+      net-scp (>= 1.0.0)
+      net-sftp (>= 2.0.0)
+      net-ssh (>= 2.0.14)
+      net-ssh-gateway (>= 1.1.0)
+    highline (1.6.19)
+    json (1.8.0)
+    net-scp (1.1.1)
+      net-ssh (>= 2.6.5)
+    net-sftp (2.1.2)
+      net-ssh (>= 2.6.5)
+    net-ssh (2.6.7)
+    net-ssh-gateway (1.2.0)
+      net-ssh (>= 2.6.5)
+    rake (10.1.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  iron_chef!
+  rake

data/Rakefile

@@ -0,0 +1,24 @@
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.test_files = FileList['test/*_test.rb']
+end
+
+task :default => :test
+
+desc "clean"
+task :clean do
+  rm_f Dir.glob("*.gem")
+end
+
+namespace :gem do
+  desc "build the gem"
+  task :build => :clean do
+    sh "gem build iron_chef.gemspec"
+  end
+
+  desc "push the gem"
+  task :push => :build do
+    sh "gem push #{Dir.glob("*.gem").first}"
+  end
+end

data/bin/ironchef

@@ -0,0 +1,151 @@
+#!/usr/bin/env ruby
+
+require 'optparse'
+require 'fileutils'
+
+OptionParser.new do |opts|
+  opts.banner = "Usage: #{File.basename($0)} [project-name-devops]"
+
+  opts.on("-h", "--help", "Displays this help info") do
+    puts opts
+    exit 0
+  end
+
+  begin
+    opts.parse!(ARGV)
+  rescue OptionParser::ParseError => e
+    warn e.message
+    puts opts
+    exit 1
+  end
+end
+
+
+if ARGV.empty?
+  abort "Please specify the DevOps project directory , e.g. '#{File.basename($0)}-devops'"
+elsif ARGV.length > 1
+  abort "Too many arguments; please specify only the DevOps project directory."
+end
+
+def unindent(string)
+  indentation = string[/\A\s*/]
+  string.strip.gsub(/^#{indentation}/, "")
+end
+
+base = ARGV.shift
+
+FileUtils.mkdir_p(base)
+
+FileUtils.mkdir_p("#{base}/environments")
+FileUtils.mkdir_p("#{base}/nodes")
+FileUtils.mkdir_p("#{base}/data_bags/environments")
+
+files = {
+  ".gitignore" => unindent(<<-FILE),
+    /cookbooks
+    /tmp
+    
+  FILE
+  
+  "Gemfile" => unindent(<<-FILE),
+    source 'https://rubygems.org'
+  
+    gem 'iron_chef'
+    
+  FILE
+  
+  "Capfile" => unindent(<<-FILE),
+    require 'iron_chef'
+    load 'config/deploy'
+  
+  FILE
+  
+  "config/deploy.rb" => unindent(<<-FILE),
+    set :chef_environments, %w(staging production)
+
+    # don't forget to run locally
+    # chmod 600 /your-full/local-path-to-ssh-key/xxxxx_keypair_ec2.pem
+    # ssh-add /your-full/local-path-to-ssh-key/xxxxx_keypair_ec2.pem
+
+    ssh_options[:keys] = File.expand_path('~/your-local-path-to-ssh-key/xxxxx_keypair_ec2.pem')
+    default_run_options[:pty] = true
+
+    set :user, 'ec2-user'
+    set :use_sudo, false
+
+  FILE
+
+  "roles/base_server.rb" => unindent(<<-FILE),
+    name "base_server"
+    description "Base Server Role"
+    # run_list
+    # default_attributes
+  FILE
+
+  "roles/app_server.rb" => unindent(<<-FILE),
+    name "app_server"
+    description "Application Server Role"
+    # run_list
+    # default_attributes
+  FILE
+
+  "roles/db_server.rb" => unindent(<<-FILE),
+    name "db_server"
+    description "Database Server Role"
+    # run_list
+    # default_attributes
+  FILE
+
+  "roles/web_server.rb" => unindent(<<-FILE),
+    name "web_server"
+    description "Web Server Role"
+    # run_list
+    # default_attributes
+  FILE
+
+  "cookbooks/.gitkeep" => '',
+
+  "site-cookbooks/commons/recipes/default.rb" => unindent(<<-FILE),
+  # retrieve environment specific data bag item
+  env = Chef::DataBagItem.load('environments', node['chef_environment'])
+  Chef::Log.info("Loaded environments information from DataBagItem env[\#{env['id']}]")
+  Chef::Log.info("Loaded environments information from DataBagItem env[\#{env['description']}]")
+
+  # retrieve global settings specific data bag item
+  gs_default = Chef::DataBagItem.load('global_settings', 'default')
+  Chef::Log.info("Loaded global settings information from DataBagItem gs_default[\#{gs_default['id']}]")
+  Chef::Log.info("Loaded global settings information from DataBagItem gs_default[\#{gs_default['description']}]")
+  FILE
+
+  "site-cookbooks/commons/attributes/default.rb" => '',
+
+  "data_bags/global_settings/default.json" => "{\n\"id\": \"default\",\n\"description\": \"global settings default data bag item\"\n}",
+
+  "README.md" => "\# #{base}"
+}
+
+files.each do |file, content|
+  file = File.join(base, file)
+  if File.exists?(file)
+    warn "[skip] '#{file}' already exists"
+  elsif File.exists?(file.downcase)
+    warn "[skip] '#{file.downcase}' exists, which could conflict with `#{file}'"
+  else
+    unless File.exists?(File.dirname(file))
+      puts "[add] making directory '#{File.dirname(file)}'"
+      FileUtils.mkdir_p(File.dirname(file))
+    end
+    puts "[add] writing '#{file}'"
+    File.open(file, "w") { |f| f.write(content) }
+  end
+end
+
+Dir.chdir(base) do
+  puts   'Installing gem dependencies'
+  system 'bundle'
+
+  system 'cap env:prepare'
+
+  puts "Created Iron Chef DevOps project '#{base}'"
+
+end

data/iron_chef.gemspec

@@ -0,0 +1,29 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'iron_chef/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "iron_chef"
+  gem.platform      = Gem::Platform::RUBY
+  gem.version       = IronChef::VERSION
+  gem.license       = "MIT"
+
+  gem.required_ruby_version = '>= 1.9.3'
+  gem.required_rubygems_version = '>= 1.8.11'
+
+  gem.authors       = ["Scott Rosenthal"]
+  gem.email         = ["sr7575@gmail.com"]
+  gem.description   = %q{Iron Chef is a lightweight Chef Solo wrapper built as a capistrano plugin}
+  gem.summary       = %q{Iron Chef makes cloud server provisioning with Chef Solo powerful and easy.}
+  gem.homepage      = "https://github.com/scottvrosenthal/iron_chef"
+  gem.license       = "MIT"
+  gem.files         = `git ls-files | grep -vE '(jenkins|.travis.yml|.gitmodules|.gitignore|.ruby-version|.ruby-gemset|README.md)'`.split("\n")
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+
+  gem.add_dependency 'capistrano', '>= 2.15.4'
+  gem.add_dependency 'json'
+
+end

data/lib/iron_chef.rb

@@ -0,0 +1,14 @@
+$LOAD_PATH << File.expand_path(File.dirname(__FILE__))
+
+require 'iron_chef/rsync'
+require 'iron_chef/async_enumerable'
+require 'iron_chef/erb'
+require 'iron_chef/plugin'
+require 'iron_chef/thread_pool'
+require 'iron_chef/util'
+require 'iron_chef/writer/batched'
+require 'iron_chef/writer/file'
+require 'iron_chef/writer/streaming'
+require 'iron_chef/tasks'
+
+Capistrano.plugin :iron_chef, IronChef::Plugin

data/lib/iron_chef/async_enumerable.rb

@@ -0,0 +1,19 @@
+module IronChef
+  module AsyncEnumerable
+    def each(&block)
+      pool = IronChef::ThreadPool.new(IronChef::Util.thread_pool_size)
+      super do |item|
+        pool.schedule(item, &block)
+      end
+      pool.shutdown
+    end
+
+    def map(&block)
+      pool = IronChef::ThreadPool.new(IronChef::Util.thread_pool_size)
+      super do |item|
+        pool.schedule(item, &block)
+      end
+      pool.shutdown
+    end
+  end
+end

data/lib/iron_chef/erb.rb

@@ -0,0 +1,19 @@
+require 'erb'
+require 'yaml'
+require 'json'
+
+module IronChef
+  module ERB
+    def self.read_erb(path)
+      ::ERB.new(File.read(path)).result binding
+    end
+
+    def self.read_erb_yaml(path)
+      YAML::load(read_erb path)
+    end
+
+    def self.read_erb_json(path)
+      JSON::parse(read_erb path)
+    end
+  end
+end

data/lib/iron_chef/plugin.rb

@@ -0,0 +1,271 @@
+module IronChef
+  module Plugin
+
+    def fetch_chef_environment_dir
+      fetch(:chef_environment_dir, 'environments')
+    end
+
+    def fetch_chef_nodes_dir
+      fetch(:chef_nodes_dir, 'nodes')
+    end
+
+    def find_node(node_path)
+      raise "Node YAML file #{node_path} not found" unless node_path && File.exists?(node_path)
+
+      node_name   = File.basename(node_path).gsub('.yml','')
+      node_config = IronChef::ERB.read_erb_yaml(node_path)
+
+      node_config['node_name'] = node_name
+
+      node_config
+    end
+
+    def node(node_name)
+      nodes_location  = fetch_chef_nodes_dir
+      unless node_path = Dir.glob("./#{nodes_location}/**/#{node_name}.yml")[0]
+        abort "Node '#{node_name}' is unknown. Known nodes are #{nodes_list.join(', ')}."
+      end
+      find_node(node_path)
+    end
+
+    def nodes_list
+      nodes_location  = fetch_chef_nodes_dir
+      nodes_available = Dir.glob("./#{nodes_location}/**/*.yml").map { |f| File.basename(f, '.*') }
+      nodes_available.sort
+    end
+
+    def env_nodes_list
+      nodes_location  = fetch_chef_nodes_dir
+      nodes_available = Dir.glob("./#{nodes_location}/**/*.yml").map { |f| File.basename(f, '.*') }
+      env_nodes_available = []
+      nodes_available.each do |node_name|
+        node_config = node(node_name)
+        if node_config['json']
+          if node_config['json']['chef_environment']
+            node_env = node_config['json']['chef_environment']
+            if "#{chef_environment}" == "#{node_env}"
+              env_nodes_available << node_config['node_name']
+            end
+          else
+            puts "Node '#{node_config['node_name']}' ['json']['chef_environment'] attribute is empty or missing."
+          end
+        else
+          puts "Node '#{node_config['node_name']}' ['json'] attribute is empty or missing."
+        end
+      end
+
+      if env_nodes_available.size == 0
+        abort "No nodes found for chef environment '#{chef_environment}'. Known nodes are #{nodes_available.join(', ')}."
+      end
+      env_nodes_available.sort
+    end
+
+    def tasks_for_env(nodes_names)
+
+      servers = []
+
+      nodes_names.each do |node_name|
+        node_config = node(node_name)
+        if node_config['server']
+          if node_config['server']['host']
+
+            servers << [node_config['server']['host'], node_config['node_name']]
+
+            task(node_config['node_name']) do
+              role :server, node_config['server']['host'], { node_name: node_config['node_name'] }
+            end
+          else
+            puts "Node '#{node_config['node_name']}' ['server']['host'] attribute is empty or missing."
+          end
+        else
+          puts "Node '#{node_config['node_name']}' ['server'] attribute is empty or missing."
+        end
+      end
+
+      if nodes_names
+        task(:all_nodes) do
+          servers.each do |server|
+            host_name, node_name = server
+            role :server, host_name, { node_name: node_name }
+          end
+        end
+      end
+
+    end
+
+    def upload_node_json(node_name)
+
+      node_config = node(node_name)
+
+      node_dna = {
+        :run_list => node_run_list(node_config)
+      }.merge(node_config['json'])
+
+      put node_dna.to_json, "#{chef_destination}/node.json", :via => :scp
+
+    end
+
+    def dump_nodes_json
+
+      nodes_available = nodes_list
+
+      nodes_location  = fetch_chef_nodes_dir
+
+      FileUtils.mkdir_p("./tmp/#{nodes_location}")
+
+      nodes_available.each do |node_name|
+        node_config = node(node_name)
+
+        node_dna = {
+          :run_list => node_run_list(node_config)
+        }.merge(node_config['json'])
+
+        node_dna_json_file = "./tmp/#{nodes_location}/#{node_config['node_name']}.json"
+        File.open(node_dna_json_file, "w") do |f|
+          f.puts node_dna.to_json
+        end
+
+        puts "Created #{node_dna_json_file}"
+      end
+    end
+
+    def node_run_list(node_config)
+      run_list = []
+      run_list += node_config['roles'].map   { |r| "role[#{r}]"   } if node_config['roles']
+      run_list += node_config['recipes'].map { |r| "recipe[#{r}]" } if node_config['recipes']
+
+      run_list
+    end
+
+    def cookbooks
+      Array(fetch(:chef_cookbooks) { (:chef_cookbooks).select { |path| File.exist?(path) } })
+    end
+
+    def upload_solo_rb
+      cookbook_paths = cookbooks.map { |c| "File.join(chef_root, #{c.to_s.inspect})" }.join(', ')
+      solo_rb = <<-RUBY
+      solo true
+      chef_root = File.expand_path(File.dirname(__FILE__))
+      file_cache_path chef_root
+      cookbook_path   [ #{cookbook_paths} ]
+      role_path       File.join(chef_root, "roles")
+      data_bag_path   File.join(chef_root, "data_bags")
+      json_attribs    File.join(chef_root, "node.json")
+      log_level "#{chef_log_level}".to_sym
+      RUBY
+      put solo_rb, "#{chef_destination}/solo.rb", :via => :scp
+    end
+
+    def rsync
+      IronChef::Util.thread_pool_size = chef_parallel_rsync_pool_size
+      servers = IronChef::Util.optionally_async(find_servers_for_task(current_task), chef_parallel_rsync)
+      overrides = {}
+      overrides[:user] = fetch(:user, ENV['USER'])
+      overrides[:port] = fetch(:port) if exists?(:port)
+
+      failed_servers = servers.map do |server|
+        rsync_cmd = IronChef::Rsync.command(
+          chef_source,
+          IronChef::Rsync.remote_address(server.user || fetch(:user, ENV['USER']), server.host, chef_destination),
+          :delete => true,
+          :excludes => chef_excludes,
+          :ssh => ssh_options.merge(server.options[:ssh_options]||{}).merge(overrides)
+        )
+        logger.debug rsync_cmd
+
+        server.host unless system rsync_cmd
+      end.compact
+
+      raise "rsync failed on #{failed_servers.join(',')}" if failed_servers.any?
+
+      upload_chef_solo_config(servers)
+    end
+
+    def upload_chef_solo_config(servers)
+
+      servers.map do |server|
+        # allows use to use node aliases for Iron Chef
+        node_name = server.options[:node_name]
+
+        raise "upload_chef_solo_config failed on #{server.host} with missing node name on role" unless node_name
+        upload_node_json(node_name)
+
+        upload_solo_rb
+      end
+
+    end
+
+    def prepare
+      run "mkdir -p #{chef_destination}"
+      release_chef_client_lock
+      run "chown -R $USER: #{chef_destination}"
+    end
+
+    def why_run
+      chef(:why_run)
+    end
+
+    def apply
+      chef(:apply)
+    end
+
+    def lock
+      if should_lock?
+        run <<-CHECK_LOCK
+if [ -f #{chef_lock_file} ]; then
+    stat -c "#{red_text("Chef in progress, #{chef_lock_file} owned by %U since %x")}" #{chef_lock_file} >&2;
+    exit 1;
+fi
+        CHECK_LOCK
+
+        run "touch #{chef_lock_file}"
+      end
+    end
+
+    def unlock
+      run prepare_sudo_cmd("rm -f #{chef_lock_file}; true") if should_lock?
+    end
+
+    def release_chef_client_lock
+      run prepare_sudo_cmd("rm -f #{chef_destination}/chef-client-running.pid; true")
+    end
+
+    def prepare_sudo_cmd(cmd)
+      user == 'root' ? cmd : "sudo -- sh -c '#{cmd}'"
+    end
+
+    private
+
+    def should_lock?
+      chef_lock_file && !ENV['NO_CHEF_LOCK']
+    end
+
+    def chef(command = :why_run)
+      chef_cmd = "cd #{chef_destination} && #{chef_command} #{chef_parameters}"
+      flag = command == :why_run ? '--why-run' : ''
+
+      writer = if chef_stream_output
+                 IronChef::Writer::Streaming.new(logger)
+               else
+                 IronChef::Writer::Batched.new(logger)
+               end
+
+      writer = IronChef::Writer::File.new(writer, chef_write_to_file) unless chef_write_to_file.nil?
+
+      prepared_chef_cmd = prepare_sudo_cmd("#{chef_cmd} #{flag}")
+      begin
+        run prepared_chef_cmd do |channel, stream, data|
+          writer.collect_output(channel[:host], data)
+        end
+        logger.debug "Chef #{command} complete."
+      ensure
+        writer.all_output_collected
+      end
+    end
+
+    def red_text(text)
+      "\033[0;31m#{text}\033[0m"
+    end
+    
+  end
+end

data/lib/iron_chef/rsync.rb

@@ -0,0 +1,166 @@
+module IronChef
+  class Rsync
+    class << self
+      def command(from, to, options={})
+        flags = ['-az']
+        flags << '--delete' if options[:delete]
+        flags << excludes(options[:excludes]) if options.has_key?(:excludes)
+        flags << ssh_options(options[:ssh]) if options.has_key?(:ssh)
+
+        "rsync #{flags.compact.join(' ')} #{from} #{to}"
+      end
+
+      def remote_address(user, host, path)
+        user_with_host = [user, host].compact.join('@')
+        [user_with_host, path].join(':')
+      end
+
+      def excludes(patterns)
+        [patterns].flatten.map { |p| "--exclude=#{p}" }
+      end
+
+
+      #
+      # Convert Net::SSH options into OpenSSH options.
+      #
+      # For a list of the options normally support by Net::SSH (and thus Capistrano), see
+      # http://net-ssh.github.com/net-ssh/classes/Net/SSH.html#method-c-start
+      #
+      # Also, to see how Net::SSH does the opposite of the conversion we are doing here, check out:
+      # https://github.com/net-ssh/net-ssh/blob/master/lib/net/ssh/config.rb
+      #
+      # API mismatch:
+      #
+      # * many OpenSSH options not supported
+      # * some options only make sense for Net::SSH
+      # * compression: for Net::SSH, this option is supposed to accept true, false, or algorithm. OpenSSH accepts 'yes' or 'no'
+      #
+      def ssh_options(options)
+        mapped_options = options.map do |key, value|
+          next unless value
+
+          case key
+          when :auth_methods            then opt_auth_methods(value)
+          when :bind_address            then opt('BindAddress', value)
+          when :compression             then opt('Compression', value ? 'yes' : 'no')
+          when :compression_level       then opt('CompressionLevel', value.to_i)
+          when :config                  then "-F '#{value}'"
+          when :encryption              then opt('Ciphers', [value].flatten.join(','))
+          when :forward_agent           then opt('ForwardAgent', value)
+          when :global_known_hosts_file then opt('GlobalKnownHostsFile', value)
+          when :hmac                    then opt('MACs', [value].flatten.join(','))
+          when :host_key                then opt('HostKeyAlgorithms', [value].flatten.join(','))
+          when :host_key_alias          then opt('HostKeyAlias', value)
+          when :host_name               then opt('HostName', value)
+          when :kex                     then opt('KexAlgorithms', [value].flatten.join(','))
+          when :key_data                then nil # not supported
+          when :keys                    then [value].flatten.select { |k| File.exist?(k) }.map { |k| "-i '#{k}'" }
+          when :keys_only               then opt('IdentitiesOnly', value ? 'yes' : 'no')
+          when :languages               then nil # not applicable
+          when :logger                  then nil # not applicable
+          when :paranoid                then opt('StrictHostKeyChecking', value ? 'yes' : 'no')
+          when :passphrase              then nil # not supported
+          when :password                then nil # not supported
+          when :port                    then "-p #{value.to_i}"
+          when :properties              then nil # not applicable
+          when :proxy                   then nil # not applicable
+          when :rekey_blocks_limit      then nil # not supported
+          when :rekey_limit             then opt('RekeyLimit', reverse_interpret_size(value))
+          when :rekey_packet_limit      then nil # not supported
+          when :timeout                 then opt('ConnectTimeout', value.to_i)
+          when :user                    then "-l #{value}"
+          when :user_known_hosts_file   then multi_opt('UserKnownHostsFile', value)
+          when :verbose                 then opt('LogLevel', interpret_log_level(value))
+          end
+        end.compact
+
+        %[-e "ssh #{mapped_options.join(' ')}"] unless mapped_options.empty?
+      end
+
+      private
+
+      def opt(option_name, option_value)
+        "-o #{option_name}='#{option_value}'"
+      end
+
+      def multi_opt(option_name, option_values)
+        [option_values].flatten.map do |value|
+          opt(option_name, value)
+        end.join(' ')
+      end
+
+      #
+      # In OpenSSH, password and pubkey default to 'yes', hostbased defaults to 'no'.
+      # Regardless, if :auth_method is configured, then we explicitly disable methods not included.
+      #
+      def opt_auth_methods(value)
+        value = [value].flatten
+        opts = []
+        if value.any?
+          if value.include? 'password'
+            opts << opt('PasswordAuthentication', 'yes')
+          else
+            opts << opt('PasswordAuthentication', 'no')
+          end
+          if value.include? 'publickey'
+            opts << opt('PubkeyAuthentication', 'yes')
+          else
+            opts << opt('PubkeyAuthentication', 'no')
+          end
+          if value.include? 'hostbased'
+            opts << opt('HostbasedAuthentication', 'yes')
+          else
+            opts << opt('HostbasedAuthentication', 'no')
+          end
+        end
+        if opts.any?
+          return opts.join(' ')
+        else
+          nil
+        end
+      end
+
+      #
+      # Converts the given integer size in bytes into a string with 'K', 'M', 'G' suffix, as appropriate.
+      #
+      # reverse of interpret_size in https://github.com/net-ssh/net-ssh/blob/master/lib/net/ssh/config.rb
+      #
+      def reverse_interpret_size(size)
+        size = size.to_i
+        if size < 1024
+          "#{size}"
+        elsif size < 1024 * 1024
+          "#{size/1024}K"
+        elsif size < 1024 * 1024 * 1024
+          "#{size/(1024*1024)}M"
+        else
+          "#{size/(1024*1024*1024)}G"
+        end
+      end
+
+      def interpret_log_level(level)
+        if level.is_a? Symbol
+          case level
+            when :debug then "DEBUG"
+            when :info then "INFO"
+            when :warn then "ERROR"
+            when :error then "ERROR"
+            when :fatal then "FATAL"
+            else "INFO"
+          end
+        elsif level.is_a? Integer
+          case level
+            when Logger::DEBUG then "DEBUG"
+            when Logger::INFO then "INFO"
+            when Logger::WARN then "ERROR"
+            when Logger::ERROR then "ERROR"
+            when Logger::FATAL then "FATAL"
+            else "INFO"
+          end
+        else
+          "INFO"
+        end
+      end
+    end
+  end
+end

data/lib/iron_chef/tasks.rb

@@ -0,0 +1,181 @@
+require 'json'
+require 'fileutils'
+
+Capistrano::Configuration.instance.load do
+
+  set :chef_source, '.'
+  set :chef_destination, '/tmp/chef'
+  set :chef_cookbooks,   %w(cookbooks site-cookbooks)
+  set :chef_log_level, 'info'
+  set :chef_command, '/opt/chef/embedded/bin/ruby /opt/chef/bin/chef-solo -c /tmp/chef/solo.rb'
+  set :chef_parameters, '--color'
+  set :chef_excludes, %w(.git .svn nodes)
+  set :chef_stream_output, false
+  set :chef_parallel_rsync, true
+  set :chef_parallel_rsync_pool_size, 10
+  set :chef_syntax_check, false
+  set :chef_write_to_file, nil
+  set :chef_runner, nil
+  set :chef_lock_file, '/tmp/chef.lock'
+  set :chef_nodes_dir, 'nodes'
+  set :chef_data_bags_dir, 'data_bags'
+  set :chef_environment_dir, 'environments'
+
+  namespace :chef do
+
+    desc "Pushes the current chef configuration to the server."
+    task :update_code, :except => { :nochef => true } do
+      iron_chef.rsync
+    end
+
+    desc "Runs chef with --why-run flag to to understand the decisions it makes."
+    task :why_run, :except => { :nochef => true } do
+      iron_chef.lock
+      transaction do
+        on_rollback { iron_chef.unlock }
+        iron_chef.prepare
+        update_code
+        iron_chef.why_run
+        iron_chef.unlock
+      end
+    end
+
+    desc "Applies the current chef config to the server."
+    task :apply, :except => { :nochef => true } do
+      iron_chef.lock
+      transaction do
+        on_rollback { iron_chef.unlock }
+        iron_chef.prepare
+        update_code
+        iron_chef.apply
+        iron_chef.unlock
+      end
+    end
+
+    desc "Clears the chef lockfile on the server."
+    task :unlock, :except => { :nochef => true } do
+      iron_chef.unlock
+    end
+    
+    desc "Clears the chef destination folder on the server."
+    task :clear, :except => { :nochef => true } do
+      run iron_chef.prepare_sudo_cmd("rm -rf #{chef_destination}/*")
+      iron_chef.unlock
+    end
+
+    desc "Shows all nodes available for chef config."
+    task :nodes, :except => { :nochef => true } do
+      puts iron_chef.nodes_list
+    end
+
+    desc "Dump each node's dynamically generated node.json file to local ./tmp/#{chef_nodes_dir} directory."
+    task :dump_nodes_json, :except => { :nochef => true } do
+      iron_chef.dump_nodes_json
+    end
+
+  end ## end chef namespace ##
+
+  ## begin env tasks
+
+  unless exists?(:chef_environments)
+    set :chef_environments, Dir["./#{chef_environment_dir}/*.rb"].map { |f| File.basename(f, ".rb") }
+  end
+
+  desc "Target individual nodes."
+  task :nodes, :except => { :nochef => true }  do
+
+      nodes_available = iron_chef.nodes_list
+
+      iron_chef.tasks_for_env(nodes_available)
+
+  end
+
+  chef_environments.each do |name|
+    desc "Set the target chef environment to '#{name}'."
+    task name, :except => { :nochef => true }  do
+      set :chef_environment, name.to_sym
+      if File.exist?(File.join(chef_environment_dir, "#{chef_environment}.rb"))
+        load "./#{chef_environment_dir}/#{chef_environment}"
+
+        iron_chef.tasks_for_env(iron_chef.env_nodes_list)
+
+      end
+    end
+  end
+
+  on :load do
+    if chef_environments.include?(ARGV.first)
+      # Execute the specified chef environment so that recipes required in environment can contribute to task list
+      find_and_execute_task(ARGV.first) if ARGV.any?{ |option| option =~ /-T|--tasks|-e|--explain/ }
+    else
+      # Execute the default chef environment so that recipes required in environment can contribute tasks
+      find_and_execute_task('nodes')
+    end
+  end
+
+  namespace :env do
+
+    desc "Stub out the chef environment config files."
+    task :prepare, :except => { :nochef => true } do
+      FileUtils.mkdir_p(chef_environment_dir)
+      chef_environments.each do |name|
+        rb_env_file = File.join(chef_environment_dir, "#{name}.rb")
+        unless File.exists?(rb_env_file)
+          File.open(rb_env_file, "w") do |f|
+            f.puts "# #{name.upcase}-specific chef environment configuration"
+            f.puts "# please put general chef environment config in config/deploy.rb"
+          end
+          yml_env_node_file = File.join(chef_nodes_dir, "#{name}-server1.yml")
+          unless File.exists?(yml_env_node_file)
+            File.open(yml_env_node_file, "w") do |f|
+              f.puts "json:\n  chef_environment: #{name}\n\nroles:\n  - app_server\n\nrecipes:\n  - commons\n\nserver:\n  host: ec2-xxx-xxx-xxx-xxx.us-west-2.compute.amazonaws.com"
+            end
+          end
+          json_env_data_bag_file = File.join("#{chef_data_bags_dir}/environments", "#{name}.json")
+          unless File.exists?(json_env_data_bag_file)
+            File.open(json_env_data_bag_file, "w") do |f|
+              f.puts "{\n\"id\": \"#{name}\",\n\"description\": \"environments #{name} data_bag_item\"\n}"
+            end
+          end
+          puts "Created chef environment config files for: #{name}"
+        end
+      end
+    end
+
+    desc "Shows chef environment nodes available for chef apply config."
+    task :nodes, :except => { :nochef => true } do
+      if chef_environments.include?(ARGV.first)
+        puts iron_chef.env_nodes_list
+      else
+        puts iron_chef.nodes_list
+      end
+    end
+
+  end
+
+  ## end env tasks
+
+  ## begin bootstrap namespace ##
+
+  namespace :bootstrap do
+
+    desc "Installs chef via omnibus on host."
+    task :chef, :except => { :nochef => true }  do
+      run "mkdir -p #{chef_destination}"
+
+      script = <<-BASH
+#!/bin/sh
+
+curl -s -o /tmp/chef-omnibus-install.sh https://www.opscode.com/chef/install.sh
+chmod +x /tmp/chef-omnibus-install.sh
+/tmp/chef-omnibus-install.sh > /tmp/chef-omnibus-install.log
+
+BASH
+
+      put script, "/tmp/chef-install.sh", :via => :scp
+      run iron_chef.prepare_sudo_cmd("chmod +x /tmp/chef-install.sh")
+      run iron_chef.prepare_sudo_cmd("/tmp/chef-install.sh > /tmp/chef-install.log")
+    end
+
+  end ## end bootstrap namespace ##
+end

data/lib/iron_chef/thread_pool.rb

@@ -0,0 +1,39 @@
+require 'thread'
+
+module IronChef
+  class ThreadPool
+    def initialize(size)
+      @size = size
+      @jobs = Queue.new
+      @retvals = []
+
+      @pool = Array.new(@size) do |i|
+        Thread.new do
+          Thread.current[:id] = i
+
+          catch(:exit) do
+            loop do
+              job, args = @jobs.pop
+              @retvals << job.call(*args)
+            end
+          end
+        end
+      end
+    end
+
+
+    def schedule(*args, &block)
+      @jobs << [block, args]
+    end
+
+
+    def shutdown
+      @size.times do
+        schedule { throw :exit }
+      end
+
+      @pool.map(&:join)
+      @retvals
+    end
+  end
+end

data/lib/iron_chef/util.rb

@@ -0,0 +1,23 @@
+module IronChef
+  module Util
+    DEFAULT_THREAD_POOL_SIZE = 10
+
+    def self.thread_pool_size
+      @thread_pool_size ||= DEFAULT_THREAD_POOL_SIZE
+    end
+
+    def self.thread_pool_size=(size)
+      @thread_pool_size = size
+    end
+
+    def self.optionally_async(collection, async)
+      if async
+        async_collection = collection.clone
+        async_collection.extend IronChef::AsyncEnumerable
+        async_collection
+      else
+        collection
+      end
+    end
+  end
+end

data/lib/iron_chef/version.rb

@@ -0,0 +1,3 @@
+module IronChef
+  VERSION = "0.0.10"
+end

data/lib/iron_chef/writer/batched.rb

@@ -0,0 +1,22 @@
+module IronChef
+  module Writer
+    class Batched
+      def initialize(logger)
+        @outputs = {}
+        @logger = logger
+      end
+
+      def collect_output(host, data)
+        @outputs[host] ||= ""
+        @outputs[host] << data
+      end
+
+      def all_output_collected
+        @outputs.keys.sort.each do |host|
+          @logger.info "Chef output for #{host}"
+          @logger.debug @outputs[host], host
+        end
+      end
+    end
+  end
+end

data/lib/iron_chef/writer/file.rb

@@ -0,0 +1,23 @@
+module IronChef
+  module Writer
+    class File
+      def initialize(writer, file)
+        @wrapped_writer = writer
+        @logger = Capistrano::Logger.new(:output => file)
+        @logger.level = Capistrano::Logger::TRACE
+        @file_writer = Batched.new(@logger)
+      end
+
+      def collect_output(host, data)
+        @wrapped_writer.collect_output(host, data)
+        @file_writer.collect_output(host, data)
+      end
+
+      def all_output_collected
+        @wrapped_writer.all_output_collected
+        @file_writer.all_output_collected
+        @logger.close
+      end
+    end
+  end
+end

data/lib/iron_chef/writer/streaming.rb

@@ -0,0 +1,16 @@
+module IronChef
+  module Writer
+    class Streaming
+      def initialize(logger)
+        @logger = logger
+      end
+
+      def collect_output(host, data)
+        @logger.debug data, host
+      end
+
+      def all_output_collected
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,90 @@
+--- !ruby/object:Gem::Specification
+name: iron_chef
+version: !ruby/object:Gem::Version
+  version: 0.0.10
+platform: ruby
+authors:
+- Scott Rosenthal
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-07-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: capistrano
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 2.15.4
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 2.15.4
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Iron Chef is a lightweight Chef Solo wrapper built as a capistrano plugin
+email:
+- sr7575@gmail.com
+executables:
+- ironchef
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- Gemfile.lock
+- Rakefile
+- bin/ironchef
+- iron_chef.gemspec
+- lib/iron_chef.rb
+- lib/iron_chef/async_enumerable.rb
+- lib/iron_chef/erb.rb
+- lib/iron_chef/plugin.rb
+- lib/iron_chef/rsync.rb
+- lib/iron_chef/tasks.rb
+- lib/iron_chef/thread_pool.rb
+- lib/iron_chef/util.rb
+- lib/iron_chef/version.rb
+- lib/iron_chef/writer/batched.rb
+- lib/iron_chef/writer/file.rb
+- lib/iron_chef/writer/streaming.rb
+homepage: https://github.com/scottvrosenthal/iron_chef
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.9.3
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.8.11
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.3
+signing_key: 
+specification_version: 4
+summary: Iron Chef makes cloud server provisioning with Chef Solo powerful and easy.
+test_files: []