chef 11.4.4 → 11.6.0.hotfix.1

data/lib/chef/knife/delete.rb

@@ -1,18 +1,30 @@
 require 'chef/chef_fs/knife'
-require 'chef/chef_fs/file_system'
 
 class Chef
   class Knife
     class Delete < Chef::ChefFS::Knife
       banner "knife delete [PATTERN1 ... PATTERNn]"
 
-      common_options
+      deps do
+        require 'chef/chef_fs/file_system'
+      end
 
       option :recurse,
+        :short => '-r',
         :long => '--[no-]recurse',
         :boolean => true,
         :default => false,
         :description => "Delete directories recursively."
+      option :both,
+        :long => '--both',
+        :boolean => true,
+        :default => false,
+        :description => "Delete both the local and remote copies."
+      option :local,
+        :long => '--local',
+        :boolean => true,
+        :default => false,
+        :description => "Delete the local copy (leave the remote copy)."
 
       def run
         if name_args.length == 0
@@ -22,16 +34,71 @@ class Chef
         end
 
         # Get the matches (recursively)
-        pattern_args.each do |pattern|
-          Chef::ChefFS::FileSystem.list(chef_fs, pattern) do |result|
-            begin
-              result.delete(config[:recurse])
-              puts "Deleted #{result.path_for_printing}"
-            rescue Chef::ChefFS::FileSystem::NotFoundError
-              STDERR.puts "#{result.path_for_printing}: No such file or directory"
+        error = false
+        if config[:local]
+          pattern_args.each do |pattern|
+            Chef::ChefFS::FileSystem.list(local_fs, pattern).each do |result|
+              if delete_result(result)
+                error = true
+              end
             end
           end
+        elsif config[:both]
+          pattern_args.each do |pattern|
+            Chef::ChefFS::FileSystem.list_pairs(pattern, chef_fs, local_fs).each do |chef_result, local_result|
+              if delete_result(chef_result, local_result)
+                error = true
+              end
+            end
+          end
+        else # Remote only
+          pattern_args.each do |pattern|
+            Chef::ChefFS::FileSystem.list(chef_fs, pattern).each do |result|
+              if delete_result(result)
+                error = true
+              end
+            end
+          end
+        end
+
+        if error
+          exit 1
+        end
+      end
+
+      def format_path_with_root(entry)
+        root = entry.root == chef_fs ? " (remote)" : " (local)"
+        "#{format_path(entry)}#{root}"
+      end
+
+      def delete_result(*results)
+        deleted_any = false
+        found_any = false
+        error = false
+        results.each do |result|
+          begin
+            result.delete(config[:recurse])
+            deleted_any = true
+            found_any = true
+          rescue Chef::ChefFS::FileSystem::NotFoundError
+            # This is not an error unless *all* of them were not found
+          rescue Chef::ChefFS::FileSystem::MustDeleteRecursivelyError => e
+            ui.error "#{format_path_with_root(e.entry)} must be deleted recursively!  Pass -r to knife delete."
+            found_any = true
+            error = true
+          rescue Chef::ChefFS::FileSystem::OperationNotAllowedError => e
+            ui.error "#{format_path_with_root(e.entry)} #{e.reason}."
+            found_any = true
+            error = true
+          end
+        end
+        if deleted_any
+          output("Deleted #{format_path(results[0])}")
+        elsif !found_any
+          ui.error "#{format_path(results[0])}: No such file or directory"
+          error = true
         end
+        error
       end
     end
   end

data/lib/chef/knife/deps.rb

@@ -0,0 +1,139 @@
+require 'chef/chef_fs/knife'
+
+class Chef
+  class Knife
+    class Deps < Chef::ChefFS::Knife
+      banner "knife deps PATTERN1 [PATTERNn]"
+
+      deps do
+        require 'chef/chef_fs/file_system'
+        require 'chef/run_list'
+      end
+
+      option :recurse,
+        :long => '--[no-]recurse',
+        :boolean => true,
+        :description => "List dependencies recursively (default: true).  Only works with --tree."
+      option :tree,
+        :long => '--tree',
+        :boolean => true,
+        :description => "Show dependencies in a visual tree.  May show duplicates."
+      option :remote,
+        :long => '--remote',
+        :boolean => true,
+        :description => "List dependencies on the server instead of the local filesystem"
+
+      attr_accessor :exit_code
+
+      def run
+        if config[:recurse] == false && !config[:tree]
+          ui.error "--no-recurse requires --tree"
+          exit(1)
+        end
+        config[:recurse] = true if config[:recurse].nil?
+
+        @root = config[:remote] ? chef_fs : local_fs
+        dependencies = {}
+        pattern_args.each do |pattern|
+          Chef::ChefFS::FileSystem.list(@root, pattern).each do |entry|
+            if config[:tree]
+              print_dependencies_tree(entry, dependencies)
+            else
+              print_flattened_dependencies(entry, dependencies)
+            end
+          end
+        end
+        exit exit_code if exit_code
+      end
+
+      def print_flattened_dependencies(entry, dependencies)
+        if !dependencies[entry.path]
+          dependencies[entry.path] = get_dependencies(entry)
+          dependencies[entry.path].each do |child|
+            child_entry = Chef::ChefFS::FileSystem.resolve_path(@root, child)
+            print_flattened_dependencies(child_entry, dependencies)
+          end
+          output format_path(entry)
+        end
+      end
+
+      def print_dependencies_tree(entry, dependencies, printed = {}, depth = 0)
+        dependencies[entry.path] = get_dependencies(entry) if !dependencies[entry.path]
+        output "#{'  '*depth}#{format_path(entry)}"
+        if !printed[entry.path] && (config[:recurse] || depth == 0)
+          printed[entry.path] = true
+          dependencies[entry.path].each do |child|
+            child_entry = Chef::ChefFS::FileSystem.resolve_path(@root, child)
+            print_dependencies_tree(child_entry, dependencies, printed, depth+1)
+          end
+        end
+      end
+
+      def get_dependencies(entry)
+        begin
+          if entry.parent && entry.parent.path == '/cookbooks'
+            return entry.chef_object.metadata.dependencies.keys.map { |cookbook| "/cookbooks/#{cookbook}" }
+
+          elsif entry.parent && entry.parent.path == '/nodes'
+            node = JSON.parse(entry.read, :create_additions => false)
+            result = []
+            if node['chef_environment'] && node['chef_environment'] != '_default'
+              result << "/environments/#{node['chef_environment']}.json"
+            end
+            if node['run_list']
+              result += dependencies_from_runlist(node['run_list'])
+            end
+            result
+
+          elsif entry.parent && entry.parent.path == '/roles'
+            role = JSON.parse(entry.read, :create_additions => false)
+            result = []
+            if role['run_list']
+              dependencies_from_runlist(role['run_list']).each do |dependency|
+                result << dependency if !result.include?(dependency)
+              end
+            end
+            if role['env_run_lists']
+              role['env_run_lists'].each_pair do |env,run_list|
+                dependencies_from_runlist(run_list).each do |dependency|
+                  result << dependency if !result.include?(dependency)
+                end
+              end
+            end
+            result
+
+          elsif !entry.exists?
+            raise Chef::ChefFS::FileSystem::NotFoundError.new(entry)
+
+          else
+            []
+          end
+        rescue Chef::ChefFS::FileSystem::NotFoundError => e
+          ui.error "#{format_path(e.entry)}: No such file or directory"
+          self.exit_code = 2
+          []
+        end
+      end
+
+      def dependencies_from_runlist(run_list)
+        chef_run_list = Chef::RunList.new
+        chef_run_list.reset!(run_list)
+        chef_run_list.map do |run_list_item|
+          case run_list_item.type
+          when :role
+            "/roles/#{run_list_item.name}.json"
+          when :recipe
+            if run_list_item.name =~ /(.+)::[^:]*/
+              "/cookbooks/#{$1}"
+            else
+              "/cookbooks/#{run_list_item.name}"
+            end
+          else
+            raise "Unknown run list item type #{run_list_item.type}"
+          end
+        end
+      end
+    end
+  end
+end
+

data/lib/chef/knife/diff.rb

@@ -1,12 +1,13 @@
 require 'chef/chef_fs/knife'
-require 'chef/chef_fs/command_line'
 
 class Chef
   class Knife
     class Diff < Chef::ChefFS::Knife
       banner "knife diff PATTERNS"
 
-      common_options
+      deps do
+        require 'chef/chef_fs/command_line'
+      end
 
       option :recurse,
         :long => '--[no-]recurse',
@@ -24,6 +25,11 @@ class Chef
         :boolean => true,
         :description => "Only show names and statuses of modified files: Added, Deleted, Modified, and Type Changed."
 
+      option :diff_filter,
+        :long => '--diff-filter=[(A|D|M|T)...[*]]',
+        :description => "Select only files that are Added (A), Deleted (D), Modified (M), or have their type (i.e. regular file, directory) changed (T). Any combination of the filter characters (including none) can be used. When * (All-or-none) is added to the combination, all paths are selected if
+           there is any file that matches other criteria in the comparison; if there is no file that matches other criteria, nothing is selected."
+
       def run
         if config[:name_only]
           output_mode = :name_only
@@ -34,10 +40,21 @@ class Chef
         patterns = pattern_args_from(name_args.length > 0 ? name_args : [ "" ])
 
         # Get the matches (recursively)
-        patterns.each do |pattern|
-          Chef::ChefFS::CommandLine.diff(pattern, chef_fs, local_fs, config[:recurse] ? nil : 1, output_mode) do |diff|
-            puts diff
+        error = false
+        begin
+          patterns.each do |pattern|
+            found_error = Chef::ChefFS::CommandLine.diff_print(pattern, chef_fs, local_fs, config[:recurse] ? nil : 1, output_mode, proc { |entry| format_path(entry) }, config[:diff_filter], ui ) do |diff|
+              stdout.print diff
+            end
+            error = true if found_error
           end
+        rescue Chef::ChefFS::FileSystem::OperationFailedError => e
+          ui.error "Failed on #{format_path(e.entry)} in #{e.operation}: #{e.message}"
+          error = true
+        end
+
+        if error
+          exit 1
         end
       end
     end

data/lib/chef/knife/download.rb

@@ -1,12 +1,13 @@
 require 'chef/chef_fs/knife'
-require 'chef/chef_fs/command_line'
 
 class Chef
   class Knife
     class Download < Chef::ChefFS::Knife
       banner "knife download PATTERNS"
 
-      common_options
+      deps do
+        require 'chef/chef_fs/command_line'
+      end
 
       option :recurse,
         :long => '--[no-]recurse',
@@ -33,6 +34,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 +47,14 @@ class Chef
           exit 1
         end
 
+        error = false
         pattern_args.each do |pattern|
-          Chef::ChefFS::FileSystem.copy_to(pattern, chef_fs, local_fs, config[:recurse] ? nil : 1, config)
+          if Chef::ChefFS::FileSystem.copy_to(pattern, chef_fs, local_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/edit.rb

@@ -0,0 +1,76 @@
+require 'chef/chef_fs/knife'
+
+class Chef
+  class Knife
+    class Edit < Chef::ChefFS::Knife
+      banner "knife edit [PATTERN1 ... PATTERNn]"
+
+      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)
+        error = false
+        pattern_args.each do |pattern|
+          Chef::ChefFS::FileSystem.list(config[:local] ? local_fs : chef_fs, pattern).each do |result|
+            if result.dir?
+              ui.error "#{format_path(result)}: is a directory" if pattern.exact_path
+              error = true
+            else
+              begin
+                new_value = edit_text(result.read, File.extname(result.name))
+                if new_value
+                  result.write(new_value)
+                  output "Updated #{format_path(result)}"
+                else
+                  output "#{format_path(result)} unchanged!"
+                end
+              rescue Chef::ChefFS::FileSystem::OperationNotAllowedError => e
+                ui.error "#{format_path(e.entry)}: #{e.reason}."
+                error = true
+              rescue Chef::ChefFS::FileSystem::NotFoundError => e
+                ui.error "#{format_path(e.entry)}: No such file or directory"
+                error = true
+              end
+            end
+          end
+        end
+        if error
+          exit 1
+        end
+      end
+
+      def edit_text(text, extension)
+        if (!config[:disable_editing])
+          file = Tempfile.new([ 'knife-edit-', extension ])
+          begin
+            # Write the text to a temporary file
+            file.open
+            file.write(text)
+            file.close
+
+            # Let the user edit the temporary file
+            if !system("#{config[:editor]} #{file.path}")
+              raise "Please set EDITOR environment variable"
+            end
+
+            file.open
+            result_text = file.read
+            return result_text if result_text != text
+
+          ensure
+            file.close!
+          end
+        end
+      end
+    end
+  end
+end
+

data/lib/chef/knife/environment_show.rb

@@ -22,18 +22,13 @@ class Chef
   class Knife
     class EnvironmentShow < Knife
 
+      include Knife::Core::MultiAttributeReturnOption
+
       deps do
         require 'chef/environment'
         require 'chef/json_compat'
       end
 
-      @attrs_to_show = []
-      option :attribute,
-        :short => "-a [ATTR]",
-        :long => "--attribute [ATTR]",
-        :proc => lambda {|val| @attrs_to_show << val},
-        :description => "Show one or more attributes"
-
       banner "knife environment show ENVIRONMENT (options)"
 
       def run

data/lib/chef/knife/list.rb

@@ -1,107 +1,151 @@
 require 'chef/chef_fs/knife'
-require 'chef/chef_fs/file_system'
 
 class Chef
   class Knife
     class List < Chef::ChefFS::Knife
-      banner "knife list [-dR] [PATTERN1 ... PATTERNn]"
+      banner "knife list [-dfR1p] [PATTERN1 ... PATTERNn]"
 
-      common_options
+      deps do
+        require 'chef/chef_fs/file_system'
+        require 'highline'
+      end
 
       option :recursive,
         :short => '-R',
         :boolean => true,
-        :description => "List directories recursively."
+        :description => "List directories recursively"
       option :bare_directories,
         :short => '-d',
         :boolean => true,
-        :description => "When directories match the pattern, do not show the directories' children."
+        :description => "When directories match the pattern, do not show the directories' children"
+      option :local,
+        :long => '--local',
+        :boolean => true,
+        :description => "List local directory instead of remote"
+      option :flat,
+        :short => '-f',
+        :long => '--flat',
+        :boolean => true,
+        :description => "Show a list of filenames rather than the prettified ls-like output normally produced"
+      option :one_column,
+        :short => '-1',
+        :boolean => true,
+        :description => "Show only one column of results"
+      option :trailing_slashes,
+        :short => '-p',
+        :boolean => true,
+        :description => "Show trailing slashes after directories"
+
+      attr_accessor :exit_code
 
       def run
         patterns = name_args.length == 0 ? [""] : name_args
 
         # Get the matches (recursively)
-        results = []
-        dir_results = []
-        pattern_args_from(patterns).each do |pattern|
-          Chef::ChefFS::FileSystem.list(chef_fs, pattern) do |result|
-            if result.dir? && !config[:bare_directories]
-              dir_results += add_dir_result(result)
-            elsif result.exists?
-              results << result
-            elsif pattern.exact_path
-              STDERR.puts "#{format_path(result.path)}: No such file or directory"
-            end
+        all_results = parallelize(pattern_args_from(patterns), :flatten => true) do |pattern|
+          pattern_results = Chef::ChefFS::FileSystem.list(config[:local] ? local_fs : chef_fs, pattern)
+          if pattern_results.first && !pattern_results.first.exists? && pattern.exact_path
+            ui.error "#{format_path(pattern_results.first)}: No such file or directory"
+            self.exit_code = 1
+          end
+          pattern_results
+        end
+
+        # Process directories
+        if !config[:bare_directories]
+          dir_results = parallelize(all_results.select { |result| result.dir? }, :flatten => true) do |result|
+            add_dir_result(result)
+          end.to_a
+        else
+          dir_results = []
+        end
+
+        # Process all other results
+        results = all_results.select { |result| result.exists? && (!result.dir? || config[:bare_directories]) }.to_a
+
+        # Flatten out directory results if necessary
+        if config[:flat]
+          dir_results.each do |result, children|
+            results += children
           end
+          dir_results = []
         end
 
+        # Sort by path for happy output
         results = results.sort_by { |result| result.path }
         dir_results = dir_results.sort_by { |result| result[0].path }
 
+        # Print!
         if results.length == 0 && dir_results.length == 1
           results = dir_results[0][1]
           dir_results = []
         end
 
         print_result_paths results
+        printed_something = results.length > 0
         dir_results.each do |result, children|
-          puts ""
-          puts "#{format_path(result.path)}:"
-          print_results(children.map { |result| result.name }.sort, "")
+          if printed_something
+            output ""
+          else
+            printed_something = true
+          end
+          output "#{format_path(result)}:"
+          print_results(children.map { |result| maybe_add_slash(result.name, result.dir?) }.sort, "")
         end
+
+        exit self.exit_code if self.exit_code
       end
 
       def add_dir_result(result)
         begin
           children = result.children.sort_by { |child| child.name }
-        rescue Chef::ChefFS::FileSystem::NotFoundError
-          STDERR.puts "#{format_path(result.path)}: No such file or directory"
+        rescue Chef::ChefFS::FileSystem::NotFoundError => e
+          ui.error "#{format_path(e.entry)}: No such file or directory"
           return []
         end
 
         result = [ [ result, children ] ]
         if config[:recursive]
-          children.each do |child|
-            if child.dir?
-              result += add_dir_result(child)
-            end
-          end
+          child_dirs = children.select { |child| child.dir? }
+          result += parallelize(child_dirs, :flatten => true) { |child| add_dir_result(child) }.to_a
         end
         result
       end
 
-      def list_dirs_recursive(children)
-        results = children.select { |child| child.dir? }.to_a
-        results.each do |child|
-          results += list_dirs_recursive(child.children)
-        end
-        results
-      end
-
       def print_result_paths(results, indent = "")
-        print_results(results.map { |result| format_path(result.path) }, indent)
+        print_results(results.map { |result| maybe_add_slash(format_path(result), result.dir?) }, indent)
       end
 
       def print_results(results, indent)
         return if results.length == 0
 
         print_space = results.map { |result| result.length }.max + 2
-        # TODO: tput cols is not cross platform
-        columns = $stdout.isatty ? Integer(`tput cols`) : 0
-        current_column = 0
+        if config[:one_column] || !stdout.isatty
+          columns = 0
+        else
+          columns = HighLine::SystemExtensions.terminal_size[0]
+        end
+        current_line = ''
         results.each do |result|
-          if current_column != 0 && current_column + print_space > columns
-            puts ""
-            current_column = 0
+          if current_line.length > 0 && current_line.length + print_space > columns
+            output current_line.rstrip
+            current_line = ''
           end
-          if current_column == 0
-            print indent
-            current_column += indent.length
+          if current_line.length == 0
+            current_line << indent
           end
-          print result + (' ' * (print_space - result.length))
-          current_column += print_space
+          current_line << result
+          current_line << (' ' * (print_space - result.length))
+        end
+        output current_line.rstrip if current_line.length > 0
+      end
+
+      def maybe_add_slash(path, is_dir)
+        if config[:trailing_slashes] && is_dir
+          "#{path}/"
+        else
+          path
         end
-        puts ""
       end
     end
   end