mbailey-chef 0.9.12.1

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/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_by_last_action(true)
+          end
+        else
+          create_env
+          Chef::Log.debug("Created #{@new_resource}")
+          @new_resource.updated_by_last_action(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_by_last_action(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_by_last_action(true)
+        end
+      end
+
+      def action_modify
+        if @key_exists
+          if compare_value
+            modify_env
+            @new_resource.updated_by_last_action(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/erl_call.rb

@@ -0,0 +1,72 @@
+#
+# Author:: Joe Williams (<joe@joetify.com>)
+# Copyright:: Copyright (c) 2009 Joe Williams
+# 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/log'
+require 'chef/mixin/command'
+require 'chef/provider'
+
+class Chef
+  class Provider
+    class ErlCall < Chef::Provider
+      include Chef::Mixin::Command
+
+      def initialize(node, new_resource)
+        super(node, new_resource)
+      end
+
+      def load_current_resource
+        true
+      end
+
+      def action_run
+        case @new_resource.name_type
+        when "sname"
+          node = "-sname #{@new_resource.node_name}"
+        when "name"
+          node = "-name #{@new_resource.node_name}"
+        end
+
+        if @new_resource.cookie
+          cookie = "-c #{@new_resource.cookie}"
+        else
+          cookie = ""
+        end
+
+        if @new_resource.distributed
+          distributed = "-s"
+        else
+          distributed = ""
+        end
+
+        command = "erl_call -e #{distributed} #{node} #{cookie}"
+
+        status = popen4(command, :waitlast => true) do |pid, stdin, stdout, stderr|
+          Chef::Log.debug("Running erl_call[#{@new_resource.name}]")
+          Chef::Log.debug("erl_call[#{@new_resource.name}] command: #{command}")
+          Chef::Log.debug("erl_call[#{@new_resource.name}] code: #{@new_resource.code}")
+          @new_resource.code.each_line { |line| stdin.puts "#{line.chomp!}" }
+          stdin.close
+          Chef::Log.info("Ran erl_call[#{@new_resource.name}] successfully")
+          Chef::Log.debug("erl_call[#{@new_resource.name}] output: ")
+          stdout.each_line { |line| Chef::Log.debug("#{line}")}
+        end
+      end
+
+    end
+  end
+end

data/lib/chef/provider/execute.rb

@@ -0,0 +1,58 @@
+#
+# Author:: Adam Jacob (<adam@opscode.com>)
+# Copyright:: Copyright (c) 2008 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/mixin/command'
+require 'chef/log'
+require 'chef/provider'
+
+class Chef
+  class Provider
+    class Execute < Chef::Provider
+      
+      include Chef::Mixin::Command
+      
+      def load_current_resource
+        true
+      end
+      
+      def action_run
+        command_args = {
+          :command => @new_resource.command,
+          :command_string => @new_resource.to_s,
+        }
+        command_args[:creates] = @new_resource.creates if @new_resource.creates
+        command_args[:only_if] = @new_resource.only_if if @new_resource.only_if
+        command_args[:not_if] = @new_resource.not_if if @new_resource.not_if
+        command_args[:timeout] = @new_resource.timeout if @new_resource.timeout
+        command_args[:returns] = @new_resource.returns if @new_resource.returns
+        command_args[:environment] = @new_resource.environment if @new_resource.environment
+        command_args[:user] = @new_resource.user if @new_resource.user
+        command_args[:group] = @new_resource.group if @new_resource.group
+        command_args[:cwd] = @new_resource.cwd if @new_resource.cwd
+        command_args[:umask] = @new_resource.umask if @new_resource.umask
+        
+        status = run_command(command_args)
+        if status
+          @new_resource.updated_by_last_action(true)
+          Chef::Log.info("Ran #{@new_resource} successfully")
+        end
+      end
+      
+    end
+  end
+end

data/lib/chef/provider/file.rb

@@ -0,0 +1,213 @@
+#
+# Author:: Adam Jacob (<adam@opscode.com>)
+# Copyright:: Copyright (c) 2008 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/config'
+require 'chef/log'
+require 'chef/resource/file'
+require 'chef/mixin/checksum'
+require 'chef/provider'
+require 'etc'
+require 'fileutils'
+
+class Chef
+  class Provider
+    class File < Chef::Provider
+      include Chef::Mixin::Checksum
+
+      def negative_complement(big)
+        if big > 1073741823 # Fixnum max
+          big -= (2**32) # diminished radix wrap to negative
+        end
+        big
+      end
+
+      def octal_mode(mode)
+        ((mode.respond_to?(:oct) ? mode.oct : mode.to_i) & 007777)
+      end
+
+      private :negative_complement, :octal_mode
+
+      def load_current_resource
+        @current_resource = Chef::Resource::File.new(@new_resource.name)
+        @new_resource.path.gsub!(/\\/, "/") # for Windows
+        @current_resource.path(@new_resource.path)
+        if ::File.exist?(@current_resource.path) && ::File.readable?(@current_resource.path)
+          cstats = ::File.stat(@current_resource.path)
+          @current_resource.owner(cstats.uid)
+          @current_resource.group(cstats.gid)
+          @current_resource.mode(octal_mode(cstats.mode))
+        end
+        @current_resource
+      end
+
+      # Compare the content of a file.  Returns true if they are the same, false if they are not.
+      def compare_content
+        checksum(@current_resource.path) == new_resource_content_checksum
+      end
+
+      # Set the content of the file, assuming it is not set correctly already.
+      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_by_last_action(true)
+        end
+      end
+
+      # Compare the ownership of a file.  Returns true if they are the same, false if they are not.
+      def compare_owner
+        return false if @new_resource.owner.nil?
+
+        @set_user_id = case @new_resource.owner
+                       when /^\d+$/, Integer
+                         @new_resource.owner.to_i
+                       else
+                         # This raises an ArgumentError if you can't find the user
+                         Etc.getpwnam(@new_resource.owner).uid
+                       end
+
+        @set_user_id == @current_resource.owner
+      end
+
+      # Set the ownership on the file, assuming it is not set correctly already.
+      def set_owner
+        unless compare_owner
+          Chef::Log.info("Setting owner to #{@set_user_id} for #{@new_resource}")
+          @set_user_id = negative_complement(@set_user_id)
+          ::File.chown(@set_user_id, nil, @new_resource.path)
+          @new_resource.updated_by_last_action(true)
+        end
+      end
+
+      # Compares the group of a file.  Returns true if they are the same, false if they are not.
+      def compare_group
+        return false if @new_resource.group.nil?
+
+        @set_group_id = case @new_resource.group
+                        when /^\d+$/, Integer
+                          @new_resource.group.to_i
+                        else
+                          Etc.getgrnam(@new_resource.group).gid
+                        end
+
+        @set_group_id == @current_resource.group
+      end
+
+      def set_group
+        unless compare_group
+          Chef::Log.info("Setting group to #{@set_group_id} for #{@new_resource}")
+          @set_group_id = negative_complement(@set_group_id)
+          ::File.chown(nil, @set_group_id, @new_resource.path)
+          @new_resource.updated_by_last_action(true)
+        end
+      end
+
+      def compare_mode
+        case @new_resource.mode
+        when /^\d+$/, Integer
+          octal_mode(@new_resource.mode) == octal_mode(@current_resource.mode)
+        else
+          false
+        end
+      end
+
+      def set_mode
+        unless compare_mode && @new_resource.mode != nil
+          Chef::Log.info("Setting mode to #{sprintf("%o" % octal_mode(@new_resource.mode))} for #{@new_resource}")
+          # CHEF-174, bad mojo around treating integers as octal.  If a string is passed, we try to do the "right" thing
+          ::File.chmod(octal_mode(@new_resource.mode), @new_resource.path)
+          @new_resource.updated_by_last_action(true)
+        end
+      end
+
+      def action_create
+        unless ::File.exists?(@new_resource.path)
+          Chef::Log.info("Creating #{@new_resource} at #{@new_resource.path}")
+          ::File.open(@new_resource.path, "w+") {|f| f.write @new_resource.content }
+          @new_resource.updated_by_last_action(true)
+        else
+          set_content unless @new_resource.content.nil?
+        end
+        set_owner unless @new_resource.owner.nil?
+        set_group unless @new_resource.group.nil?
+        set_mode unless @new_resource.mode.nil?
+      end
+
+      def action_create_if_missing
+        action_create
+      end
+
+      def action_delete
+        if ::File.exists?(@new_resource.path)
+          if ::File.writable?(@new_resource.path)
+            backup unless ::File.symlink?(@new_resource.path)
+            Chef::Log.info("Deleting #{@new_resource} at #{@new_resource.path}")
+            ::File.delete(@new_resource.path)
+            @new_resource.updated_by_last_action(true)
+          else
+            raise "Cannot delete #{@new_resource} at #{@new_resource_path}!"
+          end
+        end
+      end
+
+      def action_touch
+        action_create
+        time = Time.now
+        Chef::Log.info("Updating #{@new_resource} with new atime/mtime of #{time}")
+        ::File.utime(time, time, @new_resource.path)
+        @new_resource.updated_by_last_action(true)
+      end
+
+      def backup(file=nil)
+        file ||= @new_resource.path
+        if @new_resource.backup != false && @new_resource.backup > 0 && ::File.exist?(file)
+          time = Time.now
+          savetime = time.strftime("%Y%m%d%H%M%S")
+          backup_filename = "#{@new_resource.path}.chef-#{savetime}"
+          backup_filename = backup_filename.sub(/^([A-Za-z]:)/, "") #strip drive letter on Windows
+          # 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[::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|
+              Chef::Log.info("Removing backup of #{@new_resource} at #{backup_to_delete}")
+              FileUtils.rm(backup_to_delete)
+            end
+          end
+        end
+      end
+
+      private
+
+      def new_resource_content_checksum
+        @new_resource.content && Digest::SHA2.hexdigest(@new_resource.content)
+      end
+    end
+  end
+end