chef 12.10.24-universal-mingw32 → 12.11.18-universal-mingw32

data/lib/chef/decorator/lazy.rb

@@ -0,0 +1,60 @@
+#--
+# Copyright:: Copyright 2016 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.
+#
+
+require "chef/decorator"
+
+class Chef
+  class Decorator
+    # Lazy wrapper to delay construction of an object until a method is
+    # called against the object.
+    #
+    # @example
+    #
+    #     def foo
+    #       puts "allocated"
+    #       "value"
+    #     end
+    #
+    #     a = Chef::Decorator::Lazy.new { foo }
+    #
+    #     puts "started"
+    #     a
+    #     puts "still lazy"
+    #     puts a
+    #
+    #   outputs:
+    #
+    #     started
+    #     still lazy
+    #     allocated
+    #     value
+    #
+    # @since 12.10.x
+    class Lazy < Decorator
+      def initialize(&block)
+        super
+        @block = block
+      end
+
+      def __getobj__
+        __setobj__(@block.call) unless defined?(@delegate_sd_obj)
+        super
+      end
+
+    end
+  end
+end

data/lib/chef/decorator/lazy_array.rb

@@ -0,0 +1,59 @@
+#--
+# Copyright:: Copyright 2016 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.
+#
+
+require "chef/decorator/lazy"
+
+class Chef
+  class Decorator
+    # Lazy Array around Lazy Objects
+    #
+    # This only lazys access through `#[]`.  In order to implement #each we need to
+    # know how many items we have and what their indexes are, so we'd have to evalute
+    # the proc which makes that impossible.  You can call methods like #each and the
+    # decorator will forward the method, but item access will not be lazy.
+    #
+    # #at() and #fetch() are not implemented but technically could be.
+    #
+    # @example
+    #     def foo
+    #         puts "allocated"
+    #           "value"
+    #     end
+    #
+    #     a = Chef::Decorator::LazyArray.new { [ foo ] }
+    #
+    #     puts "started"
+    #     a[0]
+    #     puts "still lazy"
+    #     puts a[0]
+    #
+    #   outputs:
+    #
+    #     started
+    #     still lazy
+    #     allocated
+    #     value
+    #
+    # @since 12.10.x
+    class LazyArray < Lazy
+      def [](idx)
+        block = @block
+        Lazy.new { block.call[idx] }
+      end
+    end
+  end
+end

data/lib/chef/deprecation/provider/remote_file.rb

@@ -56,7 +56,7 @@ class Chef
         def source_file(source, current_checksum, &block)
           if absolute_uri?(source)
             fetch_from_uri(source, &block)
-          elsif !Chef::Config[:solo]
+          elsif !Chef::Config[:solo_legacy_mode]
             fetch_from_chef_server(source, current_checksum, &block)
           else
             fetch_from_local_cookbook(source, &block)

data/lib/chef/dsl/core.rb

@@ -18,27 +18,35 @@
 #
 
 require "chef/dsl/declare_resource"
+require "chef/dsl/universal"
 require "chef/mixin/notifying_block"
-require "chef/mixin/powershell_out"
-require "chef/mixin/shell_out"
+require "chef/mixin/lazy_module_include"
 
 class Chef
   module DSL
-    # This is the "Core DSL" with various bits of Sugar that are mixed into core providers as well
-    # as user LWRPs.  This module deliberately does not mixin the Resources or Defintions DSL bits
-    # so that cookbooks are not injeting random things into the namespace of core providers.
+    # Part of a family of DSL mixins.
     #
-    # - If you are writing cookbooks:  you have come to the wrong place, please inject things into
-    #   Chef::DSL::Recipe instead.
+    # Chef::DSL::Recipe mixes into Recipes and LWRP Providers.
+    #   - this does not target core chef resources and providers.
+    #   - this is restricted to recipe/resource/provider context where a resource collection exists.
+    #   - cookbook authors should typically include modules into here.
     #
-    # - If you are writing core chef:  you have come to the right place, please drop your DSL modules
-    #   into here.
+    # Chef::DSL::Core mixes into Recipes, LWRP Providers and Core Providers
+    #   - this adds cores providers on top of the Recipe DSL.
+    #   - this is restricted to recipe/resource/provider context where a resource collection exists.
+    #   - core chef authors should typically include modules into here.
+    #
+    # Chef::DSL::Universal mixes into Recipes, LWRP Resources+Providers, Core Resources+Providers, and Attributes files.
+    #   - this adds resources and attributes files.
+    #   - do not add helpers which manipulate the resource collection.
+    #   - this is for general-purpose stuff that is useful nearly everywhere.
+    #   - it also pollutes the namespace of nearly every context, watch out.
     #
     module Core
+      include Chef::DSL::Universal
       include Chef::DSL::DeclareResource
       include Chef::Mixin::NotifyingBlock
-      include Chef::Mixin::PowershellOut
-      include Chef::Mixin::ShellOut
+      extend Chef::Mixin::LazyModuleInclude
     end
   end
 end

data/lib/chef/dsl/platform_introspection.rb

@@ -245,6 +245,22 @@ class Chef
         end
       end
 
+      # Shamelessly stolen from https://github.com/sethvargo/chef-sugar/blob/master/lib/chef/sugar/docker.rb
+      # Given a node object, returns whether the node is a docker container.
+      #
+      # === Parameters
+      # node:: [Chef::Node] The node to check.
+      #
+      # === Returns
+      # true:: if the current node is a docker container
+      # false:: if the current node is not a docker container
+      def docker?(node = run_context.nil? ? nil : run_context.node)
+        # Using "File.exist?('/.dockerinit') || File.exist?('/.dockerenv')" makes Travis sad,
+        # and that makes us sad too.
+        node && node[:virtualization] && node[:virtualization][:systems] &&
+          node[:virtualization][:systems][:docker] && node[:virtualization][:systems][:docker] == "guest"
+      end
+
     end
   end
 end

data/lib/chef/dsl/recipe.rb

@@ -21,7 +21,6 @@ require "chef/exceptions"
 require "chef/dsl/resources"
 require "chef/dsl/definitions"
 require "chef/dsl/data_query"
-require "chef/dsl/platform_introspection"
 require "chef/dsl/include_recipe"
 require "chef/dsl/registry_helper"
 require "chef/dsl/reboot_pending"
@@ -33,20 +32,27 @@ require "chef/mixin/lazy_module_include"
 
 class Chef
   module DSL
-    # This is the "Recipe DSL" which is all the sugar, plus all the resources and definitions
-    # which are mixed into user LWRPs/Resources/Providers.
+    # Part of a family of DSL mixins.
     #
-    # - If you are writing cookbooks:  you have come to the right place, please inject things
-    #   into here if you want to make them available to all recipe and non-core provider code.
+    # Chef::DSL::Recipe mixes into Recipes and LWRP Providers.
+    #   - this does not target core chef resources and providers.
+    #   - this is restricted to recipe/resource/provider context where a resource collection exists.
+    #   - cookbook authors should typically include modules into here.
     #
-    # - If you are writing core chef:  you have likely come to the wrong place, please consider
-    #   dropping your DSL modules into Chef::DSL::Core instead so that we can use them in core
-    #   providers (unless they are *only* intended for recipe code).
+    # Chef::DSL::Core mixes into Recipes, LWRP Providers and Core Providers
+    #   - this adds cores providers on top of the Recipe DSL.
+    #   - this is restricted to recipe/resource/provider context where a resource collection exists.
+    #   - core chef authors should typically include modules into here.
+    #
+    # Chef::DSL::Universal mixes into Recipes, LWRP Resources+Providers, Core Resources+Providers, and Attributes files.
+    #   - this adds resources and attributes files.
+    #   - do not add helpers which manipulate the resource collection.
+    #   - this is for general-purpose stuff that is useful nearly everywhere.
+    #   - it also pollutes the namespace of nearly every context, watch out.
     #
     module Recipe
       include Chef::DSL::Core
       include Chef::DSL::DataQuery
-      include Chef::DSL::PlatformIntrospection
       include Chef::DSL::IncludeRecipe
       include Chef::DSL::RegistryHelper
       include Chef::DSL::RebootPending

data/lib/chef/dsl/universal.rb

@@ -0,0 +1,50 @@
+#--
+# Author:: Adam Jacob (<adam@chef.io>)
+# Author:: Christopher Walters (<cw@chef.io>)
+# Copyright:: Copyright 2008-2016, 2009-2015 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.
+#
+
+require "chef/dsl/platform_introspection"
+require "chef/mixin/powershell_out"
+require "chef/mixin/shell_out"
+
+class Chef
+  module DSL
+    # Part of a family of DSL mixins.
+    #
+    # Chef::DSL::Recipe mixes into Recipes and LWRP Providers.
+    #   - this does not target core chef resources and providers.
+    #   - this is restricted to recipe/resource/provider context where a resource collection exists.
+    #   - cookbook authors should typically include modules into here.
+    #
+    # Chef::DSL::Core mixes into Recipes, LWRP Providers and Core Providers
+    #   - this adds cores providers on top of the Recipe DSL.
+    #   - this is restricted to recipe/resource/provider context where a resource collection exists.
+    #   - core chef authors should typically include modules into here.
+    #
+    # Chef::DSL::Universal mixes into Recipes, LWRP Resources+Providers, Core Resources+Providers, and Attributes files.
+    #   - this adds resources and attributes files.
+    #   - do not add helpers which manipulate the resource collection.
+    #   - this is for general-purpose stuff that is useful nearly everywhere.
+    #   - it also pollutes the namespace of nearly every context, watch out.
+    #
+    module Universal
+      include Chef::DSL::PlatformIntrospection
+      include Chef::Mixin::PowershellOut
+      include Chef::Mixin::ShellOut
+    end
+  end
+end

data/lib/chef/environment.rb

@@ -244,7 +244,7 @@ class Chef
     end
 
     def self.load(name)
-      if Chef::Config[:solo]
+      if Chef::Config[:solo_legacy_mode]
         load_from_file(name)
       else
         self.from_hash(chef_server_rest.get("environments/#{name}"))
@@ -310,7 +310,7 @@ class Chef
 
     def self.validate_cookbook_version(version)
       begin
-        if Chef::Config[:solo]
+        if Chef::Config[:solo_legacy_mode]
           raise Chef::Exceptions::IllegalVersionConstraint,
                 "Environment cookbook version constraints not allowed in chef-solo"
         else

data/lib/chef/exceptions.rb

@@ -42,6 +42,8 @@ class Chef
     end
 
     class Application < RuntimeError; end
+    class SigInt < RuntimeError; end
+    class SigTerm < RuntimeError; end
     class Cron < RuntimeError; end
     class Env < RuntimeError; end
     class Exec < RuntimeError; end
@@ -56,6 +58,14 @@ class Chef
     class UnsupportedAction < RuntimeError; end
     class MissingLibrary < RuntimeError; end
 
+    class DeprecatedExitCode < RuntimeError
+      def initalize
+        super "Exiting with a non RFC 062 Exit Code."
+        require "chef/application/exit_code"
+        Chef::Application::ExitCode.notify_deprecated_exit_code
+      end
+    end
+
     class CannotDetermineNodeName < RuntimeError
       def initialize
         super "Unable to determine node name: configure node_name or configure the system's hostname and fqdn"
@@ -66,6 +76,9 @@ class Chef
     class Group < RuntimeError; end
     class Link < RuntimeError; end
     class Mount < RuntimeError; end
+    class Reboot < Exception; end
+    class RebootPending < Exception; end
+    class RebootFailed < Mixlib::ShellOut::ShellCommandFailed; end
     class PrivateKeyMissing < RuntimeError; end
     class CannotWritePrivateKey < RuntimeError; end
     class RoleNotFound < RuntimeError; end
@@ -426,18 +439,20 @@ This error is most often caused by network issues (proxies, etc) outside of chef
       end
     end
 
-    class AuditControlGroupDuplicate < RuntimeError
+    class AuditError < RuntimeError; end
+
+    class AuditControlGroupDuplicate < AuditError
       def initialize(name)
         super "Control group with name '#{name}' has already been defined"
       end
     end
-    class AuditNameMissing < RuntimeError; end
-    class NoAuditsProvided < RuntimeError
+    class AuditNameMissing < AuditError; end
+    class NoAuditsProvided < AuditError
       def initialize
         super "You must provide a block with controls"
       end
     end
-    class AuditsFailed < RuntimeError
+    class AuditsFailed < AuditError
       def initialize(num_failed, num_total)
         super "Audit phase found failures - #{num_failed}/#{num_total} controls failed"
       end

data/lib/chef/handler.rb

@@ -57,16 +57,47 @@ class Chef
   #
   class Handler
 
+    def self.handler_for(*args)
+      if args.include?(:start)
+        Chef::Config[:start_handlers] ||= []
+        Chef::Config[:start_handlers] |= [self]
+      end
+      if args.include?(:report)
+        Chef::Config[:report_handlers] ||= []
+        Chef::Config[:report_handlers] |= [self]
+      end
+      if args.include?(:exception)
+        Chef::Config[:exception_handlers] ||= []
+        Chef::Config[:exception_handlers] |= [self]
+      end
+    end
+
     # The list of currently configured start handlers
     def self.start_handlers
       Array(Chef::Config[:start_handlers])
     end
 
+    def self.resolve_handler_instance(handler)
+      if handler.is_a?(Class)
+        if handler.respond_to?(:instance)
+          # support retrieving a Singleton reporting object
+          handler.instance
+        else
+          # just a class with no way to insert data
+          handler.new
+        end
+      else
+        # the Chef::Config array contains an instance, not a class
+        handler
+      end
+    end
+
     # Run the start handlers. This will usually be called by a notification
     # from Chef::Client
     def self.run_start_handlers(run_status)
       Chef::Log.info("Running start handlers")
       start_handlers.each do |handler|
+        handler = resolve_handler_instance(handler)
         handler.run_report_safely(run_status)
       end
       Chef::Log.info("Start handlers complete.")
@@ -90,6 +121,7 @@ class Chef
       events.handlers_start(report_handlers.size)
       Chef::Log.info("Running report handlers")
       report_handlers.each do |handler|
+        handler = resolve_handler_instance(handler)
         handler.run_report_safely(run_status)
         events.handler_executed(handler)
       end
@@ -115,6 +147,7 @@ class Chef
       events.handlers_start(exception_handlers.size)
       Chef::Log.error("Running exception handlers")
       exception_handlers.each do |handler|
+        handler = resolve_handler_instance(handler)
         handler.run_report_safely(run_status)
         events.handler_executed(handler)
       end

data/lib/chef/knife/cookbook_show.rb

@@ -51,6 +51,10 @@ class Chef
         :description => "Show corresponding URIs"
 
       def run
+        cookbook_name, cookbook_version, segment, filename = @name_args
+
+        cookbook = Chef::CookbookVersion.load(cookbook_name, cookbook_version) unless cookbook_version.nil?
+
         case @name_args.length
         when 4 # We are showing a specific file
           node = Hash.new
@@ -64,10 +68,6 @@ class Chef
             end
           end
 
-          cookbook_name, segment, filename = @name_args[0], @name_args[2], @name_args[3]
-          cookbook_version = @name_args[1] == "latest" ? "_latest" : @name_args[1]
-
-          cookbook = rest.get("cookbooks/#{cookbook_name}/#{cookbook_version}")
           manifest_entry = cookbook.preferred_manifest_record(node, segment, filename)
           temp_file = rest.streaming_request(manifest_entry[:url])
 
@@ -76,14 +76,10 @@ class Chef
           pretty_print(temp_file.read)
 
         when 3 # We are showing a specific part of the cookbook
-          cookbook_version = @name_args[1] == "latest" ? "_latest" : @name_args[1]
-          result = rest.get("cookbooks/#{@name_args[0]}/#{cookbook_version}")
-          output(result.manifest[@name_args[2]])
+          output(cookbook.manifest[segment])
         when 2 # We are showing the whole cookbook data
-          cookbook_version = @name_args[1] == "latest" ? "_latest" : @name_args[1]
-          output(rest.get("cookbooks/#{@name_args[0]}/#{cookbook_version}"))
+          output(cookbook)
         when 1 # We are showing the cookbook versions (all of them)
-          cookbook_name = @name_args[0]
           env           = config[:environment]
           api_endpoint  = env ? "environments/#{env}/cookbooks/#{cookbook_name}" : "cookbooks/#{cookbook_name}"
           output(format_cookbook_list_for_display(rest.get(api_endpoint)))