chef 11.14.6-x86-mingw32 → 11.16.0-x86-mingw32

data/lib/chef/resources.rb

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

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

@@ -0,0 +1,115 @@
+#
+# Author:: Adam Edwards (<adamed@getchef.com>)
+#
+# Copyright:: 2014, 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'
+
+class Chef::Util::DSC
+  class ConfigurationGenerator
+    def initialize(node, config_directory)
+      @node = node
+      @config_directory = config_directory
+    end
+
+    def configuration_document_from_script_code(code, configuration_flags, shellout_flags)
+      Chef::Log.debug("DSC: DSC code:\n '#{code}'")
+      generated_script_path = write_document_generation_script(code, 'chef_dsc')
+      begin
+        configuration_document_from_script_path(generated_script_path, 'chef_dsc', configuration_flags, shellout_flags)
+      ensure
+        ::FileUtils.rm(generated_script_path)
+      end
+    end
+
+    def configuration_document_from_script_path(script_path, configuration_name, configuration_flags, shellout_flags)
+      validate_configuration_name!(configuration_name)
+
+      document_generation_cmdlet = Chef::Util::Powershell::Cmdlet.new(
+        @node,
+        configuration_document_generation_code(script_path, configuration_name))
+
+      merged_configuration_flags = get_merged_configuration_flags!(configuration_flags, configuration_name)
+
+      document_generation_cmdlet.run!(merged_configuration_flags, shellout_flags)
+      configuration_document_location = find_configuration_document(configuration_name)
+
+      if ! configuration_document_location
+        raise RuntimeError, "No DSC configuration for '#{configuration_name}' was generated from supplied DSC script"
+      end
+
+      configuration_document = get_configuration_document(configuration_document_location)
+      ::FileUtils.rm_rf(configuration_document_location)
+      configuration_document
+    end
+
+    protected
+
+    # From PowerShell error help for the Configuration language element:
+    #   Standard names may only contain letters (a-z, A-Z), numbers (0-9), and underscore (_).
+    #   The name may not be null or empty, and should start with a letter.
+    def validate_configuration_name!(configuration_name)
+      if !!(configuration_name =~ /\A[A-Za-z]+[_a-zA-Z0-9]*\Z/) == false
+        raise ArgumentError, 'Configuration `#{configuration_name}` is not a valid PowerShell cmdlet name'
+      end
+    end
+
+    def get_merged_configuration_flags!(configuration_flags, configuration_name)
+      merged_configuration_flags = { :outputpath  => configuration_document_directory(configuration_name) }
+      if configuration_flags
+        configuration_flags.map do | switch, value |
+          if merged_configuration_flags.key?(switch.to_s.downcase.to_sym)
+            raise ArgumentError, "The `flags` attribute for the dsc_script resource contained a command line switch :#{switch.to_s} that is disallowed."
+          end
+          merged_configuration_flags[switch.to_s.downcase.to_sym] = value
+        end
+      end
+      merged_configuration_flags
+    end
+
+    def configuration_code(code, configuration_name)
+      "$ProgressPreference = 'SilentlyContinue';Configuration '#{configuration_name}'\n{\n\tnode 'localhost'\n{\n\t#{code}\n}}\n"
+    end
+
+    def configuration_document_generation_code(configuration_script, configuration_name)
+      ". '#{configuration_script}';#{configuration_name}"
+    end
+
+    def write_document_generation_script(code, configuration_name)
+      script_path = "#{@config_directory}/chef_dsc_config.ps1"
+      ::File.open(script_path, 'wt') do | script |
+        script.write(configuration_code(code, configuration_name))
+      end
+      script_path
+    end
+
+    def find_configuration_document(configuration_name)
+      document_directory = configuration_document_directory(configuration_name)
+      document_file_name = ::Dir.entries(document_directory).find { | path | path =~ /.*.mof/ }
+      ::File.join(document_directory, document_file_name) if document_file_name
+    end
+
+    def configuration_document_directory(configuration_name)
+      ::File.join(@config_directory, configuration_name)
+    end
+
+    def get_configuration_document(document_path)
+      ::File.open(document_path, 'rb') do | file |
+        file.read
+      end
+    end
+  end
+end

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

@@ -0,0 +1,133 @@
+#
+# Author:: Jay Mundrawala (<jdm@getchef.com>)
+#
+# Copyright:: 2014, 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/log'
+require 'chef/util/dsc/resource_info'
+
+class Chef
+  class Util
+    class DSC
+      class LocalConfigurationManager
+        module Parser
+          # Parses the output from LCM and returns a list of Chef::Util::DSC::ResourceInfo objects
+          # that describe how the resources affected the system
+          #
+          # Example:
+          #   parse <<-EOF
+          #   What if: [Machine]: LCM: [Start Set      ]
+          #   What if: [Machine]: LCM: [Start Resource ] [[File]FileToNotBeThere]
+          #   What if: [Machine]: LCM: [Start Set      ] [[File]FileToNotBeThere]
+          #   What if:                                   [C:\ShouldNotExist.txt] removed
+          #   What if: [Machine]: LCM: [End Set        ] [[File]FileToNotBeThere] in 0.1 seconds
+          #   What if: [Machine]: LCM: [End Resource   ] [[File]FileToNotBeThere]
+          #   What if: [Machine]: LCM: [End Set        ]
+          #   EOF
+          #
+          #   would return
+          #
+          #   [
+          #     Chef::Util::DSC::ResourceInfo.new(
+          #       '[[File]FileToNotBeThere]',
+          #       true,
+          #       [
+          #         '[[File]FileToNotBeThere]',
+          #         '[C:\Shouldnotexist.txt]',
+          #         '[[File]FileToNotBeThere] in 0.1 seconds'
+          #       ]
+          #     )
+          #   ]
+          #
+          def self.parse(lcm_output)
+            return [] unless lcm_output
+
+            current_resource = Hash.new
+
+            resources = []
+            lcm_output.lines.each do |line|
+              op_action, op_type, info = parse_line(line)
+
+              case op_action
+              when :start
+                case op_type
+                when :set
+                  if current_resource[:name]
+                    current_resource[:context] = :logging
+                    current_resource[:logs] = [info]
+                  end
+                when :resource
+                  if current_resource[:name]
+                    resources.push(current_resource)
+                  end
+                  current_resource = {:name => info}
+                else
+                  Chef::Log.debug("Ignoring op_action #{op_action}: Read line #{line}")
+                end
+              when :end
+                # Make sure we log the last line
+                if current_resource[:context] == :logging and info.include? current_resource[:name]
+                  current_resource[:logs].push(info)
+                end
+                current_resource[:context] = nil
+              when :skip
+                current_resource[:skipped] = true
+              when :info
+                if current_resource[:context] == :logging
+                  current_resource[:logs].push(info)
+                end
+              end
+            end
+
+            if current_resource[:name]
+              resources.push(current_resource)
+            end
+
+            build_resource_info(resources)
+          end
+
+          def self.parse_line(line)
+            if match = line.match(/^.*?:.*?:\s*LCM:\s*\[(.*?)\](.*)/)
+                # If the line looks like
+                # What If: [machinename]: LCM: [op_action op_type] message
+                # extract op_action, op_type, and message
+                operation, info = match.captures
+                op_action, op_type = operation.strip.split(' ').map {|m| m.downcase.to_sym}
+            else
+              op_action = op_type = :info
+              if match = line.match(/^.*?:.*?: \s+(.*)/)
+                info = match.captures[0]
+              else
+                info = line
+              end
+            end
+            info.strip! # Because this was formatted for humans
+            return [op_action, op_type, info]
+          end
+          private_class_method :parse_line
+
+          def self.build_resource_info(resources)
+            resources.map do |r|
+              Chef::Util::DSC::ResourceInfo.new(r[:name], !r[:skipped], r[:logs])
+            end
+          end
+          private_class_method :build_resource_info
+
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,137 @@
+#
+# Author:: Adam Edwards (<adamed@getchef.com>)
+#
+# Copyright:: 2014, 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/dsc/lcm_output_parser'
+
+class Chef::Util::DSC
+  class LocalConfigurationManager
+    def initialize(node, configuration_path)
+      @node = node
+      @configuration_path = configuration_path
+      clear_execution_time
+    end
+
+    def test_configuration(configuration_document)
+      status = run_configuration_cmdlet(configuration_document)
+      handle_what_if_exception!(status.stderr) unless status.succeeded?
+      configuration_update_required?(status.return_value)
+    end
+
+    def set_configuration(configuration_document)
+      run_configuration_cmdlet(configuration_document, true)
+    end
+
+    def last_operation_execution_time_seconds
+      if @operation_start_time && @operation_end_time
+        @operation_end_time - @operation_start_time
+      end
+    end
+
+    private
+
+    def run_configuration_cmdlet(configuration_document, apply_configuration = false)
+      Chef::Log.debug("DSC: Calling DSC Local Config Manager to #{apply_configuration ? "set" : "test"} configuration document.")
+      test_only_parameters = ! apply_configuration ? '-whatif; if (! $?) { exit 1 }' : ''
+
+      start_operation_timing
+      command_code = lcm_command_code(@configuration_path, test_only_parameters)
+      status = nil
+
+      begin
+        save_configuration_document(configuration_document)
+        cmdlet = ::Chef::Util::Powershell::Cmdlet.new(@node, "#{command_code}")
+        if apply_configuration
+          status = cmdlet.run!
+        else
+          status = cmdlet.run
+        end
+      ensure
+        end_operation_timing
+        remove_configuration_document
+        if last_operation_execution_time_seconds
+          Chef::Log.debug("DSC: DSC operation completed in #{last_operation_execution_time_seconds} seconds.")
+        end
+      end
+      Chef::Log.debug("DSC: Completed call to DSC Local Config Manager")
+      status
+    end
+
+    def lcm_command_code(configuration_path, test_only_parameters)
+      <<-EOH
+$ProgressPreference = 'SilentlyContinue';start-dscconfiguration -path #{@configuration_path} -wait -erroraction 'continue' -force #{test_only_parameters}
+EOH
+    end
+
+    def handle_what_if_exception!(what_if_exception_output)
+        if what_if_exception_output.gsub(/\s+/, ' ') =~ /A parameter cannot be found that matches parameter name 'Whatif'/i
+          # LCM returns an error if any of the resources do not support the opptional What-If
+          Chef::Log::warn("Received error while testing configuration due to resource not supporting 'WhatIf'")
+        elsif output_has_dsc_module_failure?(what_if_exception_output)
+          Chef::Log::warn("Received error while testing configuration due to a module for an imported resource possibly not being fully installed:\n#{what_if_exception_output.gsub(/\s+/, ' ')}")
+        else
+          raise Chef::Exceptions::PowershellCmdletException, "Powershell Cmdlet failed: #{what_if_exception_output.gsub(/\s+/, ' ')}"
+        end
+    end
+
+    def output_has_dsc_module_failure?(what_if_output)
+      !! (what_if_output =~ /\sCimException/ &&
+        what_if_output =~ /ProviderOperationExecutionFailure/ &&
+        what_if_output =~ /\smodule\s+is\s+installed/)
+    end
+
+    def configuration_update_required?(what_if_output)
+      Chef::Log.debug("DSC: DSC returned the following '-whatif' output from test operation:\n#{what_if_output}")
+      begin
+        Parser::parse(what_if_output)
+      rescue Chef::Util::DSC::LocalConfigurationManager::Parser => e
+        Chef::Log::warn("Could not parse LCM output: #{e}")
+        [Chef::Util::DSC::ResourceInfo.new('Unknown DSC Resources', true, ['Unknown changes because LCM output was not parsable.'])]
+      end
+    end
+
+    def save_configuration_document(configuration_document)
+      ::FileUtils.mkdir_p(@configuration_path)
+      ::File.open(configuration_document_path, 'wb') do | file |
+        file.write(configuration_document)
+      end
+    end
+
+    def remove_configuration_document
+      ::FileUtils.rm(configuration_document_path)
+    end
+
+    def configuration_document_path
+      File.join(@configuration_path,'..mof')
+    end
+
+    def clear_execution_time
+      @operation_start_time = nil
+      @operation_end_time = nil
+    end
+
+    def start_operation_timing
+      clear_execution_time
+      @operation_start_time = Time.now
+    end
+
+    def end_operation_timing
+      @operation_end_time = Time.now
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+
+class Chef
+  class Util
+    class DSC
+        class ResourceInfo
+          # The name is the text following [Start Set]
+          attr_reader :name
+
+          # A list of all log messages between [Start Set] and [End Set].
+          # Each line is an element in the list.
+          attr_reader :change_log
+
+          def initialize(name, sets, change_log)
+            @name = name
+            @sets = sets
+            @change_log = change_log || []
+          end
+
+          # Does this resource change the state of the system?
+          def changes_state?
+            @sets
+          end
+        end
+    end
+  end
+end

data/lib/chef/util/path_helper.rb

@@ -32,7 +32,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 +50,7 @@ class Chef
             return true
           end
         end
-        
+
         false
       end
 

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

@@ -0,0 +1,136 @@
+#
+# Author:: Adam Edwards (<adamed@getchef.com>)
+#
+# Copyright:: 2014, 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 'mixlib/shellout'
+require 'chef/mixin/windows_architecture_helper'
+require 'chef/util/powershell/cmdlet_result'
+
+class Chef::Util::Powershell
+  class Cmdlet
+    def initialize(node, cmdlet, output_format=nil, output_format_options={})
+      @output_format = output_format
+      @node = node
+
+      case output_format
+      when nil
+        @json_format = false
+      when :json
+        @json_format = true
+      when :text
+        @json_format = false
+      when :object
+        @json_format = true
+      else
+        raise ArgumentError, "Invalid output format #{output_format.to_s} specified"
+      end
+
+      @cmdlet = cmdlet
+      @output_format_options = output_format_options
+    end
+
+    attr_reader :output_format
+
+    def run(switches={}, execution_options={}, *arguments)
+      arguments_string = arguments.join(' ')
+
+      switches_string = command_switches_string(switches)
+
+      json_depth = 5
+
+      if @json_format && @output_format_options.has_key?(:depth)
+        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 }"
+
+      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)
+    end
+
+    def run!(switches={}, execution_options={}, *arguments)
+      result = run(switches, execution_options, arguments)
+
+      if ! result.succeeded?
+        raise Chef::Exceptions::PowershellCmdletException, "Powershell Cmdlet failed: #{result.stderr}"
+      end
+
+      result
+    end
+
+    protected
+
+    include Chef::Mixin::WindowsArchitectureHelper
+
+    def validate_switch_name!(switch_parameter_name)
+      if !!(switch_parameter_name.to_s =~ /\A[A-Za-z]+[_a-zA-Z0-9]*\Z/) == false
+        raise ArgumentError, "`#{switch_parameter_name}` is not a valid PowerShell cmdlet switch parameter name"
+      end
+    end
+
+    def escape_parameter_value(parameter_value)
+      parameter_value.gsub(/(`|'|"|#)/,'`\1')
+    end
+
+    def escape_string_parameter_value(parameter_value)
+      "'#{escape_parameter_value(parameter_value)}'"
+    end
+
+    def command_switches_string(switches)
+      command_switches = switches.map do | switch_name, switch_value |
+        if switch_name.class != Symbol
+          raise ArgumentError, "Invalid type `#{switch_name} `for PowerShell switch '#{switch_name.to_s}'. The switch must be specified as a Symbol'"
+        end
+
+        validate_switch_name!(switch_name)
+
+        switch_argument = ''
+        switch_present = true
+
+        case switch_value
+        when Numeric
+          switch_argument = switch_value.to_s
+        when Float
+          switch_argument = switch_value.to_s
+        when FalseClass
+          switch_present = false
+        when TrueClass
+        when String
+          switch_argument = escape_string_parameter_value(switch_value)
+        else
+          raise ArgumentError, "Invalid argument type `#{switch_value.class}` specified for PowerShell switch `:#{switch_name.to_s}`. Arguments to PowerShell must be of type `String`, `Numeric`, `Float`, `FalseClass`, or `TrueClass`"
+        end
+
+        switch_present ? ["-#{switch_name.to_s.downcase}", switch_argument].join(' ').strip : ''
+      end
+
+      command_switches.join(' ')
+    end
+  end
+end
+