chef 16.7.61-universal-mingw32 → 16.9.20-universal-mingw32

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

@@ -1,169 +0,0 @@
-#
-# Author:: Adam Edwards (<adamed@chef.io>)
-#
-# Copyright:: Copyright (c) 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.
-#
-
-module Mixlib
-  autoload :ShellOut, "mixlib/shellout"
-end
-require_relative "../../mixin/windows_architecture_helper"
-require_relative "cmdlet_result"
-
-class Chef
-  class Util
-    class Powershell
-      class Cmdlet
-        def initialize(node, cmdlet, output_format = nil, output_format_options = {})
-          @output_format = output_format
-          @node = node
-
-          case output_format
-          when nil, :text
-            @json_format = false
-          when :json, :object
-            @json_format = true
-          else
-            raise ArgumentError, "Invalid output format #{output_format} specified"
-          end
-
-          @cmdlet = cmdlet
-          @output_format_options = output_format_options
-        end
-
-        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)
-
-          json_depth = 5
-
-          if @json_format && @output_format_options.key?(:depth)
-            json_depth = @output_format_options[:depth]
-          end
-
-          json_command = if @json_format
-                           " | convertto-json -compress -depth #{json_depth} > #{streams[:json].path}"
-                         else
-                           ""
-                         end
-          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)
-
-          status = nil
-
-          with_os_architecture(@node) do
-            status = command.run_command
-          end
-
-          CmdletResult.new(status, streams, @output_format)
-        end
-
-        def run!(switches = {}, execution_options = {}, *arguments)
-          result = run(switches, execution_options, arguments)
-
-          unless 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 =~ /\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}'. The switch must be specified as a Symbol'"
-            end
-
-            validate_switch_name!(switch_name)
-
-            switch_argument = ""
-            switch_present = true
-
-            case switch_value
-            when Numeric, 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}`. 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
-
-        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.exist? name }
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,61 +0,0 @@
-#
-# Author:: Adam Edwards (<adamed@chef.io>)
-#
-# Copyright:: Copyright (c) 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_relative "../../json_compat"
-
-class Chef
-  class Util
-    class Powershell
-      class CmdletResult
-        attr_reader :output_format
-
-        def initialize(status, streams, output_format)
-          @status = status
-          @output_format = output_format
-          @streams = streams
-        end
-
-        def stdout
-          @status.stdout
-        end
-
-        def stderr
-          @status.stderr
-        end
-
-        def stream(name)
-          @streams[name].read
-        end
-
-        def return_value
-          if output_format == :object
-            Chef::JSONCompat.parse(stream(:json))
-          elsif output_format == :json
-            stream(:json)
-          else
-            @status.stdout
-          end
-        end
-
-        def succeeded?
-          @succeeded = @status.status.exitstatus == 0
-        end
-      end
-    end
-  end
-end

data/spec/data/trusted_certs_empty/README.md

@@ -1 +0,0 @@
-A directory with no certs. Used for testing directories with no certs during bootstrap.

data/spec/functional/util/powershell/cmdlet_spec.rb

@@ -1,111 +0,0 @@
-#
-# Author:: Adam Edwards (<adamed@chef.io>)
-#
-# Copyright:: Copyright (c) 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/json_compat"
-require "spec_helper"
-
-describe Chef::Util::Powershell::Cmdlet, :windows_powershell_dsc_only do
-  before(:all) do
-    @node = Chef::Node.new
-    @node.consume_external_attrs(OHAI_SYSTEM.data, {})
-  end
-  let(:cmd_output_format) { :text }
-  let(:simple_cmdlet) { Chef::Util::Powershell::Cmdlet.new(@node, "get-childitem", cmd_output_format, { depth: 2 }) }
-  let(:invalid_cmdlet) { Chef::Util::Powershell::Cmdlet.new(@node, "get-idontexist", cmd_output_format) }
-  let(:cmdlet_get_item_requires_switch_or_argument) { Chef::Util::Powershell::Cmdlet.new(@node, "get-item", cmd_output_format, { depth: 2 }) }
-  let(:cmdlet_alias_requires_switch_or_argument) { Chef::Util::Powershell::Cmdlet.new(@node, "alias", cmd_output_format, { depth: 2 }) }
-  let(:etc_directory) { "#{ENV["systemroot"]}\\system32\\drivers\\etc" }
-  let(:architecture_cmdlet) { Chef::Util::Powershell::Cmdlet.new(@node, "$env:PROCESSOR_ARCHITECTURE") }
-
-  it "executes a simple process" do
-    result = simple_cmdlet.run
-    expect(result.succeeded?).to eq(true)
-  end
-
-  it "#run does not raise a PowershellCmdletException exception if the command cannot be executed" do
-    expect { invalid_cmdlet.run }.not_to raise_error
-  end
-
-  it "#run! raises a PowershellCmdletException exception if the command cannot be executed" do
-    expect { invalid_cmdlet.run! }.to raise_error(Chef::Exceptions::PowershellCmdletException)
-  end
-
-  it "executes a 64-bit command on a 64-bit OS, 32-bit otherwise" do
-    os_arch = ENV["PROCESSOR_ARCHITEW6432"]
-    if os_arch.nil?
-      os_arch = ENV["PROCESSOR_ARCHITECTURE"]
-    end
-
-    result = architecture_cmdlet.run
-    execution_arch = result.return_value
-    execution_arch.strip!
-    expect(execution_arch).to eq(os_arch)
-  end
-
-  it "passes command line switches to the command" do
-    result = cmdlet_alias_requires_switch_or_argument.run({ name: "ls" })
-    expect(result.succeeded?).to eq(true)
-  end
-
-  it "passes command line arguments to the command" do
-    result = cmdlet_alias_requires_switch_or_argument.run({}, {}, "ls")
-    expect(result.succeeded?).to eq(true)
-  end
-
-  it "passes command line arguments and switches to the command" do
-    result = cmdlet_get_item_requires_switch_or_argument.run({ path: etc_directory }, {}, " | select-object -property fullname | format-table -hidetableheaders")
-    expect(result.succeeded?).to eq(true)
-    returned_directory = result.return_value
-    returned_directory.strip!
-    expect(returned_directory).to eq(etc_directory)
-  end
-
-  it "passes execution options to the command" do
-    result = cmdlet_get_item_requires_switch_or_argument.run({}, { cwd: etc_directory }, ". | select-object -property fullname | format-table -hidetableheaders")
-    expect(result.succeeded?).to eq(true)
-    returned_directory = result.return_value
-    returned_directory.strip!
-    expect(returned_directory).to eq(etc_directory)
-  end
-
-  context "when returning json" do
-    let(:cmd_output_format) { :json }
-    it "returns json format data" do
-      result = cmdlet_alias_requires_switch_or_argument.run({}, {}, "ls")
-      expect(result.succeeded?).to eq(true)
-      expect { Chef::JSONCompat.parse(result.return_value) }.not_to raise_error
-    end
-  end
-
-  context "when returning Ruby objects" do
-    let(:cmd_output_format) { :object }
-    it "returns object format data" do
-      result = simple_cmdlet.run({}, { cwd: etc_directory }, "hosts")
-      expect(result.succeeded?).to eq(true)
-      data = result.return_value
-      expect(data["Name"]).to eq("hosts")
-    end
-  end
-
-  context "when constructor is given invalid arguments" do
-    let(:cmd_output_format) { :invalid }
-    it "throws an exception if an invalid format is passed to the constructor" do
-      expect { simple_cmdlet }.to raise_error(ArgumentError)
-    end
-  end
-end

data/spec/scripts/ssl-serve.rb

@@ -1,47 +0,0 @@
-# ssl-serve.rb
-# USAGE: ruby ssl-serve.rb
-#
-# ssl-serve is a script that serves a local directory over SSL.
-# You can use it to test various HTTP behaviors in chef, like chef-client's
-# `-j` and `-c` options and remote_file with https connections.
-#
-require "pp"
-require "openssl"
-require "webrick"
-require "webrick/https"
-
-$ssl = true
-
-CHEF_SPEC_DATA = File.expand_path("../data", __dir__)
-cert_text = File.read(File.expand_path("ssl/chef-rspec.cert", CHEF_SPEC_DATA))
-cert = OpenSSL::X509::Certificate.new(cert_text)
-key_text = File.read(File.expand_path("ssl/chef-rspec.key", CHEF_SPEC_DATA))
-key = OpenSSL::PKey::RSA.new(key_text)
-
-server_opts = {}
-if $ssl
-  server_opts.merge!( { SSLEnable: true,
-                        SSLVerifyClient: OpenSSL::SSL::VERIFY_NONE,
-                        SSLCertificate: cert,
-                        SSLPrivateKey: key })
-end
-
-# 5 == debug, 3 == warning
-LOGGER = WEBrick::Log.new(STDOUT, 5)
-DEFAULT_OPTIONS = {
-  server: "webrick",
-  Port: 9000,
-  Host: "localhost",
-  environment: :none,
-  Logger: LOGGER,
-  DocumentRoot: File.expand_path("#{Dir.tmpdir}/chef-118-sampledata"),
-  #:AccessLog => [] # Remove this option to enable the access log when debugging.
-}.freeze
-
-webrick_opts = DEFAULT_OPTIONS.merge(server_opts)
-pp webrick_opts: webrick_opts
-
-server = WEBrick::HTTPServer.new(webrick_opts)
-trap("INT") { server.shutdown }
-
-server.start

data/spec/unit/util/powershell/cmdlet_spec.rb

@@ -1,106 +0,0 @@
-#
-# Author:: Jay Mundrawala <jdm@chef.io>
-# Copyright:: Copyright (c) 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"
-require "chef/util/powershell/cmdlet"
-
-describe Chef::Util::Powershell::Cmdlet do
-  before (:all) do
-    @node = Chef::Node.new
-    @cmdlet = Chef::Util::Powershell::Cmdlet.new(@node, "Some-Commandlet")
-  end
-
-  describe "#validate_switch_name!" do
-    it "should not raise an error if a name contains all upper case letters" do
-      @cmdlet.send(:validate_switch_name!, "HELLO")
-    end
-
-    it "should not raise an error if the name contains all lower case letters" do
-      @cmdlet.send(:validate_switch_name!, "hello")
-    end
-
-    it "should not raise an error if no special characters are used except _" do
-      @cmdlet.send(:validate_switch_name!, "hello_world")
-    end
-
-    %w{! @ # $ % ^ & * & * ( ) - = + \{ \} . ? < > \\ /}.each do |sym|
-      it "raises an Argument error if it configuration name contains #{sym}" do
-        expect do
-          @cmdlet.send(:validate_switch_name!, "Hello#{sym}")
-        end.to raise_error(ArgumentError)
-      end
-    end
-  end
-
-  describe "#escape_parameter_value" do
-    # Is this list really complete?
-    %w{` " # '}.each do |c|
-      it "escapse #{c}" do
-        expect(@cmdlet.send(:escape_parameter_value, "stuff #{c}")).to eql("stuff `#{c}")
-      end
-    end
-
-    it "does not do anything to a string without special characters" do
-      expect(@cmdlet.send(:escape_parameter_value, "stuff")).to eql("stuff")
-    end
-  end
-
-  describe "#escape_string_parameter_value" do
-    it "surrounds a string with ''" do
-      expect(@cmdlet.send(:escape_string_parameter_value, "stuff")).to eql("'stuff'")
-    end
-  end
-
-  describe "#command_switches_string" do
-    it "raises an ArgumentError if the key is not a symbol" do
-      expect do
-        @cmdlet.send(:command_switches_string, { "foo" => "bar" })
-      end.to raise_error(ArgumentError)
-    end
-
-    it "does not allow invalid switch names" do
-      expect do
-        @cmdlet.send(:command_switches_string, { foo!: "bar" })
-      end.to raise_error(ArgumentError)
-    end
-
-    it "ignores switches with a false value" do
-      expect(@cmdlet.send(:command_switches_string, { foo: false })).to eql("")
-    end
-
-    it "should correctly handle a value type of string" do
-      expect(@cmdlet.send(:command_switches_string, { foo: "bar" })).to eql("-foo 'bar'")
-    end
-
-    it "should correctly handle a value type of string even when it is 0 length" do
-      expect(@cmdlet.send(:command_switches_string, { foo: "" })).to eql("-foo ''")
-    end
-
-    it "should not quote integers" do
-      expect(@cmdlet.send(:command_switches_string, { foo: 1 })).to eql("-foo 1")
-    end
-
-    it "should not quote floats" do
-      expect(@cmdlet.send(:command_switches_string, { foo: 1.0 })).to eql("-foo 1.0")
-    end
-
-    it "has just the switch when the value is true" do
-      expect(@cmdlet.send(:command_switches_string, { foo: true })).to eql("-foo")
-    end
-  end
-end