chef 12.1.2 → 12.2.0.rc.1

data/lib/chef/resource/dsc_resource.rb

@@ -0,0 +1,83 @@
+#
+# Author:: Adam Edwards (<adamed@getchef.com>)
+#
+# Copyright:: 2014, Opscode, Inc.
+#
+# 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/dsl/powershell'
+
+class Chef
+  class Resource
+    class DscResource < Chef::Resource
+
+      provides :dsc_resource, os: "windows"
+
+      include Chef::DSL::Powershell
+
+      def initialize(name, run_context)
+        super
+        @properties = {}
+        @resource_name = :dsc_resource
+        @resource = nil
+        @allowed_actions.push(:run)
+        @action = :run
+      end
+
+      def resource(value=nil)
+        if value
+          @resource = value
+        else
+          @resource
+        end
+      end
+
+      def module_name(value=nil)
+        if value
+          @module_name = value
+        else
+          @module_name
+        end
+      end
+
+      def property(property_name, value=nil)
+        if not property_name.is_a?(Symbol)
+          raise TypeError, "A property name of type Symbol must be specified, '#{property_name.to_s}' of type #{property_name.class.to_s} was given"
+        end
+
+        if value.nil?
+          value_of(@properties[property_name])
+        else
+          @properties[property_name] = value
+        end
+      end
+
+      def properties
+        @properties.reduce({}) do |memo, (k, v)|
+          memo[k] = value_of(v)
+          memo
+        end
+      end
+
+      private
+
+      def value_of(value)
+        if value.is_a?(DelayedEvaluator)
+          value.call
+        else
+          value
+        end
+      end
+    end
+  end
+end

data/lib/chef/resource/env.rb

@@ -25,6 +25,8 @@ class Chef
 
       state_attrs :value
 
+      provides :env, os: "windows"
+
       def initialize(name, run_context=nil)
         super
         @resource_name = :env

data/lib/chef/resource/git.rb

@@ -27,7 +27,7 @@ class Chef
       def initialize(name, run_context=nil)
         super
         @resource_name = :git
-        @additional_remotes = Hash[]
+        @additional_remotes = {}
       end
 
       def additional_remotes(arg=nil)

data/lib/chef/resource/group.rb

@@ -25,6 +25,8 @@ class Chef
 
       state_attrs :members
 
+      provides :group
+
       def initialize(name, run_context=nil)
         super
         @resource_name = :group

data/lib/chef/resource/homebrew_package.rb

@@ -26,7 +26,7 @@ class Chef
     class HomebrewPackage < Chef::Resource::Package
 
       provides :homebrew_package
-      provides :package, os: ["mac_os_x", "darwin"]
+      provides :package, os: "darwin"
 
       def initialize(name, run_context=nil)
         super

data/lib/chef/resource/lwrp_base.rb

@@ -70,14 +70,6 @@ class Chef
         alias_method :resource_name=, :resource_name
       end
 
-      # Define an attribute on this resource, including optional validation
-      # parameters.
-      def self.attribute(attr_name, validation_opts={})
-        define_method(attr_name) do |arg=nil|
-          set_or_return(attr_name.to_sym, arg, validation_opts)
-        end
-      end
-
       # Sets the default action
       def self.default_action(action_name=NULL_ARG)
         unless action_name.equal?(NULL_ARG)

data/lib/chef/resource/mdadm.rb

@@ -27,6 +27,8 @@ class Chef
 
       state_attrs :devices, :level, :chunk
 
+      provides :mdadm
+
       def initialize(name, run_context=nil)
         super
         @resource_name = :mdadm

data/lib/chef/resource/mount.rb

@@ -27,6 +27,8 @@ class Chef
 
       state_attrs :mount_point, :device_type, :fstype, :username, :password, :domain
 
+      provides :mount
+
       def initialize(name, run_context=nil)
         super
         @resource_name = :mount

data/lib/chef/resource/powershell_script.rb

@@ -21,6 +21,8 @@ class Chef
   class Resource
     class PowershellScript < Chef::Resource::WindowsScript
 
+      provides :powershell_script, os: "windows"
+
       def initialize(name, run_context=nil)
         super(name, run_context, :powershell_script, "powershell.exe")
         @convert_boolean_return = false

data/lib/chef/resource/user.rb

@@ -26,6 +26,8 @@ class Chef
 
       state_attrs :uid, :gid, :home
 
+      provides :user
+
       def initialize(name, run_context=nil)
         super
         @resource_name = :user

data/lib/chef/resources.rb

@@ -29,6 +29,7 @@ require 'chef/resource/deploy_revision'
 require 'chef/resource/directory'
 require 'chef/resource/dpkg_package'
 require 'chef/resource/dsc_script'
+require 'chef/resource/dsc_resource'
 require 'chef/resource/easy_install_package'
 require 'chef/resource/env'
 require 'chef/resource/erl_call'

data/lib/chef/run_context.rb

@@ -50,7 +50,7 @@ class Chef
     # recipes, which is triggered by #load. (See also: CookbookCompiler)
     attr_accessor :resource_collection
 
-    # The list of audits (control groups) to execute during the audit phase
+    # The list of control groups to execute during the audit phase
     attr_accessor :audits
 
     # A Hash containing the immediate notifications triggered by resources

data/lib/chef/shell.rb

@@ -29,6 +29,7 @@ require 'chef/config_fetcher'
 require 'chef/shell/shell_session'
 require 'chef/shell/ext'
 require 'chef/json_compat'
+require 'chef/util/path_helper'
 
 # = Shell
 # Shell is Chef in an IRB session. Shell can interact with a Chef server via the
@@ -101,7 +102,7 @@ module Shell
   end
 
   def self.configure_irb
-    irb_conf[:HISTORY_FILE] = "~/.chef/chef_shell_history"
+    irb_conf[:HISTORY_FILE] = Chef::Util::PathHelper.home(".chef", "chef_shell_history")
     irb_conf[:SAVE_HISTORY] = 1000
 
     irb_conf[:IRB_RC] = lambda do |conf|
@@ -295,18 +296,19 @@ FOOTER
     private
 
     def config_file_for_shell_mode(environment)
+      dot_chef_dir = Chef::Util::PathHelper.home('.chef')
       if config[:config_file]
         config[:config_file]
-      elsif environment && ENV['HOME']
+      elsif environment
         Shell.env = environment
-        config_file_to_try = ::File.join(ENV['HOME'], '.chef', environment, 'chef_shell.rb')
+        config_file_to_try = ::File.join(dot_chef_dir, environment, 'chef_shell.rb')
         unless ::File.exist?(config_file_to_try)
           puts "could not find chef-shell config for environment #{environment} at #{config_file_to_try}"
           exit 1
         end
         config_file_to_try
-      elsif ENV['HOME'] && ::File.exist?(File.join(ENV['HOME'], '.chef', 'chef_shell.rb'))
-        File.join(ENV['HOME'], '.chef', 'chef_shell.rb')
+      elsif dot_chef_dir && ::File.exist?(File.join(dot_chef_dir, 'chef_shell.rb'))
+        File.join(dot_chef_dir, 'chef_shell.rb')
       elsif config[:solo]
         Chef::Config.platform_specific_path("/etc/chef/solo.rb")
       elsif config[:client]

data/lib/chef/util/dsc/resource_store.rb

@@ -0,0 +1,110 @@
+#
+# Author:: Jay Mundrawala (<jdm@chef.io>)
+#
+# Copyright:: Copyright (c) 2015 Chef Software, Inc.
+#
+# 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/util/powershell/cmdlet'
+require 'chef/util/powershell/cmdlet_result'
+require 'chef/exceptions'
+
+class Chef
+class Util
+class DSC
+  class ResourceStore
+
+    def self.instance
+      @@instance ||= ResourceStore.new.tap do |store|
+        store.send(:populate_cache)
+      end
+    end
+
+    def resources
+      @resources ||= []
+    end
+
+    def find(name, module_name=nil)
+      found = find_resources(name, module_name, resources)
+
+      # We don't have it, query for the resource...it might
+      # have been added since we last queried
+      if found.length == 0
+        rs = query_resource(name)
+        add_resources(rs)
+        found = find_resources(name, module_name, rs)
+      end
+
+      found
+    end
+
+    private
+
+    def add_resource(new_r)
+      count = resources.count do |r|
+        r['ResourceType'].casecmp(new_r['ResourceType']) == 0
+      end
+      if count == 0
+        resources << new_r
+      end
+    end
+
+    def add_resources(rs)
+      rs.each do |r|
+        add_resource(r)
+      end
+    end
+
+    def populate_cache
+      @resources = query_resources
+    end
+
+    def find_resources(name, module_name, rs)
+      found = rs.find_all do |r|
+        name_matches = r['Name'].casecmp(name) == 0
+        if name_matches
+          module_name == nil || (r['Module'] and r['Module']['Name'].casecmp(module_name) == 0)
+        else
+          false
+        end
+      end
+    end
+
+
+    # Returns a list of dsc resources
+    def query_resources
+      cmdlet = Chef::Util::Powershell::Cmdlet.new(nil, 'get-dscresource',
+          :object)
+      result = cmdlet.run
+      result.return_value
+    end
+
+    # Returns a list of dsc resources matching the provided name
+    def query_resource(resource_name)
+      cmdlet = Chef::Util::Powershell::Cmdlet.new(nil, "get-dscresource #{resource_name}",
+          :object)
+      result = cmdlet.run
+      ret_val = result.return_value
+      if ret_val.nil?
+        []
+      elsif ret_val.is_a? Array
+        ret_val
+      else
+        [ret_val]
+      end
+    end
+  end
+end
+end
+end

data/lib/chef/util/path_helper.rb

@@ -142,6 +142,82 @@ class Chef
       def self.relative_path_from(from, to)
         pathname = Pathname.new(Chef::Util::PathHelper.cleanpath(to)).relative_path_from(Pathname.new(Chef::Util::PathHelper.cleanpath(from)))
       end
+
+      # Retrieves the "home directory" of the current user while trying to ascertain the existence
+      # of said directory.  The path returned uses / for all separators (the ruby standard format).
+      # If the home directory doesn't exist or an error is otherwise encountered, nil is returned.
+      # 
+      # If a set of path elements is provided, they are appended as-is to the home path if the
+      # homepath exists. 
+      # 
+      # If an optional block is provided, the joined path is passed to that block if the home path is
+      # valid and the result of the block is returned instead.
+      #
+      # Home-path discovery is performed once.  If a path is discovered, that value is memoized so
+      # that subsequent calls to home_dir don't bounce around.
+      #
+      # See self.all_homes.
+      def self.home(*args)
+        @@home_dir ||= self.all_homes { |p| break p }
+        if @@home_dir
+          path = File.join(@@home_dir, *args)
+          block_given? ? (yield path) : path
+        end
+      end
+
+      # See self.home.  This method performs a similar operation except that it yields all the different
+      # possible values of 'HOME' that one could have on this platform.  Hence, on windows, if
+      # HOMEDRIVE\HOMEPATH and USERPROFILE are different, the provided block will be called twice.
+      # This method goes out and checks the existence of each location at the time of the call.
+      #
+      # The return is a list of all the returned values from each block invocation or a list of paths
+      # if no block is provided.
+      def self.all_homes(*args)
+        paths = []
+        if Chef::Platform.windows?
+          # By default, Ruby uses the the following environment variables to determine Dir.home:
+          # HOME
+          # HOMEDRIVE HOMEPATH
+          # USERPROFILE
+          # Ruby only checks to see if the variable is specified - not if the directory actually exists.
+          # On Windows, HOMEDRIVE HOMEPATH can point to a different location (such as an unavailable network mounted drive)
+          # while USERPROFILE points to the location where the user application settings and profile are stored.  HOME
+          # is not defined as an environment variable (usually).  If the home path actually uses UNC, then the prefix is
+          # HOMESHARE instead of HOMEDRIVE.
+          #
+          # We instead walk down the following and only include paths that actually exist.
+          # HOME
+          # HOMEDRIVE HOMEPATH
+          # HOMESHARE HOMEPATH
+          # USERPROFILE
+
+          paths << ENV['HOME']
+          paths << ENV['HOMEDRIVE'] + ENV['HOMEPATH'] if ENV['HOMEDRIVE'] && ENV['HOMEPATH']
+          paths << ENV['HOMESHARE'] + ENV['HOMEPATH'] if ENV['HOMESHARE'] && ENV['HOMEPATH']
+          paths << ENV['USERPROFILE']
+        end
+        paths << Dir.home
+
+        # Depending on what environment variables we're using, the slashes can go in any which way.
+        # Just change them all to / to keep things consistent.
+        # Note: Maybe this is a bad idea on some unixy systems where \ might be a valid character depending on
+        # the particular brand of kool-aid you consume.  This code assumes that \ and / are both
+        # path separators on any system being used.
+        paths = paths.map { |home_path| home_path.gsub(path_separator, ::File::SEPARATOR) if home_path }
+        
+        # Filter out duplicate paths and paths that don't exist.
+        valid_paths = paths.select { |home_path| home_path && Dir.exists?(home_path) }
+        valid_paths = valid_paths.uniq
+        
+        # Join all optional path elements at the end.
+        # If a block is provided, invoke it - otherwise just return what we've got.
+        joined_paths = valid_paths.map { |home_path| File.join(home_path, *args) }
+        if block_given?
+          joined_paths.each { |p| yield p }
+        else
+          joined_paths
+        end
+      end
     end
   end
 end

data/lib/chef/util/powershell/cmdlet.rb

@@ -20,7 +20,9 @@ require 'mixlib/shellout'
 require 'chef/mixin/windows_architecture_helper'
 require 'chef/util/powershell/cmdlet_result'
 
-class Chef::Util::Powershell
+class Chef
+class Util
+class Powershell
   class Cmdlet
     def initialize(node, cmdlet, output_format=nil, output_format_options={})
       @output_format = output_format
@@ -46,6 +48,10 @@ class Chef::Util::Powershell
     attr_reader :output_format
 
     def run(switches={}, execution_options={}, *arguments)
+      streams = { :json => CmdletStream.new('json'),
+                  :verbose => CmdletStream.new('verbose'),
+                }
+
       arguments_string = arguments.join(' ')
 
       switches_string = command_switches_string(switches)
@@ -56,21 +62,25 @@ class Chef::Util::Powershell
         json_depth = @output_format_options[:depth]
       end
 
-      json_command = @json_format ? " | convertto-json -compress -depth #{json_depth}" : ""
-      command_string = "powershell.exe -executionpolicy bypass -noprofile -noninteractive -command \"trap [Exception] {write-error -exception ($_.Exception.Message);exit 1};#{@cmdlet} #{switches_string} #{arguments_string}#{json_command}\";if ( ! $? ) { exit 1 }"
+      json_command = @json_format ? " | convertto-json -compress -depth #{json_depth} "\
+                                    "> #{streams[:json].path}" : ""
+      redirections = "4> '#{streams[:verbose].path}'"
+      command_string = "powershell.exe -executionpolicy bypass -noprofile -noninteractive "\
+                       "-command \"trap [Exception] {write-error -exception "\
+                       "($_.Exception.Message);exit 1};#{@cmdlet} #{switches_string} "\
+                       "#{arguments_string} #{redirections}"\
+                       "#{json_command}\";if ( ! $? ) { exit 1 }"
 
       augmented_options = {:returns => [0], :live_stream => false}.merge(execution_options)
       command = Mixlib::ShellOut.new(command_string, augmented_options)
 
-      os_architecture = "#{ENV['PROCESSOR_ARCHITEW6432']}" == 'AMD64' ? :x86_64 : :i386
-
       status = nil
 
       with_os_architecture(@node) do
         status = command.run_command
       end
 
-      CmdletResult.new(status, @output_format)
+      CmdletResult.new(status, streams, @output_format)
     end
 
     def run!(switches={}, execution_options={}, *arguments)
@@ -131,6 +141,30 @@ class Chef::Util::Powershell
 
       command_switches.join(' ')
     end
+
+    class CmdletStream
+      def initialize(name)
+        @filename = Dir::Tmpname.create(name) {}
+        ObjectSpace.define_finalizer(self, self.class.destroy(@filename))
+      end
+
+      def path
+        @filename
+      end
+
+      def read
+        if File.exist? @filename
+          File.open(@filename, 'rb:bom|UTF-16LE') do |f|
+            f.read.encode('UTF-8')
+          end
+        end
+      end
+
+      def self.destroy(name)
+        proc { File.delete(name) if File.exists? name }
+      end
+    end
   end
 end
-
+end
+end