chef 0.9.6 → 0.9.8.beta.1

data/lib/chef/mixin/command/windows.rb

@@ -0,0 +1,72 @@
+#
+# Author:: Adam Jacob (<adam@opscode.com>)
+# Copyright:: Copyright (c) 2008 Opscode, Inc.
+# Author:: Doug MacEachern (<dougm@vmware.com>)
+# Copyright:: Copyright (c) 2010 VMware, 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 'win32/open3'
+
+class Chef
+  module Mixin
+    module Command
+      module Windows
+        def popen4(cmd, args={}, &b)
+
+          # By default, we are waiting before we yield the block.
+          args[:waitlast] ||= false
+
+          #XXX :user, :group, :environment support?
+
+          Open4.popen4(cmd) do |stdin,stdout,stderr,cid|
+            if b
+              if args[:waitlast]
+                b[cid, stdin, stdout, stderr]
+                # send EOF so that if the child process is reading from STDIN
+                # it will actually finish up and exit
+                stdin.close_write
+              else
+                o = StringIO.new
+                e = StringIO.new
+
+                stdin.close
+
+                stdout.sync = true
+                stderr.sync = true
+
+                line = stdout.gets(nil)
+                if line
+                  o.write(line)
+                end
+                line = stderr.gets(nil)
+                if line
+                  e.write(line)
+                end
+                o.rewind
+                e.rewind
+                b[cid, stdin, o, e]
+              end
+            else
+              [cid, stdin, stdout, stderr]
+            end
+          end
+          $?
+        end
+
+      end
+    end
+  end
+end

data/lib/chef/mixin/find_preferred_file.rb

@@ -47,9 +47,9 @@ class Chef
           name = File.basename(full)
           case file_type
           when :remote_file
-            rf =~ /^.+#{cookbook_id}[\\|\/]files[\\|\/](.+?)[\\|\/]#{name}/
+            rf =~ /^.+#{Regexp.escape(cookbook_id)}[\\|\/]files[\\|\/](.+?)[\\|\/]#{Regexp.escape(name)}/
           when :template
-            rf =~ /^.+#{cookbook_id}[\\|\/]templates[\\|\/](.+?)[\\|\/]#{name}/
+            rf =~ /^.+#{Regexp.escape(cookbook_id)}[\\|\/]templates[\\|\/](.+?)[\\|\/]#{Regexp.escape(name)}/
           end
           singlecopy = $1
           files[full] = {
@@ -78,7 +78,7 @@ class Chef
         
         preferences.each do |pref|
           Chef::Log.debug("Looking for #{pref}")
-          matcher = /^(.+#{pref})$/
+          matcher = /^(.+#{Regexp.escape(pref)})$/
           if match = matcher.match(file_list_str)
             return match[1]
           end

data/lib/chef/mixin/language.rb

@@ -24,6 +24,69 @@ class Chef
   module Mixin
     module Language
 
+      # Implementation class for determining platform dependent values
+      class PlatformDependentValue
+
+        # Create a platform dependent value object.
+        # === Arguments
+        # platform_hash (Hash) a hash of the same structure as Chef::Platform,
+        # like this:
+        #   {
+        #     :debian => {:default => 'the value for all debian'}
+        #     [:centos, :redhat, :fedora] => {:default => "value for all EL variants"}
+        #     :ubuntu => { :default => "default for ubuntu", '10.04' => "value for 10.04 only"},
+        #     :default => "the default when nothing else matches"
+        #   }
+        # * platforms can be specified as Symbols or Strings
+        # * multiple platforms can be grouped by using an Array as the key
+        # * values for platforms need to be Hashes of the form:
+        #   {platform_version => value_for_that_version}
+        # * the exception to the above is the default value, which is given as
+        #   :default => default_value
+        def initialize(platform_hash)
+          @values = {}
+          platform_hash.each { |platforms, value| set(platforms, value)}
+        end
+
+        def value_for_node(node)
+          platform, version = node[:platform].to_s, node[:platform_version].to_s
+          if @values.key?(platform) && @values[platform].key?(version)
+            @values[platform][version]
+          elsif @values.key?(platform) && @values[platform].key?("default")
+            @values[platform]["default"]
+          elsif @values.key?("default")
+            @values["default"]
+          else
+            nil
+          end
+        end
+
+        private
+
+        def set(platforms, value)
+          if platforms.to_s == 'default'
+            @values["default"] = value
+          else
+            assert_valid_platform_values!(platforms, value)
+            Array(platforms).each { |platform| @values[platform.to_s] = format_values(value)}
+            value
+          end
+        end
+
+        def format_values(hash)
+          formatted_array = hash.map { |key, value| [key.to_s, value]}.flatten
+          Hash[*formatted_array]
+        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} "
+            msg << "you gave a value #{value.inspect} for platform(s) #{platforms}"
+            raise ArgumentError, msg
+          end
+        end
+      end
+
       # Given a hash similar to the one we use for Platforms, select a value from the hash.  Supports
       # per platform defaults, along with a single base default. Arrays may be passed as hash keys and
       # will be expanded.
@@ -34,29 +97,7 @@ class Chef
       # === Returns
       # value:: Whatever the most specific value of the hash is.
       def value_for_platform(platform_hash)
-        result = nil
-        
-        platform_hash.each_pair do |key, value|
-          if key.is_a?(Array)
-            key.each { |array_key| platform_hash[array_key] = value }
-            platform_hash.delete(key)
-          end
-        end
-        if platform_hash.has_key?(node[:platform])
-          if platform_hash[node[:platform]].has_key?(node[:platform_version])
-            result = platform_hash[node[:platform]][node[:platform_version]]
-          elsif platform_hash[node[:platform]].has_key?("default")
-            result = platform_hash[node[:platform]]["default"]
-          end
-        end
-  
-        unless result
-          if platform_hash.has_key?("default")
-            result = platform_hash["default"]
-          end
-        end  
-  
-        result
+        PlatformDependentValue.new(platform_hash).value_for_node(node)
       end
 
       # Given a list of platforms, returns true if the current recipe is being run on a node with

data/lib/chef/node.rb

@@ -460,6 +460,20 @@ class Chef
       end
     end
 
+    def self.find_or_create(node_name)
+      load(node_name)
+    rescue Net::HTTPServerException => e
+      raise unless e.response.code == '404'
+      node = build(node_name)
+      node.create
+    end
+
+    def self.build(node_name)
+      node = new
+      node.name(node_name)
+      node
+    end
+
     # Load a node by name
     def self.load(name)
       Chef::REST.new(Chef::Config[:chef_server_url]).get_rest("nodes/#{name}")
@@ -536,7 +550,11 @@ class Chef
       self
     end
 
-    def prepare_for_run(ohai_data, json_cli_attrs)
+    # Consume data from ohai and Attributes provided as JSON on the command line.
+    # The run_list from the command-line attributes will be applied immediately,
+    # other attributes from the command line will be saved for later. Ohai data
+    # is applied immediately
+    def process_external_attrs(ohai_data, json_cli_attrs)
       Chef::Log.debug("Extracting run list from JSON attributes provided on command line")
       @json_attrib_for_expansion = consume_run_list(json_cli_attrs)
 
@@ -546,8 +564,11 @@ class Chef
       Chef::Log.debug("Platform is #{platform} version #{version}")
       @automatic_attrs[:platform] = platform
       @automatic_attrs[:platform_version] = version
-      # We clear defaults and overrides, so that any deleted attributes between runs are
-      # still gone.
+    end
+
+    # Clear defaults and overrides, so that any deleted attributes between runs are
+    # still gone.
+    def reset_defaults_and_overrides
       @default_attrs = Mash.new
       @override_attrs = Mash.new
     end
@@ -574,6 +595,9 @@ class Chef
       @default_attrs = Chef::Mixin::DeepMerge.merge(default_attrs, expansion.default_attrs)
       @override_attrs = Chef::Mixin::DeepMerge.merge(override_attrs, expansion.override_attrs)
 
+      @automatic_attrs[:recipes] = expansion.recipes
+      @automatic_attrs[:roles] = expansion.roles
+
       expansion.recipes
     end
     

data/lib/chef/node/attribute.rb

@@ -7,9 +7,9 @@
 # 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.
@@ -23,6 +23,8 @@ require 'chef/log'
 class Chef
   class Node
     class Attribute
+      HIDDEN_ATTRIBUES = [:@override, :@attribute, :@default, :@normal, :@automatic]
+
       attr_accessor :normal,
                     :default,
                     :override,
@@ -46,8 +48,8 @@ class Chef
         @current_default = default
         @override = override
         @current_override = override
-        @automatic = automatic 
-        @current_automatic = automatic 
+        @automatic = automatic
+        @current_automatic = automatic
         @state = state
         @auto_vivifiy_on_read = false
         @set_unless_value_present = false
@@ -93,7 +95,7 @@ class Chef
         # See the comments in []= for more details.
         @has_been_read = true
 
-        # If we have a set type, our destiny is to write 
+        # If we have a set type, our destiny is to write
         if @set_type
           a_value = @set_type == :automatic ? value_or_descend(current_automatic, key, auto_vivifiy_on_read) : nil
           o_value = @set_type == :override ? value_or_descend(current_override, key, auto_vivifiy_on_read) : nil
@@ -101,7 +103,7 @@ class Chef
           d_value = @set_type == :default ? value_or_descend(current_default, key, auto_vivifiy_on_read) : nil
 
           determine_value(a_value, o_value, n_value, d_value)
-        # Our destiny is only to read, so we get the full list. 
+        # Our destiny is only to read, so we get the full list.
         else
           a_value = value_or_descend(current_automatic, key)
           o_value = value_or_descend(current_override, key)
@@ -249,7 +251,7 @@ class Chef
       def keys
         tkeys = current_automatic ? current_automatic.keys : []
         [ current_override, current_normal, current_default ].each do |attr_hash|
-          if attr_hash 
+          if attr_hash
             attr_hash.keys.each do |key|
               tkeys << key unless tkeys.include?(key)
             end
@@ -295,18 +297,18 @@ class Chef
           value = Chef::Mixin::DeepMerge.merge(value, d_value) if hash_and_not_cna?(d_value)
           value = Chef::Mixin::DeepMerge.merge(value, n_value) if hash_and_not_cna?(n_value)
           value = Chef::Mixin::DeepMerge.merge(value, o_value) if hash_and_not_cna?(o_value)
-          value = Chef::Mixin::DeepMerge.merge(value, a_value) 
+          value = Chef::Mixin::DeepMerge.merge(value, a_value)
           value
         elsif hash_and_not_cna?(o_value)
           value = {}
           value = Chef::Mixin::DeepMerge.merge(value, d_value) if hash_and_not_cna?(d_value)
           value = Chef::Mixin::DeepMerge.merge(value, n_value) if hash_and_not_cna?(n_value)
-          value = Chef::Mixin::DeepMerge.merge(value, o_value) 
+          value = Chef::Mixin::DeepMerge.merge(value, o_value)
           value
         elsif hash_and_not_cna?(n_value)
           value = {}
           value = Chef::Mixin::DeepMerge.merge(value, d_value) if hash_and_not_cna?(d_value)
-          value = Chef::Mixin::DeepMerge.merge(value, n_value) 
+          value = Chef::Mixin::DeepMerge.merge(value, n_value)
           value
         elsif hash_and_not_cna?(d_value)
           d_value
@@ -426,6 +428,14 @@ class Chef
         end
       end
 
+      def inspect
+        determine_value(current_automatic, current_override, current_normal, current_default)
+
+        "#<#{self.class} " << instance_variables.map{|iv|
+          iv.to_s + '=' + (HIDDEN_ATTRIBUES.include?(iv.to_sym) ? "{...}" : instance_variable_get(iv).inspect)
+        }.join(', ') << ">"
+      end
+
       def to_hash
         result = determine_value(current_automatic, current_override, current_normal, current_default)
         if result.class == Hash

data/lib/chef/platform.rb

@@ -80,14 +80,6 @@ class Chef
               :mdadm => Chef::Provider::Mdadm
             }
           },
-          :scientific => {
-            :default => {
-              :service => Chef::Provider::Service::Redhat,
-              :cron => Chef::Provider::Cron,
-              :package => Chef::Provider::Package::Yum,
-              :mdadm => Chef::Provider::Mdadm
-            }
-          },
           :fedora   => {
             :default => {
               :service => Chef::Provider::Service::Redhat,
@@ -157,7 +149,9 @@ class Chef
           :solaris  => {},
           :solaris2 => {
             :default => {
-              :service => Chef::Provider::Service::Solaris
+              :service => Chef::Provider::Service::Solaris,
+        			:package => Chef::Provider::Package::Solaris,
+        			:cron => Chef::Provider::Cron
             }
           },
           :default  => {

data/lib/chef/provider/cron.rb

@@ -25,7 +25,7 @@ class Chef
     class Cron < Chef::Provider
       include Chef::Mixin::Command
 
-      CRON_PATTERN = /([0-9\*\-\,\/]+)\s*([0-9\*\-\,\/]+)\s*([0-9\*\-\,\/]+)\s*([0-9\*\-\,\/]+)\s*([0-9\*\-\,\/]+)\s*(.*)/
+      CRON_PATTERN = /([-0-9*,\/]+)\s([-0-9*,\/]+)\s([-0-9*,\/]+)\s([-0-9*,\/]+)\s([-0-9*,\/]+)\s(.*)/
 
       def initialize(new_resource, run_context)
         super(new_resource, run_context)

data/lib/chef/provider/deploy.rb

@@ -51,7 +51,10 @@ class Chef
       
       def run(command, &block)
         exec = execute(command, &block)
-        exec.user(@new_resource.user)
+        exec.user(@new_resource.user) if @new_resource.user
+        exec.group(@new_resource.group) if @new_resource.group
+        exec.cwd(release_path) unless exec.cwd
+        exec.environment(@new_resource.environment) unless exec.environment 
         exec
       end
       

data/lib/chef/provider/group.rb

@@ -45,7 +45,7 @@ class Chef
         end
         
         if group_info
-          @new_resource.gid(group_info.gid)
+          @new_resource.gid(group_info.gid) unless @new_resource.gid
           @current_resource.gid(group_info.gid)
           @current_resource.members(group_info.mem)
         end

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

@@ -50,7 +50,7 @@ class Chef
           gid = nil; next_gid_guess = 200
           groups_gids = safe_dscl("list /Groups gid")
           while(next_gid_guess < search_limit + 200)
-            if groups_gids =~ Regexp.new("#{next_gid_guess}\n")
+            if groups_gids =~ Regexp.new("#{Regexp.escape(next_gid_guess.to_s)}\n")
               next_gid_guess += 1
             else
               gid = next_gid_guess
@@ -63,7 +63,7 @@ class Chef
         def gid_used?(gid)
           return false unless gid
           groups_gids = safe_dscl("list /Groups gid")
-          !! ( groups_gids =~ Regexp.new("#{gid}\n") )
+          !! ( groups_gids =~ Regexp.new("#{Regexp.escape(gid.to_s)}\n") )
         end
 
         def set_gid

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

@@ -49,10 +49,10 @@ class Chef
           mounted = false
           shell_out!("mount").stdout.each_line do |line|
             case line
-            when /^#{device_mount_regex}\s+on\s+#{@new_resource.mount_point}/
+            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#{@new_resource.mount_point}\s+/
+            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
@@ -65,14 +65,14 @@ class Chef
             case line
             when /^[#\s]/
               next
-            when /^#{device_fstab_regex}\s+#{@new_resource.mount_point}\s+(\S+)\s+(\S+)\s+(\S+)\s+(\S+)/
+            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")
-            when /^[\/\w]+\s+#{@new_resource.mount_point}/
+            when /^[\/\w]+\s+#{Regexp.escape(@new_resource.mount_point)}/
               enabled = false
               Chef::Log.debug("Found conflicting mount point #{@new_resource.mount_point} in /etc/fstab")
             end
@@ -147,7 +147,7 @@ class Chef
             
             found = false
             ::File.readlines("/etc/fstab").reverse_each do |line|
-              if !found && line =~ /^#{device_fstab_regex}\s+#{@new_resource.mount_point}/
+              if !found && line =~ /^#{device_fstab_regex}\s+#{Regexp.escape(@new_resource.mount_point)}/
                 found = true
                 Chef::Log.debug("Removing #{@new_resource.mount_point} from fstab")
                 next
@@ -203,7 +203,7 @@ class Chef
         end
 
         def device_mount_regex
-          ::File.symlink?(device_real) ? "(?:#{device_real})|(?:#{::File.readlink(device_real)})" : device_real
+          ::File.symlink?(device_real) ? "(?:#{Regexp.escape(device_real)})|(?:#{Regexp.escape(::File.readlink(device_real))})" : Regexp.escape(device_real)
         end
 
         def device_fstab_regex