chef 0.8.16 → 0.9.0.a3

data/lib/chef/node/attribute.rb

@@ -23,37 +23,65 @@ require 'chef/log'
 class Chef
   class Node
     class Attribute
-      attr_accessor :attribute,
+      attr_accessor :normal,
                     :default,
                     :override,
+                    :automatic,
                     :state,
-                    :current_attribute,
+                    :current_normal,
                     :current_default,
                     :current_override,
+                    :current_automatic,
                     :auto_vivifiy_on_read,
                     :set_unless_value_present,
-                    :has_been_read
+                    :has_been_read,
+                    :set_type
 
       include Enumerable
 
-      def initialize(attribute, default, override, state=[])
-        @attribute = attribute
-        @current_attribute = attribute
+      def initialize(normal, default, override, automatic, state=[])
+        @normal = normal
+        @current_normal = normal
         @default = default
         @current_default = default
         @override = override
         @current_override = override
+        @automatic = automatic 
+        @current_automatic = automatic 
         @state = state
         @auto_vivifiy_on_read = false
         @set_unless_value_present = false
+        @set_type = :normal
         @has_been_read = false
       end
 
+      def attribute
+        normal
+      end
+
+      def attribute=(value)
+        normal = value
+      end
+
+      def set_type_hash
+        case @set_type
+        when :normal
+          @normal
+        when :override
+          @override
+        when :default
+          @default
+        when :automatic
+          @automatic
+        end
+      end
+
       # Reset our internal state to the top of every tree
       def reset
-        @current_attribute = @attribute
+        @current_normal = @normal
         @current_default = @default
         @current_override = @override
+        @current_automatic = @automatic
         @has_been_read = false
         @state = []
       end
@@ -65,16 +93,18 @@ class Chef
         # See the comments in []= for more details.
         @has_been_read = true
 
-        o_value = value_or_descend(current_override, key, auto_vivifiy_on_read)
-        a_value = value_or_descend(current_attribute, key, auto_vivifiy_on_read)
-        d_value = value_or_descend(current_default, key, auto_vivifiy_on_read)
+        a_value = value_or_descend(current_automatic, key, auto_vivifiy_on_read && @set_type == :automatic)
+        o_value = value_or_descend(current_override, key, auto_vivifiy_on_read && @set_type == :override)
+        n_value = value_or_descend(current_normal, key, auto_vivifiy_on_read && @set_type == :normal)
+        d_value = value_or_descend(current_default, key, auto_vivifiy_on_read && @set_type == :default)
 
-        determine_value(o_value, a_value, d_value)
+        determine_value(a_value, o_value, n_value, d_value)
       end
 
       def attribute?(key)
+        return true if get_value(automatic, key)
         return true if get_value(override, key)
-        return true if get_value(attribute, key)
+        return true if get_value(normal, key)
         return true if get_value(default, key)
         false
       end
@@ -90,8 +120,9 @@ class Chef
       def each(&block)
         get_keys.each do |key|
           value = determine_value(
+            get_value(automatic, key),
             get_value(override, key),
-            get_value(attribute, key),
+            get_value(normal, key),
             get_value(default, key)
           )
           block.call([key, value])
@@ -101,8 +132,9 @@ class Chef
       def each_pair(&block)
         get_keys.each do |key|
           value = determine_value(
+            get_value(automatic, key),
             get_value(override, key),
-            get_value(attribute, key),
+            get_value(normal, key),
             get_value(default, key)
           )
           block.call(key, value)
@@ -112,8 +144,9 @@ class Chef
       def each_attribute(&block)
         get_keys.each do |key|
           value = determine_value(
+            get_value(automatic, key),
             get_value(override, key),
-            get_value(attribute, key),
+            get_value(normal, key),
             get_value(default, key)
           )
           block.call(key, value)
@@ -129,8 +162,9 @@ class Chef
       def each_value(&block)
         get_keys.each do |key|
           value = determine_value(
+            get_value(automatic, key),
             get_value(override, key),
-            get_value(attribute, key),
+            get_value(normal, key),
             get_value(default, key)
           )
           block.call(value)
@@ -144,8 +178,9 @@ class Chef
       def fetch(key, default_value=nil, &block)
         if get_keys.include? key
           determine_value(
+            get_value(automatic, key),
             get_value(override, key),
-            get_value(attribute, key),
+            get_value(normal, key),
             get_value(default, key)
           )
         elsif default_value
@@ -201,18 +236,12 @@ class Chef
       end
 
       def keys
-        tkeys = []
-        if current_override
-          tkeys = current_override.keys
-        end
-        if current_attribute
-          current_attribute.keys.each do |key|
-            tkeys << key unless tkeys.include?(key)
-          end
-        end
-        if current_default
-          current_default.keys.each do |key|
-            tkeys << key unless tkeys.include?(key)
+        tkeys = current_automatic ? current_automatic.keys : []
+        [ current_override, current_normal, current_default ].each do |attr_hash|
+          if attr_hash 
+            attr_hash.keys.each do |key|
+              tkeys << key unless tkeys.include?(key)
+            end
           end
         end
         tkeys
@@ -249,47 +278,40 @@ class Chef
         (! to_check.kind_of?(Chef::Node::Attribute)) && to_check.respond_to?(:has_key?)
       end
 
-      def determine_value(o_value, a_value, d_value)
-        # If all three have hash values, merge them
-        if hash_and_not_cna?(o_value) && hash_and_not_cna?(a_value) && hash_and_not_cna?(d_value)
-          value = Chef::Mixin::DeepMerge.merge(d_value, a_value)
-          value = Chef::Mixin::DeepMerge.merge(value, o_value)
+      def determine_value(a_value, o_value, n_value, d_value)
+        if hash_and_not_cna?(a_value)
+          value = {}
+          value = Chef::Mixin::DeepMerge.merge(value, d_value) if hash_and_not_cna?(d_value)
+          value = Chef::Mixin::DeepMerge.merge(value, n_value) if hash_and_not_cna?(n_value)
+          value = Chef::Mixin::DeepMerge.merge(value, o_value) if hash_and_not_cna?(o_value)
+          value = Chef::Mixin::DeepMerge.merge(value, a_value) 
           value
-        # If only the override and attributes have values, merge them
-        elsif hash_and_not_cna?(o_value) && hash_and_not_cna?(a_value)
-          Chef::Mixin::DeepMerge.merge(a_value, o_value)
-        # If only the override and default attributes have values, merge them
-        elsif hash_and_not_cna?(o_value) && hash_and_not_cna?(d_value)
-          Chef::Mixin::DeepMerge.merge(d_value, o_value)
-        # If only the override attribute has a value (any value) use it
-        elsif ! o_value.nil?
-          o_value
-        # If the attributes is a hash, and the default is a hash, merge them
-        elsif hash_and_not_cna?(a_value) && hash_and_not_cna?(d_value)
-          Chef::Mixin::DeepMerge.merge(d_value, a_value)
-        # If we have an attribute value, use it
-        elsif ! a_value.nil?
-          a_value
-        # If we have a default value, use it
-        elsif ! d_value.nil?
+        elsif hash_and_not_cna?(o_value)
+          value = {}
+          value = Chef::Mixin::DeepMerge.merge(value, d_value) if hash_and_not_cna?(d_value)
+          value = Chef::Mixin::DeepMerge.merge(value, n_value) if hash_and_not_cna?(n_value)
+          value = Chef::Mixin::DeepMerge.merge(value, o_value) 
+          value
+        elsif hash_and_not_cna?(n_value)
+          value = {}
+          value = Chef::Mixin::DeepMerge.merge(value, d_value) if hash_and_not_cna?(d_value)
+          value = Chef::Mixin::DeepMerge.merge(value, n_value) 
+          value
+        elsif hash_and_not_cna?(d_value)
           d_value
         else
-          nil
+          return a_value if ! a_value.nil?
+          return o_value if ! o_value.nil?
+          return n_value if ! n_value.nil?
+          return d_value if ! d_value.nil?
+          return nil
         end
       end
 
       def []=(key, value)
         if set_unless_value_present
-          if get_value(@default, key) != nil
-            Chef::Log.debug("Not setting #{state.join("/")}/#{key} to #{value.inspect} because it has a default value already")
-            return false
-          end
-          if get_value(@attribute, key) != nil
-            Chef::Log.debug("Not setting #{state.join("/")}/#{key} to #{value.inspect} because it has a node attribute value already")
-            return false
-          end
-          if get_value(@override, key) != nil
-            Chef::Log.debug("Not setting #{state.join("/")}/#{key} to #{value.inspect} because it has an override value already")
+          if get_value(set_type_hash, key) != nil
+            Chef::Log.debug("Not setting #{state.join("/")}/#{key} to #{value.inspect} because it has a #{@set_type} value already")
             return false
           end
         end
@@ -302,8 +324,7 @@ class Chef
         # supporting one more single-use style.
         @state.pop if @has_been_read && @state.last == key
 
-        set_value(@attribute, key, value)
-        set_value(@override, key, value)
+        set_value(set_type_hash, key, value)
         value
       end
 
@@ -344,30 +365,23 @@ class Chef
       end
 
       def value_or_descend(data_hash, key, auto_vivifiy=false)
-
         if auto_vivifiy
-          data_hash = auto_vivifiy(data_hash, key)
-          unless current_attribute.has_key?(key)
-            current_attribute[key] = data_hash[key]
-          end
-          unless current_default.has_key?(key)
-            current_default[key] = data_hash[key]
-          end
-          unless current_override.has_key?(key)
-            current_override[key] = data_hash[key]
-          end
+          hash_to_vivifiy = auto_vivifiy(data_hash, key)
+          data_hash[key] = hash_to_vivifiy[key]
         else
           return nil if data_hash == nil
           return nil unless data_hash.has_key?(key)
         end
 
         if data_hash[key].respond_to?(:has_key?)
-          cna = Chef::Node::Attribute.new(@attribute, @default, @override, @state)
-          cna.current_attribute = current_attribute.nil? ? Mash.new : current_attribute[key]
+          cna = Chef::Node::Attribute.new(@normal, @default, @override, @automatic, @state)
+          cna.current_normal = current_normal.nil? ? Mash.new : current_normal[key]
           cna.current_default   = current_default.nil? ? Mash.new : current_default[key]
           cna.current_override  = current_override.nil? ? Mash.new : current_override[key]
+          cna.current_automatic  = current_automatic.nil? ? Mash.new : current_automatic[key]
           cna.auto_vivifiy_on_read = auto_vivifiy_on_read
           cna.set_unless_value_present = set_unless_value_present
+          cna.set_type = set_type
           cna
         else
           data_hash[key]
@@ -399,7 +413,7 @@ class Chef
       end
 
       def to_hash
-        result = determine_value(current_override, current_attribute, current_default)
+        result = determine_value(current_automatic, current_override, current_normal, current_default)
         if result.class == Hash
           result
         else

data/lib/chef/platform.rb

@@ -129,26 +129,39 @@ class Chef
           },
           :mswin => {
             :default => {
-              :service => Chef::Provider::Service::Windows
+              :env =>  Chef::Provider::Env::Windows,
+              :service => Chef::Provider::Service::Windows,
+              :user => Chef::Provider::User::Windows,
+              :group => Chef::Provider::Group::Windows
             }
           },
           :mingw32 => {
             :default => {
-              :service => Chef::Provider::Service::Windows
+              :env =>  Chef::Provider::Env::Windows,
+              :service => Chef::Provider::Service::Windows,
+              :user => Chef::Provider::User::Windows,
+              :group => Chef::Provider::Group::Windows
             }
           },
           :windows => {
             :default => {
-              :service => Chef::Provider::Service::Windows
+              :env =>  Chef::Provider::Env::Windows,
+              :service => Chef::Provider::Service::Windows,
+              :user => Chef::Provider::User::Windows,
+              :group => Chef::Provider::Group::Windows
             }
           },
           :solaris  => {},
+          :solaris2 => {
+            :default => {
+              :service => Chef::Provider::Service::Solaris
+            }
+          },
           :default  => {
             :file => Chef::Provider::File,
             :directory => Chef::Provider::Directory,
             :link => Chef::Provider::Link,
             :template => Chef::Provider::Template,
-            :remote_file => Chef::Provider::RemoteFile,
             :remote_directory => Chef::Provider::RemoteDirectory,
             :execute => Chef::Provider::Execute,
             :mount => Chef::Provider::Mount::Mount,
@@ -224,7 +237,14 @@ class Chef
         return platform, version
       end
 
+      def provider_for_resource(resource)
+        node = resource.run_context && resource.run_context.node
+        raise ArgumentError, "Cannot find the provider for a resource with no run context set" unless node
+        find_provider_for_node(node, resource).new(resource, resource.run_context)
+      end
+
       def provider_for_node(node, resource_type)
+        raise NotImplementedError, "#{self.class.name} no longer supports #provider_for_node"
         find_provider_for_node(node, resource_type).new(node, resource_type)
       end
 

data/lib/chef/provider.rb

@@ -26,16 +26,25 @@ class Chef
     
     include Chef::Mixin::RecipeDefinitionDSLCore
     
-    attr_accessor :node, :new_resource, :current_resource
+    attr_accessor :new_resource, :current_resource, :run_context
     
-    def initialize(node, new_resource, collection=nil, definitions={}, cookbook_loader=nil)
-      @node = node
+    def initialize(new_resource, run_context)
       @new_resource = new_resource
       @current_resource = nil
-      @collection = collection
-      @definitions = definitions
-      @cookbook_loader = cookbook_loader
-      @cookbook_name = @new_resource.cookbook_name
+      @run_context = run_context
+    end
+
+    def node
+      run_context && run_context.node
+    end
+
+    # Used by providers supporting embedded recipes
+    def resource_collection
+      run_context && run_context.resource_collection
+    end
+
+    def cookbook_name
+      new_resource.cookbook_name
     end
     
     def load_current_resource
@@ -50,12 +59,21 @@ class Chef
     protected
     
     def recipe_eval(&block)
-      provider_collection, @collection = @collection, Chef::ResourceCollection.new
+      # This block has new resource definitions within it, which
+      # essentially makes it an in-line Chef run. Save our current
+      # run_context and create one anew, so the new Chef run only
+      # executes the embedded resources.
+      #
+      # TODO: timh,cw: 2010-5-14: This means that the resources within
+      # this block cannot interact with resources outside, e.g.,
+      # manipulating notifies.
+      saved_run_context = run_context
+      self.run_context = Chef::RunContext.new(saved_run_context.node, saved_run_context.cookbook_collection)
       
       instance_eval(&block)
-      Chef::Runner.new(@node, @collection).converge
+      Chef::Runner.new(run_context).converge
       
-      @collection = provider_collection
+      self.run_context = saved_run_context
     end
     
     public

data/lib/chef/provider/breakpoint.rb

@@ -25,9 +25,9 @@ class Chef
       
       def action_break
         if defined?(Shef) && Shef.running?
-          @collection.iterator.pause
+          run_context.resource_collection.iterator.pause
           @new_resource.updated = true
-          @collection.iterator
+          run_context.resource_collection.iterator
         end
       end
       

data/lib/chef/provider/cookbook_file.rb

@@ -0,0 +1,96 @@
+#
+# Author:: Daniel DeLeo (<dan@opscode.com>)
+# Copyright:: Copyright (c) 2010 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/file_access_control'
+require 'chef/provider/file'
+require 'tempfile'
+
+class Chef
+  class Provider
+    class CookbookFile < Chef::Provider::File
+      
+      def load_current_resource
+        @current_resource = Chef::Resource::CookbookFile.new(@new_resource.name)
+        @new_resource.path.gsub!(/\\/, "/") # for Windows
+        @current_resource.path(@new_resource.path)
+        @current_resource
+      end
+
+
+      def action_create
+         if file_cache_location
+           Chef::Log.debug("content of file #{@new_resource.path} requires update")
+           backup_new_resource
+           Tempfile.open(::File.basename(@new_resource.name)) do |staging_file|
+             Chef::Log.debug("staging #{file_cache_location} to #{staging_file.path}")
+             staging_file.close
+             stage_file_to_tmpdir(staging_file.path)
+             FileUtils.mv(staging_file.path, @new_resource.path)
+           end
+           @new_resource.updated = true
+         else
+           set_all_access_controls(@new_resource.path)
+         end
+         @new_resource.updated
+       end
+
+      def action_create_if_missing
+        if ::File.exists?(@new_resource.path)
+          Chef::Log.debug("File #{@new_resource.path} exists, taking no action.")
+        else
+          action_create
+        end
+      end
+      
+      def file_cache_location
+        @file_cache_location ||= begin
+          cookbook = run_context.cookbook_collection[resource_cookbook]
+          cookbook.preferred_filename_on_disk_location(node, :files, @new_resource.source, @new_resource.path)
+        end
+      end
+      
+      # Determine the cookbook to get the file from. If new resource sets an 
+      # explicit cookbook, use it, otherwise fall back to the implicit cookbook
+      # i.e., the cookbook the resource was declared in.
+      def resource_cookbook
+        @new_resource.cookbook || @new_resource.cookbook_name
+      end
+      
+      # Copy the file from the cookbook cache to a temporary location and then
+      # set its file access control settings.
+      def stage_file_to_tmpdir(staging_file_location)
+        FileUtils.cp(file_cache_location, staging_file_location)
+        set_all_access_controls(staging_file_location)
+      end
+
+      def set_all_access_controls(file)
+        access_controls = Chef::FileAccessControl.new(@new_resource, file)
+        access_controls.set_all
+        @new_resource.updated = access_controls.modified?
+      end
+
+      def backup_new_resource
+        if ::File.exists?(@new_resource.path)
+          Chef::Log.info "Backing up current file at #{@new_resource.path}"
+          backup @new_resource.path
+        end
+      end
+
+    end
+  end
+end