chef 11.4.4 → 11.6.0.hotfix.1

data/lib/chef/knife/node_run_list_set.rb

@@ -0,0 +1,66 @@
+#
+# Author:: Mike Fiedler (<miketheman@gmail.com>)
+# Copyright:: Copyright (c) 2013 Mike Fiedler
+# 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'
+
+class Chef
+  class Knife
+    class NodeRunListSet < Knife
+
+      deps do
+        require 'chef/node'
+        require 'chef/json_compat'
+      end
+
+      banner "knife node run_list set NODE ENTRIES (options)"
+
+      def run
+        if @name_args.size < 2
+          ui.fatal "You must supply both a node name and a run list."
+          show_usage
+          exit 1
+        elsif @name_args.size > 2
+          # Check for nested lists and create a single plain one
+          entries = @name_args[1..-1].map do |entry|
+            entry.split(',').map { |e| e.strip }
+          end.flatten
+        else
+          # Convert to array and remove the extra spaces
+          entries = @name_args[1].split(',').map { |e| e.strip }
+        end
+        node = Chef::Node.load(@name_args[0])
+
+        set_run_list(node, entries)
+
+        node.save
+
+        config[:run_list] = true
+
+        output(format_for_display(node))
+      end
+
+      # Clears out any existing run_list_items and sets them to the
+      # specified entries
+      def set_run_list(node, entries)
+        node.run_list.run_list_items.clear
+        entries.each { |e| node.run_list << e }
+      end
+
+    end
+  end
+end

data/lib/chef/knife/node_show.rb

@@ -24,6 +24,7 @@ class Chef
     class NodeShow < Knife
 
       include Knife::Core::NodeFormattingOptions
+      include Knife::Core::MultiAttributeReturnOption
 
       deps do
         require 'chef/node'
@@ -32,13 +33,6 @@ class Chef
 
       banner "knife node show NODE (options)"
 
-      @attrs_to_show = []
-      option :attribute,
-        :short => "-a [ATTR]",
-        :long => "--attribute [ATTR]",
-        :proc => lambda {|val| @attrs_to_show << val},
-        :description => "Show one or more attributes"
-
       option :run_list,
         :short => "-r",
         :long => "--run-list",

data/lib/chef/knife/raw.rb

@@ -1,21 +1,28 @@
-require 'json'
+require 'chef/knife'
 
 class Chef
   class Knife
     class Raw < Chef::Knife
       banner "knife raw REQUEST_PATH"
 
+      deps do
+        require 'json'
+        require 'chef/rest'
+        require 'chef/config'
+        require 'chef/chef_fs/raw_request'
+      end
+
       option :method,
         :long => '--method METHOD',
         :short => '-m METHOD',
         :default => "GET",
-        :description => "Request method (GET, POST, PUT or DELETE)"
+        :description => "Request method (GET, POST, PUT or DELETE).  Default: GET"
 
       option :pretty,
         :long => '--[no-]pretty',
         :boolean => true,
         :default => true,
-        :description => "Pretty-print JSON output"
+        :description => "Pretty-print JSON output.  Default: true"
 
       option :input,
         :long => '--input FILE',
@@ -39,70 +46,19 @@ class Chef
           data = IO.read(config[:input])
         end
         chef_rest = Chef::REST.new(Chef::Config[:chef_server_url])
-        puts api_request(chef_rest, config[:method].to_sym, chef_rest.create_url(name_args[0]), {}, data)
-      end
-
-      ACCEPT_ENCODING = "Accept-Encoding".freeze
-      ENCODING_GZIP_DEFLATE = "gzip;q=1.0,deflate;q=0.6,identity;q=0.3".freeze
-
-      def redirected_to(response)
-        return nil  unless response.kind_of?(Net::HTTPRedirection)
-        # Net::HTTPNotModified is undesired subclass of Net::HTTPRedirection so test for this
-        return nil  if response.kind_of?(Net::HTTPNotModified)
-        response['location']
-      end
-
-      def api_request(chef_rest, method, url, headers={}, data=false)
-        json_body = data
-#        json_body = data ? Chef::JSONCompat.to_json(data) : nil
-        # Force encoding to binary to fix SSL related EOFErrors
-        # cf. http://tickets.opscode.com/browse/CHEF-2363
-        # http://redmine.ruby-lang.org/issues/5233
-#        json_body.force_encoding(Encoding::BINARY) if json_body.respond_to?(:force_encoding)
-        headers = build_headers(chef_rest, method, url, headers, json_body)
-
-        chef_rest.retriable_rest_request(method, url, json_body, headers) do |rest_request|
-          response = rest_request.call {|r| r.read_body}
-
-          response_body = chef_rest.decompress_body(response)
-
-          if response.kind_of?(Net::HTTPSuccess)
-            if config[:pretty] && response['content-type'] =~ /json/
-              JSON.pretty_generate(JSON.parse(response_body, :create_additions => false))
-            else
-              response_body
-            end
-          elsif redirect_location = redirected_to(response)
-            raise "Redirected to #{create_url(redirect_location)}"
-            follow_redirect {api_request(:GET, create_url(redirect_location))}
-          else
-            # have to decompress the body before making an exception for it. But the body could be nil.
-            response.body.replace(chef_rest.decompress_body(response)) if response.body.respond_to?(:replace)
-
-            if response['content-type'] =~ /json/
-              exception = response_body
-              msg = "HTTP Request Returned #{response.code} #{response.message}: "
-              msg << (exception["error"].respond_to?(:join) ? exception["error"].join(", ") : exception["error"].to_s)
-              Chef::Log.info(msg)
-            end
-            puts response.body
-            response.error!
-          end
+        begin
+          output Chef::ChefFS::RawRequest.api_request(chef_rest, config[:method].to_sym, chef_rest.create_url(name_args[0]), {}, data)
+        rescue Timeout::Error => e
+          ui.error "Server timeout"
+          exit 1
+        rescue Net::HTTPServerException => e
+          ui.error "Server responded with error #{e.response.code} \"#{e.response.message}\""
+          ui.error "Error Body: #{e.response.body}" if e.response.body && e.response.body != ''
+          exit 1
         end
       end
 
-      def build_headers(chef_rest, method, url, headers={}, json_body=false, raw=false)
-#        headers                 = @default_headers.merge(headers)
-        #headers['Accept']       = "application/json" unless raw
-        headers['Accept']       = "application/json" unless raw
-        headers["Content-Type"] = 'application/json' if json_body
-        headers['Content-Length'] = json_body.bytesize.to_s if json_body
-        headers[Chef::REST::RESTRequest::ACCEPT_ENCODING] = Chef::REST::RESTRequest::ENCODING_GZIP_DEFLATE
-        headers.merge!(chef_rest.authentication_headers(method, url, json_body)) if chef_rest.sign_requests?
-        headers.merge!(Chef::Config[:custom_http_headers]) if Chef::Config[:custom_http_headers]
-        headers
-      end
-    end
+    end # class Raw
   end
 end
 

data/lib/chef/knife/role_show.rb

@@ -22,6 +22,8 @@ class Chef
   class Knife
     class RoleShow < Knife
 
+      include Knife::Core::MultiAttributeReturnOption
+
       deps do
         require 'chef/node'
         require 'chef/json_compat'
@@ -29,10 +31,6 @@ class Chef
 
       banner "knife role show ROLE (options)"
 
-      option :attribute,
-        :short => "-a ATTR",
-        :long => "--attribute ATTR",
-        :description => "Show only one attribute"
 
       def run
         @role_name = @name_args[0]

data/lib/chef/knife/search.rb

@@ -23,6 +23,8 @@ class Chef
   class Knife
     class Search < Knife
 
+      include Knife::Core::MultiAttributeReturnOption
+
       deps do
         require 'chef/node'
         require 'chef/environment'
@@ -54,11 +56,6 @@ class Chef
         :default => 1000,
         :proc => lambda { |i| i.to_i }
 
-      option :attribute,
-        :short => "-a ATTR",
-        :long => "--attribute ATTR",
-        :description => "Show only one attribute"
-
       option :run_list,
         :short => "-r",
         :long => "--run-list",
@@ -114,7 +111,9 @@ class Chef
           ui.msg("\n")
           result_items.each do |item|
             output(item)
-            ui.msg("\n")
+            unless config[:id_only]
+              ui.msg("\n")
+            end
           end
         end
       end

data/lib/chef/knife/show.rb

@@ -1,30 +1,53 @@
 require 'chef/chef_fs/knife'
-require 'chef/chef_fs/file_system'
 
 class Chef
   class Knife
     class Show < Chef::ChefFS::Knife
       banner "knife show [PATTERN1 ... PATTERNn]"
 
-      common_options
+      deps do
+        require 'chef/chef_fs/file_system'
+        require 'chef/chef_fs/file_system/not_found_error'
+      end
+
+      option :local,
+        :long => '--local',
+        :boolean => true,
+        :description => "Show local files instead of remote"
 
       def run
         # Get the matches (recursively)
-        pattern_args.each do |pattern|
-          Chef::ChefFS::FileSystem.list(chef_fs, pattern) do |result|
-            if result.dir?
-              STDERR.puts "#{result.path_for_printing}: is a directory" if pattern.exact_path
+        error = false
+        entry_values = parallelize(pattern_args, :flatten => true) do |pattern|
+          parallelize(Chef::ChefFS::FileSystem.list(config[:local] ? local_fs : chef_fs, pattern)) do |entry|
+            if entry.dir?
+              ui.error "#{format_path(entry)}: is a directory" if pattern.exact_path
+              error = true
+              nil
             else
               begin
-                value = result.read
-                puts "#{result.path_for_printing}:"
-                output(format_for_display(value))
-              rescue Chef::ChefFS::FileSystem::NotFoundError
-                STDERR.puts "#{result.path_for_printing}: No such file or directory"
+                [entry, entry.read]
+              rescue Chef::ChefFS::FileSystem::OperationNotAllowedError => e
+                ui.error "#{format_path(e.entry)}: #{e.reason}."
+                error = true
+                nil
+              rescue Chef::ChefFS::FileSystem::NotFoundError => e
+                ui.error "#{format_path(e.entry)}: No such file or directory"
+                error = true
+                nil
               end
             end
           end
         end
+        entry_values.each do |entry, value|
+          if entry
+            output "#{format_path(entry)}:"
+            output(format_for_display(value))
+          end
+        end
+        if error
+          exit 1
+        end
       end
     end
   end

data/lib/chef/knife/ssh.rb

@@ -25,6 +25,7 @@ class Chef
       deps do
         require 'net/ssh'
         require 'net/ssh/multi'
+        require 'chef/monkey_patches/net-ssh-multi'
         require 'readline'
         require 'chef/exceptions'
         require 'chef/search/query'
@@ -80,6 +81,12 @@ class Chef
         :description => "The ssh gateway",
         :proc => Proc.new { |key| Chef::Config[:knife][:ssh_gateway] = key.strip }
 
+      option :forward_agent,
+        :short => "-A",
+        :long => "--forward-agent",
+        :description => "Enable SSH agent forwarding",
+        :boolean => true
+
       option :identity_file,
         :short => "-i IDENTITY_FILE",
         :long => "--identity-file IDENTITY_FILE",
@@ -182,6 +189,7 @@ class Chef
           session_opts[:keys] = File.expand_path(config[:identity_file]) if config[:identity_file]
           session_opts[:keys_only] = true if config[:identity_file]
           session_opts[:password] = config[:ssh_password] if config[:ssh_password]
+          session_opts[:forward_agent] = config[:forward_agent]
           session_opts[:port] = config[:ssh_port] || Chef::Config[:knife][:ssh_port] || ssh_config[:port]
           session_opts[:logger] = Chef::Log.logger if Chef::Log.level == :debug
 

data/lib/chef/knife/upload.rb

@@ -1,12 +1,13 @@
 require 'chef/chef_fs/knife'
-require 'chef/chef_fs/command_line'
 
 class Chef
   class Knife
     class Upload < Chef::ChefFS::Knife
       banner "knife upload PATTERNS"
 
-      common_options
+      deps do
+        require 'chef/chef_fs/command_line'
+      end
 
       option :recurse,
         :long => '--[no-]recurse',
@@ -24,7 +25,13 @@ class Chef
         :long => '--[no-]force',
         :boolean => true,
         :default => false,
-        :description => "Force upload of files even if they match (quicker and harmless, but doesn't print out what it changed)"
+        :description => "Force upload of files even if they match (quicker for many files).  Will overwrite frozen cookbooks."
+
+      option :freeze,
+        :long => '--[no-]freeze',
+        :boolean => true,
+        :default => false,
+        :description => "Freeze cookbooks that get uploaded."
 
       option :dry_run,
         :long => '--dry-run',
@@ -33,6 +40,12 @@ class Chef
         :default => false,
         :description => "Don't take action, only print what would happen"
 
+      option :diff,
+        :long => '--[no-]diff',
+        :boolean => true,
+        :default => true,
+        :description => 'Turn off to avoid uploading existing files; only new (and possibly deleted) files with --no-diff'
+
       def run
         if name_args.length == 0
           show_usage
@@ -40,8 +53,14 @@ class Chef
           exit 1
         end
 
+        error = false
         pattern_args.each do |pattern|
-          Chef::ChefFS::FileSystem.copy_to(pattern, local_fs, chef_fs, config[:recurse] ? nil : 1, config)
+          if Chef::ChefFS::FileSystem.copy_to(pattern, local_fs, chef_fs, config[:recurse] ? nil : 1, config, ui, proc { |entry| format_path(entry) })
+            error = true
+          end
+        end
+        if error
+          exit 1
         end
       end
     end

data/lib/chef/knife/user_show.rb

@@ -22,6 +22,8 @@ class Chef
   class Knife
     class UserShow < Knife
 
+      include Knife::Core::MultiAttributeReturnOption
+
       deps do
         require 'chef/user'
         require 'chef/json_compat'
@@ -29,11 +31,6 @@ class Chef
 
       banner "knife user show USER (options)"
 
-      option :attribute,
-        :short => "-a ATTR",
-        :long => "--attribute ATTR",
-        :description => "Show only one attribute"
-
       def run
         @user_name = @name_args[0]
 

data/lib/chef/knife/xargs.rb

@@ -0,0 +1,265 @@
+require 'chef/chef_fs/knife'
+
+class Chef
+  class Knife
+    class Xargs < Chef::ChefFS::Knife
+      banner "knife xargs [COMMAND]"
+
+      deps do
+        require 'chef/chef_fs/file_system'
+        require 'chef/chef_fs/file_system/not_found_error'
+      end
+
+      # TODO modify to remote-only / local-only pattern (more like delete)
+      option :local,
+        :long => '--local',
+        :boolean => true,
+        :description => "Xargs local files instead of remote"
+
+      option :patterns,
+        :long => '--pattern [PATTERN]',
+        :short => '-p [PATTERN]',
+        :description => "Pattern on command line (if these are not specified, a list of patterns is expected on standard input).  Multiple patterns may be passed in this way.",
+        :arg_arity => [1,-1]
+
+      option :diff,
+        :long => '--[no-]diff',
+        :default => true,
+        :boolean => true,
+        :description => "Whether to show a diff when files change (default: true)"
+
+      option :dry_run,
+        :long => '--dry-run',
+        :boolean => true,
+        :description => "Prevents changes from actually being uploaded to the server."
+
+      option :force,
+        :long => '--[no-]force',
+        :boolean => true,
+        :default => false,
+        :description => "Force upload of files even if they are not changed (quicker and harmless, but doesn't print out what it changed)"
+
+      option :replace_first,
+        :long => '--replace-first REPLACESTR',
+        :short => '-J REPLACESTR',
+        :description => "String to replace with filenames.  -J will only replace the FIRST occurrence of the replacement string."
+
+      option :replace_all,
+        :long => '--replace REPLACESTR',
+        :short => '-I REPLACESTR',
+        :description => "String to replace with filenames.  -I will replace ALL occurrence of the replacement string."
+
+      option :max_arguments_per_command,
+        :long => '--max-args MAXARGS',
+        :short => '-n MAXARGS',
+        :description => "Maximum number of arguments per command line."
+
+      option :max_command_line,
+        :long => '--max-chars LENGTH',
+        :short => '-s LENGTH',
+        :description => "Maximum size of command line, in characters"
+
+      option :verbose_commands,
+        :short => '-t',
+        :description => "Print command to be run on the command line"
+
+      option :null_separator,
+        :short => '-0',
+        :boolean => true,
+        :description => "Use the NULL character (\0) as a separator, instead of whitespace"
+
+      def run
+        error = false
+        # Get the matches (recursively)
+        files = []
+        pattern_args_from(get_patterns).each do |pattern|
+          Chef::ChefFS::FileSystem.list(config[:local] ? local_fs : chef_fs, pattern).each do |result|
+            if result.dir?
+              # TODO option to include directories
+              ui.warn "#{format_path(result)}: is a directory.  Will not run #{command} on it."
+            else
+              files << result
+              ran = false
+
+              # If the command would be bigger than max command line, back it off a bit
+              # and run a slightly smaller command (with one less arg)
+              if config[:max_command_line]
+                command, tempfiles = create_command(files)
+                begin
+                  if command.length > config[:max_command_line].to_i
+                    if files.length > 1
+                      command, tempfiles_minus_one = create_command(files[0..-2])
+                      begin
+                        error = true if xargs_files(command, tempfiles_minus_one)
+                        files = [ files[-1] ]
+                        ran = true
+                      ensure
+                        destroy_tempfiles(tempfiles)
+                      end
+                    else
+                      error = true if xargs_files(command, tempfiles)
+                      files = [ ]
+                      ran = true
+                    end
+                  end
+                ensure
+                  destroy_tempfiles(tempfiles)
+                end
+              end
+
+              # If the command has hit the limit for the # of arguments, run it
+              if !ran && config[:max_arguments_per_command] && files.size >= config[:max_arguments_per_command].to_i
+                command, tempfiles = create_command(files)
+                begin
+                  error = true if xargs_files(command, tempfiles)
+                  files = []
+                  ran = true
+                ensure
+                  destroy_tempfiles(tempfiles)
+                end
+              end
+            end
+          end
+        end
+
+        # Any leftovers commands shall be run
+        if files.size > 0
+          command, tempfiles = create_command(files)
+          begin
+            error = true if xargs_files(command, tempfiles)
+          ensure
+            destroy_tempfiles(tempfiles)
+          end
+        end
+
+        if error
+          exit 1
+        end
+      end
+
+      def get_patterns
+        if config[:patterns]
+          [ config[:patterns] ].flatten
+        elsif config[:null_separator]
+          stdin.binmode
+          stdin.read.split("\000")
+        else
+          stdin.read.split(/\s+/)
+        end
+      end
+
+      def create_command(files)
+        command = name_args.join(' ')
+
+        # Create the (empty) tempfiles
+        tempfiles = {}
+        begin
+          # Create the temporary files
+          files.each do |file|
+            tempfile = Tempfile.new(file.name)
+            tempfiles[tempfile] = { :file => file }
+          end
+        rescue
+          destroy_tempfiles(files)
+          raise
+        end
+
+        # Create the command
+        paths = tempfiles.keys.map { |tempfile| tempfile.path }.join(' ')
+        if config[:replace_all]
+          final_command = command.gsub(config[:replace_all], paths)
+        elsif config[:replace_first]
+          final_command = command.sub(config[:replace_first], paths)
+        else
+          final_command = "#{command} #{paths}"
+        end
+
+        [final_command, tempfiles]
+      end
+
+      def destroy_tempfiles(tempfiles)
+        # Unlink the files now that we're done with them
+        tempfiles.keys.each { |tempfile| tempfile.close! }
+      end
+
+      def xargs_files(command, tempfiles)
+        error = false
+        # Create the temporary files
+        tempfiles.each_pair do |tempfile, file|
+          begin
+            value = file[:file].read
+            file[:value] = value
+            tempfile.open
+            tempfile.write(value)
+            tempfile.close
+          rescue Chef::ChefFS::FileSystem::OperationNotAllowedError => e
+            ui.error "#{format_path(e.entry)}: #{e.reason}."
+            error = true
+            tempfile.close!
+            tempfiles.delete(tempfile)
+            next
+          rescue Chef::ChefFS::FileSystem::NotFoundError => e
+            ui.error "#{format_path(e.entry)}: No such file or directory"
+            error = true
+            tempfile.close!
+            tempfiles.delete(tempfile)
+            next
+          end
+        end
+
+        return error if error && tempfiles.size == 0
+
+        # Run the command
+        if config[:verbose_commands] || Chef::Config[:verbosity] && Chef::Config[:verbosity] >= 1
+          output sub_filenames(command, tempfiles)
+        end
+        command_output = `#{command}`
+        command_output = sub_filenames(command_output, tempfiles)
+        stdout.write command_output
+
+        # Check if the output is different
+        tempfiles.each_pair do |tempfile, file|
+          # Read the new output
+          new_value = IO.binread(tempfile.path)
+
+          # Upload the output if different
+          if config[:force] || new_value != file[:value]
+            if config[:dry_run]
+              output "Would update #{format_path(file[:file])}"
+            else
+              file[:file].write(new_value)
+              output "Updated #{format_path(file[:file])}"
+            end
+          end
+
+          # Print a diff of what was uploaded
+          if config[:diff] && new_value != file[:value]
+            old_file = Tempfile.open(file[:file].name)
+            begin
+              old_file.write(file[:value])
+              old_file.close
+
+              diff = `diff -u #{old_file.path} #{tempfile.path}`
+              diff.gsub!(old_file.path, "#{format_path(file[:file])} (old)")
+              diff.gsub!(tempfile.path, "#{format_path(file[:file])} (new)")
+              stdout.write diff
+            ensure
+              old_file.close!
+            end
+          end
+        end
+
+        error
+      end
+
+      def sub_filenames(str, tempfiles)
+        tempfiles.each_pair do |tempfile, file|
+          str = str.gsub(tempfile.path, format_path(file[:file]))
+        end
+        str
+      end
+
+    end
+  end
+end
+