chef 0.10.2 → 0.10.4.rc.1

data/lib/chef/mixin/create_path.rb

@@ -35,8 +35,9 @@ class Chef
         
         if file_path.kind_of?(String)
           file_path = File.expand_path(file_path).split(File::SEPARATOR)
-          file_path.shift if file_path[0] = ''
-          unless file_path[0].match("^#{File::SEPARATOR}")
+          file_path.shift if file_path[0] == ''
+          # Check if path starts with a separator or drive letter (Windows)
+          unless file_path[0].match("^#{File::SEPARATOR}|^[a-zA-Z]:")
             file_path[0] = "#{File::SEPARATOR}#{file_path[0]}"
           end
         end

data/lib/chef/mixin/get_source_from_package.rb

@@ -0,0 +1,42 @@
+# Author:: Lamont Granquist (<lamont@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.
+#
+
+
+#
+# mixin to make this syntax work without specifying a source:
+#
+# gem_pacakge "/tmp/foo-x.y.z.gem"
+# rpm_package "/tmp/foo-x.y-z.rpm"
+# dpkg_package "/tmp/foo-x.y.z.deb"
+#
+
+class Chef
+  module Mixin
+    module GetSourceFromPackage
+      def initialize(new_resource, run_context)
+        super
+        # if we're passed something that looks like a filesystem path, with no source, use it
+        #  - require at least one '/' in the path to avoid gem_package "foo" breaking if a file named 'foo' exists in the cwd
+        if new_resource.source.nil? && new_resource.package_name.match(/#{::File::SEPARATOR}/) && ::File.exists?(new_resource.package_name)
+          Chef::Log.debug("No package source specified, but #{new_resource.package_name} exists on the filesystem, copying to package source")
+          new_resource.source(@new_resource.package_name)
+        end
+      end
+    end
+  end
+end
+

data/lib/chef/mixin/language.rb

@@ -69,24 +69,21 @@ class Chef
             @values["default"] = value
           else
             assert_valid_platform_values!(platforms, value)
-            Array(platforms).each { |platform| @values[platform.to_s] = format_values(value)}
+            Array(platforms).each { |platform| @values[platform.to_s] = normalize_keys(value)}
             value
           end
         end
 
-        def format_values(hash)
-          formatted_array = flatten_one_level(hash.map { |key, value| [key.to_s, value]})
-          Hash[*formatted_array]
-        end
-
-        def flatten_one_level(array)
-          array.inject([]) do |flatter_array, values|
-            Array(values).each {|value| flatter_array << value }
-            flatter_array
+        def normalize_keys(hash)
+          hash.inject({}) do |h, key_value|
+            keys, value = *key_value
+            Array(keys).each do |key|
+              h[key.to_s] = value
+            end
+            h
           end
         end
 
-
         def assert_valid_platform_values!(platforms, value)
           unless value.kind_of?(Hash)
             msg = "platform dependent values must be specified in the format :platform => {:version => value} "

data/lib/chef/monkey_patches/numeric.rb

@@ -4,4 +4,12 @@ unless 0.respond_to?(:fdiv)
       to_f / other
     end
   end
-end
+end
+
+# String elements referenced with [] <= 1.8.6 return a Fixnum. Cheat to allow
+# for the simpler "test"[2].ord construct
+class Numeric 
+  def ord
+    return self
+  end
+end

data/lib/chef/monkey_patches/string.rb

@@ -21,8 +21,29 @@
 # give the actual number of characters. In Chef::REST, we need the bytesize
 # so we can correctly set the Content-Length headers, but ruby 1.8.6 and lower
 # don't define String#bytesize. Monkey patching time!
+
+begin
+  require 'enumerator'
+rescue LoadError
+end
+
 class String
   unless method_defined?(:bytesize)
     alias :bytesize :size
   end
+
+  unless method_defined?(:lines)
+    def lines
+      enum_for(:each)
+    end
+  end
+end
+
+# <= 1.8.6 needs some ord! 
+class String
+  unless method_defined?(:ord)
+    def ord
+      self.unpack('c').first
+    end
+  end
 end

data/lib/chef/platform.rb

@@ -126,7 +126,8 @@ class Chef
             :default => {
               :service => Chef::Provider::Service::Redhat,
               :cron => Chef::Provider::Cron,
-              :package => Chef::Provider::Package::Zypper
+              :package => Chef::Provider::Package::Zypper,
+              :group => Chef::Provider::Group::Suse
             }
           },
           :redhat   => {

data/lib/chef/provider.rb

@@ -81,7 +81,7 @@ class Chef
     class << self
       include Chef::Mixin::ConvertToClassName
       
-      def build_from_file(cookbook_name, filename)
+      def build_from_file(cookbook_name, filename, run_context)
         pname = filename_to_qualified_string(cookbook_name, filename)
         
         # Add log entry if we override an existing light-weight provider.

data/lib/chef/provider/git.rb

@@ -38,10 +38,11 @@ class Chef
       def action_checkout
         assert_target_directory_valid!
 
-        if target_dir_non_existant_or_empty?
+        if target_dir_non_existent_or_empty?
           clone
           checkout
           enable_submodules
+          add_remotes
           @new_resource.updated_by_last_action(true)
         else
           Chef::Log.debug "#{@new_resource} checkout destination #{@new_resource.destination} already exists or is a non-empty directory"
@@ -66,7 +67,7 @@ class Chef
             Chef::Log.info "#{@new_resource} updated to revision #{target_revision}"
             @new_resource.updated_by_last_action(true)
           end
-
+          add_remotes
         else
           action_checkout
           @new_resource.updated_by_last_action(true)
@@ -85,7 +86,7 @@ class Chef
         ::File.exist?(::File.join(@new_resource.destination, ".git"))
       end
 
-      def target_dir_non_existant_or_empty?
+      def target_dir_non_existent_or_empty?
         !::File.exist?(@new_resource.destination) || Dir.entries(@new_resource.destination).sort == ['.','..']
       end
 
@@ -98,6 +99,18 @@ class Chef
         sha_hash?(result) ? result : nil
       end
 
+      def add_remotes
+        if (@new_resource.additional_remotes.length > 0)
+          @new_resource.additional_remotes.each_pair do |remote_name, remote_url|
+            Chef::Log.info "#{@new_resource} adding git remote #{remote_name} = #{remote_url}"
+            command = "git remote add #{remote_name} #{remote_url}"
+            if shell_out(command, run_options(:cwd => @new_resource.destination, :command_log_level => :info)).exitstatus != 0
+              @new_resource.updated_by_last_action(true)
+            end
+          end
+        end
+      end
+
       def clone
         remote = @new_resource.remote
 

data/lib/chef/provider/group/suse.rb

@@ -0,0 +1,53 @@
+#
+# Author:: AJ Christensen (<aj@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/provider/group/groupadd'
+require 'chef/mixin/shell_out'
+
+class Chef
+  class Provider
+    class Group
+      class Suse < Chef::Provider::Group::Groupadd
+
+        include Chef::Mixin::ShellOut
+
+        def load_current_resource
+          super
+
+          raise Chef::Exceptions::Group, "Could not find binary /usr/sbin/groupmod for #{@new_resource}" unless ::File.exists?("/usr/sbin/groupmod")
+        end
+
+        def modify_group_members
+          unless @new_resource.members.empty?
+            if(@new_resource.append)
+              @new_resource.members.each do |member|
+                Chef::Log.debug("#{@new_resource} appending member #{member} to group #{@new_resource.group_name}")
+                shell_out!("groupmod -A #{member} #{@new_resource.group_name}")
+              end
+            else
+              Chef::Log.debug("#{@new_resource} setting group members to #{@new_resource.members.join(', ')}")
+              shell_out!("groupmod -A #{@new_resource.members.join(',')} #{@new_resource.group_name}")
+            end
+          else
+            Chef::Log.debug("#{@new_resource} not changing group members, the group has no members")
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -36,29 +36,21 @@ class Chef
           @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}")
-
+          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
-
-          # Check to see if the volume is mounted. Last volume entry wins.
-          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)
-
+          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|
@@ -72,16 +64,33 @@ class Chef
               @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")
-            when /^[\/\w]+\s+#{Regexp.escape(@new_resource.mount_point)}/
+              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
@@ -112,7 +121,6 @@ class Chef
         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
@@ -165,7 +173,7 @@ class Chef
         end
 
         def device_should_exist?
-          @new_resource.device !~ /:/ && @new_resource.device !~ /\/\// && @new_resource.device != "tmpfs"
+          @new_resource.device !~ /:/ && @new_resource.device !~ /\/\// && @new_resource.device != "tmpfs" && @new_resource.fstype != 'fuse'
         end
 
         private

data/lib/chef/provider/package/apt.rb

@@ -25,44 +25,57 @@ class Chef
     class Package
       class Apt < Chef::Provider::Package
 
+        include Chef::Mixin::ShellOut
+        attr_accessor :virtual
+
         def load_current_resource
           @current_resource = Chef::Resource::Package.new(@new_resource.name)
           @current_resource.package_name(@new_resource.package_name)
+          check_package_state(@new_resource.package_name)
+          @current_resource
+        end
+
+        def check_package_state(package)
+          Chef::Log.debug("Checking package status for #{package}")
+          installed = false
+          depends = false
 
-          Chef::Log.debug("#{@new_resource} checking apt-cache policy")
-          status = popen4("apt-cache policy #{@new_resource.package_name}") do |pid, stdin, stdout, stderr|
-            stdout.each do |line|
-              case line
-              when /^\s{2}Installed: (.+)$/
-                installed_version = $1
-                if installed_version == '(none)'
-                  Chef::Log.debug("#{@new_resource} current version is nil")
-                  @current_resource.version(nil)
-                else
-                  Chef::Log.debug("#{@new_resource} current version is #{installed_version}")
-                  @current_resource.version(installed_version)
-                end
-              when /^\s{2}Candidate: (.+)$/
-                Chef::Log.debug("#{@new_resource} candidate version is #{$1}")
-                @candidate_version = $1
+          shell_out!("aptitude show #{package}").stdout.each_line do |line|
+            case line
+            when /^State: installed/
+              installed = true
+            when /^Version: (.*)/
+              @candidate_version = $1
+              if installed
+                @current_resource.version($1)
+              else
+                @current_resource.version(nil)
               end
+            when /Depends: ([^\s]*) /
+              depends = $1
+            when /Provided by: ([\w\d\-\.]*)/
+              next if installed
+              virtual_provider = $1
+              virtual_provider = depends if depends
+              Chef::Log.debug("Virtual package provided by #{virtual_provider}")
+              @virtual = true
+              installed = check_package_state(virtual_provider)
+              @candidate_version = virtual_provider
             end
           end
 
-          unless status.exitstatus == 0
-            raise Chef::Exceptions::Package, "apt-cache failed - #{status.inspect}!"
-          end
-
-          if @candidate_version == "(none)"
+          if @candidate_version.nil?
             raise Chef::Exceptions::Package, "apt does not have a version of package #{@new_resource.package_name}"
           end
 
-          @current_resource
+          return installed
         end
 
         def install_package(name, version)
+          package_name = "#{name}=#{version}"
+          package_name = "#{name} #{@candidate_version}" if @virtual
           run_command_with_systems_locale(
-            :command => "apt-get -q -y#{expand_options(@new_resource.options)} install #{name}=#{version}",
+            :command => "apt-get -q -y#{expand_options(@new_resource.options)} install #{package_name}",
             :environment => {
               "DEBIAN_FRONTEND" => "noninteractive"
             }
@@ -74,8 +87,10 @@ class Chef
         end
 
         def remove_package(name, version)
+          package_name = "#{name}"
+          package_name = "#{name} #{@candidate_version}" if @virtual
           run_command_with_systems_locale(
-            :command => "apt-get -q -y#{expand_options(@new_resource.options)} remove #{@new_resource.package_name}",
+            :command => "apt-get -q -y#{expand_options(@new_resource.options)} remove #{package_name}",
             :environment => {
               "DEBIAN_FRONTEND" => "noninteractive"
             }

data/lib/chef/provider/package/dpkg.rb

@@ -19,15 +19,18 @@
 require 'chef/provider/package'
 require 'chef/mixin/command'
 require 'chef/resource/package'
+require 'chef/mixin/get_source_from_package'
 
 class Chef
   class Provider
     class Package
       class Dpkg < Chef::Provider::Package::Apt
-        DPKG_INFO = /([a-z\d\-\+]+)\t([\w\d.-]+)/
+        DPKG_INFO = /([a-z\d\-\+]+)\t([\w\d.~-]+)/
         DPKG_INSTALLED = /^Status: install ok installed/
         DPKG_VERSION = /^Version: (.+)$/
-      
+
+        include Chef::Mixin::GetSourceFromPackage
+
         def load_current_resource
           @current_resource = Chef::Resource::Package.new(@new_resource.name)
           @current_resource.package_name(@new_resource.package_name)