chef 0.10.8 → 0.10.10.beta.1

data/lib/chef/provider/remote_directory.rb

@@ -40,15 +40,20 @@ class Chef
         )
         files_to_transfer.each do |cookbook_file_relative_path|
           create_cookbook_file(cookbook_file_relative_path)
-          files_to_purge.delete(::File.dirname(::File.join(@new_resource.path, cookbook_file_relative_path)))
+          # the file is removed from the purge list
           files_to_purge.delete(::File.join(@new_resource.path, cookbook_file_relative_path))
+          # parent directories are also removed from the purge list
+          directories=::File.dirname(::File.join(@new_resource.path, cookbook_file_relative_path)).split(::File::SEPARATOR)
+          for i in 0..directories.length-1
+            files_to_purge.delete(::File.join(directories[0..i]))
+          end
         end
         purge_unmanaged_files(files_to_purge)
       end
 
       def action_create_if_missing
         # if this action is called, ignore the existing overwrite flag
-        @new_resource.overwrite = false
+        @new_resource.overwrite(false)
         action_create
       end
 
@@ -106,6 +111,11 @@ class Chef
         cookbook_file = Chef::Resource::CookbookFile.new(target_path, run_context)
         cookbook_file.cookbook_name = @new_resource.cookbook || @new_resource.cookbook_name
         cookbook_file.source(::File.join(@new_resource.source, relative_source_path))
+        if Chef::Platform.windows? && @new_resource.files_rights
+          @new_resource.files_rights.each_pair do |permission, *args|
+            cookbook_file.rights(permission, *args)
+          end
+        end
         cookbook_file.mode(@new_resource.files_mode)    if @new_resource.files_mode
         cookbook_file.group(@new_resource.files_group)  if @new_resource.files_group
         cookbook_file.owner(@new_resource.files_owner)  if @new_resource.files_owner
@@ -125,7 +135,18 @@ class Chef
       def resource_for_directory(path)
         dir = Chef::Resource::Directory.new(path, run_context)
         dir.cookbook_name = @new_resource.cookbook || @new_resource.cookbook_name
-        dir.mode(@new_resource.mode)
+        if Chef::Platform.windows? && @new_resource.rights
+          # rights are only meant to be applied to the toppest-level directory;
+          # Windows will handle inheritance.
+          if path == @new_resource.path
+            @new_resource.rights.each do |rights| #rights is a hash
+              permissions = rights.delete(:permissions) #delete will return the value or nil if not found
+              principals = rights.delete(:principals)
+              dir.rights(permissions, principals, rights)
+            end
+          end
+        end
+        dir.mode(@new_resource.mode) if @new_resource.mode
         dir.group(@new_resource.group)
         dir.owner(@new_resource.owner)
         dir.recursive(true)

data/lib/chef/provider/remote_file.rb

@@ -63,12 +63,6 @@ class Chef
         end
       end
 
-      def enforce_ownership_and_permissions
-        set_owner if @new_resource.owner
-        set_group if @new_resource.group
-        set_mode  if @new_resource.mode
-      end
-
       def current_resource_matches_target_checksum?
         @new_resource.checksum && @current_resource.checksum && @current_resource.checksum =~ /^#{Regexp.escape(@new_resource.checksum)}/
       end

data/lib/chef/provider/route.rb

@@ -130,7 +130,7 @@ class Chef::Provider::Route < Chef::Provider
     def generate_config
       conf = Hash.new
       case node[:platform]
-      when ("centos" || "redhat" || "fedora")
+      when "centos", "redhat", "fedora"
         # walk the collection
         run_context.resource_collection.each do |resource|
           if resource.is_a? Chef::Resource::Route
@@ -143,11 +143,11 @@ class Chef::Provider::Route < Chef::Provider
 
             conf[dev] = String.new if conf[dev].nil?
             if resource.action == :add
-              conf[dev] = config_file_contents(:add, :target => resource.target, :netmask => resource.netmask, :gateway => resource.gateway)
+              conf[dev] << config_file_contents(:add, :target => resource.target, :netmask => resource.netmask, :gateway => resource.gateway)
             else
               # need to do this for the case when the last route on an int
               # is removed
-              conf[dev] = config_file_contents(:delete)
+              conf[dev] << config_file_contents(:delete)
             end
           end
         end

data/lib/chef/provider/service/debian.rb

@@ -17,13 +17,13 @@
 #
 
 require 'chef/provider/service'
-require 'chef/provider/service/invokercd'
+require 'chef/provider/service/init'
 require 'chef/mixin/command'
 
 class Chef
   class Provider
     class Service
-      class Debian < Chef::Provider::Service::Invokercd
+      class Debian < Chef::Provider::Service::Init
         UPDATE_RC_D_ENABLED_MATCHES = /\/rc[\dS].d\/S|not installed/i
         UPDATE_RC_D_PRIORITIES = /\/rc([\dS]).d\/([SK])(\d\d)/i
 

data/lib/chef/provider/service/freebsd.rb

@@ -134,7 +134,7 @@ class Chef
         def set_service_enable(value)
           lines = read_rc_conf
           # Remove line that set the old value
-          lines.delete_if { |line| line =~ /#{service_enable_variable_name}/ }
+          lines.delete_if { |line| line =~ /#{Regexp.escape(service_enable_variable_name)}/ }
           # And append the line that sets the new value at the end
           lines << "#{service_enable_variable_name}=\"#{value}\""
           write_rc_conf(lines)

data/lib/chef/provider/service/macosx.rb

@@ -0,0 +1,125 @@
+#
+# Author:: Igor Afonov <afonov@gmail.com>
+# Copyright:: Copyright (c) 2011 Igor Afonov
+# 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/service'
+
+class Chef
+  class Provider
+    class Service
+      class Macosx < Chef::Provider::Service::Simple
+        include Chef::Mixin::ShellOut
+
+        PLIST_DIRS = %w{~/Library/LaunchAgents
+                         /Library/LaunchAgents
+                         /Library/LaunchDaemons
+                         /System/Library/LaunchAgents
+                         /System/Library/LaunchDaemons }
+
+        def load_current_resource
+          @current_resource = Chef::Resource::Service.new(@new_resource.name)
+          @current_resource.service_name(@new_resource.service_name)
+          @plist = find_service_plist
+          set_service_status
+
+          @current_resource
+        end
+
+        def enable_service
+          raise Chef::Exceptions::UnsupportedAction, "#{self.to_s} does not support :enable"
+        end
+
+        def disable_service
+          raise Chef::Exceptions::UnsupportedAction, "#{self.to_s} does not support :disable"
+        end
+
+        def start_service
+          if @current_resource.running
+            Chef::Log.debug("#{@new_resource} already running, not starting")
+          else
+            if @new_resource.start_command
+              super
+            else
+              shell_out!("launchctl load -w '#{@plist}'", :user => @owner_uid, :group => @owner_gid)
+            end
+          end
+        end
+
+        def stop_service
+          unless @current_resource.running
+            Chef::Log.debug("#{@new_resource} not running, not stopping")
+          else
+            if @new_resource.stop_command
+              super
+            else
+              shell_out!("launchctl unload '#{@plist}'", :user => @owner_uid, :group => @owner_gid)
+            end
+          end
+        end
+
+        def restart_service
+          if @new_resource.restart_command
+            super
+          else
+            stop_service
+            sleep 1
+            start_service
+          end
+        end
+
+        def reload_service
+          raise Chef::Exceptions::UnsupportedAction, "#{self.to_s} does not support :reload"
+        end
+
+        def set_service_status
+          @current_resource.enabled(!@plist.nil?)
+
+          if @current_resource.enabled
+            @owner_uid = ::File.stat(@plist).uid
+            @owner_gid = ::File.stat(@plist).gid
+
+            shell_out!("launchctl list", :user => @owner_uid, :group => @owner_gid).stdout.each_line do |line|
+              case line
+              when /(\d+|-)\s+(?:\d+|-)\s+(.*\.?)#{@current_resource.service_name}/
+                pid = $1
+                @current_resource.running(!pid.to_i.zero?)
+              end
+            end
+          else
+            @current_resource.running(false)
+          end
+        end
+
+      private
+
+        def find_service_plist
+          plists = PLIST_DIRS.inject([]) do |results, dir|
+            entries = Dir.glob("#{::File.expand_path(dir)}/*#{@current_resource.service_name}*.plist")
+            entries.any? ? results << entries : results
+          end
+
+          plists.flatten!
+          if plists.size > 1
+            raise Chef::Exceptions::Service, "Several plist files match service name. Please use full service name."
+          end
+
+          plists.first
+        end
+      end
+    end
+  end
+end

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

@@ -18,12 +18,16 @@
 # limitations under the License.
 #
 
+require 'chef/mixin/shell_out'
 require 'chef/provider/service/simple'
 if RUBY_PLATFORM =~ /mswin|mingw32|windows/
   require 'win32/service'
 end
 
 class Chef::Provider::Service::Windows < Chef::Provider::Service
+
+  include Chef::Mixin::ShellOut
+
   RUNNING = 'running'
   STOPPED = 'stopped'
   AUTO_START = 'auto start'
@@ -31,7 +35,7 @@ class Chef::Provider::Service::Windows < Chef::Provider::Service
 
   def load_current_resource
     @current_resource = Chef::Resource::Service.new(@new_resource.name)
-    @current_resource.service_name(@new_resource.service_name)    
+    @current_resource.service_name(@new_resource.service_name)
     @current_resource.running(current_state == RUNNING)
     Chef::Log.debug "#{@new_resource} running: #{@current_resource.running}"
     @current_resource.enabled(start_type == AUTO_START)

data/lib/chef/provider/subversion.rb

@@ -26,6 +26,8 @@ class Chef
   class Provider
     class Subversion < Chef::Provider
 
+      SVN_INFO_PATTERN = /^([\w\s]+): (.+)$/
+
       include Chef::Mixin::Command
 
       def load_current_resource
@@ -152,14 +154,15 @@ class Chef
       end
 
       def extract_revision_info(svn_info)
-        begin
-          repo_attrs = YAML.load(svn_info)
-        rescue ArgumentError
-          # YAML doesn't appreciate input like "svn: '/tmp/deploydir' is not a working copy\n"
-          return nil
+        repo_attrs = svn_info.lines.inject({}) do |attrs, line|
+          if line =~ SVN_INFO_PATTERN
+            property, value = $1, $2
+            attrs[property] = value
+          end
+          attrs
         end
-        raise "Could not parse `svn info` data: #{svn_info}" unless repo_attrs.kind_of?(Hash)
-        rev = (repo_attrs['Last Changed Rev'] || repo_attrs['Revision']).to_s
+        rev = (repo_attrs['Last Changed Rev'] || repo_attrs['Revision'])
+        raise "Could not parse `svn info` data: #{svn_info}" if repo_attrs.empty?
         Chef::Log.debug "#{@new_resource} resolved revision #{@new_resource.revision} to #{rev}"
         rev
       end

data/lib/chef/providers.rb

@@ -60,6 +60,7 @@ require 'chef/provider/package/rubygems'
 require 'chef/provider/package/yum'
 require 'chef/provider/package/zypper'
 require 'chef/provider/package/solaris'
+require 'chef/provider/package/smartos'
 
 require 'chef/provider/service/arch'
 require 'chef/provider/service/debian'
@@ -67,12 +68,14 @@ require 'chef/provider/service/freebsd'
 require 'chef/provider/service/gentoo'
 require 'chef/provider/service/init'
 require 'chef/provider/service/insserv'
+require 'chef/provider/service/invokercd'
 require 'chef/provider/service/redhat'
 require 'chef/provider/service/simple'
 require 'chef/provider/service/systemd'
 require 'chef/provider/service/upstart'
 require 'chef/provider/service/windows'
 require 'chef/provider/service/solaris'
+require 'chef/provider/service/macosx'
 
 require 'chef/provider/user/dscl'
 require 'chef/provider/user/pw'

data/lib/chef/resource.rb

@@ -23,6 +23,7 @@ require 'chef/mixin/language'
 require 'chef/mixin/convert_to_class_name'
 require 'chef/resource/conditional'
 require 'chef/resource_collection'
+require 'chef/resource_platform_map'
 require 'chef/node'
 
 require 'chef/mixin/deprecation'
@@ -345,8 +346,10 @@ F
       end << ">"
     end
 
-    # Serialize this object as a hash
-    def to_json(*a)
+    # as_json does most of the to_json heavy lifted. It exists here in case activesupport
+    # is loaded. activesupport will call as_json and skip over to_json. This ensure
+    # json is encoded as expected
+    def as_json(*a)
       safe_ivars = instance_variables.map { |ivar| ivar.to_sym } - FORBIDDEN_IVARS
       instance_vars = Hash.new
       safe_ivars.each do |iv|
@@ -356,6 +359,11 @@ F
         'json_class' => self.class.name,
         'instance_vars' => instance_vars
       }
+    end
+
+    # Serialize this object as a hash
+    def to_json(*a)
+      results = as_json
       results.to_json(*a)
     end
 
@@ -434,8 +442,14 @@ F
 
       begin
         return if should_skip?
-
-        provider = Chef::Platform.provider_for_resource(self)
+        # leverage new platform => short_name => resource
+        # which requires explicitly setting provider in
+        # resource class
+        if self.provider
+          provider = self.provider.new(self, self.run_context)
+        else # fall back to old provider resolution
+          provider = Chef::Platform.provider_for_resource(self)
+        end
         provider.load_current_resource
         provider.send("action_#{action}")
       rescue => e
@@ -485,110 +499,190 @@ F
       updated
     end
 
-    class << self
+    def self.json_create(o)
+      resource = self.new(o["instance_vars"]["@name"])
+      o["instance_vars"].each do |k,v|
+        resource.instance_variable_set("@#{k}".to_sym, v)
+      end
+      resource
+    end
+
+    # Hook to allow a resource to run specific code after creation
+    def after_created
+      nil
+    end
 
-      def json_create(o)
-        resource = self.new(o["instance_vars"]["@name"])
-        o["instance_vars"].each do |k,v|
-          resource.instance_variable_set("@#{k}".to_sym, v)
-        end
-        resource
+    extend Chef::Mixin::ConvertToClassName
+
+    def self.attribute(attr_name, validation_opts={})
+      # This atrocity is the only way to support 1.8 and 1.9 at the same time
+      # When you're ready to drop 1.8 support, do this:
+      # define_method attr_name.to_sym do |arg=nil|
+      # etc.
+      shim_method=<<-SHIM
+      def #{attr_name}(arg=nil)
+        _set_or_return_#{attr_name}(arg)
+      end
+      SHIM
+      class_eval(shim_method)
+
+      define_method("_set_or_return_#{attr_name.to_s}".to_sym) do |arg|
+        set_or_return(attr_name.to_sym, arg, validation_opts)
       end
+    end
 
-      include Chef::Mixin::ConvertToClassName
+    def self.build_from_file(cookbook_name, filename, run_context)
+      rname = filename_to_qualified_string(cookbook_name, filename)
 
-      def attribute(attr_name, validation_opts={})
-        # This atrocity is the only way to support 1.8 and 1.9 at the same time
-        # When you're ready to drop 1.8 support, do this:
-        # define_method attr_name.to_sym do |arg=nil|
-        # etc.
-        shim_method=<<-SHIM
-        def #{attr_name}(arg=nil)
-          _set_or_return_#{attr_name}(arg)
-        end
-        SHIM
-        class_eval(shim_method)
+      # Add log entry if we override an existing light-weight resource.
+      class_name = convert_to_class_name(rname)
+      overriding = Chef::Resource.const_defined?(class_name)
+      Chef::Log.info("#{class_name} light-weight resource already initialized -- overriding!") if overriding
+
+      new_resource_class = Class.new self do |cls|
 
-        define_method("_set_or_return_#{attr_name.to_s}".to_sym) do |arg|
-          set_or_return(attr_name.to_sym, arg, validation_opts)
+        # default initialize method that ensures that when initialize is finally
+        # wrapped (see below), super is called in the event that the resource
+        # definer does not implement initialize
+        def initialize(name, run_context)
+          super(name, run_context)
         end
-      end
-      
-      def build_from_file(cookbook_name, filename, run_context)
-        rname = filename_to_qualified_string(cookbook_name, filename)
-
-        # Add log entry if we override an existing light-weight resource.
-        class_name = convert_to_class_name(rname)
-        overriding = Chef::Resource.const_defined?(class_name)
-        Chef::Log.info("#{class_name} light-weight resource already initialized -- overriding!") if overriding
-
-        new_resource_class = Class.new self do |cls|
-
-          # default initialize method that ensures that when initialize is finally
-          # wrapped (see below), super is called in the event that the resource
-          # definer does not implement initialize
-          def initialize(name, run_context)
-            super(name, run_context)
-          end
 
-          @actions_to_create = []
+        @actions_to_create = []
+
+        class << cls
+          include Chef::Mixin::FromFile
 
-          class << cls
-            include Chef::Mixin::FromFile
-            
-            attr_accessor :run_context
+          attr_accessor :run_context
+          attr_reader :action_to_set_default
 
-            def node
-              self.run_context.node
-            end
+          def node
+            self.run_context.node
+          end
 
-            def actions_to_create
-              @actions_to_create
-            end
+          def actions_to_create
+            @actions_to_create
+          end
 
-            define_method(:actions) do |*action_names|
-              actions_to_create.push(*action_names)
-            end
+          define_method(:default_action) do |action_name|
+            actions_to_create.push(action_name)
+            @action_to_set_default = action_name
           end
 
-          # set the run context in the class instance variable
-          cls.run_context = run_context
-          
-          # load resource definition from file
-          cls.class_from_file(filename)
-
-          # create a new constructor that wraps the old one and adds the actions
-          # specified in the DSL
-          old_init = instance_method(:initialize)
-
-          define_method(:initialize) do |name, *optional_args|
-            args_run_context = optional_args.shift
-            @resource_name = rname.to_sym
-            old_init.bind(self).call(name, args_run_context)
-            allowed_actions.push(self.class.actions_to_create).flatten!
+          define_method(:actions) do |*action_names|
+            actions_to_create.push(*action_names)
           end
         end
 
-        # register new class as a Chef::Resource
-        class_name = convert_to_class_name(rname)
-        Chef::Resource.const_set(class_name, new_resource_class)
-        Chef::Log.debug("Loaded contents of #{filename} into a resource named #{rname} defined in Chef::Resource::#{class_name}")
+        # set the run context in the class instance variable
+        cls.run_context = run_context
+
+        # load resource definition from file
+        cls.class_from_file(filename)
 
-        new_resource_class
+        # create a new constructor that wraps the old one and adds the actions
+        # specified in the DSL
+        old_init = instance_method(:initialize)
+
+        define_method(:initialize) do |name, *optional_args|
+          args_run_context = optional_args.shift
+          @resource_name = rname.to_sym
+          old_init.bind(self).call(name, args_run_context)
+          @action = self.class.action_to_set_default || @action
+          allowed_actions.push(self.class.actions_to_create).flatten!
+        end
       end
 
-      # Resources that want providers namespaced somewhere other than
-      # Chef::Provider can set the namespace with +provider_base+
-      # Ex:
-      #   class MyResource < Chef::Resource
-      #     provider_base Chef::Provider::Deploy
-      #     # ...other stuff
-      #   end
-      def provider_base(arg=nil)
-        @provider_base ||= arg
-        @provider_base ||= Chef::Provider
+      # register new class as a Chef::Resource
+      class_name = convert_to_class_name(rname)
+      Chef::Resource.const_set(class_name, new_resource_class)
+      Chef::Log.debug("Loaded contents of #{filename} into a resource named #{rname} defined in Chef::Resource::#{class_name}")
+
+      new_resource_class
+    end
+
+    # Resources that want providers namespaced somewhere other than
+    # Chef::Provider can set the namespace with +provider_base+
+    # Ex:
+    #   class MyResource < Chef::Resource
+    #     provider_base Chef::Provider::Deploy
+    #     # ...other stuff
+    #   end
+    def self.provider_base(arg=nil)
+      @provider_base ||= arg
+      @provider_base ||= Chef::Provider
+    end
+
+    def self.platform_map
+      @@platform_map ||= PlatformMap.new
+    end
+
+    # Maps a short_name (and optionally a platform  and version) to a
+    # Chef::Resource.  This allows finer grained per platform resource
+    # attributes and the end of overloaded resource definitions
+    # (I'm looking at you Chef::Resource::Package)
+    # Ex:
+    #   class WindowsFile < Chef::Resource
+    #     provides :file, :on_platforms => ["windows"]
+    #     # ...other stuff
+    #   end
+    #
+    # TODO: 2011-11-02 schisamo - platform_version support
+    def self.provides(short_name, opts={})
+      short_name_sym = short_name
+      if short_name.kind_of?(String)
+        short_name.downcase!
+        short_name.gsub!(/\s/, "_")
+        short_name_sym = short_name.to_sym
+      end
+      if opts.has_key?(:on_platforms)
+        platforms = [opts[:on_platforms]].flatten
+        platforms.each do |p|
+          p = :default if :all == p.to_sym
+          platform_map.set(
+            :platform => p.to_sym,
+            :short_name => short_name_sym,
+            :resource => self
+          )
+        end
+      else
+        platform_map.set(
+          :short_name => short_name_sym,
+          :resource => self
+        )
       end
+    end
+
+    # Returns a resource based on a short_name anda platform and version.
+    #
+    #
+    # ==== Parameters
+    # short_name<Symbol>:: short_name of the resource (ie :directory)
+    # platform<Symbol,String>:: platform name
+    # version<String>:: platform version
+    #
+    # === Returns
+    # <Chef::Resource>:: returns the proper Chef::Resource class
+    def self.resource_for_platform(short_name, platform=nil, version=nil)
+      platform_map.get(short_name, platform, version)
+    end
 
+    # Returns a resource based on a short_name and a node's
+    # platform and version.
+    #
+    # ==== Parameters
+    # short_name<Symbol>:: short_name of the resource (ie :directory)
+    # node<Chef::Node>:: Node object to look up platform and version in
+    #
+    # === Returns
+    # <Chef::Resource>:: returns the proper Chef::Resource class
+    def self.resource_for_node(short_name, node)
+      begin
+        platform, version = Chef::Platform.find_platform_and_version(node)
+      rescue ArgumentError
+      end
+      resource = resource_for_platform(short_name, platform, version)
+      resource
     end
 
     private