chef 10.34.6 → 11.0.0.beta.0

data/lib/chef/knife/configure.rb

@@ -81,8 +81,7 @@ client_key               '#{new_client_key}'
 validation_client_name   '#{validation_client_name}'
 validation_key           '#{validation_key}'
 chef_server_url          '#{chef_server}'
-cache_type               'BasicFile'
-cache_options( :path => '#{File.join(chef_config_path, "checksums")}' )
+syntax_check_cache_path  '#{File.join(chef_config_path, "syntax_check_cache")}'
 EOH
           unless chef_repo.empty?
             f.puts "cookbook_path [ '#{chef_repo}/cookbooks' ]"

data/lib/chef/knife/cookbook_metadata.rb

@@ -46,6 +46,7 @@ class Chef
 
         if config[:all]
           cl = Chef::CookbookLoader.new(config[:cookbook_path])
+          cl.load_cookbooks
           cl.each do |cname, cookbook|
             generate_metadata(cname.to_s)
           end

data/lib/chef/knife/cookbook_test.rb

@@ -25,7 +25,6 @@ class Chef
     class CookbookTest < Knife
 
       deps do
-        require 'chef/checksum_cache'
         require 'chef/cookbook/syntax_check'
       end
 
@@ -47,7 +46,9 @@ class Chef
 
         checked_a_cookbook = false
         if config[:all]
-          cookbook_loader.each do |key, cookbook|
+          cl = cookbook_loader
+          cl.load_cookbooks
+          cl.each do |key, cookbook|
             checked_a_cookbook = true
             test_cookbook(key)
           end

data/lib/chef/knife/cookbook_upload.rb

@@ -86,7 +86,6 @@ class Chef
         end
 
         assert_environment_valid!
-        warn_about_cookbook_shadowing
         version_constraints_to_update = {}
         upload_failures = 0
         upload_ok = 0
@@ -96,7 +95,7 @@ class Chef
         @server_side_cookbooks = Chef::CookbookVersion.list_all_versions
         justify_width = @server_side_cookbooks.map {|name| name.size}.max.to_i + 2
         if config[:all]
-
+          cookbook_repo.load_cookbooks
           cbs = []
           cookbook_repo.each do |cookbook_name, cookbook|
             cbs << cookbook
@@ -154,7 +153,7 @@ class Chef
       def cookbooks_to_upload
         @cookbooks_to_upload ||=
           if config[:all]
-            cookbook_repo
+            cookbook_repo.load_cookbooks
           else
             upload_set = {}
             @name_args.each do |cookbook_name|
@@ -229,9 +228,15 @@ WARNING
           check_for_dependencies!(cb)
         end
         Chef::CookbookUploader.new(cookbooks, config[:cookbook_path], :force => config[:force]).upload_cookbooks
-      rescue Chef::Exceptions::CookbookFrozen => e
-        ui.error e
-        raise
+      rescue Net::HTTPServerException => e
+        case e.response.code
+        when "409"
+          ui.error "Version #{cookbook.version} of cookbook #{cookbook.name} is frozen. Use --force to override."
+          Log.debug(e)
+          raise Exceptions::CookbookFrozen
+        else
+          raise
+        end
       end
 
       def check_for_broken_links!(cookbook)
@@ -255,7 +260,7 @@ WARNING
         # the version is in the cookbooks being uploaded. If not, exit and warn the user.
         cookbook.metadata.dependencies.each do |cookbook_name, version|
           unless check_server_side_cookbooks(cookbook_name, version) || check_uploading_cookbooks(cookbook_name, version)
-            ui.error "Cookbook #{cookbook.name} depends on cookbook #{cookbook_name} version #{version},"
+            ui.error "Cookbook #{cookbook.name} depends on cookbook '#{cookbook_name}' version '#{version}',"
             ui.error "which is not currently being uploaded and cannot be found on the server."
             exit 1
           end

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

@@ -56,7 +56,7 @@ class Chef
 
         def config_content
           client_rb = <<-CONFIG
-log_level        :info
+log_level        :auto
 log_location     STDOUT
 chef_server_url  "#{@chef_config[:chef_server_url]}"
 validation_client_name "#{@chef_config[:validation_client_name]}"

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

@@ -121,7 +121,19 @@ class Chef
         end
 
         def format_for_display(data)
-          if config[:attribute]
+          if formatting_subset_of_data?
+            format_data_subset_for_display(data)
+          elsif config[:id_only]
+            name_or_id_for(data)
+          elsif config[:environment] && data.respond_to?(:chef_environment)
+            {"chef_environment" => data.chef_environment}
+          else
+            data
+          end
+        end
+
+        def format_data_subset_for_display(data)
+          subset = if config[:attribute]
             result = {}
             Array(config[:attribute]).each do |nested_value_spec|
               nested_value = extract_nested_value(data, nested_value_spec)
@@ -129,22 +141,23 @@ class Chef
             end
             result
           elsif config[:run_list]
-            data = data.run_list.run_list
-            { "run_list" => data }
-          elsif config[:environment]
-            if data.respond_to?(:chef_environment)
-              {"chef_environment" => data.chef_environment}
-            else
-              # this is a place holder for now. Feel free to modify (i.e. add other cases). [nuo]
-              data
-            end
-          elsif config[:id_only]
-            data.respond_to?(:name) ? data.name : data["id"]
+            run_list = data.run_list.run_list
+            { "run_list" => run_list }
           else
-            data
+            raise ArgumentError, "format_data_subset_for_display requires attribute, run_list, or id_only config option to be set"
           end
+          {name_or_id_for(data) => subset }
+        end
+
+        def name_or_id_for(data)
+          data.respond_to?(:name) ? data.name : data["id"]
         end
 
+        def formatting_subset_of_data?
+          config[:attribute] || config[:run_list]
+        end
+
+
         def extract_nested_value(data, nested_value_spec)
           nested_value_spec.split(".").each do |attr|
             if data.nil?

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

@@ -18,7 +18,6 @@
 
 require 'chef/json_compat'
 require 'chef/node'
-require 'tempfile'
 
 class Chef
   class Knife
@@ -36,24 +35,11 @@ class Chef
         abort "You specified the --disable_editing option, nothing to edit" if config[:disable_editing]
         assert_editor_set!
 
-        updated_node_data = @ui.edit_data(view)
+        updated_node_data = edit_data(view)
         apply_updates(updated_node_data)
         @updated_node
       end
 
-      def updated?
-        pristine_copy = Chef::JSONCompat.from_json(Chef::JSONCompat.to_json(node), :create_additions => false)
-        updated_copy  = Chef::JSONCompat.from_json(Chef::JSONCompat.to_json(@updated_node), :create_additions => false)
-        unless pristine_copy == updated_copy
-          updated_properties = %w{name normal chef_environment run_list default override automatic}.reject do |key|
-             pristine_copy[key] == updated_copy[key]
-          end
-        end
-        ( pristine_copy != updated_copy ) && updated_properties
-      end
-
-      private
-
       def view
         result = {}
         result["name"] = node.name
@@ -66,7 +52,12 @@ class Chef
           result["override"]  = node.override_attrs
           result["automatic"] = node.automatic_attrs
         end
-        result
+        Chef::JSONCompat.to_json_pretty(result)
+      end
+
+      def edit_data(text)
+        edited_data = tempfile_for(text) {|filename| system("#{config[:editor]} #{filename}")}
+        Chef::JSONCompat.from_json(edited_data)
       end
 
       def apply_updates(updated_data)
@@ -93,6 +84,19 @@ class Chef
         end
       end
 
+      def updated?
+        pristine_copy = Chef::JSONCompat.from_json(Chef::JSONCompat.to_json(node), :create_additions => false)
+        updated_copy  = Chef::JSONCompat.from_json(Chef::JSONCompat.to_json(@updated_node), :create_additions => false)
+        unless pristine_copy == updated_copy
+          updated_properties = %w{name normal chef_environment run_list default override automatic}.reject do |key|
+             pristine_copy[key] == updated_copy[key]
+          end
+        end
+        ( pristine_copy != updated_copy ) && updated_properties
+      end
+
+      private
+
       def abort(message)
         ui.error(message)
         exit 1
@@ -104,6 +108,22 @@ class Chef
         end
       end
 
+      def tempfile_for(data)
+        # TODO: include useful info like the node name in the temp file
+        # name
+        basename = "knife-edit-" << rand(1_000_000_000_000_000).to_s.rjust(15, '0') << '.js'
+        filename = File.join(Dir.tmpdir, basename)
+        File.open(filename, "w+") do |f|
+          f.sync = true
+          f.puts data
+        end
+
+        yield filename
+
+        IO.read(filename)
+      ensure
+        File.unlink(filename)
+      end
     end
   end
 end

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

@@ -86,7 +86,7 @@ class Chef
         # Converts a Chef::Node object to a string suitable for output to a
         # terminal. If config[:medium_output] or config[:long_output] are set
         # the volume of output is adjusted accordingly. Uses colors if enabled
-        # in the ui object.
+        # in the the ui object.
         def summarize(data)
           if data.kind_of?(Chef::Node)
             node = data

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

@@ -41,58 +41,44 @@ class Chef
           @formatted_data ||= text_format(data)
         end
 
-        def text_format(data, indent=0)
+        def text_format(data)
           buffer = ''
 
           if data.respond_to?(:keys)
-            justify_width = data.keys.map {|k| k.to_s.size }.max.to_i + 2
+            justify_width = data.keys.map {|k| k.to_s.size }.max.to_i + 1
             data.sort.each do |key, value|
-              justified_key = ui.color("#{key}:".ljust(justify_width), :cyan)
-              if should_enumerate?(value)
-                buffer << indent_line(justified_key, indent)
-                buffer << text_format(value, indent + 1)
+              # key: ['value'] should be printed as key: value
+              if value.kind_of?(Array) && value.size == 1 && is_singleton(value[0])
+                value = value[0]
+              end
+              if is_singleton(value)
+                # Strings are printed as key: value.
+                justified_key = ui.color("#{key}:".ljust(justify_width), :cyan)
+                buffer << "#{justified_key} #{value}\n"
               else
-                buffer << indent_key_value(justified_key, value, justify_width, indent)
+                # Arrays and hashes get indented on their own lines.
+                buffer << ui.color("#{key}:\n", :cyan)
+                lines = text_format(value).split("\n")
+                lines.each { |line| buffer << "  #{line}\n" }
               end
             end
           elsif data.kind_of?(Array)
-            data.each do |item|
-              if should_enumerate?(data)
-                buffer << text_format(item, indent + 1)
-              else
-                buffer << indent_line(item, indent)
-              end
+            data.each_index do |index|
+              item = data[index]
+              buffer << text_format(data[index])
+              # Separate items with newlines if it's an array of hashes or an
+              # array of arrays
+              buffer << "\n" if !is_singleton(data[index]) && index != data.size-1
             end
           else
-            buffer << indent_line(stringify_value(data), indent)
+            buffer << "#{data}\n"
           end
           buffer
         end
 
-        # Ruby 1.8 Strings include enumberable, which is not what we want. So
-        # we have this heuristic to detect hashes and arrays instead.
-        def should_enumerate?(value)
-          ((value.respond_to?(:keys) && !value.empty? ) || ( value.kind_of?(Array) && (value.size > 1 || should_enumerate?(value.first) )))
-        end
-
-        def indent_line(string, indent)
-          ("  " * indent) << "#{string}\n"
-        end
-
-        def indent_key_value(key, value, justify_width, indent)
-          lines = value.to_s.split("\n")
-          if lines.size > 1
-            total_indent = (2 * indent) + justify_width + 1
-            indent_line("#{key} #{lines.shift}", indent) << lines.map {|l| (" " * total_indent) + l << "\n" }.join("")
-          else
-            indent_line("#{key} #{stringify_value(value)}", indent)
-          end
-        end
-
-        def stringify_value(data)
-          data.kind_of?(String) ? data : data.to_s
+        def is_singleton(value)
+          !(value.kind_of?(Array) || value.respond_to?(:keys))
         end
-
       end
     end
   end

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

@@ -21,7 +21,6 @@
 require 'forwardable'
 require 'chef/platform'
 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
@@ -149,14 +150,19 @@ class Chef
         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,39 @@
+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
+
+      option :recurse,
+        :long => '--[no-]recurse',
+        :boolean => true,
+        :default => false,
+        :description => "Delete directories recursively."
+
+      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)
+        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"
+            end
+          end
+        end
+      end
+    end
+  end
+end
+

data/lib/chef/knife/diff.rb

@@ -0,0 +1,46 @@
+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
+
+      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."
+
+      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)
+        patterns.each do |pattern|
+          Chef::ChefFS::CommandLine.diff(pattern, chef_fs, local_fs, config[:recurse] ? nil : 1, output_mode) do |diff|
+            puts diff
+          end
+        end
+      end
+    end
+  end
+end
+