chef 12.0.0.rc.0-x86-mingw32 → 12.0.0-x86-mingw32

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

@@ -29,9 +29,12 @@ class Chef
 
         provides :service, os: "linux"
 
+        def self.provides?(node, resource)
+          super && Chef::Platform::ServiceHelpers.service_resource_providers.include?(:upstart)
+        end
+
         def self.supports?(resource, action)
-          Chef::Platform::ServiceHelpers.service_resource_providers.include?(:upstart) &&
-            Chef::Platform::ServiceHelpers.config_for_service(resource.service_name).include?(:upstart)
+          Chef::Platform::ServiceHelpers.config_for_service(resource.service_name).include?(:upstart)
         end
 
         # Upstart does more than start or stop a service, creating multiple 'states' [1] that a service can be in.

data/lib/chef/provider_resolver.rb

@@ -23,22 +23,42 @@ class Chef
   class ProviderResolver
 
     attr_reader :node
+    attr_reader :resource
+    attr_reader :action
 
-    def initialize(node)
+    def initialize(node, resource, action)
       @node = node
+      @resource = resource
+      @action = action
     end
 
     # return a deterministically sorted list of Chef::Provider subclasses
     def providers
-      Chef::Provider.descendants.sort {|a,b| a.to_s <=> b.to_s }
+      @providers ||= Chef::Provider.descendants
     end
 
-    def resolve(resource, action)
+    def resolve
       maybe_explicit_provider(resource) ||
         maybe_dynamic_provider_resolution(resource, action) ||
         maybe_chef_platform_lookup(resource)
     end
 
+    # this cut looks at if the provider can handle the resource type on the node
+    def enabled_handlers
+      @enabled_handlers ||=
+        providers.select do |klass|
+          klass.provides?(node, resource)
+        end.sort {|a,b| a.to_s <=> b.to_s }
+    end
+
+    # this cut looks at if the provider can handle the specific resource and action
+    def supported_handlers
+      @supported_handlers ||=
+        enabled_handlers.select do |klass|
+          klass.supports?(resource, action)
+        end
+    end
+
     private
 
     # if resource.provider is set, just return one of those objects
@@ -49,31 +69,23 @@ class Chef
 
     # try dynamically finding a provider based on querying the providers to see what they support
     def maybe_dynamic_provider_resolution(resource, action)
-      # this cut only depends on the node value and is going to be static for all nodes
-      # will contain all providers that could possibly support a resource on a node
-      enabled_handlers = providers.select do |klass|
-        klass.provides?(node, resource)
-      end
-
       # log this so we know what providers will work for the generic resource on the node (early cut)
       Chef::Log.debug "providers for generic #{resource.resource_name} resource enabled on node include: #{enabled_handlers}"
 
-      # ask all the enabled providers if they can actually support the resource
-      supported_handlers = enabled_handlers.select do |klass|
-        klass.supports?(resource, action)
-      end
-
       # what providers were excluded by machine state (late cut)
       Chef::Log.debug "providers that refused resource #{resource} were: #{enabled_handlers - supported_handlers}"
       Chef::Log.debug "providers that support resource #{resource} include: #{supported_handlers}"
 
+      # if none of the providers specifically support the resource, we still need to pick one of the providers that are
+      # enabled on the node to handle the why-run use case.
       handlers = supported_handlers.empty? ? enabled_handlers : supported_handlers
+      Chef::Log.debug "no providers supported the resource, falling back to enabled handlers" if supported_handlers.empty?
 
       if handlers.count >= 2
+        # this magic stack ranks the providers by where they appear in the provider_priority_map, it is mostly used
+        # to pick amongst N different ways to start init scripts on different debian/ubuntu systems.
         priority_list = [ get_provider_priority_map(resource.resource_name, node) ].flatten.compact
-
         handlers = handlers.sort_by { |x| i = priority_list.index x; i.nil? ? Float::INFINITY : i }
-
         handlers = [ handlers.first ]
       end
 
@@ -81,6 +93,8 @@ class Chef
 
       raise Chef::Exceptions::AmbiguousProviderResolution.new(resource, handlers) if handlers.count >= 2
 
+      Chef::Log.debug "dynamic provider resolver FAILED to resolve a provider" if handlers.empty?
+
       return nil if handlers.empty?
 
       handlers[0]

data/lib/chef/resource.rb

@@ -29,6 +29,7 @@ require 'chef/resource/conditional_action_not_nothing'
 require 'chef/resource_collection'
 require 'chef/node_map'
 require 'chef/node'
+require 'chef/provider_resolver'
 require 'chef/platform'
 
 require 'chef/mixin/deprecation'
@@ -679,7 +680,7 @@ F
     end
 
     def provider_for_action(action)
-      provider = run_context.provider_resolver.resolve(self, action).new(self, run_context)
+      provider = Chef::ProviderResolver.new(node, self, action).resolve.new(self, run_context)
       provider.action = action
       provider
     end

data/lib/chef/resources.rb

@@ -78,3 +78,10 @@ require 'chef/resource/windows_package'
 require 'chef/resource/yum_package'
 require 'chef/resource/lwrp_base'
 require 'chef/resource/bff_package'
+
+begin
+  # Optional resources chef_node, chef_client, machine, machine_image, etc.
+  require 'cheffish'
+  require 'chef/provisioning'
+rescue LoadError
+end

data/lib/chef/run_context.rb

@@ -18,7 +18,6 @@
 # limitations under the License.
 
 require 'chef/resource_collection'
-require 'chef/provider_resolver'
 require 'chef/cookbook_version'
 require 'chef/node'
 require 'chef/role'
@@ -51,9 +50,6 @@ class Chef
     # recipes, which is triggered by #load. (See also: CookbookCompiler)
     attr_accessor :resource_collection
 
-    # Chef::ProviderResolver for this run
-    attr_accessor :provider_resolver
-
     # A Hash containing the immediate notifications triggered by resources
     # during the converge phase of the chef run.
     attr_accessor :immediate_notification_collection
@@ -87,7 +83,6 @@ class Chef
 
       @node.run_context = self
       @cookbook_compiler = nil
-      @provider_resolver = Chef::ProviderResolver.new(@node)
     end
 
     # Triggers the compile phase of the chef run. Implemented by

data/lib/chef/run_list/run_list_expansion.rb

@@ -96,8 +96,8 @@ class Chef
       end
 
       def apply_role_attributes(role)
-        @default_attrs = Chef::Mixin::DeepMerge.role_merge(@default_attrs, role.default_attributes)
-        @override_attrs = Chef::Mixin::DeepMerge.role_merge(@override_attrs, role.override_attributes)
+        @default_attrs = Chef::Mixin::DeepMerge.merge(@default_attrs, role.default_attributes)
+        @override_attrs = Chef::Mixin::DeepMerge.merge(@override_attrs, role.override_attributes)
       end
 
       def applied_role?(role_name)

data/lib/chef/shell.rb

@@ -308,9 +308,9 @@ FOOTER
       elsif ENV['HOME'] && ::File.exist?(File.join(ENV['HOME'], '.chef', 'chef_shell.rb'))
         File.join(ENV['HOME'], '.chef', 'chef_shell.rb')
       elsif config[:solo]
-        "/etc/chef/solo.rb"
+        Chef::Config.platform_specific_path("/etc/chef/solo.rb")
       elsif config[:client]
-        "/etc/chef/client.rb"
+        Chef::Config.platform_specific_path("/etc/chef/client.rb")
       else
         nil
       end

data/lib/chef/util/selinux.rb

@@ -21,6 +21,7 @@
 # limitations under the License.
 
 require 'chef/mixin/shell_out'
+require 'chef/mixin/which'
 
 class Chef
   class Util
@@ -32,6 +33,7 @@ class Chef
     module Selinux
 
       include Chef::Mixin::ShellOut
+      include Chef::Mixin::Which
 
       # We want to initialize below variables once during a
       # chef-client run therefore they are class variables.
@@ -67,15 +69,6 @@ class Chef
         @@selinuxenabled_path
       end
 
-      def which(cmd)
-        paths = ENV['PATH'].split(File::PATH_SEPARATOR) + [ '/bin', '/usr/bin', '/sbin', '/usr/sbin' ]
-        paths.each do |path|
-          filename = File.join(path, cmd)
-          return filename if File.executable?(filename)
-        end
-        false
-      end
-
       def check_selinux_enabled?
         if selinuxenabled_path
           cmd = shell_out!(selinuxenabled_path, :returns => [0,1])
@@ -97,4 +90,3 @@ class Chef
     end
   end
 end
-

data/lib/chef/version.rb

@@ -17,7 +17,7 @@
 
 class Chef
   CHEF_ROOT = File.dirname(File.expand_path(File.dirname(__FILE__)))
-  VERSION = '12.0.0.rc.0'
+  VERSION = '12.0.0'
 end
 
 #

data/lib/chef/workstation_config_loader.rb

@@ -25,7 +25,7 @@ class Chef
   class WorkstationConfigLoader
 
     # Path to a config file requested by user, (e.g., via command line option). Can be nil
-    attr_reader :explicit_config_file
+    attr_accessor :explicit_config_file
 
     # TODO: initialize this with a logger for Chef and Knife
     def initialize(explicit_config_file, logger=nil)

data/spec/support/shared/unit/resource/static_provider_resolution.rb

@@ -43,12 +43,7 @@ def static_provider_resolution(opts={})
       node
     }
     let(:events) { Chef::EventDispatch::Dispatcher.new }
-    let(:provider_resolver) { Chef::ProviderResolver.new(node) }
-    let(:run_context) {
-      run_context = Chef::RunContext.new(node, {}, events)
-      run_context.provider_resolver = provider_resolver
-      run_context
-    }
+    let(:run_context) { Chef::RunContext.new(node, {}, events) }
     let(:resource) { resource_class.new("foo", run_context) }
 
     it "should return a #{resource_class}" do

data/spec/unit/api_client/registration_spec.rb

@@ -209,6 +209,28 @@ describe Chef::ApiClient::Registration do
       registration.write_key
       IO.read(key_location).should == "--begin rsa key etc--"
     end
+
+    context 'when the client key location is a symlink' do
+      it 'does not follow the symlink', :unix_only do
+        expected_flags = (File::CREAT|File::TRUNC|File::RDWR)
+
+        if defined?(File::NOFOLLOW)
+          expected_flags |= File::NOFOLLOW
+        end
+
+        expect(registration.file_flags).to eq(expected_flags)
+      end
+
+      context 'with follow_client_key_symlink set to true' do
+        before do
+          Chef::Config[:follow_client_key_symlink] = true
+        end
+
+        it 'follows the symlink', :unix_only do
+          expect(registration.file_flags).to eq(File::CREAT|File::TRUNC|File::RDWR)
+        end
+      end
+    end
   end
 
   describe "when registering a client" do

data/spec/unit/application/knife_spec.rb

@@ -33,6 +33,11 @@ describe Chef::Application::Knife do
     end
   end
 
+  after(:each) do
+    # reset some really nasty global state
+    NoopKnifeCommand.reset_config_loader!
+  end
+
   before(:each) do
     # Prevent code from getting loaded on every test invocation.
     Chef::Knife.stub(:load_commands)
@@ -109,7 +114,6 @@ describe Chef::Application::Knife do
       end
       Chef::Config[:client_key].should == full_path
     end
-
   end
 
   describe "with environment configuration" do
@@ -168,6 +172,6 @@ describe Chef::Application::Knife do
         @knife.run
       end
     end
-
   end
+
 end

data/spec/unit/chef_fs/data_handler/group_handler_spec.rb

@@ -0,0 +1,63 @@
+#
+# Author:: Ryan Cragun (<ryan@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 'spec_helper'
+require 'lib/chef/chef_fs/data_handler/group_data_handler'
+
+class TestEntry < Mash
+  attr_accessor :name, :org
+
+  def initialize(name, org)
+    @name = name
+    @org = org
+  end
+end
+
+describe Chef::ChefFS::DataHandler::GroupDataHandler do
+  describe '#normalize_for_post' do
+    let(:entry) do
+      TestEntry.new('workers.json', 'hive')
+    end
+
+    let(:group) do
+      { 'name' => 'worker_bees',
+        'clients' => %w(honey sting),
+        'users' => %w(fizz buzz),
+        'actors' => %w(honey)
+      }
+    end
+
+    let(:normalized) do
+      { 'actors' =>
+          { 'users' => %w(fizz buzz),
+            'clients'=> %w(honey sting),
+            'groups'=> []
+          },
+        'groupname' => 'workers',
+        'name' => 'worker_bees',
+        'orgname' => 'hive'
+      }
+    end
+
+    let(:handler) { described_class.new }
+
+    it 'normalizes the users, clients and groups into actors' do
+      expect(handler.normalize_for_post(group, entry)).to eq(normalized)
+    end
+  end
+end

data/spec/unit/config_spec.rb

@@ -426,7 +426,7 @@ describe Chef::Config do
         let(:locales) { locale_array.join("\n") }
 
         before do
-          allow(Chef::Config).to receive(:shell_out_with_systems_locale).with("locale -a").and_return(shell_out)
+          allow(Chef::Config).to receive(:shell_out_with_systems_locale!).with("locale -a").and_return(shell_out)
         end
 
         shared_examples_for "a suitable locale" do
@@ -434,7 +434,7 @@ describe Chef::Config do
             expect(Chef::Log).to_not receive(:warn).with(/Please install an English UTF-8 locale for Chef to use/)
             expect(Chef::Log).to_not receive(:debug).with(/Defaulting to locale en_US.UTF-8 on Windows/)
             expect(Chef::Log).to_not receive(:debug).with(/No usable locale -a command found/)
-            expect(Chef::Config[:internal_locale]).to eq expected_locale
+            expect(Chef::Config.guess_internal_locale).to eq expected_locale
           end
         end
 
@@ -485,7 +485,7 @@ describe Chef::Config do
 
           it "should fall back to C locale" do
             expect(Chef::Log).to receive(:warn).with("Please install an English UTF-8 locale for Chef to use, falling back to C locale and disabling UTF-8 support.")
-            expect(Chef::Config[:internal_locale]).to eq 'C'
+            expect(Chef::Config.guess_internal_locale).to eq 'C'
           end
         end
 
@@ -493,7 +493,7 @@ describe Chef::Config do
           let(:locale_array) { [] }
 
           before do
-            allow(Chef::Config).to receive(:shell_out_with_systems_locale).and_raise("THIS IS AN ERROR")
+            allow(Chef::Config).to receive(:shell_out_with_systems_locale!).and_raise("THIS IS AN ERROR")
           end
 
           it "should default to 'en_US.UTF-8'" do
@@ -502,7 +502,7 @@ describe Chef::Config do
             else
               expect(Chef::Log).to receive(:debug).with("No usable locale -a command found, assuming you have en_US.UTF-8 installed.")
             end
-            expect(Chef::Config[:internal_locale]).to eq "en_US.UTF-8"
+            expect(Chef::Config.guess_internal_locale).to eq "en_US.UTF-8"
           end
         end
       end

data/spec/unit/knife/bootstrap_spec.rb

@@ -29,7 +29,7 @@ describe Chef::Knife::Bootstrap do
     Chef::Log.logger = Logger.new(StringIO.new)
     Chef::Config[:knife][:bootstrap_template] = bootstrap_template unless bootstrap_template.nil?
 
-    k = Chef::Knife::Bootstrap.new
+    k = Chef::Knife::Bootstrap.new(bootstrap_cli_options)
     k.merge_configs
 
     k.ui.stub(:stderr).and_return(stderr)
@@ -41,11 +41,37 @@ describe Chef::Knife::Bootstrap do
 
   let(:bootstrap_template) { nil }
 
+  let(:bootstrap_cli_options) { [ ] }
+
   it "should use chef-full as default template" do
     knife.bootstrap_template.should be_a_kind_of(String)
     File.basename(knife.bootstrap_template).should eq("chef-full")
   end
 
+  context "with :distro and :bootstrap_template cli options" do
+    let(:bootstrap_cli_options) { [ "--bootstrap-template", "my-template", "--distro", "other-template" ] }
+
+    it "should select bootstrap template" do
+      expect(File.basename(knife.bootstrap_template)).to eq("my-template")
+    end
+  end
+
+  context "with :distro and :template_file cli options" do
+    let(:bootstrap_cli_options) { [ "--distro", "my-template", "--template-file", "other-template" ] }
+
+    it "should select bootstrap template" do
+      expect(File.basename(knife.bootstrap_template)).to eq("other-template")
+    end
+  end
+
+  context "with :bootstrap_template and :template_file cli options" do
+    let(:bootstrap_cli_options) { [ "--bootstrap-template", "my-template", "--template-file", "other-template" ] }
+
+    it "should select bootstrap template" do
+      expect(File.basename(knife.bootstrap_template)).to eq("my-template")
+    end
+  end
+
   context "when finding templates" do
     context "when :bootstrap_template config is set to a file" do
       context "that doesn't exist" do