giraffesoft-chef 0.7.15

data/lib/chef/platform.rb

@@ -0,0 +1,254 @@
+#
+# 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/params_validate'
+require 'chef/platform'
+require 'chef/resource'
+Dir[File.join(File.dirname(__FILE__), 'provider/**/*.rb')].sort.each { |lib| require lib }
+
+class Chef
+  class Platform
+        
+    @platforms = {
+      :mac_os_x => {
+        :default => {
+          :package => Chef::Provider::Package::Macports
+        }
+      },
+      :freebsd => {
+        :default => {
+          :group   => Chef::Provider::Group::Pw,
+          :package => Chef::Provider::Package::Freebsd,
+          :service => Chef::Provider::Service::Freebsd,
+          :user    => Chef::Provider::User::Pw,
+          :cron    => Chef::Provider::Cron
+        }
+      },
+      :ubuntu   => {
+        :default => {
+          :package => Chef::Provider::Package::Apt,
+          :service => Chef::Provider::Service::Debian,
+          :cron => Chef::Provider::Cron,
+        }
+      },
+      :debian => {
+        :default => {
+          :package => Chef::Provider::Package::Apt,
+          :service => Chef::Provider::Service::Debian,
+          :cron => Chef::Provider::Cron,
+        }
+      },
+      :centos   => {
+        :default => {
+          :service => Chef::Provider::Service::Redhat,
+          :cron => Chef::Provider::Cron,
+          :package => Chef::Provider::Package::Yum
+        }
+      },
+      :redhat   => {
+        :default => {
+          :service => Chef::Provider::Service::Redhat,
+          :cron => Chef::Provider::Cron,
+          :package => Chef::Provider::Package::Yum
+        }
+      },
+      :gentoo   => {
+        :default => {
+          :package => Chef::Provider::Package::Portage,
+          :service => Chef::Provider::Service::Gentoo,
+          :cron => Chef::Provider::Cron,
+        }
+      },
+      :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,
+        :script => Chef::Provider::Script,
+        :service => Chef::Provider::Service::Init,
+        :perl => Chef::Provider::Script,
+        :python => Chef::Provider::Script,
+        :ruby => Chef::Provider::Script,
+        :bash => Chef::Provider::Script,
+        :csh => Chef::Provider::Script,
+        :user => Chef::Provider::User::Useradd,
+        :group => Chef::Provider::Group::Gpasswd,
+        :http_request => Chef::Provider::HttpRequest,
+        :route => Chef::Provider::Route,
+        :ifconfig => Chef::Provider::Ifconfig,
+        :ruby_block => Chef::Provider::RubyBlock
+      }
+    }
+
+    class << self
+      attr_accessor :platforms
+      
+      include Chef::Mixin::ParamsValidate
+            
+      def find(name, version)
+        provider_map = @platforms[:default].clone
+        
+        name_sym = name
+        if name.kind_of?(String)
+          name.downcase!
+          name.gsub!(/\s/, "_")
+          name_sym = name.to_sym
+        end
+        
+        if @platforms.has_key?(name_sym)
+          if @platforms[name_sym].has_key?(version) 
+            Chef::Log.debug("Platform #{name.to_s} version #{version} found")
+            if @platforms[name_sym].has_key?(:default)
+              provider_map.merge!(@platforms[name_sym][:default])
+            end
+            provider_map.merge!(@platforms[name_sym][version])
+          elsif @platforms[name_sym].has_key?(:default)
+            provider_map.merge!(@platforms[name_sym][:default])
+          end
+        else
+          Chef::Log.debug("Platform #{name} not found, using all defaults. (Unsupported platform?)")
+        end
+        provider_map
+      end
+      
+      def find_provider(platform, version, resource_type)
+        pmap = Chef::Platform.find(platform, version)
+        rtkey = resource_type
+        if resource_type.kind_of?(Chef::Resource)
+          return resource_type.provider if resource_type.provider
+          rtkey = resource_type.resource_name.to_sym
+        end
+        if pmap.has_key?(rtkey)
+          pmap[rtkey]
+        else
+          Chef::Log.error("#{rtkey.inspect} #{pmap.inspect}")
+          raise(
+            ArgumentError, 
+            "Cannot find a provider for #{resource_type} on #{platform} version #{version}"
+          )
+        end
+      end
+      
+      def find_platform_and_version(node)
+        platform = nil
+        version = nil
+        
+        if node[:platform]
+          platform = node[:platform]
+        elsif node.attribute?("os")
+          platform = node[:os]
+        end
+        
+        raise ArgumentError, "Cannot find a platform for #{node}" unless platform
+        
+        if node[:platform_version]
+          version = node[:platform_version]
+        elsif node[:os_version]
+          version = node[:os_version]
+        elsif node[:os_release]
+          version = node[:os_release]
+        end
+        
+        raise ArgumentError, "Cannot find a version for #{node}" unless version
+        
+        return platform, version
+      end
+      
+      def provider_for_node(node, resource_type)
+        find_provider_for_node(node, resource_type).new(node, resource_type)
+      end
+
+      def find_provider_for_node(node, resource_type)
+        platform, version = find_platform_and_version(node)        
+        provider = find_provider(platform, version, resource_type)
+      end
+      
+      def set(args)
+        validate(
+          args,
+          {
+            :platform => {
+              :kind_of => Symbol,
+              :required => false,
+            },
+            :version => {
+              :kind_of => String,
+              :required => false,
+            },
+            :resource => {
+              :kind_of => Symbol,
+            },
+            :provider => {
+              :kind_of => [ String, Symbol, Class ],
+            }
+          }
+        )
+        if args.has_key?(:platform)          
+          if args.has_key?(:version)
+            if @platforms.has_key?(args[:platform])
+              if @platforms[args[:platform]].has_key?(args[:version])
+                @platforms[args[:platform]][args[:version]][args[:resource].to_sym] = args[:provider]
+              else
+                @platforms[args[:platform]][args[:version]] = {
+                  args[:resource].to_sym => args[:provider] 
+                }
+              end
+            else
+              @platforms[args[:platform]] = {
+                args[:version] => {
+                  args[:resource].to_sym => args[:provider]
+                }
+              }
+            end
+          else
+            if @platforms.has_key?(args[:platform])            
+              if @platforms[args[:platform]].has_key?(:default)
+                @platforms[args[:platform]][:default][args[:resource].to_sym] = args[:provider]
+              else
+                @platforms[args[:platform]] = { :default => { args[:resource].to_sym => args[:provider] } }
+              end
+            else
+              @platforms[args[:platform]] = {
+                :default => {
+                  args[:resource].to_sym => args[:provider]
+                }
+              }
+            end
+          end
+        else
+          if @platforms.has_key?(:default)
+            @platforms[:default][args[:resource].to_sym] = args[:provider]
+          else
+            @platforms[:default] = {
+              args[:resource].to_sym => args[:provider]
+            }
+          end
+        end
+      end
+            
+    end    
+    
+  end
+end

data/lib/chef/provider.rb

@@ -0,0 +1,101 @@
+#
+# Author:: Adam Jacob (<adam@opscode.com>)
+# Author:: Christopher Walters (<cw@opscode.com>)
+# Copyright:: Copyright (c) 2008, 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/mixin/from_file'
+require 'chef/mixin/convert_to_class_name'
+require 'chef/mixin/recipe_definition_dsl_core'
+
+class Chef
+  class Provider
+    
+    include Chef::Mixin::RecipeDefinitionDSLCore
+    
+    attr_accessor :node, :new_resource, :current_resource
+    
+    def initialize(node, new_resource, collection=nil, definitions={}, cookbook_loader=nil)
+      @node = node
+      @new_resource = new_resource
+      @current_resource = nil
+      @collection = collection
+      @definitions = definitions
+      @cookbook_loader = cookbook_loader
+      @cookbook_name = @new_resource.cookbook_name
+    end
+    
+    def load_current_resource
+      raise Chef::Exceptions::Override, "You must override load_current_resource in #{self.to_s}"
+    end
+    
+    def action_nothing
+      Chef::Log.debug("Doing nothing for #{@new_resource.to_s}")
+      true
+    end
+    
+    protected
+    
+    def recipe_eval(*args, &block)
+      provider_collection, @collection = @collection, Chef::ResourceCollection.new
+      
+      instance_eval(*args, &block)
+      Chef::Runner.new(@node, @collection).converge
+      
+      @collection = provider_collection
+    end
+    
+    public
+    
+    class << self
+      include Chef::Mixin::ConvertToClassName
+      
+      def build_from_file(cookbook_name, filename)
+        pname = filename_to_qualified_string(cookbook_name, filename)
+        
+        new_provider_class = Class.new self do |cls|
+          
+          def load_current_resource
+            # silence Chef::Exceptions::Override exception
+          end
+          
+          class << cls
+            include Chef::Mixin::FromFile
+            
+            # setup DSL's shortcut methods
+            def action(name, &block)
+              define_method("action_#{name.to_s}") do
+                instance_eval(&block)
+              end
+            end
+          end
+          
+          # load provider definition from file
+          cls.class_from_file(filename)
+        end
+        
+        # register new class as a Chef::Provider
+        pname = filename_to_qualified_string(cookbook_name, filename)
+        class_name = convert_to_class_name(pname)
+        Chef::Provider.const_set(class_name, new_provider_class)
+        Chef::Log.debug("Loaded contents of #{filename} into a provider named #{pname} defined in Chef::Provider::#{class_name}")
+        
+        new_provider_class
+      end
+    end
+
+  end
+end

data/lib/chef/provider/cron.rb

@@ -0,0 +1,187 @@
+#
+# Author:: Bryan McLellan (btm@loftninjas.org)
+# Copyright:: Copyright (c) 2009 Bryan McLellan
+# 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 Cron < Chef::Provider
+      include Chef::Mixin::Command
+
+      def initialize(node, new_resource, collection=nil, definitions=nil, cookbook_loader=nil)
+        super(node, new_resource, collection, definitions, cookbook_loader)
+        @cron_exists = false
+        @cron_empty = false
+      end
+      attr_accessor :cron_exists, :cron_empty
+
+      def load_current_resource
+        crontab = String.new
+        @current_resource = Chef::Resource::Cron.new(@new_resource.name)
+        @current_resource.user(@new_resource.user)
+        status = popen4("crontab -l -u #{@new_resource.user}") do |pid, stdin, stdout, stderr|
+          stdout.each { |line| crontab << line }
+        end
+        if status.exitstatus > 1
+          raise Chef::Exceptions::Cron, "Error determining state of #{@new_resource.name}, exit: #{status.exitstatus}"
+        elsif status.exitstatus == 0
+          cron_found = false
+          crontab.each do |line|
+            case line
+            when /^# Chef Name: #{@new_resource.name}/
+              Chef::Log.debug("Found cron '#{@new_resource.name}'")
+              cron_found = true
+              @cron_exists = true
+              next
+            when /^MAILTO=(\S*)/
+              @current_resource.mailto($1) if cron_found
+              next
+            when /^PATH=(\S*)/
+              @current_resource.path($1) if cron_found
+              next
+            when /^SHELL=(\S*)/
+              @current_resource.shell($1) if cron_found
+              next
+            when /^HOME=(\S*)/
+              @current_resource.home($1) if cron_found
+              next
+            when /([0-9\*]+)\s*([0-9\*]+)\s*([0-9\*]+)\s*([0-9\*]+)\s*([0-9\*]+)\s*(.*)/
+              if cron_found
+                @current_resource.minute($1) 
+                @current_resource.hour($2) 
+                @current_resource.day($3)
+                @current_resource.month($4) 
+                @current_resource.weekday($5) 
+                @current_resource.command($6)
+                cron_found=false
+              end
+              next
+            else
+              next
+            end
+          end
+          Chef::Log.debug("Cron '#{@new_resource.name}' not found") unless @cron_exists
+        elsif status.exitstatus == 1
+          Chef::Log.debug("Cron empty for '#{@new_resource.user}'")
+          @cron_empty = true
+        end
+        
+        @current_resource
+      end
+
+      def compare_cron
+        [ :minute, :hour, :day, :month, :weekday, :command, :mailto, :path, :shell, :home ].any? do |cron_var|
+          !@new_resource.send(cron_var).nil? && @new_resource.send(cron_var) != @current_resource.send(cron_var)
+        end
+      end
+
+      def action_create
+        crontab = String.new
+        newcron = String.new
+        cron_found = false
+
+        newcron << "# Chef Name: #{new_resource.name}\n"
+        [ :mailto, :path, :shell, :home ].each do |v|
+          newcron << "#{v.to_s.upcase}=#{@new_resource.send(v)}\n" if @new_resource.send(v)
+        end
+        newcron << "#{@new_resource.minute} #{@new_resource.hour} #{@new_resource.day} #{@new_resource.month} #{@new_resource.weekday} #{@new_resource.command}\n"
+
+        if @cron_exists
+          unless compare_cron
+            Chef::Log.debug("Skipping existing cron entry '#{@new_resource.name}'")
+            return
+          end
+          status = popen4("crontab -l -u #{@new_resource.user}") do |pid, stdin, stdout, stderr|
+            stdout.each_line do |line|
+              case line
+              when /^# Chef Name: #{@new_resource.name}\n/
+                cron_found = true
+                next
+              when /([0-9\*]+)\s*([0-9\*]+)\s*([0-9\*]+)\s*([0-9\*]+)\s*([0-9\*]+)\s*(.*)/
+                if cron_found
+                  cron_found = false
+                  crontab << newcron
+                  next
+                end
+              else
+                next if cron_found
+              end
+              crontab << line 
+            end
+          end
+
+          status = popen4("crontab -u #{@new_resource.user} -", :waitlast => true) do |pid, stdin, stdout, stderr|
+            crontab.each { |line| stdin.puts "#{line}" }
+            stdin.close rescue nil
+          end
+          Chef::Log.info("Updated cron '#{@new_resource.name}'")
+          @new_resource.updated = true
+        else
+          unless @cron_empty
+            status = popen4("crontab -l -u #{@new_resource.user}") do |pid, stdin, stdout, stderr|
+              stdout.each { |line| crontab << line }
+            end
+          end
+  
+          crontab << newcron
+
+          status = popen4("crontab -u #{@new_resource.user} -", :waitlast => true) do |pid, stdin, stdout, stderr|
+            crontab.each { |line| stdin.puts "#{line}" }
+            stdin.close rescue nil
+          end
+          Chef::Log.info("Added cron '#{@new_resource.name}'")
+          @new_resource.updated = true
+        end
+      end
+
+      def action_delete
+        if @cron_exists
+          crontab = String.new
+          cron_found = false
+          status = popen4("crontab -l -u #{@new_resource.user}") do |pid, stdin, stdout, stderr|
+            stdout.each_line do |line|
+              case line
+              when /^# Chef Name: #{@new_resource.name}\n/
+                cron_found = true
+                next
+              when /([0-9\*]+)\s*([0-9\*]+)\s*([0-9\*]+)\s*([0-9\*]+)\s*([0-9\*]+)\s*(.*)/
+                if cron_found
+                  cron_found = false
+                  next
+                end
+              else
+                next if cron_found
+              end
+              crontab << line 
+            end
+          end
+
+          status = popen4("crontab -u #{@new_resource.user} -", :waitlast => true) do |pid, stdin, stdout, stderr|
+            crontab.each { |line| stdin.puts "#{line}" }
+            stdin.close rescue nil
+          end
+          Chef::Log.debug("Deleted cron '#{@new_resource.name}'")
+          @new_resource.updated = true
+        end
+      end
+
+    end
+  end
+end