chef 11.12.0.alpha.1 → 11.12.0.rc.1

data/lib/chef/exceptions.rb

@@ -76,6 +76,7 @@ class Chef
     class CookbookNotFoundInRepo < ArgumentError; end
     class RecipeNotFound < ArgumentError; end
     class AttributeNotFound < RuntimeError; end
+    class MissingCookbookDependency < StandardError; end # CHEF-5120
     class InvalidCommandOption < RuntimeError; end
     class CommandTimeout < RuntimeError; end
     class RequestedUIDUnavailable < RuntimeError; end

data/lib/chef/guard_interpreter/default_guard_interpreter.rb

@@ -0,0 +1,42 @@
+#
+# Author:: Adam Edwards (<adamed@getchef.com>)
+# Copyright:: Copyright (c) 2014 Chef Software, Inc.
+# 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.
+#
+
+class Chef
+  class GuardInterpreter
+    class DefaultGuardInterpreter
+      include Chef::Mixin::ShellOut
+
+      protected
+
+      def initialize(command, opts)
+        @command = command
+        @command_opts = opts
+      end
+
+      public
+
+      def evaluate
+        shell_out(@command, @command_opts).status.success?
+      rescue Chef::Exceptions::CommandTimeout
+        Chef::Log.warn "Command '#{@command}' timed out"
+        false
+      end
+    end
+  end
+end
+      

data/lib/chef/guard_interpreter/resource_guard_interpreter.rb

@@ -0,0 +1,122 @@
+#
+# Author:: Adam Edwards (<adamed@getchef.com>)
+# Copyright:: Copyright (c) 2014 Opscode, Inc.
+# 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/guard_interpreter/default_guard_interpreter'
+
+class Chef
+  class GuardInterpreter
+    class ResourceGuardInterpreter < DefaultGuardInterpreter
+
+      def initialize(parent_resource, command, opts, &block)
+        super(command, opts)
+        @parent_resource = parent_resource
+        @resource = get_interpreter_resource(parent_resource)
+      end
+
+      def evaluate
+        # Add attributes inherited from the parent class
+        # to the resource
+        merge_inherited_attributes
+
+        # Script resources have a code attribute, which is
+        # what is used to execute the command, so include
+        # that with attributes specified by caller in opts
+        block_attributes = @command_opts.merge({:code => @command})
+
+        # Handles cases like powershell_script where default
+        # attributes are different when used in a guard vs. not. For
+        # powershell_script in particular, this will go away when
+        # the one attribue that causes this changes its default to be
+        # the same after some period to prepare for deprecation
+        if @resource.class.respond_to?(:get_default_attributes)
+          block_attributes = @resource.class.send(:get_default_attributes, @command_opts).merge(block_attributes)
+        end
+
+        resource_block = block_from_attributes(block_attributes)
+        evaluate_action(nil, &resource_block)
+      end
+
+      protected
+
+      def evaluate_action(action=nil, &block)
+        @resource.instance_eval(&block)
+
+        run_action = action || @resource.action
+
+        begin
+          @resource.run_action(run_action)
+          resource_updated = @resource.updated
+        rescue Mixlib::ShellOut::ShellCommandFailed
+          resource_updated = nil
+        end
+
+        resource_updated
+      end
+
+      def get_interpreter_resource(parent_resource)
+        if parent_resource.nil? || parent_resource.node.nil?
+          raise ArgumentError, "Node for guard resource parent must not be nil"
+        end
+
+        resource_class = Chef::Resource.resource_for_node(parent_resource.guard_interpreter, parent_resource.node)
+
+        if resource_class.nil?
+          raise ArgumentError, "Specified guard_interpreter resource #{parent_resource.guard_interpreter.to_s} unknown for this platform"
+        end
+
+        if ! resource_class.ancestors.include?(Chef::Resource::Script)
+          raise ArgumentError, "Specified guard interpreter class #{resource_class} must be a kind of Chef::Resource::Script resource"
+        end
+
+        empty_events = Chef::EventDispatch::Dispatcher.new
+        anonymous_run_context = Chef::RunContext.new(parent_resource.node, {}, empty_events)
+        interpreter_resource = resource_class.new('Guard resource', anonymous_run_context)
+
+        interpreter_resource
+      end
+
+      def block_from_attributes(attributes)
+        Proc.new do
+          attributes.keys.each do |attribute_name|
+            send(attribute_name, attributes[attribute_name]) if respond_to?(attribute_name)
+          end
+        end
+      end
+
+      def merge_inherited_attributes
+        inherited_attributes = []
+
+        if @parent_resource.class.respond_to?(:guard_inherited_attributes)
+          inherited_attributes = @parent_resource.class.send(:guard_inherited_attributes)
+        end
+
+        if inherited_attributes && !inherited_attributes.empty?
+          inherited_attributes.each do |attribute|
+            if @parent_resource.respond_to?(attribute) && @resource.respond_to?(attribute)
+              parent_value = @parent_resource.send(attribute)
+              child_value = @resource.send(attribute)
+              if parent_value || child_value
+                @resource.send(attribute, parent_value)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/chef/http.rb

@@ -393,4 +393,3 @@ class Chef
 
   end
 end
-

data/lib/chef/http/decompressor.rb

@@ -94,16 +94,21 @@ class Chef
       # object you can use to unzip/inflate a streaming response.
       def stream_response_handler(response)
         if gzip_disabled?
+          Chef::Log.debug "disable_gzip is set. \
+            Not using #{response[CONTENT_ENCODING]} \
+            and initializing noop stream deflator."
           NoopInflater.new
         else
           case response[CONTENT_ENCODING]
           when GZIP
-            Chef::Log.debug "decompressing gzip stream"
+            Chef::Log.debug "Initializing gzip stream deflator"
             GzipInflater.new
           when DEFLATE
-            Chef::Log.debug "decompressing inflate stream"
+            Chef::Log.debug "Initializing deflate stream deflator"
             DeflateInflater.new
           else
+            Chef::Log.debug "content_encoding = '#{response[CONTENT_ENCODING]}' \
+              initializing noop stream deflator."
             NoopInflater.new
           end
         end
@@ -137,5 +142,3 @@ class Chef
     end
   end
 end
-
-

data/lib/chef/http/simple.rb

@@ -11,6 +11,11 @@ class Chef
       use Decompressor
       use CookieManager
 
+      # ValidateContentLength should come after Decompressor
+      # because the order of middlewares is reversed when handling
+      # responses.
+      use ValidateContentLength
+
     end
   end
 end

data/lib/chef/http/validate_content_length.rb

@@ -49,22 +49,20 @@ class Chef
       end
 
       def handle_response(http_response, rest_request, return_value)
-        unless http_response['content-length']
-          Chef::Log.debug("HTTP server did not include a Content-Length header in response, cannot identify truncated downloads.")
-          return [http_response, rest_request, return_value]
-        end
-        validate(response_content_length(http_response), http_response.body.bytesize)
+        validate(http_response, http_response.body.bytesize) if http_response && http_response.body
         return [http_response, rest_request, return_value]
       end
 
       def handle_stream_complete(http_response, rest_request, return_value)
-        if http_response['content-length'].nil?
-          Chef::Log.debug("HTTP server did not include a Content-Length header in response, cannot idenfity streamed download.")
-        elsif @content_length_counter.nil?
+        if @content_length_counter.nil?
           Chef::Log.debug("No content-length information collected for the streamed download, cannot identify streamed download.")
         else
-          validate(response_content_length(http_response), @content_length_counter.content_length)
+          validate(http_response, @content_length_counter.content_length)
         end
+
+        # Make sure the counter is reset since this object might get used
+        # again. See CHEF-5100
+        @content_length_counter = nil
         return [http_response, rest_request, return_value]
       end
 
@@ -73,7 +71,9 @@ class Chef
       end
 
       private
+
       def response_content_length(response)
+        return nil if response['content-length'].nil?
         if response['content-length'].is_a?(Array)
           response['content-length'].first.to_i
         else
@@ -81,12 +81,28 @@ class Chef
         end
       end
 
-      def validate(content_length, response_length)
-        Chef::Log.debug "Content-Length header = #{content_length}"
-        Chef::Log.debug "Response body length = #{response_length}"
+      def validate(http_response, response_length)
+        content_length    = response_content_length(http_response)
+        transfer_encoding = http_response['transfer-encoding']
+        content_encoding  = http_response['content-encoding']
+
+        if content_length.nil?
+          Chef::Log.debug "HTTP server did not include a Content-Length header in response, cannot identify truncated downloads."
+          return true
+        end
+
+        # if Transfer-Encoding is set the RFC states that we must ignore the Content-Length field
+        # CHEF-5041: some proxies uncompress gzip content, leave the incorrect content-length, but set the transfer-encoding field
+        unless transfer_encoding.nil?
+          Chef::Log.debug "Transfer-Encoding header is set, skipping Content-Length check."
+          return true
+        end
+
         if response_length != content_length
           raise Chef::Exceptions::ContentLengthMismatch.new(response_length, content_length)
         end
+
+        Chef::Log.debug "Content-Length validated correctly."
         true
       end
     end

data/lib/chef/knife.rb

@@ -421,6 +421,7 @@ class Chef
 
       # Don't try to load a knife.rb if it wasn't specified.
       if config[:config_file]
+        Chef::Config.config_file = config[:config_file]
         fetcher = Chef::ConfigFetcher.new(config[:config_file], Chef::Config.config_file_jail)
         if fetcher.config_missing?
           ui.error("Specified config file #{config[:config_file]} does not exist#{Chef::Config.config_file_jail ? " or is not under config file jail #{Chef::Config.config_file_jail}" : ""}!")

data/lib/chef/knife/client_bulk_delete.rb

@@ -27,6 +27,11 @@ class Chef
         require 'chef/json_compat'
       end
 
+      option :delete_validators,
+       :short => "-D",
+       :long => "--delete-validators",
+       :description => "Force deletion of clients if they're validators"
+
       banner "knife client bulk delete REGEX (options)"
 
       def run
@@ -38,28 +43,62 @@ class Chef
 
         matcher = /#{name_args[0]}/
         clients_to_delete = {}
+        validators_to_delete = {}
         all_clients.each do |name, client|
           next unless name =~ matcher
-          clients_to_delete[client.name] = client
+          if client.validator
+            validators_to_delete[client.name] = client
+          else
+            clients_to_delete[client.name] = client
+          end
         end
 
-        if clients_to_delete.empty?
+        if clients_to_delete.empty? && validators_to_delete.empty?
           ui.info "No clients match the expression /#{name_args[0]}/"
           exit 0
         end
 
-        ui.msg("The following clients will be deleted:")
-        ui.msg("")
-        ui.msg(ui.list(clients_to_delete.keys.sort, :columns_down))
-        ui.msg("")
-        ui.confirm("Are you sure you want to delete these clients")
+        check_and_delete_validators(validators_to_delete)
+        check_and_delete_clients(clients_to_delete)
+      end
 
-        clients_to_delete.sort.each do |name, client|
+      def check_and_delete_validators(validators)
+        unless validators.empty?
+          unless config[:delete_validators]
+            ui.msg("Following clients are validators and will not be deleted.")
+            print_clients(validators)
+            ui.msg("You must specify --delete-validators to delete the validator clients")
+          else
+            ui.msg("The following validators will be deleted:")
+            print_clients(validators)
+            if ui.confirm_without_exit("Are you sure you want to delete these validators")
+              destroy_clients(validators)
+            end
+          end
+        end
+      end
+
+      def check_and_delete_clients(clients)
+        unless clients.empty?
+          ui.msg("The following clients will be deleted:")
+          print_clients(clients)
+          ui.confirm("Are you sure you want to delete these clients")
+          destroy_clients(clients)
+        end
+      end
+
+      def destroy_clients(clients)
+        clients.sort.each do |name, client|
           client.destroy
           ui.msg("Deleted client #{name}")
         end
       end
+
+      def print_clients(clients)
+        ui.msg("")
+        ui.msg(ui.list(clients.keys.sort, :columns_down))
+        ui.msg("")
+      end
     end
   end
 end
-

data/lib/chef/knife/client_delete.rb

@@ -27,9 +27,9 @@ class Chef
         require 'chef/json_compat'
       end
 
-      option :force,
-       :short => "-f",
-       :long => "--force",
+      option :delete_validators,
+       :short => "-D",
+       :long => "--delete-validators",
        :description => "Force deletion of client if it's a validator"
 
       banner "knife client delete CLIENT (options)"
@@ -46,7 +46,7 @@ class Chef
         delete_object(Chef::ApiClient, @client_name, 'client') {
           object = Chef::ApiClient.load(@client_name)
           if object.validator
-            unless config[:force]
+            unless config[:delete_validators]
               ui.fatal("You must specify --force to delete the validator client #{@client_name}")
               exit 2
             end

data/lib/chef/knife/cookbook_bulk_delete.rb

@@ -49,7 +49,7 @@ class Chef
         ui.msg ""
 
         unless config[:yes]
-          ui.confirm("Do you really want to delete these cookbooks? (Y/N) ", false)
+          ui.confirm("Do you really want to delete these cookbooks")
 
           if config[:purge]
             ui.msg("Files that are common to multiple cookbooks are shared, so purging the files may break other cookbooks.")

data/lib/chef/knife/cookbook_upload.rb

@@ -93,6 +93,7 @@ class Chef
         end
 
         assert_environment_valid!
+        warn_about_cookbook_shadowing
         version_constraints_to_update = {}
         upload_failures = 0
         upload_ok = 0
@@ -139,6 +140,7 @@ class Chef
             end
           end
 
+
           upload_failures += @name_args.length - @cookbooks_to_upload.length
 
           if upload_failures == 0
@@ -199,6 +201,10 @@ class Chef
       end
 
       def warn_about_cookbook_shadowing
+        # because cookbooks are lazy-loaded, we have to force the loader
+        # to load the cookbooks the user intends to upload here:
+        cookbooks_to_upload
+        
         unless cookbook_repo.merged_cookbooks.empty?
           ui.warn "* " * 40
           ui.warn(<<-WARNING)
@@ -257,14 +263,18 @@ WARNING
       end
 
       def check_for_dependencies!(cookbook)
-        # for each dependency, check if the version is on the server, or
+        # for all dependencies, check if the version is on the server, or
         # 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 "which is not currently being uploaded and cannot be found on the server."
-            exit 1
-          end
+        missing_dependencies = cookbook.metadata.dependencies.reject do |cookbook_name, version|
+          check_server_side_cookbooks(cookbook_name, version) || check_uploading_cookbooks(cookbook_name, version)
+        end
+
+        unless missing_dependencies.empty?
+          missing_cookbook_names = missing_dependencies.map { |cookbook_name, version|  "'#{cookbook_name}' version '#{version}'"}
+          ui.error "Cookbook #{cookbook.name} depends on cookbooks which are not currently"
+          ui.error "being uploaded and cannot be found on the server."
+          ui.error "The missing cookbook(s) are: #{missing_cookbook_names.join(', ')}"
+          exit 1
         end
       end