chef 11.4.4 → 11.6.0.hotfix.1

data/lib/chef/resource/remote_file.rb

@@ -32,7 +32,11 @@ class Chef
         super
         @resource_name = :remote_file
         @action = "create"
-        @source = nil
+        @source = []
+        @use_etag = true
+        @use_last_modified = true
+        @ftp_active_mode = false
+        @headers = {}
         @provider = Chef::Provider::RemoteFile
       end
 
@@ -54,6 +58,48 @@ class Chef
         )
       end
 
+      # Disable or enable ETag and Last Modified conditional GET. Equivalent to
+      #   use_etag(true_or_false)
+      #   use_last_modified(true_or_false)
+      def use_conditional_get(true_or_false)
+        use_etag(true_or_false)
+        use_last_modified(true_or_false)
+      end
+
+      def use_etag(args=nil)
+        set_or_return(
+          :use_etag,
+          args,
+          :kind_of => [ TrueClass, FalseClass ]
+        )
+      end
+
+      alias :use_etags :use_etag
+
+      def use_last_modified(args=nil)
+        set_or_return(
+          :use_last_modified,
+          args,
+          :kind_of => [ TrueClass, FalseClass ]
+        )
+      end
+
+      def ftp_active_mode(args=nil)
+        set_or_return(
+          :ftp_active_mode,
+          args,
+          :kind_of => [ TrueClass, FalseClass ]
+        )
+      end
+
+      def headers(args=nil)
+        set_or_return(
+          :headers,
+          args,
+          :kind_of => Hash
+        )
+      end
+
       def after_created
         validate_source(@source)
       end

data/lib/chef/resource/route.rb

@@ -31,7 +31,7 @@ class Chef
         super
         @resource_name = :route
         @target = name
-        @action = :add
+        @action = [:add]
         @allowed_actions.push(:add, :delete)
         @netmask = nil
         @gateway = nil

data/lib/chef/resource/template.rb

@@ -29,6 +29,9 @@ class Chef
 
       provides :template, :on_platforms => :all
 
+      attr_reader :inline_helper_blocks
+      attr_reader :inline_helper_modules
+
       def initialize(name, run_context=nil)
         super
         @resource_name = :template
@@ -38,6 +41,9 @@ class Chef
         @local = false
         @variables = Hash.new
         @provider = Chef::Provider::Template
+        @inline_helper_blocks = {}
+        @inline_helper_modules = []
+        @helper_modules = []
       end
 
       def source(file=nil)
@@ -71,6 +77,145 @@ class Chef
           :kind_of => [ TrueClass, FalseClass ]
         )
       end
+
+      # Declares a helper method to be defined in the template context when
+      # rendering.
+      #
+      # === Example:
+      #
+      # ==== Basic usage:
+      # Given the following helper:
+      #   helper(:static_value) { "hello from helper" }
+      # A template with the following code:
+      #   <%= static_value %>
+      # Will render as;
+      #   hello from helper
+      #
+      # ==== Referencing Instance Variables:
+      # Any instance variables available to the template can be referenced in
+      # the method body. For example, you can simplify accessing app-specific
+      # node attributes like this:
+      #   helper(:app) { @node[:my_app_attributes] }
+      # And use it in a template like this:
+      #   <%= app[:listen_ports] %>
+      # This is equivalent to the non-helper template code:
+      #   <%= @node[:my_app_attributes][:listen_ports] %>
+      #
+      # ==== Method Arguments:
+      # Helper methods can also take arguments. The syntax available for
+      # argument specification will be dependent on ruby version. Ruby 1.8 only
+      # supports a subset of the argument specification syntax available for
+      # method definition, whereas 1.9 supports the full syntax.
+      #
+      # Continuing the above example of simplifying attribute access, we can
+      # define a helper to look up app-specific attributes like this:
+      #   helper(:app) { |setting| @node[:my_app_attributes][setting] }
+      # The template can then look up attributes like this:
+      #   <%= app(:listen_ports) %>
+      def helper(method_name, &block)
+        unless block_given?
+          raise Exceptions::ValidationFailed,
+            "`helper(:method)` requires a block argument (e.g., `helper(:method) { code }`)"
+        end
+
+        unless method_name.kind_of?(Symbol)
+          raise Exceptions::ValidationFailed,
+            "method_name argument to `helper(method_name)` must be a symbol (e.g., `helper(:method) { code }`)"
+        end
+
+        @inline_helper_blocks[method_name] = block
+      end
+
+      # Declares a module to define helper methods in the template's context
+      # when rendering. There are two primary forms.
+      #
+      # === Inline Module Definition
+      # When a block is given, the block is used to define a module which is
+      # then mixed in to the template context w/ `extend`.
+      #
+      # ==== Inline Module Example
+      # Given the following code in the template resource:
+      #   helpers do
+      #     # Add "syntax sugar" for referencing app-specific attributes
+      #     def app(attribute)
+      #       @node[:my_app_attributes][attribute]
+      #     end
+      #   end
+      # You can use it in the template like so:
+      #   <%= app(:listen_ports) %>
+      # Which is equivalent to:
+      #   <%= @node[:my_app_attributes][:listen_ports] %>
+      #
+      # === External Module Form
+      # When a module name is given, the template context will be extended with
+      # that module. This is the recommended way to customize template contexts
+      # when you need to define more than an handful of helper functions (but
+      # also try to keep your template helpers from getting out of hand--if you
+      # have very complex logic in your template helpers, you should further
+      # extract your code into separate libraries).
+      #
+      # ==== External Module Example
+      # To extract the above inline module code to a library, you'd create a
+      # library file like this:
+      #   module MyTemplateHelper
+      #     # Add "syntax sugar" for referencing app-specific attributes
+      #     def app(attribute)
+      #       @node[:my_app_attributes][attribute]
+      #     end
+      #   end
+      # And in the template resource:
+      #   helpers(MyTemplateHelper)
+      # The template code in the above example will work unmodified.
+      def helpers(module_name=nil,&block)
+        if block_given? and !module_name.nil?
+          raise Exceptions::ValidationFailed,
+            "Passing both a module and block to #helpers is not supported. Call #helpers multiple times instead"
+        elsif block_given?
+          @inline_helper_modules << block
+        elsif module_name.kind_of?(::Module)
+          @helper_modules << module_name
+        elsif module_name.nil?
+          raise Exceptions::ValidationFailed,
+            "#helpers requires either a module name or inline module code as a block.\n" +
+            "e.g.: helpers do; helper_code; end;\n" +
+            "OR: helpers(MyHelpersModule)"
+        else
+          raise Exceptions::ValidationFailed,
+            "Argument to #helpers must be a module. You gave #{module_name.inspect} (#{module_name.class})"
+        end
+      end
+
+      # Compiles all helpers from inline method definitions, inline module
+      # definitions, and external modules into an Array of Modules. The context
+      # object for the template is extended with these modules to provide
+      # per-resource template logic.
+      def helper_modules
+        compiled_helper_methods + compiled_helper_modules + @helper_modules
+      end
+
+      private
+
+      # compiles helper methods into a module that can be included in template context
+      def compiled_helper_methods
+        if inline_helper_blocks.empty?
+          []
+        else
+          resource_helper_blocks = inline_helper_blocks
+          helper_mod = Module.new do
+            resource_helper_blocks.each do |method_name, method_body|
+              define_method(method_name, &method_body)
+            end
+          end
+          [ helper_mod ]
+        end
+      end
+
+      def compiled_helper_modules
+        @inline_helper_modules.map do |module_body|
+          Module.new(&module_body)
+        end
+      end
+
     end
   end
 end

data/lib/chef/resource/windows_script.rb

@@ -0,0 +1,62 @@
+#
+# Author:: Adam Edwards (<adamed@opscode.com>)
+# Copyright:: Copyright (c) 2013 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/resource/script'
+require 'chef/mixin/windows_architecture_helper'
+
+class Chef
+  class Resource
+    class WindowsScript < Chef::Resource::Script
+
+      protected
+
+      def initialize(name, run_context, resource_name, interpreter_command)
+        super(name, run_context)
+        @interpreter = interpreter_command        
+        @resource_name = resource_name
+      end
+
+      include Chef::Mixin::WindowsArchitectureHelper
+
+      public
+      
+      def architecture(arg=nil)
+        assert_architecture_compatible!(arg) if ! arg.nil?
+        result = set_or_return(
+          :architecture,
+          arg,
+          :kind_of => Symbol
+        )
+      end
+      
+      protected
+
+      def assert_architecture_compatible!(desired_architecture)
+        if ! node_supports_windows_architecture?(node, desired_architecture)
+          raise Chef::Exceptions::Win32ArchitectureIncorrect,
+          "cannot execute script with requested architecture '#{desired_architecture.to_s}' on a system with architecture '#{node_windows_architecture(node)}'"
+        end
+      end
+
+      def node
+        run_context && run_context.node
+      end
+      
+    end
+  end
+end

data/lib/chef/resource_collection.rb

@@ -24,6 +24,14 @@ class Chef
   class ResourceCollection
     include Enumerable
 
+    # Matches a multiple resource lookup specification,
+    # e.g., "service[nginx,unicorn]"
+    MULTIPLE_RESOURCE_MATCH = /^(.+)\[(.+?),(.+)\]$/
+
+    # Matches a single resource lookup specification,
+    # e.g., "service[nginx]"
+    SINGLE_RESOURCE_MATCH = /^(.+)\[(.+)\]$/
+
     attr_reader :iterator
 
     def initialize
@@ -52,8 +60,12 @@ class Chef
         @resources << a
         @resources_by_name[a.to_s] = @resources.length - 1
       end
+      self
     end
 
+    # 'push' is an alias method to <<
+    alias_method :push, :<<
+
     def insert(resource)
       is_chef_resource(resource)
       if @insert_after_idx
@@ -73,14 +85,6 @@ class Chef
       end
     end
 
-    def push(*args)
-      args.flatten.each do |arg|
-        is_chef_resource(arg)
-        @resources.push(arg)
-        @resources_by_name[arg.to_s] = @resources.length - 1
-      end
-    end
-
     def each
       @resources.each do |resource|
         yield resource
@@ -154,6 +158,36 @@ class Chef
     # compat.
     alias_method :resources, :find
 
+
+    # Returns true if +query_object+ is a valid string for looking up a
+    # resource, or raises InvalidResourceSpecification if not.
+    # === Arguments
+    # * query_object should be a string of the form
+    # "resource_type[resource_name]", a single element Hash (e.g., :service =>
+    # "apache2"), or a Chef::Resource (this is the happy path). Other arguments
+    # will raise an exception.
+    # === Returns
+    # * true returns true for all valid input.
+    # === Raises
+    # * Chef::Exceptions::InvalidResourceSpecification for all invalid input.
+    def validate_lookup_spec!(query_object)
+      case query_object
+      when Chef::Resource
+        true
+      when SINGLE_RESOURCE_MATCH, MULTIPLE_RESOURCE_MATCH
+        true
+      when Hash
+        true
+      when String
+        raise Chef::Exceptions::InvalidResourceSpecification,
+          "The string `#{query_object}' is not valid for resource collection lookup. Correct syntax is `resource_type[resource_name]'"
+      else
+        raise Chef::Exceptions::InvalidResourceSpecification,
+          "The object `#{query_object.inspect}' is not valid for resource collection lookup. " + 
+          "Use a String like `resource_type[resource_name]' or a Chef::Resource object"
+      end
+    end
+
     # Serialize this object as a hash
     def to_json(*a)
       instance_vars = Hash.new
@@ -192,7 +226,7 @@ class Chef
       def find_resource_by_string(arg)
         results = Array.new
         case arg
-        when /^(.+)\[(.+?),(.+)\]$/
+        when MULTIPLE_RESOURCE_MATCH
           resource_type = $1
           arg =~ /^.+\[(.+)\]$/
           resource_list = $1
@@ -200,13 +234,13 @@ class Chef
             resource_name = "#{resource_type}[#{name}]"
             results << lookup(resource_name)
           end
-        when /^(.+)\[(.+)\]$/
+        when SINGLE_RESOURCE_MATCH
           resource_type = $1
           name = $2
           resource_name = "#{resource_type}[#{name}]"
           results << lookup(resource_name)
         else
-          raise ArgumentError, "You must have a string like resource_type[name]!"
+          raise ArgumentError, "Bad string format #{arg}, you must have a string like resource_type[name]!"
         end
         return results
       end

data/lib/chef/resource_reporter.rb

@@ -20,13 +20,12 @@
 #
 
 require 'uri'
+require 'chef/monkey_patches/securerandom'
 require 'chef/event_dispatch/base'
 
 class Chef
   class ResourceReporter < EventDispatch::Base
 
-
-
     class ResourceReport < Struct.new(:new_resource,
                                       :current_resource,
                                       :action,
@@ -65,10 +64,12 @@ class Chef
         else
           #as_hash["result"] = "failed"
         end
-        as_hash["cookbook_name"] = new_resource.cookbook_name
-        as_hash["cookbook_version"] = new_resource.cookbook_version.version
-        as_hash
+        if new_resource.cookbook_name
+          as_hash["cookbook_name"] = new_resource.cookbook_name
+          as_hash["cookbook_version"] = new_resource.cookbook_version.version
+        end
 
+        as_hash
       end
 
       def finish
@@ -78,14 +79,16 @@ class Chef
       def success?
         !self.exception
       end
-    end
+
+    end # End class ResouceReport
 
     attr_reader :updated_resources
     attr_reader :status
     attr_reader :exception
     attr_reader :run_id
     attr_reader :error_descriptions
-    attr_reader :summary_only
+
+    PROTOCOL_VERSION = '0.1.0'
 
     def initialize(rest_client)
       if Chef::Config[:enable_reporting] && !Chef::Config[:why_run]
@@ -98,37 +101,55 @@ class Chef
       @pending_update  = nil
       @status = "success"
       @exception = nil
-      @run_id = nil
+      @run_id = SecureRandom.uuid
       @rest_client = rest_client
-      @node = nil
       @error_descriptions = {}
-      @summary_only = true
     end
 
-    def node_load_completed(node, expanded_run_list_with_versions, config)
-      @node = node
+    def run_started(run_status)
+      @run_status = run_status
+
       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}")
-          @summary_only = server_response["summary_only"]
+          resource_history_url = "reports/nodes/#{node_name}/runs"
+          server_response = @rest_client.post_rest(resource_history_url, {:action => :start, :run_id => @run_id,
+                                                                          :start_time => start_time.to_s}, headers)
         rescue Timeout::Error, Errno::EINVAL, Errno::ECONNRESET, EOFError, Net::HTTPBadResponse, Net::HTTPHeaderSyntaxError, Net::ProtocolError => e
-          if !e.response || e.response.code.to_s != "404"
-            if Chef::Config[:enable_reporting_url_fatals]
-              Chef::Log.error("Received exception #{"(" + e.response.code + ") " if e.response.code}attempting to generate run history id (URL Path: #{resource_history_url}), and enable_reporting_url_fatals is set, aborting run.")
-              raise
-            else
-              Chef::Log.info("Received exception #{"(" + e.response.code + ") " if e.response.code}attempting to generate run history id (URL Path: #{resource_history_url}), disabling reporting for this run.")
-            end
-          else
-            Chef::Log.debug("Received 404 attempting to generate run history id (URL Path: #{resource_history_url}), assuming feature is not supported on server.")
-          end
-          @reporting_enabled = false
+          handle_error_starting_run(e, resource_history_url)
+        end
+      end
+    end
+
+    def handle_error_starting_run(e, url)
+      message = "Reporting error starting run. URL: #{url} "
+      code = if e.response.code
+               e.response.code.to_s
+             else
+               "Exception Code Empty"
+             end
+
+      if !e.response || (code != "404" && code != "406")
+        exception = "Exception: #{code} "
+        if Chef::Config[:enable_reporting_url_fatals]
+          reporting_status = "Reporting fatals enabled. Aborting run. "
+          Chef::Log.error(message + exception + reporting_status)
+          raise
+        else
+          reporting_status = "Disabling reporting for run."
+          Chef::Log.info(message + exception + reporting_status)
+        end
+      else
+        reason = "Received #{code}. "
+        if code == "406"
+          reporting_status = "Client version not supported. Please update the client. Disabling reporting for run."
+          Chef::Log.info(message + reason + reporting_status)
+        else
+          reporting_status = "Disabling reporting for run."
+          Chef::Log.debug(message + reason + reporting_status)
         end
       end
+
+      @reporting_enabled = false
     end
 
     def resource_current_state_loaded(new_resource, action, current_resource)
@@ -177,29 +198,25 @@ class Chef
     def run_failed(exception)
       @exception = exception
       @status = "failure"
-      post_reporting_data
+      # If we failed before we received the run_started callback, there's not much we can do
+      # in terms of reporting
+      if @run_status
+          post_reporting_data
+      end
     end
 
     def post_reporting_data
       if reporting_enabled?
         run_data = prepare_run_data
-        resource_history_url = "reports/nodes/#{@node.name}/runs/#{@run_id}"
+        resource_history_url = "reports/nodes/#{node_name}/runs/#{@run_id}"
         Chef::Log.info("Sending resource update report (run-id: #{@run_id})")
         Chef::Log.debug run_data.inspect
         compressed_data = encode_gzip(run_data.to_json)
         begin
-          #if summary only is enabled send the uncompressed run_data excluding the run_data["resources"] and some additional metrics.
-          if @summary_only
-            run_data = report_summary(run_data, compressed_data)
-            Chef::Log.info("run_data_summary: #{run_data}")
-            @rest_client.post_rest(resource_history_url, run_data)
-          else
-            Chef::Log.debug("Sending compressed run data...")
-            # Since we're posting compressed data we can not directly call
-            # post_rest which expects JSON
-            reporting_url = @rest_client.create_url(resource_history_url)
-            @rest_client.raw_http_request(:POST, reporting_url, {'Content-Encoding' => 'gzip'}, compressed_data)
-          end
+          Chef::Log.debug("Sending compressed run data...")
+          # Since we're posting compressed data we can not directly call post_rest which expects JSON
+          reporting_url = @rest_client.create_url(resource_history_url)
+          @rest_client.raw_http_request(:POST, reporting_url, headers({'Content-Encoding' => 'gzip'}), compressed_data)
         rescue Net::HTTPServerException => e
           if e.response.code.to_s == "400"
             Chef::FileCache.store("failed-reporting-data.json", Chef::JSONCompat.to_json_pretty(run_data), 0640)
@@ -212,7 +229,24 @@ class Chef
         Chef::Log.debug("Server doesn't support resource history, skipping resource report.")
       end
     end
-    
+
+    def headers(additional_headers = {})
+      options = {'X-Ops-Reporting-Protocol-Version' => PROTOCOL_VERSION}
+      options.merge(additional_headers)
+    end
+
+    def node_name
+      @run_status.node.name
+    end
+
+    def start_time
+      @run_status.start_time
+    end
+
+    def end_time
+      @run_status.end_time
+    end
+
     def prepare_run_data
       run_data = {}
       run_data["action"] = "end"
@@ -220,9 +254,11 @@ class Chef
         resource_record.for_json
       end
       run_data["status"] = @status
-      run_data["run_list"] = @node.run_list.to_json
+      run_data["run_list"] = @run_status.node.run_list.to_json
       run_data["total_res_count"] = @total_res_count.to_s
       run_data["data"] = {}
+      run_data["start_time"] = start_time.to_s
+      run_data["end_time"] = end_time.to_s
 
       if exception
         exception_data = {}
@@ -235,13 +271,6 @@ class Chef
       run_data
     end
 
-    def report_summary(run_data, compressed_data)
-      run_data["updated_res_count"] = updated_resources.count.to_s
-      run_data["post_size"] = compressed_data.bytesize.to_s
-      run_data["resources"] = []
-      run_data
-    end
-
     def run_list_expand_failed(node, exception)
       description = Formatters::ErrorMapper.run_list_expand_failed(node, exception)
       @error_descriptions = description.for_json