chef 11.12.0.alpha.1 → 11.12.0.rc.1

data/lib/chef/resource/cron.rb

@@ -43,6 +43,7 @@ class Chef
         @path = nil
         @shell = nil
         @home = nil
+        @time = nil
         @environment = {}
       end
 
@@ -121,13 +122,28 @@ class Chef
           converted_arg = arg
         end
         begin
-          if integerize(arg) > 7 then raise RangeError end
+          error_message = "You provided '#{arg}' as a weekday, acceptable values are "
+          error_message << Provider::Cron::WEEKDAY_SYMBOLS.map {|sym| ":#{sym.to_s}"}.join(', ')
+          error_message << " and a string in crontab format"
+          if (arg.is_a?(Symbol) && !Provider::Cron::WEEKDAY_SYMBOLS.include?(arg)) ||
+            (!arg.is_a?(Symbol) && integerize(arg) > 7) ||
+            (!arg.is_a?(Symbol) && integerize(arg) < 0)
+            raise RangeError, error_message
+          end
         rescue ArgumentError
         end
         set_or_return(
           :weekday,
           converted_arg,
-          :kind_of => String
+          :kind_of => [String, Symbol]
+        )
+      end
+      
+      def time(arg=nil)
+        set_or_return(
+          :time,
+          arg,
+          :equal_to => Chef::Provider::Cron::SPECIAL_TIME_VALUES
         )
       end
 

data/lib/chef/resource/execute.rb

@@ -125,8 +125,6 @@ class Chef
         )
       end
 
-
-
     end
   end
 end

data/lib/chef/resource/powershell_script.rb

@@ -15,17 +15,39 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
-
 require 'chef/resource/windows_script'
 
 class Chef
   class Resource
     class PowershellScript < Chef::Resource::WindowsScript
 
+      set_guard_inherited_attributes(:architecture)
+
       def initialize(name, run_context=nil)
         super(name, run_context, :powershell_script, "powershell.exe")
+        @convert_boolean_return = false
+      end
+
+      def convert_boolean_return(arg=nil)
+        set_or_return(
+          :convert_boolean_return,
+          arg,
+          :kind_of => [ FalseClass, TrueClass ]
+        )
       end
 
+      protected
+
+      # Allow callers evaluating guards to request default
+      # attribute values. This is needed to allow
+      # convert_boolean_return to be true in guard context by default,
+      # and false by default otherwise. When this mode becomes the
+      # default for this resource, this method can be removed since
+      # guard context and recipe resource context will have the
+      # same behavior.
+      def self.get_default_attributes(opts)
+        {:convert_boolean_return => true}
+      end
     end
   end
 end

data/lib/chef/resource/script.rb

@@ -58,6 +58,31 @@ class Chef
         )
       end
 
+      def self.set_guard_inherited_attributes(*inherited_attributes)
+        @class_inherited_attributes = inherited_attributes
+      end
+
+      def self.guard_inherited_attributes(*inherited_attributes)
+        # Similar to patterns elsewhere, return attributes from this
+        # class and superclasses as a form of inheritance
+        ancestor_attributes = []
+
+        if superclass.respond_to?(:guard_inherited_attributes)
+          ancestor_attributes = superclass.guard_inherited_attributes
+        end
+
+        ancestor_attributes.concat(@class_inherited_attributes ? @class_inherited_attributes : []).uniq
+      end
+
+      set_guard_inherited_attributes(
+       :cwd,
+       :environment,
+       :group,
+       :path,
+       :user,
+       :umask
+       )
+
     end
   end
 end

data/lib/chef/resource/subversion.rb

@@ -32,6 +32,10 @@ class Chef
         allowed_actions << :force_export
       end
 
+      # Override exception to strip password if any, so it won't appear in logs and different Chef notifications
+      def custom_exception_message(e)
+        "#{self} (#{defined_at}) had an error: #{e.class.name}: #{svn_password ? e.message.gsub(svn_password, "[hidden_password]") : e.message}"
+      end
     end
   end
 end

data/lib/chef/resource/windows_package.rb

@@ -0,0 +1,79 @@
+#
+# Author:: Bryan McLellan <btm@loftninjas.org>
+# Copyright:: Copyright (c) 2014 Chef Software, 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/resource/package'
+require 'chef/provider/package/windows'
+require 'chef/win32/error' if RUBY_PLATFORM =~ /mswin|mingw|windows/
+
+class Chef
+  class Resource
+    class WindowsPackage < Chef::Resource::Package
+
+      provides :package, :on_platforms => ["windows"]
+
+      def initialize(name, run_context=nil)
+        super
+        @allowed_actions = [ :install, :remove ]
+        @provider = Chef::Provider::Package::Windows
+        @resource_name = :windows_package
+        @source ||= source(@package_name)
+
+        # Unique to this resource
+        @installer_type = nil
+        @timeout = 600
+        # In the past we accepted return code 127 for an unknown reason and 42 because of a bug
+        @returns = [ 0 ]
+      end
+
+      def installer_type(arg=nil)
+        set_or_return(
+          :installer_type,
+          arg,
+          :kind_of => [ String ]
+        )
+      end
+
+      def timeout(arg=nil)
+        set_or_return(
+          :timeout,
+          arg,
+          :kind_of => [ String, Integer ]
+        )
+      end
+
+      def returns(arg=nil)
+        set_or_return(
+          :returns,
+          arg,
+          :kind_of => [ String, Integer, Array ]
+        )
+      end
+
+      def source(arg=nil)
+        if arg == nil && self.instance_variable_defined?(:@source) == true
+          @source
+        else
+          raise ArgumentError, "Bad type for WindowsPackage resource, use a String" unless arg.is_a?(String)
+          Chef::Log.debug("#{package_name}: sanitizing source path '#{arg}'")
+          @source = ::File.absolute_path(arg).gsub(::File::SEPARATOR, ::File::ALT_SEPARATOR)
+        end
+      end
+    end
+  end
+end
+

data/lib/chef/resource/windows_script.rb

@@ -52,11 +52,6 @@ class Chef
           "cannot execute script with requested architecture '#{desired_architecture.to_s}' on a system with architecture '#{node_windows_architecture(node)}'"
         end
       end
-
-      def node
-        run_context && run_context.node
-      end
-
     end
   end
 end

data/lib/chef/resources.rb

@@ -69,6 +69,7 @@ require 'chef/resource/template'
 require 'chef/resource/timestamped_deploy'
 require 'chef/resource/user'
 require 'chef/resource/whyrun_safe_ruby_block'
+require 'chef/resource/windows_package'
 require 'chef/resource/yum_package'
 require 'chef/resource/lwrp_base'
 require 'chef/resource/bff_package'

data/lib/chef/rest.rb

@@ -57,6 +57,7 @@ class Chef
     # http://localhost:4000, a call to +get_rest+ with 'nodes' will make an
     # HTTP GET request to http://localhost:4000/nodes
     def initialize(url, client_name=Chef::Config[:node_name], signing_key_filename=Chef::Config[:client_key], options={})
+      options = options.dup
       options[:client_name] = client_name
       options[:signing_key_filename] = signing_key_filename
       super(url, options)
@@ -65,7 +66,6 @@ class Chef
       @authenticator = Authenticator.new(options)
       @request_id = RemoteRequestID.new(options)
 
-      @middlewares << ValidateContentLength.new(options)
       @middlewares << JSONInput.new(options)
       @middlewares << JSONToModelOutput.new(options)
       @middlewares << CookieManager.new(options)
@@ -73,6 +73,11 @@ class Chef
       @middlewares << @authenticator
       @middlewares << @request_id
 
+      # ValidateContentLength should come after Decompressor
+      # because the order of middlewares is reversed when handling
+      # responses.
+      @middlewares << ValidateContentLength.new(options)
+
     end
 
     def signing_key_filename

data/lib/chef/run_context.rb

@@ -77,13 +77,15 @@ class Chef
       @events = events
 
       @node.run_context = self
+
+      @cookbook_compiler = nil
     end
 
     # Triggers the compile phase of the chef run. Implemented by
     # Chef::RunContext::CookbookCompiler
     def load(run_list_expansion)
-      compiler = CookbookCompiler.new(self, run_list_expansion, events)
-      compiler.compile
+      @cookbook_compiler = CookbookCompiler.new(self, run_list_expansion, events)
+      @cookbook_compiler.compile
     end
 
     # Adds an immediate notification to the
@@ -141,6 +143,18 @@ class Chef
       Chef::Log.debug("Loading Recipe #{recipe_name} via include_recipe")
 
       cookbook_name, recipe_short_name = Chef::Recipe.parse_recipe_name(recipe_name)
+
+      if unreachable_cookbook?(cookbook_name) # CHEF-4367
+        Chef::Log.warn(<<-ERROR_MESSAGE)
+MissingCookbookDependency:
+Recipe `#{recipe_name}` is not in the run_list, and cookbook '#{cookbook_name}'
+is not a dependency of any cookbook in the run_list.  To load this recipe,
+first add a dependency on cookbook '#{cookbook_name}' in the cookbook you're
+including it from in that cookbook's metadata.
+ERROR_MESSAGE
+      end
+
+
       if loaded_fully_qualified_recipe?(cookbook_name, recipe_short_name)
         Chef::Log.debug("I am not loading #{recipe_name}, because I have already seen it.")
         false
@@ -228,6 +242,12 @@ class Chef
       cookbook.has_cookbook_file_for_node?(node, cb_file_name)
     end
 
+    # Delegates to CookbookCompiler#unreachable_cookbook?
+    # Used to raise an error when attempting to load a recipe belonging to a
+    # cookbook that is not in the dependency graph. See also: CHEF-4367
+    def unreachable_cookbook?(cookbook_name)
+      @cookbook_compiler.unreachable_cookbook?(cookbook_name)
+    end
 
     private
 

data/lib/chef/run_context/cookbook_compiler.rb

@@ -16,6 +16,7 @@
 # limitations under the License.
 #
 
+require 'set'
 require 'chef/log'
 require 'chef/recipe'
 require 'chef/resource/lwrp_base'
@@ -149,6 +150,17 @@ class Chef
         @events.recipe_load_complete
       end
 
+      # Whether or not a cookbook is reachable from the set of cookbook given
+      # by the run_list plus those cookbooks' dependencies.
+      def unreachable_cookbook?(cookbook_name)
+        !reachable_cookbooks.include?(cookbook_name)
+      end
+
+      # All cookbooks in the dependency graph, returned as a Set.
+      def reachable_cookbooks
+        @reachable_cookbooks ||= Set.new(cookbook_order)
+      end
+
       private
 
       def load_attributes_from_cookbook(cookbook_name)

data/lib/chef/util/editor.rb

@@ -0,0 +1,92 @@
+#
+# Author:: Chris Bandy (<bandy.chris@gmail.com>)
+# Copyright:: Copyright (c) 2014 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.
+#
+
+class Chef
+  class Util
+    class Editor
+      attr_reader :lines
+
+      def initialize(lines)
+        @lines = lines.to_a.clone
+      end
+
+      def append_line_after(search, line_to_append)
+        lines = []
+
+        @lines.each do |line|
+          lines << line
+          lines << line_to_append if line.match(search)
+        end
+
+        (lines.length - @lines.length).tap { @lines = lines }
+      end
+
+      def append_line_if_missing(search, line_to_append)
+        count = 0
+
+        unless @lines.find { |line| line.match(search) }
+          count = 1
+          @lines << line_to_append
+        end
+
+        count
+      end
+
+      def remove_lines(search)
+        count = 0
+
+        @lines.delete_if do |line|
+          count += 1 if line.match(search)
+        end
+
+        count
+      end
+
+      def replace(search, replace)
+        count = 0
+
+        @lines.map! do |line|
+          if line.match(search)
+            count += 1
+            line.gsub!(search, replace)
+          else
+            line
+          end
+        end
+
+        count
+      end
+
+      def replace_lines(search, replace)
+        count = 0
+
+        @lines.map! do |line|
+          if line.match(search)
+            count += 1
+            replace
+          else
+            line
+          end
+        end
+
+        count
+      end
+    end
+  end
+end
+

data/lib/chef/util/file_edit.rb

@@ -15,8 +15,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+require 'chef/util/editor'
 require 'fileutils'
-require 'tempfile'
 
 class Chef
   class Util
@@ -24,108 +24,76 @@ class Chef
 
       private
 
-      attr_accessor :original_pathname, :contents, :file_edited
+      attr_reader :editor, :original_pathname
 
       public
 
       def initialize(filepath)
+        raise ArgumentError, "File '#{filepath}' does not exist" unless File.exist?(filepath)
+        @editor = Editor.new(File.open(filepath, &:readlines))
         @original_pathname = filepath
         @file_edited = false
+      end
 
-        raise ArgumentError, "File doesn't exist" unless File.exist? @original_pathname
-        @contents = File.open(@original_pathname) { |f| f.readlines }
+      # return if file has been edited
+      def file_edited?
+        @file_edited
       end
 
       #search the file line by line and match each line with the given regex
       #if matched, replace the whole line with newline.
       def search_file_replace_line(regex, newline)
-        search_match(regex, newline, 'r', 1)
+        @changes = (editor.replace_lines(regex, newline) > 0) || @changes
       end
 
       #search the file line by line and match each line with the given regex
       #if matched, replace the match (all occurances)  with the replace parameter
       def search_file_replace(regex, replace)
-        search_match(regex, replace, 'r', 2)
+        @changes = (editor.replace(regex, replace) > 0) || @changes
       end
 
       #search the file line by line and match each line with the given regex
       #if matched, delete the line
       def search_file_delete_line(regex)
-        search_match(regex, " ", 'd', 1)
+        @changes = (editor.remove_lines(regex) > 0) || @changes
       end
 
       #search the file line by line and match each line with the given regex
       #if matched, delete the match (all occurances) from the line
       def search_file_delete(regex)
-        search_match(regex, " ", 'd', 2)
+        search_file_replace(regex, '')
       end
 
       #search the file line by line and match each line with the given regex
       #if matched, insert newline after each matching line
       def insert_line_after_match(regex, newline)
-        search_match(regex, newline, 'i', 1)
+        @changes = (editor.append_line_after(regex, newline) > 0) || @changes
       end
 
       #search the file line by line and match each line with the given regex
       #if not matched, insert newline at the end of the file
       def insert_line_if_no_match(regex, newline)
-        search_match(regex, newline, 'i', 2)
+        @changes = (editor.append_line_if_missing(regex, newline) > 0) || @changes
+      end
+
+      def unwritten_changes?
+        !!@changes
       end
 
       #Make a copy of old_file and write new file out (only if file changed)
       def write_file
-
-        # file_edited is false when there was no match in the whole file and thus no contents have changed.
-        if file_edited
+        if @changes
           backup_pathname = original_pathname + ".old"
           FileUtils.cp(original_pathname, backup_pathname, :preserve => true)
           File.open(original_pathname, "w") do |newfile|
-            contents.each do |line|
+            editor.lines.each do |line|
               newfile.puts(line)
             end
             newfile.flush
           end
+          @file_edited = true
         end
-        self.file_edited = false
-      end
-
-      private
-
-      #helper method to do the match, replace, delete, and insert operations
-      #command is the switch of delete, replace, and insert ('d', 'r', 'i')
-      #method is to control operation on whole line or only the match (1 for line, 2 for match)
-      def search_match(regex, replace, command, method)
-
-        #convert regex to a Regexp object (if not already is one) and store it in exp.
-        exp = Regexp.new(regex)
-
-        #loop through contents and do the appropriate operation depending on 'command' and 'method'
-        new_contents = []
-
-        contents.each do |line|
-          if line.match(exp)
-            self.file_edited = true
-            case
-            when command == 'r'
-              new_contents << ((method == 1) ? replace : line.gsub!(exp, replace))
-            when command == 'd'
-              if method == 2
-                new_contents << line.gsub!(exp, "")
-              end
-            when command == 'i'
-              new_contents << line
-              new_contents << replace unless method == 2
-            end
-          else
-            new_contents << line
-          end
-        end
-        if command == 'i' && method == 2 && ! file_edited
-          new_contents << replace
-          self.file_edited = true
-        end
-
-        self.contents = new_contents
+        @changes = false
       end
     end
   end