chef 0.8.16 → 0.9.0.a3

data/lib/chef/provider/cron.rb

@@ -27,8 +27,8 @@ class Chef
 
       CRON_PATTERN = /([0-9\*\-\,\/]+)\s*([0-9\*\-\,\/]+)\s*([0-9\*\-\,\/]+)\s*([0-9\*\-\,\/]+)\s*([0-9\*\-\,\/]+)\s*(.*)/
 
-      def initialize(node, new_resource, collection=nil, definitions=nil, cookbook_loader=nil)
-        super(node, new_resource, collection, definitions, cookbook_loader)
+      def initialize(new_resource, run_context)
+        super(new_resource, run_context)
         @cron_exists = false
         @cron_empty = false
       end

data/lib/chef/provider/deploy.rb

@@ -30,14 +30,10 @@ class Chef
       
       attr_reader :scm_provider, :release_path
       
-      def initialize(node, new_resource, collection=nil, definitions=nil, cookbook_loader=nil)
-        super(node, new_resource, collection, definitions, cookbook_loader)
+      def initialize(new_resource, run_context)
+        super(new_resource, run_context)
         
-        # NOTE: workaround for CHEF-577
-        @definitions ||= Hash.new
-        @collection = Chef::ResourceCollection.new
-        
-        @scm_provider = @new_resource.scm_provider.new(@node, @new_resource)
+        @scm_provider = new_resource.scm_provider.new(new_resource, run_context)
         
         # @configuration is not used by Deploy, it is only for backwards compat with
         # chef-deploy or capistrano hooks that might use it to get environment information
@@ -275,17 +271,23 @@ class Chef
       end
       
       def install_gems
+        gem_resource_collection_runner.converge
+      end
+
+      def gem_resource_collection_runner
         gems_collection = Chef::ResourceCollection.new
         gem_packages.each { |rbgem| gems_collection << rbgem }
-        Chef::Runner.new(@node, gems_collection).converge
+        gems_run_context = run_context.dup
+        gems_run_context.resource_collection = gems_collection
+        Chef::Runner.new(gems_run_context)
       end
-      
+
       def gem_packages
         return [] unless ::File.exist?("#{release_path}/gems.yml")
         gems = YAML.load(IO.read("#{release_path}/gems.yml"))
         
         gems.map do |g|
-          r = Chef::Resource::GemPackage.new(g[:name], nil, node)
+          r = Chef::Resource::GemPackage.new(g[:name])
           r.version g[:version]
           r.action :install
           r.source "http://gems.github.com"

data/lib/chef/provider/env.rb

@@ -0,0 +1,152 @@
+#
+# Author:: Doug MacEachern (<dougm@vmware.com>)
+# Copyright:: Copyright (c) 2010 VMware, 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/provider'
+require 'chef/mixin/command'
+require 'chef/resource/env'
+
+class Chef
+  class Provider
+    class Env < Chef::Provider
+      include Chef::Mixin::Command
+      attr_accessor :key_exists
+
+      def initialize(new_resource, run_context)
+        super
+        @key_exists = true
+      end
+
+      def load_current_resource
+        @current_resource = Chef::Resource::Env.new(@new_resource.name)
+        @current_resource.key_name(@new_resource.key_name)
+
+        if env_key_exists(@new_resource.key_name)
+          @current_resource.value(env_value(@new_resource.key_name))
+        else
+          @key_exists = false
+          Chef::Log.debug("#{@new_resource}: key does not exist")
+        end
+
+        @current_resource
+      end
+
+      def env_value(key_name)
+        raise Chef::Exceptions::Env, "#{@new_resource} - #{self.to_s} provider does not implement env_value!"
+      end
+
+      def env_key_exists(key_name)
+        env_value(key_name) ? true : false
+      end
+
+      # Check to see if value needs any changes
+      #
+      # ==== Returns
+      # <true>:: If a change is required
+      # <false>:: If a change is not required
+      def compare_value
+        if @new_resource.delim
+          #e.g. check for existing value within PATH
+          not @current_resource.value.split(@new_resource.delim).any? do |val|
+            val == @new_resource.value
+          end
+        else
+          @new_resource.value != @current_resource.value
+        end
+      end
+
+      def action_create
+        if @key_exists
+          if compare_value
+            modify_env
+            Chef::Log.info("Altered #{@new_resource}")
+            @new_resource.updated = true
+          end
+        else
+          create_env
+          Chef::Log.debug("Created #{@new_resource}")
+          @new_resource.updated = true
+        end
+      end
+
+      #e.g. delete a PATH element
+      #
+      # ==== Returns
+      # <true>:: If we handled the element case and caller should not delete the key
+      # <false>:: Caller should delete the key, either no :delim was specific or value was empty
+      #           after we removed the element.
+      def delete_element
+        return false unless @new_resource.delim #no delim: delete the key
+        if compare_value
+          Chef::Log.debug("#{@new_resource}: element '#{@new_resource.value}' does not exist")
+          return true #do not delete the key
+        else
+          new_value =
+            @current_resource.value.split(@new_resource.delim).select { |item|
+            item != @new_resource.value
+          }.join(@new_resource.delim)
+
+          if new_value.empty?
+            return false #nothing left here, delete the key
+          else
+            old_value = @new_resource.value(new_value)
+            create_env
+            Chef::Log.debug("Deleted #{old_value} element")
+            @new_resource.updated = true
+            return true #we removed the element and updated; do not delete the key
+          end
+        end
+      end
+
+      def action_delete
+        if @key_exists && !delete_element
+          delete_env
+          Chef::Log.debug("Deleted #{@new_resource}")
+          @new_resource.updated = true
+        end
+      end
+
+      def action_modify
+        if @key_exists
+          if compare_value
+            modify_env
+            @new_resource.updated = true
+            Chef::Log.info("Modified #{@new_resource}")
+          end
+        else
+          raise Chef::Exceptions::Env, "Cannot modify #{@new_resource} - key does not exist!"
+        end
+      end
+
+      def create_env
+        raise Chef::Exceptions::UnsupportedAction, "#{self.to_s} does not support :#{@new_resource.action}"
+      end
+
+      def delete_env
+        raise Chef::Exceptions::UnsupportedAction, "#{self.to_s} does not support :delete"
+      end
+
+      def modify_env
+        if @new_resource.delim
+          #e.g. add to PATH
+          @new_resource.value << @new_resource.delim << @current_resource.value
+        end
+        create_env
+      end
+     end
+  end
+end

data/lib/chef/provider/env/windows.rb

@@ -0,0 +1,75 @@
+#
+# Author:: Doug MacEachern (<dougm@vmware.com>)
+# Copyright:: Copyright (c) 2010 VMware, 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.
+#
+
+if RUBY_PLATFORM =~ /mswin|mingw32|windows/
+  require 'ruby-wmi'
+  require 'Win32API'
+end
+
+class Chef
+  class Provider
+    class Env
+      class Windows < Chef::Provider::Env
+
+        def create_env
+          obj = env_obj(@new_resource.key_name)
+          unless obj
+            obj = WIN32OLE.connect("winmgmts://").get("Win32_Environment").spawninstance_
+            obj.name = @new_resource.key_name
+            obj.username = "<System>"
+          end
+          obj.variablevalue = @new_resource.value
+          obj.put_
+          broadcast_env_change
+        end
+
+        def delete_env
+          obj = env_obj(@new_resource.key_name)
+          if obj
+            obj.delete_
+            broadcast_env_change
+          end
+        end
+
+        def env_value(key_name)
+          obj = env_obj(key_name)
+          return obj ? obj.variablevalue : nil
+        end
+
+        def env_obj(key_name)
+          WMI::Win32_Environment.find(:first,
+                                      :conditions => { :name => key_name })
+        end
+
+        #see: http://msdn.microsoft.com/en-us/library/ms682653%28VS.85%29.aspx
+        HWND_BROADCAST = 0xffff
+        WM_SETTINGCHANGE = 0x001A
+        SMTO_BLOCK = 0x0001
+        SMTO_ABORTIFHUNG = 0x0002
+        SMTO_NOTIMEOUTIFNOTHUNG = 0x0008
+
+        def broadcast_env_change
+          result = 0
+          flags = SMTO_BLOCK | SMTO_ABORTIFHUNG | SMTO_NOTIMEOUTIFNOTHUNG
+          @send_message ||= Win32API.new('user32', 'SendMessageTimeout', 'LLLPLLP', 'L')
+          @send_message.call(HWND_BROADCAST, WM_SETTINGCHANGE, 0, 'Environment', flags, 5000, result)
+        end
+      end
+    end
+  end
+end

data/lib/chef/provider/file.rb

@@ -20,7 +20,6 @@ require 'chef/config'
 require 'chef/log'
 require 'chef/resource/file'
 require 'chef/mixin/checksum'
-require 'chef/mixin/generate_url'
 require 'chef/provider'
 require 'etc'
 require 'fileutils'
@@ -29,7 +28,6 @@ class Chef
   class Provider
     class File < Chef::Provider
       include Chef::Mixin::Checksum
-      include Chef::Mixin::GenerateURL
 
       def negative_complement(big)
         if big > 1073741823 # Fixnum max
@@ -67,6 +65,7 @@ class Chef
       def set_content
         unless compare_content
           Chef::Log.info("Setting content for #{@new_resource}")
+          backup @new_resource.path if ::File.exists?(@new_resource.path)
           ::File.open(@new_resource.path, "w") {|f| f.write @new_resource.content }
           @new_resource.updated = true
         end
@@ -181,16 +180,18 @@ class Chef
           time = Time.now
           savetime = time.strftime("%Y%m%d%H%M%S")
           backup_filename = "#{@new_resource.path}.chef-#{savetime}"
-          prefix = Chef::Config[:file_backup_path] || ""
-          if Chef::Config[:file_backup_path]
-            FileUtils.mkdir_p(::File.dirname(Chef::Config[:file_backup_path] + backup_filename))
-          end
-          Chef::Log.info("Backing up #{@new_resource} to #{prefix + backup_filename}")
-          FileUtils.cp(file, prefix + backup_filename, :preserve => true)
+          # if :file_backup_path is nil, we fallback to the old behavior of
+          # keeping the backup in the same directory. We also need to to_s it
+          # so we don't get a type error around implicit to_str conversions.
+          prefix = Chef::Config[:file_backup_path].to_s
+          backup_path = ::File.join(prefix, backup_filename)
+          FileUtils.mkdir_p(::File.dirname(backup_path)) if Chef::Config[:file_backup_path]
+          Chef::Log.info("Backing up #{@new_resource} to #{backup_path}")
+          FileUtils.cp(file, backup_path, :preserve => true)
 
           # Clean up after the number of backups
           slice_number = @new_resource.backup
-          backup_files = Dir[prefix + "#{@new_resource.path}.chef-*"].sort { |a,b| b <=> a }
+          backup_files = Dir[::File.join(prefix, ".#{@new_resource.path}.chef-*")].sort { |a,b| b <=> a }
           if backup_files.length >= @new_resource.backup
             remainder = backup_files.slice(slice_number..-1)
             remainder.each do |backup_to_delete|
@@ -201,11 +202,6 @@ class Chef
         end
       end
 
-      def generate_url(url, type, args=nil)
-        cookbook_name = (@new_resource.respond_to?(:cookbook) && @new_resource.cookbook) ? @new_resource.cookbook : @new_resource.cookbook_name
-        generate_cookbook_url(url, cookbook_name, type, @node, args)
-      end
-
       private
 
       def new_resource_content_checksum

data/lib/chef/provider/group.rb

@@ -27,8 +27,8 @@ class Chef
       include Chef::Mixin::Command
       attr_accessor :group_exists
       
-      def initialize(node, new_resource, collection=nil, definitions=nil, cookbook_loader=nil)
-        super(node, new_resource, collection, definitions, cookbook_loader)
+      def initialize(new_resource, run_context)
+        super
         @group_exists = true
       end
       
@@ -115,6 +115,19 @@ class Chef
           raise Chef::Exceptions::Group, "Cannot modify #{@new_resource} - group does not exist!"
         end
       end
+      
+      def create_group
+        raise NotImplementedError, "subclasses of Chef::Provider::Group should define #create_group"
+      end
+
+      def manage_group
+        raise NotImplementedError, "subclasses of Chef::Provider::Group should define #manage_group"
+      end
+
+      def remove_group
+        raise NotImplementedError, "subclasses of Chef::Provider::Group should define #remove_group"
+      end
+
     end
   end
 end

data/lib/chef/provider/group/dscl.rb

@@ -73,6 +73,7 @@ class Chef
         end
 
         def set_members
+          pp :set_members => {:append => @new_resource.append, :members => @new_resource.members}
           unless @new_resource.append
             Chef::Log.debug("#{@new_resource}: removing group members #{@current_resource.members.join(' ')}") unless @current_resource.members.empty?
             safe_dscl("create /Groups/#{@new_resource.group_name} GroupMembers ''") # clear guid list
@@ -90,35 +91,26 @@ class Chef
         end
         
         def create_group
-          manage_group(false)
+          dscl_create_group
+          set_gid
+          set_members
         end
         
-        def manage_group(manage=true)#
-          fields = []
-          if manage
-            [:group_name,:gid,:members].each do |field|
-              if @current_resource.send(field) != @new_resource.send(field)
-                fields << field if @new_resource.send(field)
-              end
-            end
-          else
-            # create
-            fields = [:group_name,:gid,:members]
+        def manage_group
+          if @new_resource.group_name && (@current_resource.group_name != @new_resource.group_name)
+            dscl_create_group
           end
-
-          fields.each do |field|
-            case field
-            when :group_name
-              safe_dscl("create /Groups/#{@new_resource.group_name}")
-              safe_dscl("create /Groups/#{@new_resource.group_name} Password '*'")
-              
-            when :gid
-              set_gid
-              
-            when :members
-              set_members
-            end
+          if @new_resource.gid && (@current_resource.gid != @new_resource.gid)
+            set_gid
           end
+          if @new_resource.members && (@current_resource.members != @new_resource.members)
+            set_members
+          end
+        end
+        
+        def dscl_create_group
+          safe_dscl("create /Groups/#{@new_resource.group_name}")
+          safe_dscl("create /Groups/#{@new_resource.group_name} Password '*'")
         end
         
         def remove_group

data/lib/chef/provider/group/gpasswd.rb

@@ -17,12 +17,15 @@
 #
 
 require 'chef/provider/group/groupadd'
+require 'chef/mixin/shell_out'
 
 class Chef
   class Provider
     class Group
       class Gpasswd < Chef::Provider::Group::Groupadd
-        
+
+        include Chef::Mixin::ShellOut
+
         def load_current_resource
           super
 
@@ -34,11 +37,11 @@ class Chef
             if(@new_resource.append)
               @new_resource.members.each do |member|
                 Chef::Log.debug("#{@new_resource}: appending member #{member} to group #{@new_resource.group_name}")
-                run_command(:command => "gpasswd -a #{member} #{@new_resource.group_name}")
+                shell_out!("gpasswd -a #{member} #{@new_resource.group_name}")
               end
             else
               Chef::Log.debug("#{@new_resource}: setting group members to #{@new_resource.members.join(', ')}")
-              run_command(:command => "gpasswd -M #{@new_resource.members.join(',')} #{@new_resource.group_name}")
+              shell_out!("gpasswd -M #{@new_resource.members.join(',')} #{@new_resource.group_name}")
             end
           else
             Chef::Log.debug("#{@new_resource}: not changing group members, the group has no members")