chef 10.34.6-x86-mingw32 → 11.6.2-x86-mingw32

data/lib/chef/knife/core/ui.rb

@@ -19,9 +19,8 @@
 #
 
 require 'forwardable'
-require 'chef/platform'
+require 'chef/platform/query_helpers'
 require 'chef/knife/core/generic_presenter'
-require 'tempfile'
 
 class Chef
   class Knife
@@ -37,6 +36,8 @@ class Chef
       attr_reader :stdin
       attr_reader :config
 
+      attr_reader :presenter
+
       def_delegator :@presenter, :format_list_for_display
       def_delegator :@presenter, :format_for_display
       def_delegator :@presenter, :format_cookbook_list_for_display
@@ -63,14 +64,24 @@ class Chef
       # Prints a message to stdout. Aliased as +info+ for compatibility with
       # the logger API.
       def msg(message)
-        stdout.puts message
+        begin
+          stdout.puts message
+        rescue Errno::EPIPE => e
+          raise e if @config[:verbosity] >= 2
+          exit 0
+        end
       end
 
       alias :info :msg
 
       # Prints a msg to stderr. Used for warn, error, and fatal.
       def err(message)
-        stderr.puts message
+        begin
+          stderr.puts message
+        rescue Errno::EPIPE => e
+          raise e if @config[:verbosity] >= 2
+          exit 0
+        end
       end
 
       # Print a warning message
@@ -142,21 +153,31 @@ class Chef
       end
 
       def pretty_print(data)
-        stdout.puts data
+        begin
+          stdout.puts data
+        rescue Errno::EPIPE => e
+          raise e if @config[:verbosity] >= 2
+          exit 0
+        end
       end
 
       def edit_data(data, parse_output=true)
         output = Chef::JSONCompat.to_json_pretty(data)
 
         if (!config[:disable_editing])
-          Tempfile.open([ 'knife-edit-', '.json' ]) do |tf|
-            tf.sync = true
-            tf.puts output
-            tf.close
-            raise "Please set EDITOR environment variable" unless system("#{config[:editor]} #{tf.path}")
-
-            output = IO.read(tf.path)
-          end
+          filename = "knife-edit-"
+          0.upto(20) { filename += rand(9).to_s }
+          filename << ".js"
+          filename = File.join(Dir.tmpdir, filename)
+          tf = File.open(filename, "w")
+          tf.sync = true
+          tf.puts output
+          tf.close
+          raise "Please set EDITOR environment variable" unless system("#{config[:editor]} #{tf.path}")
+          tf = File.open(filename, "r")
+          output = tf.gets(nil)
+          tf.close
+          File.unlink(filename)
         end
 
         parse_output ? Chef::JSONCompat.from_json(output) : output

data/lib/chef/knife/delete.rb

@@ -0,0 +1,106 @@
+require 'chef/chef_fs/knife'
+
+class Chef
+  class Knife
+    class Delete < Chef::ChefFS::Knife
+      banner "knife delete [PATTERN1 ... PATTERNn]"
+
+      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
+          show_usage
+          ui.fatal("Must specify at least one argument.  If you want to delete everything in this directory, type \"knife delete --recurse .\"")
+          exit 1
+        end
+
+        # Get the matches (recursively)
+        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
+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

@@ -0,0 +1,63 @@
+require 'chef/chef_fs/knife'
+
+class Chef
+  class Knife
+    class Diff < Chef::ChefFS::Knife
+      banner "knife diff PATTERNS"
+
+      deps do
+        require 'chef/chef_fs/command_line'
+      end
+
+      option :recurse,
+        :long => '--[no-]recurse',
+        :boolean => true,
+        :default => true,
+        :description => "List directories recursively."
+
+      option :name_only,
+        :long => '--name-only',
+        :boolean => true,
+        :description => "Only show names of modified files."
+
+      option :name_status,
+        :long => '--name-status',
+        :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
+        end
+        if config[:name_status]
+          output_mode = :name_status
+        end
+        patterns = pattern_args_from(name_args.length > 0 ? name_args : [ "" ])
+
+        # Get the matches (recursively)
+        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
+  end
+end
+

data/lib/chef/knife/download.rb

@@ -0,0 +1,63 @@
+require 'chef/chef_fs/knife'
+
+class Chef
+  class Knife
+    class Download < Chef::ChefFS::Knife
+      banner "knife download PATTERNS"
+
+      deps do
+        require 'chef/chef_fs/command_line'
+      end
+
+      option :recurse,
+        :long => '--[no-]recurse',
+        :boolean => true,
+        :default => true,
+        :description => "List directories recursively."
+
+      option :purge,
+        :long => '--[no-]purge',
+        :boolean => true,
+        :default => false,
+        :description => "Delete matching local files and directories that do not exist remotely."
+
+      option :force,
+        :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)"
+
+      option :dry_run,
+        :long => '--dry-run',
+        :short => '-n',
+        :boolean => true,
+        :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
+          ui.fatal("Must specify at least one argument.  If you want to download everything in this directory, type \"knife download .\"")
+          exit 1
+        end
+
+        error = false
+        pattern_args.each do |pattern|
+          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
+  end
+end
+