chef 0.7.16 → 0.8.2

data/lib/chef/knife/ssh.rb

@@ -0,0 +1,170 @@
+#
+# Author:: Adam Jacob (<adam@opscode.com>)
+# Copyright:: Copyright (c) 2009 Opscode, Inc.
+# License:: Apache License, Version 2.0
+#
+# 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 'chef/knife'
+require 'chef/data_bag_item'
+
+class Chef
+  class Knife
+    class Ssh < Knife
+
+      banner "Sub-Command: ssh QUERY COMMAND (options)"
+
+      option :concurrency,
+        :short => "-C NUM",
+        :long => "--concurrency NUM",
+        :description => "The number of concurrent connections",
+        :default => nil 
+
+      option :attribute,
+        :short => "-a ATTR",
+        :long => "--attribute ATTR",
+        :description => "The attribute to use for opening the connection - default is fqdn",
+        :default => "fqdn" 
+
+      def session
+        @session ||= Net::SSH::Multi.start(:concurrent_connections => config[:concurrency])
+      end
+
+
+      def h
+        @highline ||= HighLine.new
+      end
+
+      def configure_session
+        q = Chef::Search::Query.new
+        q.search(:node, @name_args[0]) do |item|
+          data = format_for_display(item)
+          Chef::Log.debug("Adding #{data[config[:attribute]]}")
+          session.use data[config[:attribute]]
+          @longest = data[config[:attribute]].length if data[config[:attribute]].length > @longest
+        end
+      end
+
+      def fixup_sudo(command)
+        command.sub(/^sudo/, 'sudo -p \'knife sudo password: \'')
+      end
+
+      def print_data(host, data)
+        if data =~ /\n/
+          data.split(/\n/).each { |d| print_data(host, d) }
+        else
+          padding = @longest - host.length
+          print h.color(host, :cyan)
+          padding.downto(0) { print " " }
+          puts data
+        end
+      end
+
+      def ssh_command(command, subsession=nil)
+        subsession ||= session
+        command = fixup_sudo(command)
+        subsession.open_channel do |ch|
+          ch.request_pty
+          ch.exec command do |ch, success|
+            raise ArgumentError, "Cannot execute #{command}" unless success
+            ch.on_data do |ichannel, data|
+              print_data(ichannel[:host], data)
+              if data =~ /^knife sudo password: /
+                ichannel.send_data("#{get_password}\n")
+              end
+            end
+          end
+        end
+        session.loop
+      end
+
+      def get_password
+        @password ||= h.ask("Enter your password: ") { |q| q.echo = false }
+      end
+
+      # Present the prompt and read a single line from the console. It also
+      # detects ^D and returns "exit" in that case. Adds the input to the
+      # history, unless the input is empty. Loops repeatedly until a non-empty
+      # line is input.
+      def read_line
+        loop do
+          command = reader.readline("#{h.color('knife-ssh>', :bold)} ", true)
+
+          if command.nil?
+            command = "exit"
+            puts(command)
+          else
+            command.strip!
+          end
+
+          unless command.empty?
+            return command
+          end
+        end
+      end
+
+      def reader
+        Readline
+      end
+
+      def interactive
+        puts "Connected to #{h.list(session.servers_for.collect { |s| h.color(s.host, :cyan) }, :inline, " and ")}"
+        puts
+        puts "To run a command on a list of servers, do:"
+        puts "  on SERVER1 SERVER2 SERVER3; COMMAND"
+        puts "  Example: on latte foamy; echo foobar"
+        puts
+        puts "To exit interactive mode, use 'quit!'"
+        puts
+        while 1
+          command = read_line
+          case command
+          when 'quit!'
+            puts 'Bye!'
+            break
+          when /^on (.+?); (.+)$/
+            raw_list = $1.split(" ")
+            server_list = Array.new
+            session.servers.each do |session_server|
+              server_list << session_server if raw_list.include?(session_server.host) 
+            end
+            command = $2
+            ssh_command(command, session.on(*server_list))
+          else
+            ssh_command(command)
+          end
+        end
+      end
+
+      def run 
+        @longest = 0
+
+        require 'net/ssh/multi'
+        require 'readline'
+        require 'highline'
+
+        configure_session
+
+        if @name_args[1] == "interactive"
+          interactive 
+        else
+          ssh_command(@name_args[1..-1].join(" "))
+        end
+
+        session.close
+      end
+    end
+  end
+end
+

data/lib/chef/log.rb

@@ -1,6 +1,7 @@
 #
 # Author:: Adam Jacob (<adam@opscode.com>)
-# Author:: AJ Christensen (<@aj@opsocde.com>)
+# Author:: AJ Christensen (<@aj@opscode.com>)
+# Author:: Christopher Brown (<cb@opscode.com>)
 # Copyright:: Copyright (c) 2008 Opscode, Inc.
 # License:: Apache License, Version 2.0
 #
@@ -22,18 +23,39 @@ require 'mixlib/log'
 class Chef
   class Log
     extend Mixlib::Log
+    
+    class << self
+      attr_accessor :verbose
+      attr_reader :verbose_logger
+      protected :verbose_logger
+      
+      def verbose
+        !(@verbose_logger.nil?)
+      end
 
-    # This is here for compatability, before we moved to
-    # Mixlib::Log.
-    class Formatter
-      def self.show_time=(arg)
-        Mixlib::Log::Formatter.show_time = arg
+      def verbose=(value)
+        if value
+          @verbose_logger ||= Logger.new(STDOUT)
+          @verbose_logger.level = self.logger.level
+          @verbose_logger.formatter = self.logger.formatter
+        else
+          @verbose_logger = nil
+        end
+        self.verbose
       end
+      
+      def method_missing(method_symbol, *args)
+        self.verbose_logger.send(method_symbol, *args) if self.verbose
+        logger.send(method_symbol, *args)
+      end
+    end  
 
-      def self.show_time
-        Mixlib::Log::Formatter.show_time
+    class Formatter
+      def self.show_time=(*args)
+        Mixlib::Log::Formatter.show_time = *args
       end
     end
+    
   end
 end
 

data/lib/chef/mixin/checksum.rb

@@ -17,19 +17,14 @@
 #
 
 require 'digest/sha2'
+require 'chef/cache/checksum'
 
 class Chef
   module Mixin
     module Checksum
 
       def checksum(file)
-        digest = Digest::SHA256.new
-        fh = ::File.open(file)
-        fh.each do |line|
-          digest.update(line)
-        end
-        fh.close
-        digest.hexdigest
+        Chef::Cache::Checksum.checksum_for_file(file)
       end
       
     end

data/lib/chef/mixin/command.rb

@@ -39,14 +39,16 @@ class Chef
       # === Returns
       # true:: Returns true if the block is true, or if the command returns 0
       # false:: Returns false if the block is false, or if the command returns a non-zero exit code.
-      def only_if(command)
+      def only_if(command, args = {})
         if command.kind_of?(Proc)
-          res = command.call
-          unless res
-            return false
+          chdir_or_tmpdir(args[:cwd]) do
+            res = command.call
+            unless res
+              return false
+            end
           end
         else  
-          status = run_command(:command => command, :ignore_failure => true)
+          status = run_command({:command => command, :ignore_failure => true}.merge(args))
           if status.exitstatus != 0
             return false
           end
@@ -68,14 +70,16 @@ class Chef
       # === Returns
       # true:: Returns true if the block is false, or if the command returns a non-zero exit status.
       # false:: Returns false if the block is true, or if the command returns a 0 exit status.
-      def not_if(command)
+      def not_if(command, args = {})
         if command.kind_of?(Proc)
-          res = command.call
-          if res
-            return false
+          chdir_or_tmpdir(args[:cwd]) do
+            res = command.call
+            if res
+              return false
+            end
           end
         else  
-          status = run_command(:command => command, :ignore_failure => true)
+          status = run_command({:command => command, :ignore_failure => true}.merge(args))
           if status.exitstatus == 0
             return false
           end
@@ -130,7 +134,7 @@ class Chef
           stdout_string, stderr_string = stdout.string.chomp, stderr.string.chomp
         end
         
-        args[:cwd] ||= Dir.tmpdir        
+        args[:cwd] ||= Dir.tmpdir
         unless File.directory?(args[:cwd])
           raise Chef::Exceptions::Exec, "#{args[:cwd]} does not exist or is not a directory"
         end
@@ -306,6 +310,9 @@ class Chef
           begin
             if args[:waitlast]
               b[cid, *pi]
+              # send EOF so that if the child process is reading from STDIN
+              # it will actually finish up and exit
+              pi[0].close_write
               Process.waitpid2(cid).last
             else
               # This took some doing.
@@ -341,6 +348,7 @@ class Chef
                   channels_to_watch << stderr if !stderr_finished
                   ready = IO.select(channels_to_watch, nil, nil, 1.0)
                 rescue Errno::EAGAIN
+                ensure
                   results = Process.waitpid2(cid, Process::WNOHANG)
                   if results
                     stdout_finished = true
@@ -365,11 +373,11 @@ class Chef
                   end
                 end
               end
-              results = Process.waitpid2(cid).last unless results
+              results = Process.waitpid2(cid) unless results
               o.rewind
               e.rewind
               b[cid, pi[0], o, e]
-              results
+              results.last
             end
           ensure
             pi.each{|fd| fd.close unless fd.closed?}
@@ -381,6 +389,17 @@ class Chef
       
       module_function :popen4
 
+      def chdir_or_tmpdir(dir, &block)
+        dir ||= Dir.tmpdir
+        unless File.directory?(dir)
+          raise Chef::Exceptions::Exec, "#{dir} does not exist or is not a directory"
+        end
+        Dir.chdir(dir) do
+          block.call
+        end
+      end
+
+      module_function :chdir_or_tmpdir
     end
   end
 end

data/lib/chef/mixin/convert_to_class_name.rb

@@ -20,6 +20,7 @@
 class Chef
   module Mixin
     module ConvertToClassName
+      extend self
 
       def convert_to_class_name(str)
         rname = nil
@@ -38,6 +39,20 @@ class Chef
         rname
       end
       
+      def convert_to_snake_case(str, namespace=nil)
+        str = str.dup
+        str.sub!(/^#{namespace}(\:\:)?/, '') if namespace
+        str.gsub!(/[A-Z]/) {|s| "_" + s}
+        str.downcase!
+        str.sub!(/^\_/, "")
+        str
+      end
+      
+      def snake_case_basename(str)
+        with_namespace = convert_to_snake_case(str)
+        with_namespace.split("::").last.sub(/^_/, '')
+      end
+      
       def filename_to_qualified_string(base, filename)
         file_base = File.basename(filename, ".rb")
         base.to_s + (file_base == 'default' ? '' : "_#{file_base}")

data/lib/chef/mixin/deep_merge.rb

@@ -1,6 +1,8 @@
 #
 # Author:: Adam Jacob (<adam@opscode.com>)
+# Author:: Steve Midgley (http://www.misuse.org/science)
 # Copyright:: Copyright (c) 2009 Opscode, Inc.
+# Copyright:: Copyright (c) 2008 Steve Midgley
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -15,22 +17,208 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+# Notice:
+# This code is imported from deep_merge by Steve Midgley. deep_merge is
+# available under the MIT license from
+# http://trac.misuse.org/science/wiki/DeepMerge
+
 class Chef
   module Mixin
-    class DeepMerge
+    module DeepMerge
       def self.merge(first, second)
-        first = Mash.new(first).to_hash unless second.kind_of?(Mash)
-        first = first.to_hash
-        second = Mash.new(second).to_hash unless second.kind_of?(Mash)
-        second = second.to_hash
-        # Originally From: http://www.ruby-forum.com/topic/142809
-        # Author: Stefan Rusterholz
-        merger = proc do |key,v1,v2| 
-            v1.respond_to?(:keys) && v2.respond_to?(:keys) ? v1.merge(v2, &merger) : v2 
-          end
+        first  = Mash.new(first)  unless first.kind_of?(Mash)
+        second = Mash.new(second) unless second.kind_of?(Mash)
 
-        Mash.new(first.merge(second, &merger))
+        DeepMerge.deep_merge!(second, first, {:knockout_prefix => "!merge:", :preserve_unmergeables => false})
+      end
+    
+      class InvalidParameter < StandardError; end
+      
+      DEFAULT_FIELD_KNOCKOUT_PREFIX = '--' unless defined?(DEFAULT_FIELD_KNOCKOUT_PREFIX)
+     
+      # Deep Merge core documentation.
+      # deep_merge! method permits merging of arbitrary child elements. The two top level
+      # elements must be hashes. These hashes can contain unlimited (to stack limit) levels
+      # of child elements. These child elements to not have to be of the same types.
+      # Where child elements are of the same type, deep_merge will attempt to merge them together.
+      # Where child elements are not of the same type, deep_merge will skip or optionally overwrite
+      # the destination element with the contents of the source element at that level.
+      # So if you have two hashes like this:
+      #   source = {:x => [1,2,3], :y => 2}
+      #   dest =   {:x => [4,5,'6'], :y => [7,8,9]}
+      #   dest.deep_merge!(source)
+      #   Results: {:x => [1,2,3,4,5,'6'], :y => 2}
+      # By default, "deep_merge!" will overwrite any unmergeables and merge everything else.
+      # To avoid this, use "deep_merge" (no bang/exclamation mark)
+      # 
+      # Options:
+      #   Options are specified in the last parameter passed, which should be in hash format:
+      #   hash.deep_merge!({:x => [1,2]}, {:knockout_prefix => '--'})
+      #   :preserve_unmergeables  DEFAULT: false
+      #      Set to true to skip any unmergeable elements from source
+      #   :knockout_prefix        DEFAULT: nil
+      #      Set to string value to signify prefix which deletes elements from existing element
+      #   :sort_merged_arrays     DEFAULT: false
+      #      Set to true to sort all arrays that are merged together
+      #   :unpack_arrays          DEFAULT: nil
+      #      Set to string value to run "Array::join" then "String::split" against all arrays
+      #   :merge_debug            DEFAULT: false
+      #      Set to true to get console output of merge process for debugging
+      #
+      # Selected Options Details:
+      # :knockout_prefix => The purpose of this is to provide a way to remove elements 
+      #   from existing Hash by specifying them in a special way in incoming hash
+      #    source = {:x => ['--1', '2']}
+      #    dest   = {:x => ['1', '3']}
+      #    dest.ko_deep_merge!(source)
+      #    Results: {:x => ['2','3']}
+      #   Additionally, if the knockout_prefix is passed alone as a string, it will cause
+      #   the entire element to be removed:
+      #    source = {:x => '--'}
+      #    dest   = {:x => [1,2,3]}
+      #    dest.ko_deep_merge!(source)
+      #    Results: {:x => ""}
+      # :unpack_arrays => The purpose of this is to permit compound elements to be passed
+      #   in as strings and to be converted into discrete array elements
+      #   irsource = {:x => ['1,2,3', '4']}
+      #   dest   = {:x => ['5','6','7,8']}
+      #   dest.deep_merge!(source, {:unpack_arrays => ','})
+      #   Results: {:x => ['1','2','3','4','5','6','7','8'}
+      #   Why: If receiving data from an HTML form, this makes it easy for a checkbox 
+      #    to pass multiple values from within a single HTML element
+      # 
+      # There are many tests for this library - and you can learn more about the features
+      # and usages of deep_merge! by just browsing the test examples
+      def self.deep_merge!(source, dest, options = {})
+        # turn on this line for stdout debugging text
+        merge_debug = options[:merge_debug] || false
+        overwrite_unmergeable = !options[:preserve_unmergeables]
+        knockout_prefix = options[:knockout_prefix] || nil
+        raise InvalidParameter, "knockout_prefix cannot be an empty string in deep_merge!" if knockout_prefix == ""
+        raise InvalidParameter, "overwrite_unmergeable must be true if knockout_prefix is specified in deep_merge!" if knockout_prefix && !overwrite_unmergeable
+        # if present: we will split and join arrays on this char before merging
+        array_split_char = options[:unpack_arrays] || false
+        # request that we sort together any arrays when they are merged
+        sort_merged_arrays = options[:sort_merged_arrays] || false
+        di = options[:debug_indent] || ''
+        # do nothing if source is nil
+        return dest if source.nil?
+        # if dest doesn't exist, then simply copy source to it
+        if dest.nil? && overwrite_unmergeable
+          dest = source; return dest
+        end
+     
+        puts "#{di}Source class: #{source.class.inspect} :: Dest class: #{dest.class.inspect}" if merge_debug
+        if source.kind_of?(Hash)
+          puts "#{di}Hashes: #{source.inspect} :: #{dest.inspect}" if merge_debug
+          source.each do |src_key, src_value|
+            if dest.kind_of?(Hash)
+              puts "#{di} looping: #{src_key.inspect} => #{src_value.inspect} :: #{dest.inspect}" if merge_debug
+              if dest[src_key]
+                puts "#{di} ==>merging: #{src_key.inspect} => #{src_value.inspect} :: #{dest[src_key].inspect}" if merge_debug
+                dest[src_key] = deep_merge!(src_value, dest[src_key], options.merge(:debug_indent => di + '  '))
+              else # dest[src_key] doesn't exist so we want to create and overwrite it (but we do this via deep_merge!)
+                puts "#{di} ==>merging over: #{src_key.inspect} => #{src_value.inspect}" if merge_debug
+                # note: we rescue here b/c some classes respond to "dup" but don't implement it (Numeric, TrueClass, FalseClass, NilClass among maybe others)
+                begin
+                  src_dup = src_value.dup # we dup src_value if possible because we're going to merge into it (since dest is empty)
+                rescue TypeError
+                  src_dup = src_value
+                end
+                dest[src_key] = deep_merge!(src_value, src_dup, options.merge(:debug_indent => di + '  '))
+              end
+            else # dest isn't a hash, so we overwrite it completely (if permitted)
+              if overwrite_unmergeable
+                puts "#{di}  overwriting dest: #{src_key.inspect} => #{src_value.inspect} -over->  #{dest.inspect}" if merge_debug
+                dest = overwrite_unmergeables(source, dest, options)
+              end
+            end
+          end
+        elsif source.kind_of?(Array)
+          puts "#{di}Arrays: #{source.inspect} :: #{dest.inspect}" if merge_debug
+          # if we are instructed, join/split any source arrays before processing
+          if array_split_char
+            puts "#{di} split/join on source: #{source.inspect}" if merge_debug
+            source = source.join(array_split_char).split(array_split_char)
+            if dest.kind_of?(Array)
+              dest = dest.join(array_split_char).split(array_split_char)
+            end
+          end
+          # if there's a naked knockout_prefix in source, that means we are to truncate dest
+          if source.index(knockout_prefix)
+            dest = clear_or_nil(dest); source.delete(knockout_prefix)
+          end
+          if dest.kind_of?(Array)
+            if knockout_prefix
+              print "#{di} knocking out: " if merge_debug
+              # remove knockout prefix items from both source and dest
+              source.delete_if do |ko_item|
+                retval = false
+                item = ko_item.respond_to?(:gsub) ? ko_item.gsub(%r{^#{knockout_prefix}}, "") : ko_item
+                if item != ko_item
+                  print "#{ko_item} - " if merge_debug
+                  dest.delete(item)
+                  dest.delete(ko_item)
+                  retval = true
+                end
+                retval
+              end
+              puts if merge_debug
+            end
+            puts "#{di} merging arrays: #{source.inspect} :: #{dest.inspect}" if merge_debug
+            dest = dest | source
+            dest.sort! if sort_merged_arrays
+          elsif overwrite_unmergeable
+            puts "#{di} overwriting dest: #{source.inspect} -over-> #{dest.inspect}" if merge_debug
+            dest = overwrite_unmergeables(source, dest, options)
+          end
+        else # src_hash is not an array or hash, so we'll have to overwrite dest
+          puts "#{di}Others: #{source.inspect} :: #{dest.inspect}" if merge_debug
+          dest = overwrite_unmergeables(source, dest, options)
+        end
+        puts "#{di}Returning #{dest.inspect}" if merge_debug
+        dest
+      end # deep_merge!
+     
+      # allows deep_merge! to uniformly handle overwriting of unmergeable entities
+      def self.overwrite_unmergeables(source, dest, options)
+        merge_debug = options[:merge_debug] || false
+        overwrite_unmergeable = !options[:preserve_unmergeables]
+        knockout_prefix = options[:knockout_prefix] || false
+        di = options[:debug_indent] || ''
+        if knockout_prefix && overwrite_unmergeable
+          if source.kind_of?(String) # remove knockout string from source before overwriting dest
+            src_tmp = source.gsub(%r{^#{knockout_prefix}},"")
+          elsif source.kind_of?(Array) # remove all knockout elements before overwriting dest
+            src_tmp = source.delete_if {|ko_item| ko_item.kind_of?(String) && ko_item.match(%r{^#{knockout_prefix}}) }
+          else
+            src_tmp = source
+          end
+          if src_tmp == source # if we didn't find a knockout_prefix then we just overwrite dest
+            puts "#{di}#{src_tmp.inspect} -over-> #{dest.inspect}" if merge_debug
+            dest = src_tmp
+          else # if we do find a knockout_prefix, then we just delete dest
+            puts "#{di}\"\" -over-> #{dest.inspect}" if merge_debug
+            dest = ""
+          end
+        elsif overwrite_unmergeable
+          dest = source
+        end
+        dest
       end
+     
+      def self.clear_or_nil(obj)
+        if obj.respond_to?(:clear)
+          obj.clear
+        else
+          obj = nil
+        end
+        obj
+      end
+     
     end
+     
   end
 end
+
+