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

data/lib/chef/mixin/windows_env_helper.rb

@@ -1,56 +0,0 @@
-#
-# Author:: Adam Edwards (<adamed@opscode.com>)
-# Copyright:: Copyright (c) 2013 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.
-#
-
-
-require 'chef/exceptions'
-require 'chef/platform/query_helpers'
-require 'chef/win32/error' if Chef::Platform.windows?
-require 'chef/win32/api/system' if Chef::Platform.windows?
-
-class Chef
-  module Mixin
-    module WindowsEnvHelper
-
-      if Chef::Platform.windows?
-        include Chef::ReservedNames::Win32::API::System
-      end
-
-      #see: http://msdn.microsoft.com/en-us/library/ms682653%28VS.85%29.aspx
-      HWND_BROADCAST = 0xffff
-      WM_SETTINGCHANGE = 0x001A
-      SMTO_BLOCK = 0x0001
-      SMTO_ABORTIFHUNG = 0x0002
-      SMTO_NOTIMEOUTIFNOTHUNG = 0x0008
-
-      def broadcast_env_change
-        flags = SMTO_BLOCK | SMTO_ABORTIFHUNG | SMTO_NOTIMEOUTIFNOTHUNG
-        SendMessageTimeoutA(HWND_BROADCAST, WM_SETTINGCHANGE, 0, FFI::MemoryPointer.from_string('Environment').address, flags, 5000, nil)
-      end
-
-      def expand_path(path)
-        # http://msdn.microsoft.com/en-us/library/windows/desktop/ms724265%28v=vs.85%29.aspx
-        # Max size of env block on windows is 32k
-        buf = 0.chr * 32 * 1024
-        if ExpandEnvironmentStringsA(path, buf, buf.length) == 0
-          Chef::ReservedNames::Win32::Error.raise!
-        end
-        buf.strip
-      end
-    end
-  end
-end

data/lib/chef/provider/dsc_script.rb

@@ -1,175 +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/configuration_generator'
-require 'chef/util/dsc/local_configuration_manager'
-
-class Chef
-  class Provider
-    class DscScript < Chef::Provider
-      def initialize(dsc_resource, run_context)
-        super(dsc_resource, run_context)
-        @dsc_resource = dsc_resource
-        @resource_converged = false
-        @operations = {
-          :set => Proc.new { |config_manager, document|
-            config_manager.set_configuration(document)
-          },
-          :test => Proc.new { |config_manager, document|
-            config_manager.test_configuration(document)
-          }}
-      end
-
-      def action_run
-        if ! @resource_converged
-          converge_by(generate_description) do
-            run_configuration(:set)
-            Chef::Log.info("DSC resource configuration completed successfully")
-          end
-        end
-      end
-
-      def load_current_resource
-        if supports_dsc?
-          @dsc_resources_info = run_configuration(:test)
-          @resource_converged = @dsc_resources_info.all? do |resource|
-            !resource.changes_state?
-          end
-        end
-      end
-
-      def whyrun_supported?
-        true
-      end
-
-      def define_resource_requirements
-        requirements.assert(:run) do |a|
-          err = [
-            'Could not find PowerShell DSC support on the system',
-            powershell_info_str,
-            "Powershell 4.0 or higher was not detected on your system and is required to use the dsc_script resource.",
-          ]
-          a.assertion { supports_dsc? }
-          a.failure_message Chef::Exceptions::NoProviderAvailable, err.join(' ')
-          a.whyrun err + ["Assuming a previous resource installs Powershell 4.0 or higher."]
-          a.block_action!
-        end
-      end
-
-      protected
-
-      def supports_dsc?
-        run_context && Chef::Platform.supports_dsc?(node)
-      end
-
-      def run_configuration(operation)
-        config_directory = ::Dir.mktmpdir("chef-dsc-script")
-        configuration_data_path = get_configuration_data_path(config_directory)
-        configuration_flags = get_augmented_configuration_flags(configuration_data_path)
-
-        config_manager = Chef::Util::DSC::LocalConfigurationManager.new(@run_context.node, config_directory)
-
-        begin
-          configuration_document = generate_configuration_document(config_directory, configuration_flags)
-          @operations[operation].call(config_manager, configuration_document)
-        rescue Exception => e
-          Chef::Log.error("DSC operation failed: #{e.message.to_s}")
-          raise e
-        ensure
-          ::FileUtils.rm_rf(config_directory)
-        end
-      end
-
-      def get_augmented_configuration_flags(configuration_data_path)
-        updated_flags = @dsc_resource.flags.nil? ? {} : @dsc_resource.flags.dup
-        if configuration_data_path
-          Chef::Util::PathHelper.validate_path(configuration_data_path)
-          updated_flags[:configurationdata] = configuration_data_path
-        end
-        updated_flags
-      end
-
-      def generate_configuration_document(config_directory, configuration_flags)
-        shellout_flags = {
-          :cwd => @dsc_resource.cwd,
-          :environment => @dsc_resource.environment,
-          :timeout => @dsc_resource.timeout
-        }
-
-        generator = Chef::Util::DSC::ConfigurationGenerator.new(@run_context.node, config_directory)
-
-        if @dsc_resource.command
-          generator.configuration_document_from_script_path(@dsc_resource.command, configuration_name, configuration_flags, shellout_flags)
-        else
-          # If code is also not provided, we mimic what the other script resources do (execute nothing)
-          Chef::Log.warn("Neither code or command were provided for dsc_resource[#{@dsc_resource.name}].") unless @dsc_resource.code
-          generator.configuration_document_from_script_code(@dsc_resource.code || '', configuration_flags, shellout_flags)
-        end
-      end
-
-      def get_configuration_data_path(config_directory)
-        if @dsc_resource.configuration_data_script
-          @dsc_resource.configuration_data_script
-        elsif @dsc_resource.configuration_data
-          configuration_data_path = "#{config_directory}/chef_dsc_config_data.psd1"
-          ::File.open(configuration_data_path, 'wt') do | script |
-            script.write(@dsc_resource.configuration_data)
-          end
-          configuration_data_path
-        end
-      end
-
-      def configuration_name
-        @dsc_resource.configuration_name || @dsc_resource.name
-      end
-
-      def configuration_friendly_name
-        if @dsc_resource.code
-          @dsc_resource.name
-        else
-          configuration_name
-        end
-      end
-
-      private
-
-      def generate_description
-        ["converge DSC configuration '#{configuration_friendly_name}'"] +
-          @dsc_resources_info.map do |resource|
-            if resource.changes_state?
-              # We ignore the last log message because it only contains the time it took, which looks weird
-              cleaned_messages = resource.change_log[0..-2].map { |c| c.sub(/^#{Regexp.escape(resource.name)}/, '').strip }
-              "converge DSC resource #{resource.name} by #{cleaned_messages.find_all{ |c| c != ''}.join("\n")}"
-            else
-              # This is needed because a dsc script can have resouces that are both converged and not
-              "converge DSC resource #{resource.name} by doing nothing because it is already converged"
-            end
-          end
-      end
-
-      def powershell_info_str
-        if run_context && run_context.node[:languages] && run_context.node[:languages][:powershell]
-          install_info = "Powershell #{run_context.node[:languages][:powershell][:version]} was found on the system."
-        else
-          install_info = 'Powershell was not found.'
-        end
-      end
-    end
-  end
-end

data/lib/chef/resource/dsc_script.rb

@@ -1,126 +0,0 @@
-#
-# Author:: Adam Edwards (<adamed@getchef.com>)
-# 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/exceptions'
-
-class Chef
-  class Resource
-    class DscScript < Chef::Resource
-
-      provides :dsc_script, :on_platforms => ["windows"]
-
-      def initialize(name, run_context=nil)
-        super
-        @allowed_actions.push(:run)
-        @action = :run
-        @provider = Chef::Provider::DscScript
-        @resource_name = :dsc_script
-      end
-
-      def code(arg=nil)
-        if arg && command
-          raise ArgumentError, "Only one of 'code' and 'command' attributes may be specified"
-        end
-        if arg && configuration_name
-          raise ArgumentError, "The 'code' and 'command' attributes may not be used together"
-        end
-        set_or_return(
-          :code,
-          arg,
-          :kind_of => [ String ]
-        )
-      end
-
-      def configuration_name(arg=nil)
-        if arg && code
-          raise ArgumentError, "Attribute `configuration_name` may not be set if `code` is set"
-        end
-        set_or_return(
-          :configuration_name,
-          arg,
-          :kind_of => [ String ]
-        )
-      end
-
-      def command(arg=nil)
-        if arg && code
-          raise ArgumentError, "The 'code' and 'command' attributes may not be used together"
-        end
-        set_or_return(
-          :command,
-          arg,
-          :kind_of => [ String ]
-        )
-      end
-
-      def configuration_data(arg=nil)
-        if arg && configuration_data_script
-          raise ArgumentError, "The 'configuration_data' and 'configuration_data_script' attributes may not be used together"
-        end
-        set_or_return(
-          :configuration_data,
-          arg,
-          :kind_of => [ String ]
-        )
-      end
-
-      def configuration_data_script(arg=nil)
-        if arg && configuration_data
-          raise ArgumentError, "The 'configuration_data' and 'configuration_data_script' attributes may not be used together"
-        end
-        set_or_return(
-          :configuration_data_script,
-          arg,
-          :kind_of => [ String ]
-        )
-      end
-
-      def flags(arg=nil)
-        set_or_return(
-          :flags,
-          arg,
-          :kind_of => [ Hash ]
-        )
-      end
-
-      def cwd(arg=nil)
-        set_or_return(
-          :cwd,
-          arg,
-          :kind_of => [ String ]
-        )
-      end
-
-      def environment(arg=nil)
-        set_or_return(
-          :environment,
-          arg,
-          :kind_of => [ Hash ]
-        )
-      end
-
-      def timeout(arg=nil)
-        set_or_return(
-          :timeout,
-          arg,
-          :kind_of => [ Integer ]
-        )
-      end
-    end
-  end
-end

data/lib/chef/streaming_cookbook_uploader.rb

@@ -1,205 +0,0 @@
-# inspired by/cargo-culted from http://stanislavvitvitskiy.blogspot.com/2008/12/multipart-post-in-ruby.html
-# On Apr 6, 2010, at 3:00 PM, Stanislav Vitvitskiy wrote:
-#
-# It's free to use / modify / distribute. No need to mention anything. Just copy/paste and use.
-#
-# Regards,
-# Stan
-
-require 'net/http'
-require 'mixlib/authentication/signedheaderauth'
-require 'openssl'
-require 'chef/version'
-
-class Chef
-  class StreamingCookbookUploader
-
-    DefaultHeaders = { 'accept' => 'application/json', 'x-chef-version' => ::Chef::VERSION }
-
-    class << self
-
-      def post(to_url, user_id, secret_key_filename, params = {}, headers = {})
-        make_request(:post, to_url, user_id, secret_key_filename, params, headers)
-      end
-
-      def put(to_url, user_id, secret_key_filename, params = {}, headers = {})
-        make_request(:put, to_url, user_id, secret_key_filename, params, headers)
-      end
-
-      def make_request(http_verb, to_url, user_id, secret_key_filename, params = {}, headers = {})
-        Chef::Log.warn('[DEPRECATED] StreamingCookbookUploader class is deprecated. It will be removed in Chef 12. Please use CookbookSiteStreamingUploader instead.')
-        boundary = '----RubyMultipartClient' + rand(1000000).to_s + 'ZZZZZ'
-        parts = []
-        content_file = nil
-
-        timestamp = Time.now.utc.iso8601
-        secret_key = OpenSSL::PKey::RSA.new(File.read(secret_key_filename))
-
-        unless params.nil? || params.empty?
-          params.each do |key, value|
-            if value.kind_of?(File)
-              content_file = value
-              filepath = value.path
-              filename = File.basename(filepath)
-              parts << StringPart.new( "--" + boundary + "\r\n" +
-                                       "Content-Disposition: form-data; name=\"" + key.to_s + "\"; filename=\"" + filename + "\"\r\n" +
-                                       "Content-Type: application/octet-stream\r\n\r\n")
-              parts << StreamPart.new(value, File.size(filepath))
-              parts << StringPart.new("\r\n")
-            else
-              parts << StringPart.new( "--" + boundary + "\r\n" +
-                                       "Content-Disposition: form-data; name=\"" + key.to_s + "\"\r\n\r\n")
-              parts << StringPart.new(value.to_s + "\r\n")
-            end
-          end
-          parts << StringPart.new("--" + boundary + "--\r\n")
-        end
-
-        body_stream = MultipartStream.new(parts)
-
-        timestamp = Time.now.utc.iso8601
-
-        url = URI.parse(to_url)
-
-        Chef::Log.logger.debug("Signing: method: #{http_verb}, path: #{url.path}, file: #{content_file}, User-id: #{user_id}, Timestamp: #{timestamp}")
-
-        # We use the body for signing the request if the file parameter
-        # wasn't a valid file or wasn't included. Extract the body (with
-        # multi-part delimiters intact) to sign the request.
-        # TODO: tim: 2009-12-28: It'd be nice to remove this special case, and
-        # always hash the entire request body. In the file case it would just be
-        # expanded multipart text - the entire body of the POST.
-        content_body = parts.inject("") { |result,part| result + part.read(0, part.size) }
-        content_file.rewind if content_file # we consumed the file for the above operation, so rewind it.
-
-        signing_options = {
-          :http_method=>http_verb,
-          :path=>url.path,
-          :user_id=>user_id,
-          :timestamp=>timestamp}
-        (content_file && signing_options[:file] = content_file) || (signing_options[:body] = (content_body || ""))
-
-        headers.merge!(Mixlib::Authentication::SignedHeaderAuth.signing_object(signing_options).sign(secret_key))
-
-        content_file.rewind if content_file
-
-        # net/http doesn't like symbols for header keys, so we'll to_s each one just in case
-        headers = DefaultHeaders.merge(Hash[*headers.map{ |k,v| [k.to_s, v] }.flatten])
-
-        req = case http_verb
-              when :put
-                Net::HTTP::Put.new(url.path, headers)
-              when :post
-                Net::HTTP::Post.new(url.path, headers)
-              end
-        req.content_length = body_stream.size
-        req.content_type = 'multipart/form-data; boundary=' + boundary unless parts.empty?
-        req.body_stream = body_stream
-
-        http = Net::HTTP.new(url.host, url.port)
-        if url.scheme == "https"
-          http.use_ssl = true
-          http.verify_mode = OpenSSL::SSL::VERIFY_NONE
-        end
-        res = http.request(req)
-        #res = http.start {|http_proc| http_proc.request(req) }
-
-        # alias status to code and to_s to body for test purposes
-        # TODO: stop the following madness!
-        class << res
-          alias :to_s :body
-
-          # BUGBUG this makes the response compatible with what respsonse_steps expects to test headers (response.headers[] -> response[])
-          def headers
-            self
-          end
-
-          def status
-            code.to_i
-          end
-        end
-        res
-      end
-
-    end
-
-    class StreamPart
-      def initialize(stream, size)
-        Chef::Log.warn('[DEPRECATED] StreamingCookbookUploader::StreamPart class is deprecated. It will be removed in Chef 12. Please use CookbookSiteStreamingUploader::StreamPart instead.')
-        @stream, @size = stream, size
-      end
-
-      def size
-        @size
-      end
-
-      # read the specified amount from the stream
-      def read(offset, how_much)
-        @stream.read(how_much)
-      end
-    end
-
-    class StringPart
-      def initialize(str)
-        Chef::Log.warn('[DEPRECATED] StreamingCookbookUploader::StringPart class is deprecated. It will be removed in Chef 12. Please use CookbookSiteStreamingUploader::StringPart instead.')
-        @str = str
-      end
-
-      def size
-        @str.length
-      end
-
-      # read the specified amount from the string startiung at the offset
-      def read(offset, how_much)
-        @str[offset, how_much]
-      end
-    end
-
-    class MultipartStream
-      def initialize(parts)
-        Chef::Log.warn('[DEPRECATED] StreamingCookbookUploader::MultipartStream class is deprecated. It will be removed in Chef 12. Please use CookbookSiteStreamingUploader::MultipartStream instead.')
-        @parts = parts
-        @part_no = 0
-        @part_offset = 0
-      end
-
-      def size
-        @parts.inject(0) {|size, part| size + part.size}
-      end
-
-      def read(how_much)
-        return nil if @part_no >= @parts.size
-
-        how_much_current_part = @parts[@part_no].size - @part_offset
-
-        how_much_current_part = if how_much_current_part > how_much
-                                  how_much
-                                else
-                                  how_much_current_part
-                                end
-
-        how_much_next_part = how_much - how_much_current_part
-
-        current_part = @parts[@part_no].read(@part_offset, how_much_current_part)
-
-        # recurse into the next part if the current one was not large enough
-        if how_much_next_part > 0
-          @part_no += 1
-          @part_offset = 0
-          next_part = read(how_much_next_part)
-          current_part + if next_part
-                           next_part
-                         else
-                           ''
-                         end
-        else
-          @part_offset += how_much_current_part
-          current_part
-        end
-      end
-    end
-
-  end
-
-
-end