chef 16.4.41-universal-mingw32 → 16.8.9-universal-mingw32

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

@@ -1,173 +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 "mixlib/shellout" unless defined?(Mixlib::ShellOut::DEFAULT_READ_TIMEOUT)
-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
-            @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} 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
-              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}`. 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/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/integration/knife/config_get_profile_spec.rb

@@ -1,114 +0,0 @@
-#
-# Copyright 2018, Noah Kantrowitz
-#
-# 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 "spec_helper"
-require "support/shared/integration/integration_helper"
-require "support/shared/context/config"
-
-describe "knife config get-profile", :workstation do
-  include IntegrationSupport
-  include KnifeSupport
-
-  include_context "default config options"
-
-  let(:cmd_args) { [] }
-
-  when_the_repository("has a custom env") do
-    subject do
-      cmd = knife("config", "get-profile", *cmd_args, instance_filter: lambda { |instance|
-        # Fake the failsafe check because this command doesn't actually process knife.rb.
-        $__KNIFE_INTEGRATION_FAILSAFE_CHECK << " ole"
-      })
-      cmd.stdout
-    end
-
-    around do |ex|
-      # Store and reset the value of some env vars.
-      old_chef_home = ENV["CHEF_HOME"]
-      old_knife_home = ENV["KNIFE_HOME"]
-      old_home = ENV["HOME"]
-      old_wd = Dir.pwd
-      ChefConfig::PathHelper.per_tool_home_environment = "KNIFE_HOME"
-      # Clear these out because they are cached permanently.
-      ChefConfig::PathHelper.class_exec { remove_class_variable(:@@home_dir) }
-      Chef::Knife::ConfigGetProfile.reset_config_loader!
-      begin
-        ex.run
-      ensure
-        ENV["CHEF_HOME"] = old_chef_home
-        ENV["KNIFE_HOME"] = old_knife_home
-        ENV["HOME"] = old_home
-        Dir.chdir(old_wd)
-        ENV[ChefUtils.windows? ? "CD" : "PWD"] = Dir.pwd
-        ChefConfig::PathHelper.per_tool_home_environment = nil
-      end
-    end
-
-    before do
-      # Always run from the temp folder. This can't be in the `around` block above
-      # because it has to run after the before set in the "with a chef repo" shared context.
-      directory("repo")
-      Dir.chdir(path_to("repo"))
-      ENV[ChefUtils.windows? ? "CD" : "PWD"] = Dir.pwd
-      ENV["HOME"] = path_to(".")
-    end
-
-    context "with no configuration" do
-      it { is_expected.to eq "default\n" }
-    end
-
-    context "with --profile" do
-      let(:cmd_args) { %w{--profile production} }
-      it { is_expected.to eq "production\n" }
-    end
-
-    context "with an environment variable" do
-      around do |ex|
-        old_chef_profile = ENV["CHEF_PROFILE"]
-        begin
-          ENV["CHEF_PROFILE"] = "staging"
-          ex.run
-        ensure
-          ENV["CHEF_PROFILE"] = old_chef_profile
-        end
-      end
-
-      it { is_expected.to eq "staging\n" }
-    end
-
-    context "with a context file" do
-      before { file(".chef/context", "development\n") }
-      it { is_expected.to eq "development\n" }
-    end
-
-    context "with a context file under $CHEF_HOME" do
-      before do
-        file("chefhome/.chef/context", "other\n")
-        ENV["CHEF_HOME"] = path_to("chefhome")
-      end
-
-      it { is_expected.to eq "other\n" }
-    end
-
-    context "with a context file under $KNIFE_HOME" do
-      before do
-        file("knifehome/.chef/context", "other\n")
-        ENV["KNIFE_HOME"] = path_to("knifehome")
-      end
-
-      it { is_expected.to eq "other\n" }
-    end
-  end
-end