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

data/lib/chef/resource/user.rb

@@ -44,8 +44,6 @@ class Chef
           :manage_home => false,
           :non_unique => false
         }
-        @iterations = 27855
-        @salt = nil
         @allowed_actions.push(:create, :remove, :modify, :manage, :lock, :unlock)
       end
       
@@ -107,22 +105,6 @@ class Chef
         )
       end
 
-      def salt(arg=nil)
-        set_or_return(
-          :salt,
-          arg,
-          :kind_of => [ String ]
-        )
-      end
-
-      def iterations(arg=nil)
-        set_or_return(
-          :iterations,
-          arg,
-          :kind_of => [ Integer ]
-        )
-      end
-
       def system(arg=nil)
         set_or_return(
           :system,

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

@@ -7,9 +7,9 @@
 # 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.
@@ -23,7 +23,15 @@ require 'chef/resource_collection/stepable_iterator'
 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
@@ -31,18 +39,18 @@ class Chef
       @resources_by_name = Hash.new
       @insert_after_idx = nil
     end
-    
+
     def all_resources
       @resources
     end
-    
+
     def [](index)
       @resources[index]
     end
-    
+
     def []=(index, arg)
       is_chef_resource(arg)
-      @resources[index] = arg 
+      @resources[index] = arg
       @resources_by_name[arg.to_s] = index
     end
 
@@ -50,10 +58,14 @@ class Chef
       args.flatten.each do |a|
         is_chef_resource(a)
         @resources << a
-        @resources_by_name[a.to_s] = @resources.length - 1 
+        @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
@@ -67,20 +79,12 @@ class Chef
         end
         @resources_by_name[resource.to_s] = @insert_after_idx + 1
         @insert_after_idx += 1
-      else  
+      else
         @resources << resource
         @resources_by_name[resource.to_s] = @resources.length - 1
       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
@@ -94,13 +98,17 @@ class Chef
         yield resource
       end
     end
-    
+
     def each_index
       @resources.each_index do |i|
         yield i
       end
     end
-    
+
+    def empty?
+      @resources.empty?
+    end
+
     def lookup(resource)
       lookup_by = nil
       if resource.kind_of?(Chef::Resource)
@@ -125,7 +133,7 @@ class Chef
     # find("file[foobar]", "file[baz]")
     # find("file[foobar,baz]")
     #
-    # Returns the matching resource, or an Array of matching resources. 
+    # Returns the matching resource, or an Array of matching resources.
     #
     # Raises an ArgumentError if you feed it bad lookup information
     # Raises a Runtime Error if it can't find the resources you are looking for.
@@ -145,12 +153,42 @@ class Chef
       flat_results = results.flatten
       flat_results.length == 1 ? flat_results[0] : flat_results
     end
-    
+
     # resources is a poorly named, but we have to maintain it for back
     # compat.
     alias_method :resources, :find
-    
-    # Serialize this object as a hash 
+
+
+    # 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
       self.instance_variables.each do |iv|
@@ -162,7 +200,7 @@ class Chef
       }
       results.to_json(*a)
     end
-    
+
     def self.json_create(o)
       collection = self.new()
       o["instance_vars"].each do |k,v|
@@ -172,7 +210,7 @@ class Chef
     end
 
     private
-    
+
       def find_resource_by_hash(arg)
         results = Array.new
         arg.each do |resource_name, name_list|
@@ -188,28 +226,28 @@ 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
           resource_list.split(",").each do |name|
-            resource_name = "#{resource_type}[#{name}]" 
+            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
 
       def is_chef_resource(arg)
         unless arg.kind_of?(Chef::Resource)
-          raise ArgumentError, "Members must be Chef::Resource's" 
+          raise ArgumentError, "Members must be Chef::Resource's"
         end
         true
       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