chef 10.28.2-x86-mingw32

data/lib/chef/provider/link.rb

@@ -0,0 +1,130 @@
+#
+# 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/mixin/shell_out'
+require 'chef/mixin/file_class'
+require 'chef/resource/link'
+require 'chef/provider'
+require 'chef/scan_access_control'
+
+class Chef
+  class Provider
+    class Link < Chef::Provider
+      include Chef::Mixin::ShellOut
+      include Chef::Mixin::FileClass
+
+      def negative_complement(big)
+        if big > 1073741823 # Fixnum max
+          big -= (2**32) # diminished radix wrap to negative
+        end
+        big
+      end
+
+      private :negative_complement
+
+      def whyrun_supported?
+        true
+      end
+
+      def load_current_resource
+        @current_resource = Chef::Resource::Link.new(@new_resource.name)
+        @current_resource.target_file(@new_resource.target_file)
+        if file_class.symlink?(@current_resource.target_file)
+          @current_resource.link_type(:symbolic)
+          @current_resource.to(
+            canonicalize(file_class.readlink(@current_resource.target_file))
+          )
+        else
+          @current_resource.link_type(:hard)
+          if ::File.exists?(@current_resource.target_file)
+            if ::File.exists?(@new_resource.to) &&
+               file_class.stat(@current_resource.target_file).ino ==
+               file_class.stat(@new_resource.to).ino
+              @current_resource.to(canonicalize(@new_resource.to))
+            else
+              @current_resource.to("")
+            end
+          end
+        end
+        ScanAccessControl.new(@new_resource, @current_resource).set_all!
+        @current_resource
+      end
+
+      def define_resource_requirements
+        requirements.assert(:delete) do |a|
+          a.assertion do
+            if @current_resource.to
+              @current_resource.link_type == @new_resource.link_type and
+              (@current_resource.link_type == :symbolic  or @current_resource.to != '')
+            else
+              true
+            end
+          end
+          a.failure_message Chef::Exceptions::Link, "Cannot delete #{@new_resource} at #{@new_resource.target_file}! Not a #{@new_resource.link_type.to_s} link."
+          a.whyrun("Would assume the link at #{@new_resource.target_file} was previously created")
+        end
+      end
+
+      def canonicalize(path)
+        Chef::Platform.windows? ? path.gsub('/', '\\') : path
+      end
+
+      def action_create
+        if @current_resource.to != canonicalize(@new_resource.to) ||
+           @current_resource.link_type != @new_resource.link_type
+          if @current_resource.to # nil if target_file does not exist
+            converge_by("unlink existing file at #{@new_resource.target_file}") do
+              ::File.unlink(@new_resource.target_file)
+            end
+          end
+          if @new_resource.link_type == :symbolic
+            converge_by("create symlink at #{@new_resource.target_file} to #{@new_resource.to}") do
+              file_class.symlink(canonicalize(@new_resource.to),@new_resource.target_file)
+              Chef::Log.debug("#{@new_resource} created #{@new_resource.link_type} link from #{@new_resource.to} -> #{@new_resource.target_file}")
+              Chef::Log.info("#{@new_resource} created")
+            end
+          elsif @new_resource.link_type == :hard
+            converge_by("create hard link at #{@new_resource.target_file} to #{@new_resource.to}") do
+              file_class.link(@new_resource.to, @new_resource.target_file)
+              Chef::Log.debug("#{@new_resource} created #{@new_resource.link_type} link from #{@new_resource.to} -> #{@new_resource.target_file}")
+              Chef::Log.info("#{@new_resource} created")
+            end
+          end
+        end
+        if @new_resource.link_type == :symbolic
+          if access_controls.requires_changes?
+            converge_by(access_controls.describe_changes) do 
+              access_controls.set_all
+            end
+          end
+       end
+      end
+
+      def action_delete
+        if @current_resource.to # Exists
+          converge_by ("delete link at #{@new_resource.target_file}") do
+            ::File.delete(@new_resource.target_file)
+            Chef::Log.info("#{@new_resource} deleted")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/chef/provider/log.rb

@@ -0,0 +1,54 @@
+#
+# Author:: Cary Penniman (<cary@rightscale.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.
+#
+
+class Chef
+
+  class Provider
+
+    class Log
+
+      # Chef log provider, allows logging to chef's logs from recipes
+      class ChefLog < Chef::Provider
+
+        # No concept of a 'current' resource for logs, this is a no-op
+        #
+        # === Return
+        # true:: Always return true
+        def load_current_resource
+          true
+        end
+      
+        # Write the log to Chef's log
+        #
+        # === Return
+        # true:: Always return true
+        def action_write
+          Chef::Log.send(@new_resource.level, @new_resource.message)
+          @new_resource.updated_by_last_action(true)
+        end
+
+      end
+
+    end
+
+  end
+
+end
+
+
+

data/lib/chef/provider/mdadm.rb

@@ -0,0 +1,92 @@
+#
+# 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/shell_out'
+require 'chef/provider'
+
+class Chef
+  class Provider
+    class Mdadm < Chef::Provider
+
+      include Chef::Mixin::ShellOut
+
+      def popen4
+        raise Exception, "deprecated"
+      end
+
+      def whyrun_supported?
+        true
+      end
+
+      def load_current_resource
+        @current_resource = Chef::Resource::Mdadm.new(@new_resource.name)
+        @current_resource.raid_device(@new_resource.raid_device)
+        Chef::Log.debug("#{@new_resource} checking for software raid device #{@current_resource.raid_device}")
+
+        device_not_found = 4
+        mdadm = shell_out!("mdadm --detail --test #{@new_resource.raid_device}", :returns => [0,device_not_found])
+        exists = (mdadm.status == 0)
+        @current_resource.exists(exists)
+      end
+
+      def action_create
+        unless @current_resource.exists
+          converge_by("create RAID device #{new_resource.raid_device}") do 
+            command = "yes | mdadm --create #{@new_resource.raid_device} --chunk=#{@new_resource.chunk} --level #{@new_resource.level}"
+            command << " --metadata=#{@new_resource.metadata}"
+            command << " --bitmap=#{@new_resource.bitmap}" if @new_resource.bitmap
+            command << " --raid-devices #{@new_resource.devices.length} #{@new_resource.devices.join(" ")}"
+            Chef::Log.debug("#{@new_resource} mdadm command: #{command}")
+            shell_out!(command)
+            Chef::Log.info("#{@new_resource} created raid device (#{@new_resource.raid_device})")
+          end
+        else
+          Chef::Log.debug("#{@new_resource} raid device already exists, skipping create (#{@new_resource.raid_device})")
+        end
+      end
+
+      def action_assemble
+        unless @current_resource.exists
+          converge_by("assemble RAID device #{new_resource.raid_device}") do 
+            command = "yes | mdadm --assemble #{@new_resource.raid_device} #{@new_resource.devices.join(" ")}"
+            Chef::Log.debug("#{@new_resource} mdadm command: #{command}")
+            shell_out!(command)
+            Chef::Log.info("#{@new_resource} assembled raid device (#{@new_resource.raid_device})")
+          end
+        else
+          Chef::Log.debug("#{@new_resource} raid device already exists, skipping assemble (#{@new_resource.raid_device})")
+        end
+      end
+
+      def action_stop
+        if @current_resource.exists
+          converge_by("stop RAID device #{new_resource.raid_device}") do 
+            command = "yes | mdadm --stop #{@new_resource.raid_device}"
+            Chef::Log.debug("#{@new_resource} mdadm command: #{command}")
+            shell_out!(command)
+            Chef::Log.info("#{@new_resource} stopped raid device (#{@new_resource.raid_device})")
+          end
+        else
+          Chef::Log.debug("#{@new_resource} raid device doesn't exist (#{@new_resource.raid_device}) - not stopping")
+        end
+      end
+
+    end
+  end
+end

data/lib/chef/provider/mount.rb

@@ -0,0 +1,128 @@
+#
+# Author:: Joshua Timberman (<joshua@opscode.com>)
+# Copyright:: Copyright (c) 2009 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/log'
+require 'chef/mixin/command'
+require 'chef/provider'
+
+class Chef
+  class Provider
+    class Mount < Chef::Provider
+
+      include Chef::Mixin::Command
+
+
+      def whyrun_supported?
+        true
+      end
+
+      def load_current_resource
+        true
+      end
+
+      def action_mount
+        unless @current_resource.mounted
+          converge_by("mount #{@current_resource.device} to #{@current_resource.mount_point}") do 
+            status = mount_fs()
+            if status
+              Chef::Log.info("#{@new_resource} mounted")
+            end
+          end
+        else
+          Chef::Log.debug("#{@new_resource} is already mounted")
+        end
+      end
+
+      def action_umount
+        if @current_resource.mounted
+          converge_by("unmount #{@current_resource.device}") do 
+            status = umount_fs()
+            if status
+              Chef::Log.info("#{@new_resource} unmounted")
+            end
+          end
+        else
+          Chef::Log.debug("#{@new_resource} is already unmounted")
+        end
+      end
+
+      def action_remount
+        unless @new_resource.supports[:remount]
+          raise Chef::Exceptions::UnsupportedAction, "#{self.to_s} does not support :remount"
+        else
+          if @current_resource.mounted
+            converge_by("remount #{@current_resource.device}") do 
+              status = remount_fs()
+              if status
+                Chef::Log.info("#{@new_resource} remounted")
+              end
+            end
+          else
+            Chef::Log.debug("#{@new_resource} not mounted, nothing to remount")
+          end
+        end
+      end
+
+      def action_enable
+        unless @current_resource.enabled
+          converge_by("remount #{@current_resource.device}") do 
+            status = enable_fs
+            if status
+              Chef::Log.info("#{@new_resource} enabled")
+            else
+              Chef::Log.debug("#{@new_resource} already enabled")
+            end
+          end
+        end
+      end
+
+      def action_disable
+        if @current_resource.enabled
+          converge_by("remount #{@current_resource.device}") do 
+            status = disable_fs
+            if status
+              Chef::Log.info("#{@new_resource} disabled")
+            else
+              Chef::Log.debug("#{@new_resource} already disabled")
+            end
+          end
+        end
+      end
+
+      def mount_fs
+        raise Chef::Exceptions::UnsupportedAction, "#{self.to_s} does not support :mount"
+      end
+
+      def umount_fs
+        raise Chef::Exceptions::UnsupportedAction, "#{self.to_s} does not support :umount"
+      end
+
+      def remount_fs
+        raise Chef::Exceptions::UnsupportedAction, "#{self.to_s} does not support :remount"
+      end
+      
+      def enable_fs
+        raise Chef::Exceptions::UnsupportedAction, "#{self.to_s} does not support :enable"        
+      end
+      
+      def disable_fs
+        raise Chef::Exceptions::UnsupportedAction, "#{self.to_s} does not support :disable"        
+      end      
+    end
+  end
+end

data/lib/chef/provider/mount/mount.rb

@@ -0,0 +1,252 @@
+#
+# Author:: Joshua Timberman (<joshua@opscode.com>)
+# Copyright:: Copyright (c) 2009 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/provider/mount'
+require 'chef/log'
+require 'chef/mixin/shell_out'
+
+class Chef
+  class Provider
+    class Mount
+      class Mount < Chef::Provider::Mount
+        include Chef::Mixin::ShellOut
+
+        def initialize(new_resource, run_context)
+          super
+          @real_device = nil
+        end
+        attr_accessor :real_device
+
+        def load_current_resource
+          @current_resource = Chef::Resource::Mount.new(@new_resource.name)
+          @current_resource.mount_point(@new_resource.mount_point)
+          @current_resource.device(@new_resource.device)
+          mounted?
+          enabled?
+        end
+        
+        def mountable?
+          # only check for existence of non-remote devices
+          if (device_should_exist? && !::File.exists?(device_real) )
+            raise Chef::Exceptions::Mount, "Device #{@new_resource.device} does not exist"
+          elsif( !::File.exists?(@new_resource.mount_point) )
+            raise Chef::Exceptions::Mount, "Mount point #{@new_resource.mount_point} does not exist"
+          end
+          return true
+        end
+        
+        def enabled?
+          # Check to see if there is a entry in /etc/fstab. Last entry for a volume wins.
+          enabled = false
+          ::File.foreach("/etc/fstab") do |line|
+            case line
+            when /^[#\s]/
+              next
+            when /^#{device_fstab_regex}\s+#{Regexp.escape(@new_resource.mount_point)}\s+(\S+)\s+(\S+)\s+(\S+)\s+(\S+)/
+              enabled = true
+              @current_resource.fstype($1)
+              @current_resource.options($2)
+              @current_resource.dump($3.to_i)
+              @current_resource.pass($4.to_i)
+              Chef::Log.debug("Found mount #{device_fstab} to #{@new_resource.mount_point} in /etc/fstab")
+              next
+            when /^[\/\w]+\s+#{Regexp.escape(@new_resource.mount_point)}\s+/
+              enabled = false
+              Chef::Log.debug("Found conflicting mount point #{@new_resource.mount_point} in /etc/fstab")
+            end
+          end
+          @current_resource.enabled(enabled)
+        end
+        
+        def mounted?
+          mounted = false
+          shell_out!("mount").stdout.each_line do |line|
+            case line
+            when /^#{device_mount_regex}\s+on\s+#{Regexp.escape(@new_resource.mount_point)}/
+              mounted = true
+              Chef::Log.debug("Special device #{device_logstring} mounted as #{@new_resource.mount_point}")
+            when /^([\/\w])+\son\s#{Regexp.escape(@new_resource.mount_point)}\s+/
+              mounted = false
+              Chef::Log.debug("Special device #{$~[1]} mounted as #{@new_resource.mount_point}")
+            end
+          end
+          @current_resource.mounted(mounted)
+        end
+
+        def mount_fs
+          unless @current_resource.mounted
+            mountable?
+            command = "mount -t #{@new_resource.fstype}"
+            command << " -o #{@new_resource.options.join(',')}" unless @new_resource.options.nil? || @new_resource.options.empty?
+            command << case @new_resource.device_type
+            when :device
+              " #{device_real}"
+            when :label
+              " -L #{@new_resource.device}"
+            when :uuid
+              " -U #{@new_resource.device}"
+            end
+            command << " #{@new_resource.mount_point}"
+            shell_out!(command)
+            Chef::Log.debug("#{@new_resource} is mounted at #{@new_resource.mount_point}")
+          else
+            Chef::Log.debug("#{@new_resource} is already mounted at #{@new_resource.mount_point}")
+          end
+        end
+
+        def umount_fs
+          if @current_resource.mounted
+            shell_out!("umount #{@new_resource.mount_point}")
+            Chef::Log.debug("#{@new_resource} is no longer mounted at #{@new_resource.mount_point}")
+          else
+            Chef::Log.debug("#{@new_resource} is not mounted at #{@new_resource.mount_point}")
+          end
+        end
+
+        def remount_fs
+          if @current_resource.mounted and @new_resource.supports[:remount]
+            shell_out!("mount -o remount #{@new_resource.mount_point}")
+            @new_resource.updated_by_last_action(true)
+            Chef::Log.debug("#{@new_resource} is remounted at #{@new_resource.mount_point}")
+          elsif @current_resource.mounted
+            umount_fs
+            sleep 1
+            mount_fs
+          else
+            Chef::Log.debug("#{@new_resource} is not mounted at #{@new_resource.mount_point} - nothing to do")
+          end
+        end
+
+        def enable_fs
+          if @current_resource.enabled && mount_options_unchanged?
+            Chef::Log.debug("#{@new_resource} is already enabled - nothing to do")
+            return nil
+          end
+          
+          if @current_resource.enabled
+            # The current options don't match what we have, so
+            # disable, then enable.
+            disable_fs
+          end
+          ::File.open("/etc/fstab", "a") do |fstab|
+            fstab.puts("#{device_fstab} #{@new_resource.mount_point} #{@new_resource.fstype} #{@new_resource.options.nil? ? "defaults" : @new_resource.options.join(",")} #{@new_resource.dump} #{@new_resource.pass}")
+            Chef::Log.debug("#{@new_resource} is enabled at #{@new_resource.mount_point}")
+          end
+        end
+
+        def disable_fs
+          if @current_resource.enabled
+            contents = []
+            
+            found = false
+            ::File.readlines("/etc/fstab").reverse_each do |line|
+              if !found && line =~ /^#{device_fstab_regex}\s+#{Regexp.escape(@new_resource.mount_point)}/
+                found = true
+                Chef::Log.debug("#{@new_resource} is removed from fstab")
+                next
+              else
+                contents << line
+              end
+            end
+            
+            ::File.open("/etc/fstab", "w") do |fstab|
+              contents.reverse_each { |line| fstab.puts line}
+            end
+          else
+            Chef::Log.debug("#{@new_resource} is not enabled - nothing to do")
+          end
+        end
+
+        def network_device?
+          @new_resource.device =~ /:/ || @new_resource.device =~ /\/\//
+        end
+
+        def device_should_exist?
+          ( not network_device? ) &&
+            ( not %w[ tmpfs fuse ].include? @new_resource.fstype )
+        end
+
+        private
+
+        def device_fstab
+          case @new_resource.device_type
+          when :device
+            @new_resource.device
+          when :label
+            "LABEL=#{@new_resource.device}"
+          when :uuid
+            "UUID=#{@new_resource.device}"
+          end
+        end
+
+        def device_real
+          if @real_device == nil 
+            if @new_resource.device_type == :device
+              @real_device = @new_resource.device
+            else
+              @real_device = ""
+              status = popen4("/sbin/findfs #{device_fstab}") do |pid, stdin, stdout, stderr|
+                device_line = stdout.first # stdout.first consumes
+                @real_device = device_line.chomp unless device_line.nil?
+              end
+            end
+          end
+          @real_device
+        end
+
+        def device_logstring
+          case @new_resource.device_type
+          when :device
+            "#{device_real}"
+          when :label
+            "#{device_real} with label #{@new_resource.device}"
+          when :uuid
+            "#{device_real} with uuid #{@new_resource.device}"
+          end
+        end
+
+        def device_mount_regex
+          if network_device?
+            # ignore trailing slash
+            Regexp.escape(device_real)+"/?"
+          elsif ::File.symlink?(device_real)
+            "(?:#{Regexp.escape(device_real)})|(?:#{Regexp.escape(::File.readlink(device_real))})"
+          else
+            Regexp.escape(device_real)
+          end
+        end
+
+        def device_fstab_regex
+          if @new_resource.device_type == :device
+            device_mount_regex
+          else
+            device_fstab
+          end
+        end
+        
+        def mount_options_unchanged?
+          @current_resource.fstype == @new_resource.fstype and
+          @current_resource.options == @new_resource.options and
+          @current_resource.dump == @new_resource.dump and
+          @current_resource.pass == @new_resource.pass
+        end
+        
+      end
+    end
+  end
+end