chef 12.0.0.alpha.1 → 12.0.0.alpha.2

data/lib/chef/provider/whyrun_safe_ruby_block.rb

@@ -19,7 +19,7 @@
 class Chef
   class Provider
     class WhyrunSafeRubyBlock < Chef::Provider::RubyBlock
-      def action_create
+      def action_run
         @new_resource.block.call
         @new_resource.updated_by_last_action(true)
         @run_context.events.resource_update_applied(@new_resource, :create, "execute the whyrun_safe_ruby_block #{@new_resource.name}")

data/lib/chef/providers.rb

@@ -39,6 +39,7 @@ require 'chef/provider/mdadm'
 require 'chef/provider/mount'
 require 'chef/provider/package'
 require 'chef/provider/powershell_script'
+require 'chef/provider/reboot'
 require 'chef/provider/remote_directory'
 require 'chef/provider/remote_file'
 require 'chef/provider/route'

data/lib/chef/recipe.rb

@@ -69,7 +69,6 @@ class Chef
       @run_context = run_context
       # TODO: 5/19/2010 cw/tim: determine whether this can be removed
       @params = Hash.new
-      @node = deprecated_ivar(run_context.node, :node, :warn)
     end
 
     # Used in DSL mixins

data/lib/chef/resource.rb

@@ -23,7 +23,7 @@ require 'chef/dsl/data_query'
 require 'chef/dsl/registry_helper'
 require 'chef/dsl/reboot_pending'
 require 'chef/mixin/convert_to_class_name'
-require 'chef//guard_interpreter/resource_guard_interpreter'
+require 'chef/guard_interpreter/resource_guard_interpreter'
 require 'chef/resource/conditional'
 require 'chef/resource/conditional_action_not_nothing'
 require 'chef/resource_collection'
@@ -121,8 +121,8 @@ F
 
     end
 
-    FORBIDDEN_IVARS = [:@run_context, :@node, :@not_if, :@only_if, :@enclosing_provider]
-    HIDDEN_IVARS = [:@allowed_actions, :@resource_name, :@source_line, :@run_context, :@name, :@node, :@not_if, :@only_if, :@elapsed_time, :@enclosing_provider]
+    FORBIDDEN_IVARS = [:@run_context, :@not_if, :@only_if, :@enclosing_provider]
+    HIDDEN_IVARS = [:@allowed_actions, :@resource_name, :@source_line, :@run_context, :@name, :@not_if, :@only_if, :@elapsed_time, :@enclosing_provider]
 
     include Chef::DSL::DataQuery
     include Chef::Mixin::ParamsValidate
@@ -253,8 +253,6 @@ F
       @guard_interpreter = :default
       @elapsed_time = 0
       @sensitive = false
-
-      @node = run_context ? deprecated_ivar(run_context.node, :node, :warn) : nil
     end
 
     # Returns a Hash of attribute => value for the state attributes declared in

data/lib/chef/resource/mount.rb

@@ -33,6 +33,7 @@ class Chef
         @mount_point = name
         @device = nil
         @device_type = :device
+        @fsck_device = '-'
         @fstype = "auto"
         @options = ["defaults"]
         @dump = 0
@@ -77,6 +78,14 @@ class Chef
         )
       end
 
+      def fsck_device(arg=nil)
+        set_or_return(
+          :fsck_device,
+          arg,
+          :kind_of => [ String ]
+        )
+      end
+
       def fstype(arg=nil)
         set_or_return(
           :fstype,

data/lib/chef/resource/reboot.rb

@@ -0,0 +1,48 @@
+#
+# Author:: Chris Doherty <cdoherty@getchef.com>)
+# Copyright:: Copyright (c) 2014 Chef, 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'
+
+# In using this resource via notifications, it's important to *only* use
+# immediate notifications. Delayed notifications produce unintuitive and
+# probably undesired results.
+class Chef
+  class Resource
+    class Reboot < Chef::Resource
+      def initialize(name, run_context=nil)
+        super
+        @resource_name = :reboot
+        @provider = Chef::Provider::Reboot
+        @allowed_actions = [:request_reboot, :reboot_now, :cancel]
+
+        @reason = "Reboot by Chef"
+        @delay_mins = 0
+
+        # no default action.
+      end
+
+      def reason(arg=nil)
+        set_or_return(:reason, arg, :kind_of => String)
+      end
+
+      def delay_mins(arg=nil)
+        set_or_return(:delay_mins, arg, :kind_of => Fixnum)
+      end
+    end
+  end
+end

data/lib/chef/resources.rb

@@ -53,6 +53,7 @@ require 'chef/resource/perl'
 require 'chef/resource/portage_package'
 require 'chef/resource/powershell_script'
 require 'chef/resource/python'
+require 'chef/resource/reboot'
 require 'chef/resource/registry_key'
 require 'chef/resource/remote_directory'
 require 'chef/resource/remote_file'

data/lib/chef/run_context.rb

@@ -61,6 +61,9 @@ class Chef
     # Event dispatcher for this run.
     attr_reader :events
 
+    # Hash of factoids for a reboot request.
+    attr_reader :reboot_info
+
     # Creates a new Chef::RunContext object and populates its fields. This object gets
     # used by the Chef Server to generate a fully compiled recipe list for a node.
     #
@@ -76,6 +79,7 @@ class Chef
       @loaded_recipes = {}
       @loaded_attributes = {}
       @events = events
+      @reboot_info = {}
 
       @node.run_context = self
 
@@ -271,6 +275,27 @@ ERROR_MESSAGE
       end
     end
 
+    # there are options for how to handle multiple calls to these functions:
+    # 1. first call always wins (never change @reboot_info once set).
+    # 2. last call always wins (happily change @reboot_info whenever).
+    # 3. raise an exception on the first conflict.
+    # 4. disable reboot after this run if anyone ever calls :cancel.
+    # 5. raise an exception on any second call.
+    # 6. ?
+    def request_reboot(reboot_info)
+      Chef::Log::info "Changing reboot status from #{@reboot_info.inspect} to #{reboot_info.inspect}"
+      @reboot_info = reboot_info
+    end
+
+    def cancel_reboot
+      Chef::Log::info "Changing reboot status from #{@reboot_info.inspect} to {}"
+      @reboot_info = {}
+    end
+
+    def reboot_requested?
+      @reboot_info.size > 0
+    end
+
     private
 
     def loaded_recipe(cookbook, recipe)

data/lib/chef/search/query.rb

@@ -23,6 +23,7 @@ require 'chef/node'
 require 'chef/role'
 require 'chef/data_bag'
 require 'chef/data_bag_item'
+require 'chef/exceptions'
 
 class Chef
   class Search
@@ -34,17 +35,112 @@ class Chef
         @rest = Chef::REST.new(url ||Chef::Config[:chef_server_url])
       end
 
-      # Search Solr for objects of a given type, for a given query. If you give
-      # it a block, it will handle the paging for you dynamically.
-      def search(type, query="*:*", sort='X_CHEF_id_CHEF_X asc', start=0, rows=1000, &block)
-        raise ArgumentError, "Type must be a string or a symbol!" unless (type.kind_of?(String) || type.kind_of?(Symbol))
 
-        response = @rest.get_rest("search/#{type}?q=#{escape(query)}&sort=#{escape(sort)}&start=#{escape(start)}&rows=#{escape(rows)}")
-        if block
-          response["rows"].each { |o| block.call(o) unless o.nil?}
+      # This search is only kept for backwards compatibility, since the results of the
+      # new filtered search method will be in a slightly different format
+      def partial_search(type, query='*:*', *args, &block)
+        Chef::Log.warn("DEPRECATED: The 'partial_search' api is deprecated, please use the search api with 'filter_result'")
+        # accept both types of args
+        if args.length == 1 && args[0].is_a?(Hash)
+          args_hash = args[0].dup
+          # partial_search implemented in the partial search cookbook uses the
+          # arg hash :keys instead of :filter_result to filter returned data
+          args_hash[:filter_result] = args_hash[:keys]
+        else
+          args_hash = {}
+          args_hash[:sort] = args[0] if args.length >= 1
+          args_hash[:start] = args[1] if args.length >= 2
+          args_hash[:rows] = args[2] if args.length >= 3
+        end
+
+        unless block.nil?
+          raw_results = search(type,query,args_hash)
+        else
+          raw_results = search(type,query,args_hash,&block)
+        end
+        results = Array.new
+        raw_results[0].each do |r|
+          results << r["data"]
+        end
+        return results
+      end
+
+      #
+      # New search input, designed to be backwards compatible with the old method signature
+      # 'type' and 'query' are the same as before, args now will accept either a Hash of
+      # search arguments with symbols as the keys (ie :sort, :start, :rows) and a :filter_result
+      # option.
+      #
+      # :filter_result should be in the format of another Hash with the structure of:
+      # {
+      #   :returned_name1 => ["path", "to", "variable"],
+      #   :returned_name2 => ["shorter", "path"]
+      # }
+      # a real world example might be something like:
+      # {
+      #   :ip_address => ["ipaddress"],
+      #   :ruby_version => ["languages", "ruby", "version"]
+      # }
+      #  this will bring back 2 variables 'ip_address' and 'ruby_version' with whatever value was found
+      # an example of the returned json may be:
+      # {"ip_address":"127.0.0.1", "ruby_version": "1.9.3"}
+      #
+      def search(type, query='*:*', *args, &block)
+        validate_type(type)
+        validate_args(args)
+
+        scrubbed_args = Hash.new
+
+        # argify everything
+        if args[0].kind_of?(Hash)
+          scrubbed_args = args[0]
+        else
+          # This api will be deprecated in a future release
+          scrubbed_args = { :sort => args[0], :start => args[1], :rows => args[2] }
+        end
+
+        # set defaults, if they haven't been set yet.
+        scrubbed_args[:sort] ||= 'X_CHEF_id_CHEF_X asc'
+        scrubbed_args[:start] ||= 0
+        scrubbed_args[:rows] ||= 1000
+
+        do_search(type, query, scrubbed_args, &block)
+      end
+
+      def list_indexes
+        @rest.get_rest("search")
+      end
+
+      private
+      def validate_type(t)
+        unless t.kind_of?(String) || t.kind_of?(Symbol)
+          msg = "Invalid search object type #{t.inspect} (#{t.class}), must be a String or Symbol." +
+            "Useage: search(:node, QUERY, [OPTIONAL_ARGS])" +
+            "        `knife search environment QUERY (options)`"
+          raise Chef::Exceptions::InvalidSearchQuery, msg
+        end
+      end
+
+      def validate_args(a)
+        max_args = 3
+        raise Chef::Exceptions::InvalidSearchQuery, "Too many arguments! (#{a.size} for <= #{max_args})" if a.size > max_args
+      end
+
+      def escape(s)
+        s && URI.escape(s.to_s)
+      end
+
+      # new search api that allows for a cleaner implementation of things like return filters
+      # (formerly known as 'partial search').
+      # Also args should never be nil, but that is required for Ruby 1.8 compatibility
+      def do_search(type, query="*:*", args=nil, &block)
+        query_string = create_query_string(type, query, args)
+        response = call_rest_service(query_string, args)
+        unless block.nil?
+          response["rows"].each { |rowset| block.call(rowset) unless rowset.nil?}
           unless (response["start"] + response["rows"].length) >= response["total"]
-            nstart = response["start"] + rows
-            search(type, query, sort, nstart, rows, &block)
+            args[:start] = response["start"] + args[:rows]
+            do_search(type, query, args, &block)
           end
           true
         else
@@ -52,14 +148,26 @@ class Chef
         end
       end
 
-      def list_indexes
-        @rest.get_rest("search")
+      # create the full rest url string
+      def create_query_string(type, query, args)
+        # create some default variables just so we don't break backwards compatibility
+        sort = args[:sort]
+        start = args[:start]
+        rows = args[:rows]
+
+        return "search/#{type}?q=#{escape(query)}&sort=#{escape(sort)}&start=#{escape(start)}&rows=#{escape(rows)}"
       end
 
-      private
-        def escape(s)
-          s && URI.escape(s.to_s)
+      def call_rest_service(query_string, args)
+        if args.key?(:filter_result)
+          response = @rest.post_rest(query_string, args[:filter_result])
+          response_rows = response['rows'].map { |row| row['data'] }
+        else
+          response = @rest.get_rest(query_string)
+          response_rows = response['rows']
         end
+        return response
+      end
     end
   end
 end

data/lib/chef/util/path_helper.rb

@@ -16,15 +16,50 @@
 # limitations under the License.
 #
 
-require 'chef/platform'
-require 'chef/exceptions'
-
 class Chef
   class Util
     class PathHelper
       # Maximum characters in a standard Windows path (260 including drive letter and NUL)
       WIN_MAX_PATH = 259
 
+      def self.dirname(path)
+        if Chef::Platform.windows?
+          # Find the first slash, not counting trailing slashes
+          end_slash = path.size
+          while true
+            slash = path.rindex(/[#{Regexp.escape(File::SEPARATOR)}#{Regexp.escape(path_separator)}]/, end_slash - 1)
+            if !slash
+              return end_slash == path.size ? '.' : path_separator
+            elsif slash == end_slash - 1
+              end_slash = slash
+            else
+              return path[0..slash-1]
+            end
+          end
+        else
+          ::File.dirname(path)
+        end
+      end
+
+      BACKSLASH = '\\'.freeze
+
+      def self.path_separator
+        if Chef::Platform.windows?
+          File::ALT_SEPARATOR || BACKSLASH
+        else
+          File::SEPARATOR
+        end
+      end
+
+      def self.join(*args)
+        args.flatten.inject do |joined_path, component|
+          # Joined path ends with /
+          joined_path = joined_path.sub(/[#{Regexp.escape(File::SEPARATOR)}#{Regexp.escape(path_separator)}]+$/, '')
+          component = component.sub(/^[#{Regexp.escape(File::SEPARATOR)}#{Regexp.escape(path_separator)}]+/, '')
+          joined_path += "#{path_separator}#{component}"
+        end
+      end
+
       def self.validate_path(path)
         if Chef::Platform.windows?
           unless printable?(path)
@@ -32,7 +67,7 @@ class Chef
             Chef::Log.error(msg)
             raise Chef::Exceptions::ValidationFailed, msg
           end
-            
+
           if windows_max_length_exceeded?(path)
             Chef::Log.debug("Path '#{path}' is longer than #{WIN_MAX_PATH}, prefixing with'\\\\?\\'")
             path.insert(0, "\\\\?\\")
@@ -50,7 +85,7 @@ class Chef
             return true
           end
         end
-        
+
         false
       end
 
@@ -75,7 +110,7 @@ class Chef
         if Chef::Platform.windows?
           # Add the \\?\ API prefix on Windows unless add_prefix is false
           # Downcase on Windows where paths are still case-insensitive
-          abs_path.gsub!(::File::SEPARATOR, ::File::ALT_SEPARATOR)
+          abs_path.gsub!(::File::SEPARATOR, path_separator)
           if add_prefix && abs_path !~ /^\\\\?\\/
             abs_path.insert(0, "\\\\?\\")
           end
@@ -86,9 +121,22 @@ class Chef
         abs_path
       end
 
+      def self.cleanpath(path)
+        path = Pathname.new(path).cleanpath.to_s
+        # ensure all forward slashes are backslashes
+        if Chef::Platform.windows?
+          path = path.gsub(File::SEPARATOR, path_separator)
+        end
+        path
+      end
+
       def self.paths_eql?(path1, path2)
         canonical_path(path1) == canonical_path(path2)
       end
     end
   end
 end
+
+# Break a require loop when require chef/util/path_helper
+require 'chef/platform'
+require 'chef/exceptions'