chef 10.14.0.rc.1 → 10.14.0.rc.2

data/lib/chef/knife/ssh.rb

@@ -191,7 +191,7 @@ class Chef
         exit_status = 0
         subsession ||= session
         command = fixup_sudo(command)
-        command.force_encoding('binary')
+        command.force_encoding('binary') if command.respond_to?(:force_encoding)
         subsession.open_channel do |ch|
           ch.request_pty
           ch.exec command do |ch, success|
@@ -382,7 +382,7 @@ class Chef
       end
 
       def configure_identity_file
-        config[:identity_file] = get_stripped_unfrozen_value(config[:identity_file] || 
+        config[:identity_file] = get_stripped_unfrozen_value(config[:identity_file] ||
                              Chef::Config[:knife][:ssh_identity_file])
       end
 
@@ -423,4 +423,3 @@ class Chef
     end
   end
 end
-

data/lib/chef/provider/file.rb

@@ -46,43 +46,75 @@ class Chef
 
       private :negative_complement, :octal_mode
 
-      def diff_current_from_content source_content
+      def diff_current_from_content(new_content)
         result = nil
         Tempfile.open("chef-diff") do |file| 
-          file.write source_content
+          file.write new_content
           file.close 
           result = diff_current file.path
         end
         result
       end
 
-      def diff_current source_path
+      def is_binary?(path)
+        ::File.open(path) do |file|
+          buff = file.read(Chef::Config[:diff_filesize_threshold])
+          buff = "" if buff.nil?
+          return buff !~ /^[\r[:print:]]*$/
+        end
+      end
+
+      def diff_current(temp_path)
+        suppress_resource_reporting = false
+
+        return [ "(diff output suppressed by config)" ] if Chef::Config[:diff_disabled]
+        return [ "(no temp file with new content, diff output suppressed)" ] unless ::File.exists?(temp_path)  # should never happen?
+
+        # solaris does not support diff -N, so create tempfile to diff against if we are creating a new file
+        target_path = if ::File.exists?(@current_resource.path)
+                        @current_resource.path
+                      else
+                        suppress_resource_reporting = true  # suppress big diffs going to resource reporting service
+                        tempfile = Tempfile.new('chef-tempfile')
+                        tempfile.path
+                      end
+
+        diff_filesize_threshold = Chef::Config[:diff_filesize_threshold]
+        diff_output_threshold = Chef::Config[:diff_output_threshold]
+
+        if ::File.size(target_path) > diff_filesize_threshold || ::File.size(temp_path) > diff_filesize_threshold
+          return [ "(file sizes exceed #{diff_filesize_threshold} bytes, diff output suppressed)" ]
+        end
+
+        # MacOSX(BSD?) diff will *sometimes* happily spit out nasty binary diffs
+        return [ "(current file is binary, diff output suppressed)"] if is_binary?(target_path)
+        return [ "(new content is binary, diff output suppressed)"] if is_binary?(temp_path)
+
         begin
- 	  # Solaris diff doesn't support -N (treat missing files as empty) 
-          # For compatibility we'll create a temp file if the file does not exist
-          # and substitute it
-	  unless ::File.exists?(source_path) 
-	    altfile = Tempfile.new('chef-tempfile')
-            source_path = altfile.path
-          end
           # -u: Unified diff format
-          result = shell_out("diff -u #{@current_resource.path} #{source_path}" )
-          # diff will set a non-zero return code even when there's 
-          # valid stdout results, if it encounters something unexpected
-          # So as long as we have output, we'll show it.
-          if not result.stdout.empty?
+          result = shell_out("diff -u #{target_path} #{temp_path}" )
+        rescue Exception => e
+          # Should *not* receive this, but in some circumstances it seems that 
+          # an exception can be thrown even using shell_out instead of shell_out!
+          return [ "Could not determine diff. Error: #{e.message}" ]
+        end
+
+        # diff will set a non-zero return code even when there's 
+        # valid stdout results, if it encounters something unexpected
+        # So as long as we have output, we'll show it.
+        if not result.stdout.empty?
+          if result.stdout.length > diff_output_threshold
+            [ "(long diff of over #{diff_output_threshold} characters, diff output suppressed)" ]
+          else
             val = result.stdout.split("\n")
             val.delete("\")
+            @new_resource.diff(val.join("\\n")) unless suppress_resource_reporting
             val
-          elsif not result.stderr.empty?
-            "Could not determine diff. Error: #{result.stderr}"
-          else
-            "(no diff)"
           end
-        rescue Exception => e
-          # Should *not* receive this, but in some circumstances it seems that 
-          # an exception can be thrown even using shell_out instead of shell_out!
-          "Could not determine diff. Error: #{e.message}"
+        elsif not result.stderr.empty?
+          [ "Could not determine diff. Error: #{result.stderr}" ]
+        else
+          [ "(no diff)" ]
         end
       end 
 

data/lib/chef/provider/package.rb

@@ -38,7 +38,6 @@ class Chef
       end
 
       def load_current_resource
-
       end
 
       def define_resource_requirements

data/lib/chef/provider/service/freebsd.rb

@@ -70,7 +70,7 @@ class Chef
         def define_resource_requirements
           super
 
-          requirements.assert(:all_actions) do |a| 
+          requirements.assert(:start, :enable, :reload, :restart) do |a|
             a.assertion { @rcd_script_found } 
             a.failure_message Chef::Exceptions::Service, "#{@new_resource}: unable to locate the rc.d script"
           end
@@ -82,7 +82,7 @@ class Chef
             a.whyrun "Unable to determine enabled/disabled state, assuming this will be correct for an actual run.  Assuming disabled." 
           end
 
-          requirements.assert(:all_actions) do |a| 
+          requirements.assert(:start, :enable, :reload, :restart) do |a|
             a.assertion { @rcd_script_found && service_enable_variable_name != nil } 
             a.failure_message Chef::Exceptions::Service, "Could not find the service name in #{@init_command} and rcvar"
             # No recovery in whyrun mode - the init file is present but not correct.

data/lib/chef/provider/service/redhat.rb

@@ -45,7 +45,7 @@ class Chef
             a.failure_message Chef::Exceptions::Service, "#{chkconfig_file} does not exist!"
           end
 
-          requirements.assert(:all_actions) do |a|
+          requirements.assert(:start, :enable, :reload, :restart) do |a|
             a.assertion { !@service_missing }
             a.failure_message Chef::Exceptions::Service, "#{@new_resource}: unable to locate the init.d script!"
             a.whyrun "Assuming service would be disabled. The init script is not presently installed." 

data/lib/chef/provider/service/upstart.rb

@@ -65,10 +65,10 @@ class Chef
           @upstart_command_success = true
         end
 
-        def define_resource_requirements 
-          super
-
-          requirements.assert(:all_actions) do |a| 
+        def define_resource_requirements
+          # Do not call super, only call shared requirements
+          shared_resource_requirements
+          requirements.assert(:all_actions) do |a|
             if !@command_success
               whyrun_msg = @new_resource.status_command ? "Provided status command #{@new_resource.status_command} failed." : 
                 "Could not determine upstart state for service"

data/lib/chef/resource/file.rb

@@ -46,6 +46,7 @@ class Chef
         @action = "create"
         @allowed_actions.push(:create, :delete, :touch, :create_if_missing)
         @provider = Chef::Provider::File
+        @diff = nil
       end
 
 
@@ -80,6 +81,15 @@ class Chef
           :kind_of => String
         )
       end
+      
+      def diff(arg=nil)
+        set_or_return(
+          :diff,
+          arg,
+          :kind_of => String
+        )
+      end
+
 
     end
   end

data/lib/chef/resource_reporter.rb

@@ -56,8 +56,8 @@ class Chef
         as_hash["after"]  = new_resource.state
         as_hash["before"] = current_resource ? current_resource.state : {}
         as_hash["duration"] = (elapsed_time * 1000).to_i.to_s
-        # TODO: include diffs, etc. here:
-        as_hash["delta"] = ""
+        as_hash["delta"]  = new_resource.diff if new_resource.respond_to?("diff")
+        as_hash["delta"]  = "" if as_hash["delta"].nil?
         # TODO: rename as "action"
         as_hash["result"] = action.to_s
         if success?
@@ -86,7 +86,11 @@ class Chef
     attr_reader :error_descriptions
 
     def initialize(rest_client)
-      @reporting_enabled = true
+      if Chef::Config[:disable_reporting]
+        @reporting_enabled = false
+      else
+        @reporting_enabled = true
+      end
       @updated_resources = []
       @total_res_count = 0
       @pending_update  = nil
@@ -100,15 +104,20 @@ class Chef
 
     def node_load_completed(node, expanded_run_list_with_versions, config)
       @node = node
-      resource_history_url = "nodes/#{@node.name}/runs"
-      server_response = @rest_client.post_rest(resource_history_url, {:action => :begin})
-      run_uri = URI.parse(server_response["uri"])
-      @run_id = ::File.basename(run_uri.path)
-      Chef::Log.info("Chef server generated run history id: #{@run_id}")
-    rescue Net::HTTPServerException => e
-      raise unless e.response.code.to_s == "404"
-      Chef::Log.debug("Received 404 attempting to generate run history id (URL Path: #{resource_history_url}), assuming feature is not supported.")
-      @reporting_enabled = false
+
+      if reporting_enabled?
+        begin
+          resource_history_url = "reports/nodes/#{@node.name}/runs"
+          server_response = @rest_client.post_rest(resource_history_url, {:action => :begin})
+          run_uri = URI.parse(server_response["uri"])
+          @run_id = ::File.basename(run_uri.path)
+          Chef::Log.info("Chef server generated run history id: #{@run_id}")
+        rescue Net::HTTPServerException => e
+          raise unless e.response.code.to_s == "404"
+          Chef::Log.debug("Received 404 attempting to generate run history id (URL Path: #{resource_history_url}), assuming feature is not supported.")
+          @reporting_enabled = false
+        end
+      end
     end
 
     def resource_current_state_loaded(new_resource, action, current_resource)
@@ -151,7 +160,7 @@ class Chef
 
     def run_completed(node)
       if reporting_enabled?
-        resource_history_url = "nodes/#{@node.name}/runs/#{run_id}"
+        resource_history_url = "reports/nodes/#{@node.name}/runs/#{run_id}"
         run_data = report(node)
         run_data["action"] = "end"
         Chef::Log.info("Sending resource update report (run-id: #{run_id})")

data/lib/chef/version.rb

@@ -17,7 +17,7 @@
 
 class Chef
   CHEF_ROOT = File.dirname(File.expand_path(File.dirname(__FILE__)))
-  VERSION = '10.14.0.rc.1'
+  VERSION = '10.14.0.rc.2'
 end
 
 # NOTE: the Chef::Version class is defined in version_class.rb

data/spec/unit/provider/file_spec.rb

@@ -276,7 +276,132 @@ describe Chef::Provider::File do
   end
 
   describe "when a diff is requested" do
-   
+
+    before(:each) do
+      @original_config = Chef::Config.hash_dup
+    end
+
+    after(:each) do
+      Chef::Config.configuration = @original_config if @original_config
+    end
+
+    describe "when identifying files as binary or text" do
+
+      it "should identify zero-length files as text" do
+        Tempfile.open("some-temp") do |file|
+          @resource.path(file.path)
+          @provider = Chef::Provider::File.new(@resource, @run_context)
+          @provider.is_binary?(file.path).should be_false
+        end
+      end
+
+      it "should correctly identify text files as being text" do
+        Tempfile.open("some-temp") do |file|
+          @resource.path(file.path)
+          file.puts("This is a text file.")
+          file.puts("That has a couple of lines in it.")
+          file.puts("And lets make sure that other printable chars work too: ~!@\#$%^&*()`:\"<>?{}|_+,./;'[]\\-=")
+          file.close
+          @provider = Chef::Provider::File.new(@resource, @run_context)
+          @provider.is_binary?(file.path).should be_false
+        end
+      end
+
+      it "should identify a null-terminated string as binary" do
+        Tempfile.open("some-temp") do |file|
+          @resource.path(file.path)
+          file.write("This is a binary file.\0")
+          file.close
+          @provider = Chef::Provider::File.new(@resource, @run_context)
+          @provider.is_binary?(file.path).should be_true
+        end
+      end
+
+    end
+
+    it "should not return diff output when chef config has disabled it" do
+      Chef::Config[:diff_disabled] = true
+      Tempfile.open("some-temp") do |file|
+        @resource.path(file.path)
+        @provider = Chef::Provider::File.new(@resource, @run_context)
+        @provider.load_current_resource
+        result = @provider.diff_current_from_content "foo baz"
+        result.should == [ "(diff output suppressed by config)" ]
+        @resource.diff.should be_nil
+      end
+    end
+
+    it "should not return diff output when there is no new file to compare it to" do
+      Tempfile.open("some-temp") do |file|
+        Tempfile.open("other-temp") do |missing_file|
+          missing_path = missing_file.path
+          missing_file.close
+          missing_file.unlink
+          @resource.path(file.path)
+          @provider = Chef::Provider::File.new(@resource, @run_context)
+          @provider.load_current_resource
+          result = @provider.diff_current missing_path
+          result.should == [ "(no temp file with new content, diff output suppressed)" ]
+          @resource.diff.should be_nil
+        end
+      end
+    end
+
+    it "should produce diff output when the file does not exist yet, but suppress reporting it" do
+      Tempfile.open("some-temp") do |file|
+        @resource.path(file.path)
+        file.close
+        file.unlink
+        @provider = Chef::Provider::File.new(@resource, @run_context)
+        @provider.load_current_resource
+        result = @provider.diff_current_from_content "foo baz"
+        result.length.should == 4
+        @resource.diff.should be_nil
+      end
+    end
+
+    it "should not produce a diff when the current resource file is above the filesize threshold" do
+      Chef::Config[:diff_filesize_threshold] = 5
+      Tempfile.open("some-temp") do |file|
+        @resource.path(file.path)
+        file.puts("this is a line which is longer than 5 characters")
+        file.flush
+        @provider = Chef::Provider::File.new(@resource, @run_context)
+        @provider.load_current_resource
+        result = @provider.diff_current_from_content "foo"  # not longer than 5
+        result.should == [ "(file sizes exceed 5 bytes, diff output suppressed)" ]
+        @resource.diff.should be_nil
+      end
+    end
+
+    it "should not produce a diff when the new content is above the filesize threshold" do
+      Chef::Config[:diff_filesize_threshold] = 5
+      Tempfile.open("some-temp") do |file|
+        @resource.path(file.path)
+        file.puts("foo")
+        file.flush
+        @provider = Chef::Provider::File.new(@resource, @run_context)
+        @provider.load_current_resource
+        result = @provider.diff_current_from_content "this is a line that is longer than 5 characters"
+        result.should == [ "(file sizes exceed 5 bytes, diff output suppressed)" ]
+        @resource.diff.should be_nil
+      end
+    end
+
+    it "should not produce a diff when the generated diff size is above the diff size threshold" do
+      Chef::Config[:diff_output_threshold] = 5
+      Tempfile.open("some-temp") do |file|
+        @resource.path(file.path)
+        file.puts("some text to increase the size of the diff")
+        file.flush
+        @provider = Chef::Provider::File.new(@resource, @run_context)
+        @provider.load_current_resource
+        result = @provider.diff_current_from_content "this is a line that is longer than 5 characters"
+        result.should == [ "(long diff of over 5 characters, diff output suppressed)" ]
+        @resource.diff.should be_nil
+      end
+    end
+
     it "should return valid diff output when content does not match the string content provided" do
        Tempfile.open("some-temp") do |file|
          @resource.path file.path
@@ -285,12 +410,13 @@ describe Chef::Provider::File do
          result = @provider.diff_current_from_content "foo baz"
          # remove the file name info which varies.
          result.shift(2)
-	 # Result appearance seems to vary slightly under solaris diff
+         # Result appearance seems to vary slightly under solaris diff
          # So we'll compare the second line which is common to both.
          # Solaris: -1,1 +1,0 @@, "+foo baz"
-	 # Linux/Mac: -1,0, +1 @@, "+foo baz"
+         # Linux/Mac: -1,0, +1 @@, "+foo baz"
          result.length.should == 2
          result[1].should == "+foo baz"
+         @resource.diff.should_not be_nil
        end
     end
   end

data/spec/unit/provider/remote_file_spec.rb

@@ -218,6 +218,13 @@ describe Chef::Provider::RemoteFile, "action_create" do
     describe "when the target file already exists" do
       before do
         ::File.stub!(:exists?).with(@resource.path).and_return(true)
+        @provider.stub!(:diff_current).and_return([
+         "--- /tmp/foo  2012-08-30 21:28:17.632782551 +0000",
+         "+++ /tmp/bar 2012-08-30 21:28:20.816975437 +0000",
+         "@@ -1 +1 @@",
+         "-foo bar",
+         "+bar foo"
+        ])
         @provider.stub!(:get_from_server).and_return(@tempfile)
       end
 

data/spec/unit/provider/service/freebsd_service_spec.rb

@@ -32,6 +32,8 @@ describe Chef::Provider::Service::Freebsd do
     @current_resource = Chef::Resource::Service.new("apache22")
 
     @provider = Chef::Provider::Service::Freebsd.new(@new_resource,@run_context)
+    @provider.action = :start
+    @init_command = "/usr/local/etc/rc.d/apache22"
     Chef::Resource::Service.stub!(:new).and_return(@current_resource)
   end
 
@@ -131,12 +133,24 @@ RC_SAMPLE
         @provider.load_current_resource
       end
 
-      it "should raise an exception when init script is not found" do
-        ::File.stub!(:exists?).and_return(false)
-        @provider.load_current_resource
-        @provider.define_resource_requirements 
-        @provider.instance_variable_get("@rcd_script_found").should be_false
-        lambda { @provider.process_resource_requirements }.should raise_error(Chef::Exceptions::Service)
+      context "and the init script is not found" do
+        [ "start", "reload", "restart", "enable" ].each do |action|
+          it "should raise an exception when the action is #{action}" do
+            ::File.stub!(:exists?).and_return(false)
+            @provider.load_current_resource
+            @provider.define_resource_requirements 
+            @provider.instance_variable_get("@rcd_script_found").should be_false
+            @provider.action = action
+            lambda { @provider.process_resource_requirements }.should raise_error(Chef::Exceptions::Service)
+          end
+        end
+
+        [ "stop", "disable" ].each do |action|
+          it "should not raise an error when the action is #{action}" do
+            @provider.action = action
+            lambda { @provider.process_resource_requirements }.should_not raise_error
+          end
+        end
       end
 
       it "update state when current resource enabled state could not be determined" do
@@ -146,6 +160,7 @@ RC_SAMPLE
       end 
 
       it "update state when current resource enabled state could be determined" do
+        ::File.stub!(:exist?).with("/usr/local/etc/rc.d/#{@new_resource.service_name}").and_return(true)
         ::File.should_receive(:exists?).with("/etc/rc.conf").and_return  true
         @provider.load_current_resource
         @provider.instance_variable_get("@enabled_state_found").should be_false
@@ -293,10 +308,23 @@ RCVAR_SAMPLE
           @provider.stub!(:shell_out!).with("/usr/local/etc/rc.d/#{@current_resource.service_name} rcvar").and_return(@status)
         end
 
-        it "should raise an exception if rcvar does not return foobar_enable" do
-          @provider.load_current_resource
-          @provider.define_resource_requirements
-          lambda { @provider.process_resource_requirements }.should raise_error(Chef::Exceptions::Service)
+        [ "start", "reload", "restart", "enable" ].each do |action|
+          it "should raise an exception when the action is #{action}" do
+            @provider.action = action
+            @provider.load_current_resource
+            @provider.define_resource_requirements
+            lambda { @provider.process_resource_requirements }.should raise_error(Chef::Exceptions::Service)
+          end
+        end
+
+        [ "stop", "disable" ].each do |action|
+          it "should not raise an error when the action is #{action}" do
+            ::File.stub!(:exist?).with("/usr/local/etc/rc.d/#{@new_resource.service_name}").and_return(true)
+            @provider.action = action
+            @provider.load_current_resource
+            @provider.define_resource_requirements
+            lambda { @provider.process_resource_requirements }.should_not raise_error(Chef::Exceptions::Service)
+          end
         end
       end
     end