chef 11.18.12-x86-mingw32 → 12.0.0.alpha.0-x86-mingw32

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

@@ -1,115 +0,0 @@
-#
-# 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

@@ -1,133 +0,0 @@
-#
-# 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

@@ -1,141 +0,0 @@
-#
-# 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)
-      log_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 log_what_if_exception(what_if_exception_output)
-      if whatif_not_supported?(what_if_exception_output)
-        # 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 dsc_module_import_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
-        Chef::Log::warn("Received error while testing configuration:\n#{what_if_exception_output.gsub(/\s+/, ' ')}")
-      end
-    end
-
-    def whatif_not_supported?(what_if_exception_output)
-      !! (what_if_exception_output.gsub(/[\r\n]+/, '').gsub(/\s+/, ' ') =~ /A parameter cannot be found that matches parameter name 'Whatif'/i)
-    end
-
-    def dsc_module_import_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

@@ -1,26 +0,0 @@
-
-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/powershell/cmdlet.rb

@@ -1,136 +0,0 @@
-#
-# 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
-