giraffesoft-chef 0.7.15

data/lib/chef/provider/link.rb

@@ -0,0 +1,157 @@
+#
+# 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/command'
+require 'chef/resource/link'
+require 'chef/provider'
+
+class Chef
+  class Provider
+    class Link < Chef::Provider
+      include Chef::Mixin::Command
+
+      def negative_complement(big)
+        if big > 1073741823 # Fixnum max
+          big -= (2**32) # diminished radix wrap to negative
+        end
+        big
+      end
+
+      private :negative_complement
+      
+      def load_current_resource
+        @current_resource = Chef::Resource::Link.new(@new_resource.name)
+        @current_resource.target_file(@new_resource.target_file)
+        @current_resource.link_type(@new_resource.link_type)
+        if @new_resource.link_type == :symbolic          
+          if ::File.exists?(@current_resource.target_file) && ::File.symlink?(@current_resource.target_file)
+            @current_resource.to(
+              ::File.expand_path(::File.readlink(@current_resource.target_file))
+            )
+            cstats = ::File.lstat(@current_resource.target_file)
+            @current_resource.owner(cstats.uid)
+            @current_resource.group(cstats.gid)
+          else
+            @current_resource.to("")
+          end
+        elsif @new_resource.link_type == :hard
+          if ::File.exists?(@current_resource.target_file) && ::File.exists?(@new_resource.to)
+            if ::File.stat(@current_resource.target_file).ino == ::File.stat(@new_resource.to).ino
+              @current_resource.to(@new_resource.to)
+            else
+              @current_resource.to("")
+            end
+          else
+            @current_resource.to("")
+          end
+        end
+        @current_resource
+      end      
+      
+      # Compare the ownership of a symlink.  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 symlink, 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.lchown(@set_user_id, nil, @new_resource.target_file)
+          @new_resource.updated = true
+        end
+      end
+      
+      # Compares the group of a symlink.  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.lchown(nil, @set_group_id, @new_resource.target_file)
+          @new_resource.updated = true
+        end
+      end
+      
+      def action_create
+        if @current_resource.to != @new_resource.to
+          Chef::Log.info("Creating a #{@new_resource.link_type} link from #{@new_resource.to} -> #{@new_resource.target_file} for #{@new_resource}")
+          if @new_resource.link_type == :symbolic
+            run_command(
+              :command => "ln -nfs #{@new_resource.to} #{@new_resource.target_file}"
+            )
+          elsif @new_resource.link_type == :hard
+            ::File.link(@new_resource.to, @new_resource.target_file)
+          end
+          @new_resource.updated = true
+        end
+        if @new_resource.link_type == :symbolic
+          set_owner unless @new_resource.owner.nil?
+          set_group unless @new_resource.group.nil?
+        end
+      end
+      
+      def action_delete
+        if @new_resource.link_type == :symbolic 
+          if ::File.symlink?(@new_resource.target_file)
+            Chef::Log.info("Deleting #{@new_resource} at #{@new_resource.target_file}")
+            ::File.delete(@new_resource.target_file)
+            @new_resource.updated = true
+          elsif ::File.exists?(@new_resource.target_file)
+            raise Chef::Exceptions::Link, "Cannot delete #{@new_resource} at #{@new_resource.target_file}! Not a symbolic link."
+          end
+        elsif @new_resource.link_type == :hard 
+          if ::File.exists?(@new_resource.target_file)
+             if ::File.exists?(@new_resource.to) && ::File.stat(@current_resource.target_file).ino == ::File.stat(@new_resource.to).ino
+               Chef::Log.info("Deleting #{@new_resource} at #{@new_resource.target_file}")
+               ::File.delete(@new_resource.target_file)
+               @new_resource.updated = true
+             else
+               raise Chef::Exceptions::Link, "Cannot delete #{@new_resource} at #{@new_resource.target_file}! Not a hard link."
+             end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/chef/provider/mount.rb

@@ -0,0 +1,117 @@
+#
+# 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 action_mount
+        unless @current_resource.mounted
+          Chef::Log.debug("#{@new_resource}: attempting to mount")
+          status = mount_fs()
+          if status
+            @new_resource.updated = true            
+            Chef::Log.info("#{@new_resource}: mounted successfully")
+          end
+        else
+          Chef::Log.debug("#{@new_resource}: not mounting, already mounted")
+        end
+      end
+
+      def action_umount
+        if @current_resource.mounted
+          Chef::Log.debug("#{@new_resource}: attempting to unmount")
+          status = umount_fs()
+          if status
+            @new_resource.updated = true            
+            Chef::Log.info("#{@new_resource}: unmounted successfully")
+          end
+        else
+          Chef::Log.debug("#{@new_resource}: not unmounting, 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
+            Chef::Log.debug("#{@new_resource}: attempting to remount")
+            status = remount_fs()
+            if status
+              @new_resource.updated = true            
+              Chef::Log.info("#{@new_resource}: remounted successfully")
+            end
+          else
+            Chef::Log.debug("#{@new_resource}: not mounted, not remounting")
+          end
+        end
+      end
+      
+      def action_enable
+        unless @current_resource.enabled
+          status = enable_fs
+          if status
+            @new_resource.updated = true            
+            Chef::Log.info("#{@new_resource}: enabled successfully")
+          else
+            Chef::Log.debug("#{@new_resource}: not enabling, already enabled")
+          end
+        end
+      end
+      
+      def action_disable
+        if @current_resource.enabled
+          status = disable_fs
+          if status
+            @new_resource.updated = true            
+            Chef::Log.info("#{@new_resource}: disabled successfully")
+          else
+            Chef::Log.debug("#{@new_resource}: not disabling, already disabled")
+          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,208 @@
+#
+# 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/command'
+
+class Chef
+  class Provider
+    class Mount
+      class Mount < Chef::Provider::Mount
+
+        include Chef::Mixin::Command
+
+        def initialize(node, new_resource, collection=nil, definitions=nil, cookbook_loader=nil)
+          super(node, new_resource, collection, definitions, cookbook_loader)
+          @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)
+          Chef::Log.debug("Checking for mount point #{@current_resource.mount_point}")
+
+          # only check for existence of non-remote devices
+          if(@new_resource.device !~ /:/ && !::File.exists?(@new_resource.device) )
+            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
+
+          # Check to see if the volume is mounted. Last volume entry wins.
+          mounted = false
+          popen4("mount") do |pid, stdin, stdout, stderr|
+            stdout.each do |line|
+              case line
+              when /^#{device_mount_regex}\s+on\s+#{@new_resource.mount_point}/
+                mounted = true
+                Chef::Log.debug("Special device #{device_logstring} mounted as #{@new_resource.mount_point}")
+              when /^([\/\w])+\son\s#{@new_resource.mount_point}\s+/
+                mounted = false
+                Chef::Log.debug("Special device #{$~[1]} mounted as #{@new_resource.mount_point}")
+              end
+            end
+          end
+          @current_resource.mounted(mounted)
+
+          # Check to see if there is a entry in /etc/fstab. Last entry for a volume wins.
+          enabled = false
+          ::File.read("/etc/fstab").each do |line|
+            case line
+            when /^[#\s]/
+              next
+            when /^#{device_fstab_regex}\s+#{@new_resource.mount_point}/
+              enabled = true
+              Chef::Log.debug("Found mount #{device_fstab} to #{@new_resource.mount_point} in /etc/fstab")
+            when /^[\/\w]+\s+#{@new_resource.mount_point}/
+              enabled = false
+              Chef::Log.debug("Found conflicting mount point #{@new_resource.mount_point} in /etc/fstab")
+            end
+          end
+          @current_resource.enabled(enabled)
+        end
+
+        def mount_fs
+          unless @current_resource.mounted
+            command = "mount -t #{@new_resource.fstype}"
+            command << " -o #{@new_resource.options.join(',')}" unless @new_resource.options.nil? || @new_resource.options.empty?
+            command << " #{device_real}"
+            command << " #{@new_resource.mount_point}"
+            run_command(:command => command)
+            Chef::Log.info("Mounted #{@new_resource.mount_point}")
+          else
+            Chef::Log.debug("#{@new_resource.mount_point} is already mounted.")
+          end
+        end
+
+        def umount_fs
+          if @current_resource.mounted
+            command = "umount #{@new_resource.mount_point}"
+            run_command(:command => command)
+            Chef::Log.info("Unmounted #{@new_resource.mount_point}")
+          else
+            Chef::Log.debug("#{@new_resource.mount_point} is not mounted.")
+          end
+        end
+
+        def remount_fs
+          if @current_resource.mounted and @new_resource.supports[:remount]
+            command = "mount -o remount #{@new_resource.mount_point}"
+            run_command(:command => command)
+
+            @new_resource.updated = true
+            Chef::Log.info("Remounted #{@new_resource.mount_point}")
+          elsif @current_resource.mounted
+            umount_fs
+            sleep 1
+            mount_fs
+          else
+            Chef::Log.debug("#{@new_resource.mount_point} is not mounted.")
+          end
+        end
+
+        def enable_fs
+          unless @current_resource.enabled
+            ::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.info("Enabled #{@new_resource.mount_point}")
+            end
+          else
+            Chef::Log.debug("#{@new_resource.mount_point} is already enabled.")
+          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+#{@new_resource.mount_point}/
+                found = true
+                Chef::Log.debug("Removing #{@new_resource.mount_point} 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.mount_point} is not enabled")
+          end
+        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
+              status = popen4("/sbin/findfs #{device_fstab}") do |pid, stdin, stdout, stderr|
+                @real_device = stdout.first.chomp
+              end
+              unless status.exitstatus == 0
+                @real_device = "/dev/null"
+              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
+          ::File.symlink?(device_real) ? "(?:#{device_real})|(?:#{::File.readlink(device_real)})" : device_real
+        end
+
+        def device_fstab_regex
+          if @new_resource.device_type == :device
+            device_mount_regex
+          else
+            device_fstab
+          end
+        end
+      end
+    end
+  end
+end