jgrevich-knife-solo 0.1.1

data/lib/chef/knife/cook.rb

@@ -0,0 +1,130 @@
+require 'pathname'
+
+require 'chef/knife'
+require 'chef/config'
+require 'chef/cookbook/chefignore'
+
+require 'knife-solo/ssh_command'
+require 'knife-solo/kitchen_command'
+require 'knife-solo/tools'
+
+class Chef
+  class Knife
+    # Approach ported from spatula (https://github.com/trotter/spatula)
+    # Copyright 2009, Trotter Cashion
+    class Cook < Knife
+      include KnifeSolo::SshCommand
+      include KnifeSolo::KitchenCommand
+      include KnifeSolo::Tools
+
+      banner "knife cook [user@]hostname [json] (options)"
+
+      option :skip_chef_check,
+        :long => '--skip-chef-check',
+        :boolean => true,
+        :description => "Skip the version check on the Chef gem"
+
+      option :sync_only,
+        :long => '--sync-only',
+        :boolean => false,
+        :description => "Only sync the cookbook - do not run Chef"
+
+      option :skip_syntax_check,
+        :long => '--skip-syntax-check',
+        :boolean => true,
+        :description => "Skip Ruby syntax checks"
+
+      def run
+        super
+        check_syntax unless config[:skip_syntax_check]
+        Chef::Config.from_file('solo.rb')
+        check_chef_version unless config[:skip_chef_check]
+        rsync_kitchen
+        add_patches
+        cook unless config[:sync_only]
+      end
+
+      def check_syntax
+        ui.msg('Checking cookbook syntax...')
+        chefignore.remove_ignores_from(Dir["**/*.rb"]).each do |recipe|
+          ok = system "ruby -c #{recipe} >/dev/null 2>&1"
+          raise "Syntax error in #{recipe}" if not ok
+        end
+
+        chefignore.remove_ignores_from(Dir["**/*.json"]).each do |json|
+          begin
+            require 'json'
+            # parse without instantiating Chef classes
+            JSON.parse File.read(json), :create_additions => false
+          rescue => error
+            raise "Syntax error in #{json}: #{error.message}"
+          end
+        end
+      end
+
+      def node_config
+        @name_args[1] || super
+      end
+
+      def chef_path
+        Chef::Config.file_cache_path
+      end
+
+      def chefignore
+        @chefignore ||= ::Chef::Cookbook::Chefignore.new("./")
+      end
+
+      # cygwin rsync path must be adjusted to work
+      def adjust_rsync_path(path)
+        return path unless windows_node?
+        path.gsub(/^(\w):/) { "/cygdrive/#{$1}" }
+      end
+
+      def patch_path
+        Array(Chef::Config.cookbook_path).first + "/chef_solo_patches/libraries"
+      end
+
+      def rsync_exclude
+        (%w{revision-deploys tmp '.*'} + chefignore.ignores).uniq
+      end
+
+      def rsync_kitchen
+        system! %Q{rsync -rl --rsh="ssh #{ssh_args}" --delete #{rsync_exclude.collect{ |ignore| "--exclude #{ignore} " }.join} ./ :#{adjust_rsync_path(chef_path)}}
+      end
+
+      def add_patches
+        run_portable_mkdir_p(patch_path)
+        Dir[Pathname.new(__FILE__).dirname.join("patches", "*.rb")].each do |patch|
+          system! %Q{rsync -rl --rsh="ssh #{ssh_args}" #{patch} :#{adjust_rsync_path(patch_path)}}
+        end
+      end
+
+      def check_chef_version
+        constraint = "~>0.10.4"
+        result = run_command <<-BASH
+          opscode_ruby="/opt/opscode/embedded/bin/ruby"
+
+          if command -v $opscode_ruby &>/dev/null
+          then
+            ruby_bin=$opscode_ruby
+          else
+            ruby_bin="ruby"
+          fi
+
+          $ruby_bin -rubygems -e "gem 'chef', '#{constraint}'"
+        BASH
+        raise "The chef gem on #{host} is out of date. Please run `#{$0} prepare #{ssh_args}` to upgrade Chef to #{constraint}." unless result.success?
+      end
+
+      def cook
+        logging_arg = "-l debug" if config[:verbosity] > 0
+
+        stream_command <<-BASH
+          chef-solo -c #{chef_path}/solo.rb \
+                         -j #{chef_path}/#{node_config} \
+                         #{logging_arg}
+        BASH
+      end
+    end
+  end
+end

data/lib/chef/knife/kitchen.rb

@@ -0,0 +1,29 @@
+require 'chef/knife'
+
+class Chef
+  class Knife
+    class Kitchen < Knife
+      include FileUtils
+
+      banner "knife kitchen NAME"
+
+      def run
+        name = @name_args.first
+        mkdir name
+        %w(nodes roles data_bags site-cookbooks cookbooks).each do |dir|
+          mkdir name + "/#{dir}"
+          touch name + "/#{dir}/.gitkeep"
+        end
+        File.open(name + "/solo.rb", 'w') do |f|
+          f << <<-RUBY.gsub(/^ {12}/, '')
+            file_cache_path "/tmp/chef-solo"
+            data_bag_path   "/tmp/chef-solo/data_bags"
+            cookbook_path   [ "/tmp/chef-solo/site-cookbooks",
+                              "/tmp/chef-solo/cookbooks" ]
+            role_path       "/tmp/chef-solo/roles"
+          RUBY
+        end
+      end
+    end
+  end
+end

data/lib/chef/knife/patches/parser.rb

@@ -0,0 +1,211 @@
+#
+# Copyright 2011, edelight GmbH
+#
+# Authors:
+#       Markus Korn <markus.korn@edelight.de>
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require 'treetop'
+require 'chef/solr_query/query_transform'
+
+# mock QueryTransform such that we can access the location of the lucene grammar
+class Chef
+  class SolrQuery
+    class QueryTransform
+      def self.base_path
+        class_variable_get(:@@base_path)
+      end
+    end
+  end
+end
+
+def build_flat_hash(hsh, prefix="")
+  result = {}
+  hsh.each_pair do |key, value|
+    if value.kind_of?(Hash)
+      result.merge!(build_flat_hash(value, "#{prefix}#{key}_"))
+    else
+      result[prefix+key] = value
+    end
+  end
+  result
+end
+
+module Lucene
+
+  class Term < Treetop::Runtime::SyntaxNode
+    # compares a query value and a value, tailing '*'-wildcards are handled correctly.
+    # Value can either be a string or an array, all other objects are converted
+    # to a string and than checked.
+    def match( value )
+      if value.is_a?(Array)
+        value.any?{ |x| self.match(x) }
+      else
+        File.fnmatch(self.text_value, value.to_s)
+      end
+    end
+  end
+
+  class Field < Treetop::Runtime::SyntaxNode
+    # simple field -> value matches, supporting tailing '*'-wildcards in keys
+    # as well as in values
+    def match( item )
+      keys = self.elements[0].match(item)
+      if keys.nil?
+        false
+      else
+        keys.any?{ |key| self.elements[1].match(item[key]) }
+      end
+    end
+  end
+  
+  # we don't support range matches
+  # range of integers would be easy to implement
+  # but string ranges are hard
+  class FiledRange < Treetop::Runtime::SyntaxNode
+  end
+  
+  class InclFieldRange < FieldRange
+  end
+  
+  class ExclFieldRange < FieldRange
+  end
+  
+  class RangeValue < Treetop::Runtime::SyntaxNode
+  end
+  
+  class FieldName < Treetop::Runtime::SyntaxNode
+    def match( item )
+      if self.text_value.count("_") > 0
+        item.merge!(build_flat_hash(item))
+      end
+      if self.text_value.end_with?("*")
+        part = self.text_value.chomp("*")
+        item.keys.collect{ |key| key.start_with?(part)? key: nil}.compact
+      else
+        if item.has_key?(self.text_value)
+          [self.text_value,]
+        else
+          nil
+        end
+      end
+    end
+  end
+
+  class Body < Treetop::Runtime::SyntaxNode
+    def match( item )
+      self.elements[0].match( item )
+    end
+  end
+  
+  class Group < Treetop::Runtime::SyntaxNode
+    def match( item )
+      self.elements[0].match(item)
+    end
+  end
+  
+  class BinaryOp < Treetop::Runtime::SyntaxNode
+    def match( item )
+      self.elements[1].match(
+        self.elements[0].match(item),
+        self.elements[2].match(item)
+      )
+    end
+  end
+  
+  class OrOperator < Treetop::Runtime::SyntaxNode
+    def match( cond1, cond2 )
+      cond1 or cond2
+    end
+  end
+  
+  class AndOperator < Treetop::Runtime::SyntaxNode
+    def match( cond1, cond2 )
+      cond1 and cond2
+    end
+  end
+  
+  # we don't support fuzzy string matching
+  class FuzzyOp < Treetop::Runtime::SyntaxNode
+  end
+  
+  class BoostOp < Treetop::Runtime::SyntaxNode
+  end
+  
+  class FuzzyParam < Treetop::Runtime::SyntaxNode
+  end
+  
+  class UnaryOp < Treetop::Runtime::SyntaxNode
+    def match( item )
+      self.elements[0].match(
+        self.elements[1].match(item)
+      )
+    end
+  end
+  
+  class NotOperator < Treetop::Runtime::SyntaxNode
+    def match( cond )
+      not cond
+    end
+  end
+  
+  class RequiredOperator < Treetop::Runtime::SyntaxNode
+  end
+  
+  class ProhibitedOperator < Treetop::Runtime::SyntaxNode
+  end
+  
+  class Phrase < Treetop::Runtime::SyntaxNode
+    # a quoted ::Term
+    def match( value )
+      self.elements[0].match(value)
+    end
+  end
+end
+
+class Query
+  # initialize the parser by using the grammar shipped with chef
+  @@grammar = File.join(Chef::SolrQuery::QueryTransform.base_path, "lucene.treetop")
+  Treetop.load(@@grammar)
+  @@parser = LuceneParser.new
+
+  def self.parse(data)
+    # parse the query into a query tree
+    if data.nil?
+      data = "*:*"
+    end
+    tree = @@parser.parse(data)
+    if tree.nil?
+      msg = "Parse error at offset: #{@@parser.index}\n"
+      msg += "Reason: #{@@parser.failure_reason}"
+      raise "Query #{data} is not supported: #{msg}"
+    end
+    self.clean_tree(tree)
+    tree
+  end
+  
+  private
+
+  def self.clean_tree(root_node)
+    # remove all SyntaxNode elements from the tree, we don't need them as
+    # the related ruby class already knowns what to do.
+    return if root_node.elements.nil?
+    root_node.elements.delete_if do |node|
+      node.class.name == "Treetop::Runtime::SyntaxNode"
+    end
+    root_node.elements.each { |node| self.clean_tree(node) }
+  end
+end
+

data/lib/chef/knife/patches/search_patch.rb

@@ -0,0 +1,81 @@
+#
+# Copyright 2011, edelight GmbH
+#
+# Authors:
+#       Markus Korn <markus.korn@edelight.de>
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+if Chef::Config[:solo]
+  
+  if (defined? require_relative).nil?
+    # defenition of 'require_relative' for ruby < 1.9, found on stackoverflow.com
+    def require_relative(relative_feature)
+      c = caller.first
+      fail "Can't parse #{c}" unless c.rindex(/:\d+(:in `.*')?$/)
+      file = $`
+      if /\A\((.*)\)/ =~ file # eval, etc.
+        raise LoadError, "require_relative is called in #{$1}"
+      end
+      absolute = File.expand_path(relative_feature, File.dirname(file))
+      require absolute
+    end
+  end
+  
+  require_relative 'parser.rb'
+  
+  class Chef
+    class Recipe
+      
+      # Overwrite the search method of recipes to operate locally by using
+      # data found in data_bags.
+      # Only very basic lucene syntax is supported and also sorting the result
+      # is not implemented, if this search method does not support a given query
+      # an exception is raised.
+      # This search() method returns a block iterator or an Array, depending
+      # on how this method is called.
+      def search(bag_name, query=nil, sort=nil, start=0, rows=1000, &block)
+        if !sort.nil?
+          raise "Sorting search results is not supported"
+        end
+        @_query = Query.parse(query)
+        if @_query.nil?
+          raise "Query #{query} is not supported"
+        end
+        if block_given?
+          pos = 0
+        else
+          result = []
+        end
+        data_bag(bag_name.to_s).each do |bag_item_id|
+          bag_item = data_bag_item(bag_name.to_s, bag_item_id)
+          if @_query.match(bag_item)
+            if block_given?
+              if (pos >= start and pos < (start + rows))
+                yield bag_item
+              end
+              pos += 1
+            else
+              result << bag_item
+            end
+          end
+        end
+        if !block_given?
+          return result.slice(start, rows)
+        end
+      end
+    end
+  end
+
+end

data/lib/chef/knife/prepare.rb

@@ -0,0 +1,39 @@
+require 'chef/knife'
+require 'knife-solo/ssh_command'
+require 'knife-solo/kitchen_command'
+require 'knife-solo/bootstraps'
+
+class Chef
+  class Knife
+    # Approach ported from littlechef (https://github.com/tobami/littlechef)
+    # Copyright 2010, 2011, Miquel Torres <tobami@googlemail.com>
+    class Prepare < Knife
+      include KnifeSolo::SshCommand
+      include KnifeSolo::KitchenCommand
+
+      banner "knife prepare [user@]hostname (options)"
+
+      def run
+        super
+        bootstrap.bootstrap!
+        generate_node_config
+      end
+
+      def bootstrap
+        KnifeSolo::Bootstraps.class_for_operating_system(operating_system()).new(self)
+      end
+
+      def generate_node_config
+        File.open(node_config, 'w') do |f|
+          f.print <<-JSON.gsub(/^\s+/, '')
+            { "run_list": [] }
+          JSON
+        end unless node_config.exist?
+      end
+
+      def operating_system
+        @operating_system ||= run_command('uname -s').stdout.strip
+      end
+    end
+  end
+end

data/lib/knife-solo.rb

@@ -0,0 +1 @@
+require 'knife-solo/info'

data/lib/knife-solo/bootstraps.rb

@@ -0,0 +1,95 @@
+class OperatingSystemNotSupportedError < StandardError ; end
+
+module KnifeSolo
+  module Bootstraps
+    class OperatingSystemNotImplementedError < StandardError 
+    end
+
+    def self.class_exists_for?(os_name)
+      begin
+        true if self.class_for_operating_system(os_name).class == Class
+      rescue => exception
+        false
+      end
+    end
+
+    def self.class_for_operating_system(os_name)
+      begin
+        os_class_name = os_name.gsub(/\s/,'')
+        eval("KnifeSolo::Bootstraps::#{os_class_name}")
+      rescue
+        raise OperatingSystemNotImplementedError.new("#{os_name} not implemented.  Feel free to add a bootstrap implementation in KnifeSolo::Bootstraps::#{os_class_name}")
+      end
+    end
+
+    module Delegates
+      def run_command(cmd)
+        prepare.run_command(cmd)
+      end
+
+      def ui
+        prepare.ui
+      end
+
+      def prepare
+        @prepare
+      end
+    end #Delegates
+
+    module InstallCommands
+
+      def bootstrap!
+        run_pre_bootstrap_checks()
+        send("#{distro[:type]}_install")
+      end
+
+      def distro
+        raise "implement distro detection for #{self.class.name}"
+      end
+
+      def gem_packages
+        raise "implement gem packages for #{self.class.name}"
+      end
+
+      def http_client_get_url(url)
+        "wget #{url}"
+      end
+
+      def omnibus_install
+        run_command(http_client_get_url("http://opscode.com/chef/install.sh"))
+        run_command("sudo bash install.sh")
+      end
+
+      def gem_install
+        ui.msg "Installing rubygems from source..."
+        release = "rubygems-1.8.10"
+        file = "#{release}.tgz"
+        url = "http://production.cf.rubygems.org/rubygems/#{file}"
+        run_command(http_client_get_url(url))
+        run_command("tar zxf #{file}")
+        run_command("sudo ruby #{release}/setup.rb --no-format-executable")
+        run_command("sudo rm -rf #{release} #{file}")
+        run_command("sudo gem install --no-rdoc --no-ri #{gem_packages().join(' ')}")
+      end
+    end #InstallCommands
+
+    class Base
+      include KnifeSolo::Bootstraps::Delegates
+      include KnifeSolo::Bootstraps::InstallCommands
+
+      def initialize(prepare)
+        # instance of Chef::Knife::Prepare
+        @prepare = prepare
+      end
+
+      def run_pre_bootstrap_checks ; end
+      # run right before we run #{distro[:type]}_install method
+      # barf out here if need be
+    end
+    
+  end # Bootstraps
+end
+
+
+# bootstrap classes for different OSes
+Dir[File.dirname(__FILE__) + '/bootstraps/*.rb'].each {|p| require p}

data/lib/knife-solo/bootstraps/darwin.rb

@@ -0,0 +1,38 @@
+module KnifeSolo::Bootstraps
+  class Darwin < Base
+
+    def issue
+      run_command("sw_vers -productVersion").stdout.strip
+    end
+
+    def gem_packages
+      ['chef']
+    end
+    
+    def distro
+      case issue
+      when %r{10.5}
+          {:type => 'gem', :version => 'leopard'}
+      when %r{10.6}
+          {:type => 'gem', :version => 'snow_leopard'}
+      else
+          raise "OSX version #{issue} not supported"
+      end
+    end
+
+    def has_xcode_installed?
+      result = run_command("xcodebuild -version")
+      result.success?
+    end
+
+    def http_client_get_url(url)
+      filename = url.split("/").last
+      "curl '#{url}' >> #{filename}"
+    end
+
+    def run_pre_bootstrap_checks
+      raise 'xcode not installed, which is required to do anything.  please install and run again.' unless has_xcode_installed?
+    end
+
+  end
+end

data/lib/knife-solo/bootstraps/linux.rb

@@ -0,0 +1,112 @@
+module KnifeSolo::Bootstraps
+  class Linux < Base
+
+    def issue
+      prepare.run_command("cat /etc/issue").stdout.strip || perepare.run_command("lsb_release -d -s").stdout.strip
+    end
+
+    def package_list
+      @packages.join(' ')
+    end
+
+    def gem_packages
+      ['ruby-shadow','chef']
+    end
+
+    def http_client_get_url(url)
+      "wget #{url}"
+    end
+
+    def zypper_gem_install
+      ui.msg("Installing required packages...")
+      run_command("sudo zypper --non-interactive install ruby-devel make gcc rsync")
+      gem_install
+    end
+
+    def emerge_gem_install
+      ui.msg("Installing required packages...")
+      run_command("sudo USE='-test' ACCEPT_KEYWORDS='~amd64' emerge -u chef")
+      gem_install
+    end
+
+    def add_yum_repos(repo_path)
+      repo_url = "http://rbel.co/"
+
+      tmp_file = "/tmp/rbel"
+      installed = "is already installed"
+      run_command("sudo yum -y install curl")
+      run_command("curl #{repo_url}#{repo_path} -o #{tmp_file}")
+      result = run_command("sudo rpm -Uvh #{tmp_file} && rm #{tmp_file}")
+      raise result.stderr_or_stdout unless result.success? || result.stdout.match(installed)
+    end
+
+    def yum_install
+      ui.msg("Installing required packages...")
+
+      if distro[:version] == "RHEL5"
+        repo_path = "rbel5"
+      else
+        repo_path = "rbel6"
+      end
+
+      add_yum_repos(repo_path)
+      @packages = %w(rubygem-chef rsync)
+      run_command("sudo yum -y --disablerepo=* --enablerepo=#{repo_path} install #{package_list}")
+    end
+
+    def debian_gem_install
+      ui.msg "Updating apt caches..."
+      run_command("sudo apt-get update")
+
+      ui.msg "Installing required packages..."
+      @packages = %w(ruby ruby-dev libopenssl-ruby irb
+                     build-essential wget ssl-cert rsync)
+      run_command <<-BASH
+        sudo DEBIAN_FRONTEND=noninteractive apt-get --yes install #{package_list}
+      BASH
+
+      gem_install
+    end
+
+    def distro
+      return @distro if @distro
+      @distro = case issue
+      when %r{Debian GNU/Linux 5}
+        {:type => "omnibus", :version => "lenny"}
+      when %r{Debian GNU/Linux 6}
+        {:type => "omnibus", :version => "squeeze"}
+      when %r{Debian GNU/Linux wheezy}
+        {:type => "debian_gem", :version => "wheezy"}
+      when %r{Ubuntu}
+        version = run_command("lsb_release -cs").stdout.strip
+        {:type => "debian_gem", :version => version}
+      when %r{Linaro}
+        version = run_command("lsb_release -cs").stdout.strip
+        {:type => "debian_gem", :version => version}
+      when %r{CentOS.*? 5}
+        {:type => "omnibus", :version => "RHEL5"}
+      when %r{CentOS.*? 6}
+        {:type => "omnibus", :version => "RHEL6"}
+      when %r{Red Hat Enterprise.*? 5}
+        {:type => "omnibus", :version => "RHEL5"}
+      when %r{Red Hat Enterprise.*? 6}
+        {:type => "omnibus", :version => "RHEL6"}
+      when %r{Scientific Linux.*? 5}
+        {:type => "omnibus", :version => "RHEL5"}
+      when %r{Scientific Linux.*? 6}
+        {:type => "omnibus", :version => "RHEL6"}
+      when %r{SUSE Linux Enterprise Server 11 SP1}
+        {:type => "zypper_gem", :version => "SLES11"}
+      when %r{openSUSE 11.4}
+        {:type => "zypper_gem", :version => "openSUSE"}
+      when %r{This is \\n\.\\O \(\\s \\m \\r\) \\t}
+        {:type => "emerge_gem", :version => "Gentoo"}
+      else
+        raise "Distro not recognized from looking at /etc/issue. Please fork https://github.com/matschaffer/knife-solo and add support for your distro."
+      end
+      Chef::Log.debug("Distro detection yielded: #{@distro}")
+      @distro
+    end #issue
+
+  end
+end

data/lib/knife-solo/info.rb

@@ -0,0 +1,5 @@
+module KnifeSolo
+  def self.version
+    '0.1.1'
+  end
+end

data/lib/knife-solo/kitchen_command.rb

@@ -0,0 +1,29 @@
+module KnifeSolo
+  module KitchenCommand
+    class OutOfKitchenError < StandardError
+      def message
+        "This command must be run inside a Chef solo kitchen."
+      end
+    end
+
+    def self.required_directories
+      %w(nodes roles cookbooks data_bags site-cookbooks)
+    end
+
+    def self.required_files
+      %w(solo.rb)
+    end
+
+    def self.all_requirements
+      required_files + required_directories
+    end
+
+    def run
+      raise OutOfKitchenError.new unless required_files_present?
+    end
+
+    def required_files_present?
+      KitchenCommand.all_requirements.inject(true) { |m, f| m && File.exists?(f) }
+    end
+  end
+end

data/lib/knife-solo/ssh_command.rb

@@ -0,0 +1,233 @@
+require 'pathname'
+
+module KnifeSolo
+  module SshCommand
+    def self.included(other)
+      other.instance_eval do
+        deps do
+          require 'net/ssh'
+        end
+
+        option :ssh_config,
+          :short => "-F CONFIG_FILE",
+          :long => "--ssh-config-file CONFIG_FILE",
+          :description => "Alternate location for ssh config file"
+
+        option :ssh_password,
+          :short => "-P PASSWORD",
+          :long => "--ssh-password PASSWORD",
+          :description => "The ssh password"
+
+        option :ssh_identity,
+          :short => "-i FILE",
+          :long => "--ssh-identity FILE",
+          :description => "The ssh identity file"
+
+        option :ssh_port,
+          :short => "-p PORT",
+          :long => "--ssh-port PORT",
+          :description => "The ssh port"
+
+        option :startup_script,
+          :short => "-s FILE",
+          :long => "--startup-script FILE",
+          :description => "The startup script on the remote server containing variable definitions"
+      end
+    end
+
+    def node_config
+      Pathname.new("nodes/#{host}.json")
+    end
+
+    def host_descriptor
+      return @host_descriptor if @host_descriptor
+      parts = @name_args.first.split('@')
+      @host_descriptor = {
+        :host => parts.pop,
+        :user => parts.pop
+      }
+    end
+
+    def user
+      host_descriptor[:user] || config_file_options[:user] || ENV['USER']
+    end
+
+    def host
+      host_descriptor[:host]
+    end
+
+    def ask_password
+      ui.ask("Enter the password for #{user}@#{host}: ") do |q|
+        q.echo = false
+      end
+    end
+
+    def password
+      config[:ssh_password] ||= ask_password
+    end
+
+    def try_connection
+      Net::SSH.start(host, user, connection_options) do |ssh|
+        ssh.exec!("true")
+      end
+    end
+
+    def config_file_options
+      Net::SSH::Config.for(host, config_files)
+    end
+
+    def connection_options
+      options = config_file_options
+      options[:port] = config[:ssh_port] if config[:ssh_port]
+      options[:password] = config[:ssh_password] if config[:ssh_password]
+      options[:keys] = [config[:ssh_identity]] if config[:ssh_identity]
+      options
+    end
+
+    def config_files
+      Array(config[:ssh_config] || Net::SSH::Config.default_files)
+    end
+
+    def detect_authentication_method
+      return @detected if @detected
+      begin
+        try_connection
+      rescue Errno::ETIMEDOUT
+        raise "Unable to connect to #{host}"
+      rescue Net::SSH::AuthenticationFailed
+        # Ensure the password is set or ask for it immediately
+        password
+      end
+      @detected = true
+    end
+
+    def ssh_args
+      host_arg = [user, host].compact.join('@')
+      config_arg = "-F #{config[:ssh_config]}" if config[:ssh_config]
+      ident_arg = "-i #{config[:ssh_identity]}" if config[:ssh_identity]
+      port_arg = "-p #{config[:ssh_port]}" if config[:ssh_port]
+
+      [host_arg, config_arg, ident_arg, port_arg].compact.join(' ')
+    end
+
+    def startup_script
+      config[:startup_script]
+    end
+
+    class ExecResult
+      attr_accessor :stdout, :stderr, :exit_code
+
+      def initialize
+        @stdout = ""
+        @stderr = ""
+      end
+
+      def success?
+        exit_code == 0
+      end
+
+      # Helper to use when raising exceptions since some operations
+      # (e.g., command not found) error on stdout
+      def stderr_or_stdout
+        return stderr unless stderr.empty?
+        stdout
+      end
+    end
+
+    def windows_node?
+      return @windows_node unless @windows_node.nil?
+      @windows_node = run_command('ver', :process_sudo => false).stdout =~ /Windows/i
+      Chef::Log.debug("Windows node detected") if @windows_node
+      @windows_node
+    end
+
+    def sudo_available?
+      return @sudo_available unless @sudo_available.nil?
+      @sudo_available = run_command('sudo -V', :process_sudo => false).success?
+      Chef::Log.debug("`sudo` not available on #{host}") unless @sudo_available
+      @sudo_available
+    end
+
+    def process_sudo(command)
+      if sudo_available?
+        replacement = 'sudo -p \'knife sudo password: \''
+      else
+        replacement = ''
+      end
+      command.sub(/^\s*sudo/, replacement)
+    end
+
+    def process_startup_file(command)
+      command.insert(0, "source #{startup_script} && ")
+    end
+
+    def stream_command(command)
+      run_command(command, :streaming => true)
+    end
+
+    def processed_command(command, options = {})
+      command = process_sudo(command) if options[:process_sudo]
+      command = process_startup_file(command) if startup_script
+      command
+    end
+
+    def run_command(command, options={})
+      defaults = {:process_sudo => true}
+      options = defaults.merge(options)
+
+      detect_authentication_method
+
+      Chef::Log.debug("Initial command #{command}")
+      result = ExecResult.new
+
+      command = processed_command(command, options)
+      Chef::Log.debug("Running processed command #{command}")
+
+      Net::SSH.start(host, user, connection_options) do |ssh|
+        ssh.open_channel do |channel|
+          channel.request_pty
+          channel.exec(command) do |ch, success|
+            raise "ssh.channel.exec failure" unless success
+
+            channel.on_data do |ch, data|  # stdout
+              if data =~ /^knife sudo password: /
+                ch.send_data("#{password}\n")
+              else
+                Chef::Log.debug("#{command} stdout: #{data}")
+                ui.stdout << data if options[:streaming]
+                result.stdout << data
+              end
+            end
+
+            channel.on_extended_data do |ch, type, data|
+              next unless type == 1
+              Chef::Log.debug("#{command} stderr: #{data}")
+              ui.stderr << data if options[:streaming]
+              result.stderr << data
+            end
+
+            channel.on_request("exit-status") do |ch, data|
+              result.exit_code = data.read_long
+            end
+
+          end
+          ssh.loop
+        end
+      end
+      result
+    end
+
+    # TODO:
+    # - move this to a dedicated "portability" module?
+    # - use ruby in all cases instead?
+    def run_portable_mkdir_p(folder)
+      if windows_node?
+        # no mkdir -p on windows - fake it
+        run_command %Q{ruby -e "require 'fileutils'; FileUtils.mkdir_p('#{folder}')"}
+      else
+        run_command "mkdir -p #{folder}"
+      end
+    end
+
+  end
+end

data/lib/knife-solo/tools.rb

@@ -0,0 +1,7 @@
+module KnifeSolo
+  module Tools
+    def system!(command)
+      raise "Failed to launch command #{command}" unless system(command)
+    end
+  end
+end

metadata

@@ -0,0 +1,121 @@
+--- !ruby/object:Gem::Specification
+name: jgrevich-knife-solo
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+  prerelease: 
+platform: ruby
+authors:
+- Mat Schaffer
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-04-29 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: mocha
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: chef
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.10.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.10.0
+- !ruby/object:Gem::Dependency
+  name: net-ssh
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.1.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.1.3
+description: Handles bootstrapping, running chef solo, rsyncing cookbooks etc
+email: mat@schaffer.me
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/chef/knife/cook.rb
+- lib/chef/knife/kitchen.rb
+- lib/chef/knife/patches/parser.rb
+- lib/chef/knife/patches/search_patch.rb
+- lib/chef/knife/prepare.rb
+- lib/knife-solo/bootstraps/darwin.rb
+- lib/knife-solo/bootstraps/linux.rb
+- lib/knife-solo/bootstraps.rb
+- lib/knife-solo/info.rb
+- lib/knife-solo/kitchen_command.rb
+- lib/knife-solo/ssh_command.rb
+- lib/knife-solo/tools.rb
+- lib/knife-solo.rb
+homepage: https://github.com/matschaffer/knife-solo
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: nowarning
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: A collection of knife plugins for dealing with chef solo
+test_files: []