knife-windows 1.9.6 → 3.0.3

data/lib/knife-windows/path_helper.rb

@@ -1,242 +0,0 @@
-#
-# Author:: Bryan McLellan <btm@loftninjas.org>
-# Copyright:: Copyright (c) 2014-2016 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.
-#
-
-# Sourced from Chef::Util::PathHelper.
-# Should be removed when Chef 11 catches up or we stop supporting Chef 11
-
-module Knife
-  module Windows
-    class PathHelper
-      # Maximum characters in a standard Windows path (260 including drive letter and NUL)
-      WIN_MAX_PATH = 259
-
-      def self.dirname(path)
-        if Chef::Platform.windows?
-          # Find the first slash, not counting trailing slashes
-          end_slash = path.size
-          while true
-            slash = path.rindex(/[#{Regexp.escape(File::SEPARATOR)}#{Regexp.escape(path_separator)}]/, end_slash - 1)
-            if !slash
-              return end_slash == path.size ? '.' : path_separator
-            elsif slash == end_slash - 1
-              end_slash = slash
-            else
-              return path[0..slash-1]
-            end
-          end
-        else
-          ::File.dirname(path)
-        end
-      end
-
-      BACKSLASH = '\\'.freeze
-
-      def self.path_separator
-        if Chef::Platform.windows?
-          File::ALT_SEPARATOR || BACKSLASH
-        else
-          File::SEPARATOR
-        end
-      end
-
-      def self.join(*args)
-        args.flatten.inject do |joined_path, component|
-          # Joined path ends with /
-          joined_path = joined_path.sub(/[#{Regexp.escape(File::SEPARATOR)}#{Regexp.escape(path_separator)}]+$/, '')
-          component = component.sub(/^[#{Regexp.escape(File::SEPARATOR)}#{Regexp.escape(path_separator)}]+/, '')
-          joined_path += "#{path_separator}#{component}"
-        end
-      end
-
-      def self.validate_path(path)
-        if Chef::Platform.windows?
-          unless printable?(path)
-            msg = "Path '#{path}' contains non-printable characters. Check that backslashes are escaped with another backslash (e.g. C:\\\\Windows) in double-quoted strings."
-            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, "\\\\?\\")
-          end
-        end
-
-        path
-      end
-
-      def self.windows_max_length_exceeded?(path)
-        # Check to see if paths without the \\?\ prefix are over the maximum allowed length for the Windows API
-        # http://msdn.microsoft.com/en-us/library/windows/desktop/aa365247%28v=vs.85%29.aspx
-        unless path =~ /^\\\\?\\/
-          if path.length > WIN_MAX_PATH
-            return true
-          end
-        end
-
-        false
-      end
-
-      def self.printable?(string)
-        # returns true if string is free of non-printable characters (escape sequences)
-        # this returns false for whitespace escape sequences as well, e.g. \n\t
-        if string =~ /[^[:print:]]/
-          false
-        else
-          true
-        end
-      end
-
-      # Produces a comparable path.
-      def self.canonical_path(path, add_prefix=true)
-        # Rather than find an equivalent for File.absolute_path on 1.8.7, just bail out
-        raise NotImplementedError, "This feature is not supported on Ruby versions < 1.9" if RUBY_VERSION.to_f < 1.9
-
-        # First remove extra separators and resolve any relative paths
-        abs_path = File.absolute_path(path)
-
-        if Chef::Platform.windows?
-          # Add the \\?\ API prefix on Windows unless add_prefix is false
-          # Downcase on Windows where paths are still case-insensitive
-          abs_path.gsub!(::File::SEPARATOR, path_separator)
-          if add_prefix && abs_path !~ /^\\\\?\\/
-            abs_path.insert(0, "\\\\?\\")
-          end
-
-          abs_path.downcase!
-        end
-
-        abs_path
-      end
-
-      def self.cleanpath(path)
-        path = Pathname.new(path).cleanpath.to_s
-        # ensure all forward slashes are backslashes
-        if Chef::Platform.windows?
-          path = path.gsub(File::SEPARATOR, path_separator)
-        end
-        path
-      end
-
-      def self.paths_eql?(path1, path2)
-        canonical_path(path1) == canonical_path(path2)
-      end
-
-      # Note: this method is deprecated. Please use escape_glob_dirs
-      # Paths which may contain glob-reserved characters need
-      # to be escaped before globbing can be done.
-      # http://stackoverflow.com/questions/14127343
-      def self.escape_glob(*parts)
-        path = cleanpath(join(*parts))
-        path.gsub(/[\\\{\}\[\]\*\?]/) { |x| "\\"+x }
-      end
-
-      # This function does not switch to backslashes for windows
-      # This is because only forwardslashes should be used with dir (even for windows)
-      def self.escape_glob_dir(*parts)
-        path = Pathname.new(join(*parts)).cleanpath.to_s
-        path.gsub(/[\\\{\}\[\]\*\?]/) { |x| "\\" + x }
-      end
-
-      def self.relative_path_from(from, to)
-        pathname = Pathname.new(Chef::Util::PathHelper.cleanpath(to)).relative_path_from(Pathname.new(Chef::Util::PathHelper.cleanpath(from)))
-      end
-
-      # Retrieves the "home directory" of the current user while trying to ascertain the existence
-      # of said directory.  The path returned uses / for all separators (the ruby standard format).
-      # If the home directory doesn't exist or an error is otherwise encountered, nil is returned.
-      #
-      # If a set of path elements is provided, they are appended as-is to the home path if the
-      # homepath exists.
-      #
-      # If an optional block is provided, the joined path is passed to that block if the home path is
-      # valid and the result of the block is returned instead.
-      #
-      # Home-path discovery is performed once.  If a path is discovered, that value is memoized so
-      # that subsequent calls to home_dir don't bounce around.
-      #
-      # See self.all_homes.
-      def self.home(*args)
-        @@home_dir ||= self.all_homes { |p| break p }
-        if @@home_dir
-          path = File.join(@@home_dir, *args)
-          block_given? ? (yield path) : path
-        end
-      end
-
-      # See self.home.  This method performs a similar operation except that it yields all the different
-      # possible values of 'HOME' that one could have on this platform.  Hence, on windows, if
-      # HOMEDRIVE\HOMEPATH and USERPROFILE are different, the provided block will be called twice.
-      # This method goes out and checks the existence of each location at the time of the call.
-      #
-      # The return is a list of all the returned values from each block invocation or a list of paths
-      # if no block is provided.
-      def self.all_homes(*args)
-        paths = []
-        if Chef::Platform.windows?
-          # By default, Ruby uses the the following environment variables to determine Dir.home:
-          # HOME
-          # HOMEDRIVE HOMEPATH
-          # USERPROFILE
-          # Ruby only checks to see if the variable is specified - not if the directory actually exists.
-          # On Windows, HOMEDRIVE HOMEPATH can point to a different location (such as an unavailable network mounted drive)
-          # while USERPROFILE points to the location where the user application settings and profile are stored.  HOME
-          # is not defined as an environment variable (usually).  If the home path actually uses UNC, then the prefix is
-          # HOMESHARE instead of HOMEDRIVE.
-          #
-          # We instead walk down the following and only include paths that actually exist.
-          # HOME
-          # HOMEDRIVE HOMEPATH
-          # HOMESHARE HOMEPATH
-          # USERPROFILE
-
-          paths << ENV['HOME']
-          paths << ENV['HOMEDRIVE'] + ENV['HOMEPATH'] if ENV['HOMEDRIVE'] && ENV['HOMEPATH']
-          paths << ENV['HOMESHARE'] + ENV['HOMEPATH'] if ENV['HOMESHARE'] && ENV['HOMEPATH']
-          paths << ENV['USERPROFILE']
-        end
-        paths << Dir.home if ENV['HOME']
-
-        # Depending on what environment variables we're using, the slashes can go in any which way.
-        # Just change them all to / to keep things consistent.
-        # Note: Maybe this is a bad idea on some unixy systems where \ might be a valid character depending on
-        # the particular brand of kool-aid you consume.  This code assumes that \ and / are both
-        # path separators on any system being used.
-        paths = paths.map { |home_path| home_path.gsub(path_separator, ::File::SEPARATOR) if home_path }
-
-        # Filter out duplicate paths and paths that don't exist.
-        valid_paths = paths.select { |home_path| home_path && Dir.exists?(home_path) }
-        valid_paths = valid_paths.uniq
-
-        # Join all optional path elements at the end.
-        # If a block is provided, invoke it - otherwise just return what we've got.
-        joined_paths = valid_paths.map { |home_path| File.join(home_path, *args) }
-        if block_given?
-          joined_paths.each { |p| yield p }
-        else
-          joined_paths
-        end
-      end
-
-    end
-  end
-end
-
-# Break a require loop when require chef/util/path_helper
-require 'chef/platform'
-require 'chef/exceptions'

data/spec/functional/bootstrap_download_spec.rb

@@ -1,239 +0,0 @@
-#
-# Author:: Adam Edwards (<adamed@chef.io>)
-# Copyright:: Copyright (c) 2012-2016 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 'dummy_winrm_connection'
-require 'spec_helper'
-require 'tmpdir'
-
-# These test cases exercise the Knife::Windows knife plugin's ability
-# to download a bootstrap msi as part of the bootstrap process on
-# Windows nodes. The test modifies the Windows batch file generated
-# from an erb template in the plugin source in order to enable execution
-# of only the download functionality contained in the bootstrap template.
-# The test relies on knowledge of the fields of the template itself and
-# also on knowledge of the contents and structure of the Windows batch
-# file generated by the template.
-#
-# Note that if the bootstrap template changes substantially, the tests
-# should fail and will require re-implementation. If such changes
-# occur, the bootstrap code should be refactored to explicitly expose
-# the download funcitonality separately from other tasks to make the
-# test more robust.
-describe 'Knife::Windows::Core msi download functionality for knife Windows winrm bootstrap template' do
-
-  before(:all) do
-    # Since we're always running 32-bit Ruby, fix the
-    # PROCESSOR_ARCHITECTURE environment variable.
-
-    if ENV["PROCESSOR_ARCHITEW6432"]
-      ENV["PROCESSOR_ARCHITECTURE"] = ENV["PROCESSOR_ARCHITEW6432"]
-    end
-
-    # All file artifacts from this test will be written into this directory
-    @temp_directory = Dir.mktmpdir("bootstrap_test")
-
-    # Location to which the download script will be modified to write
-    # the downloaded msi
-    @local_file_download_destination = "#{@temp_directory}/chef-client-latest.msi"
-
-    source_code_directory = File.dirname(__FILE__)
-    @template_file_path ="#{source_code_directory}/../../lib/chef/knife/bootstrap/windows-chef-client-msi.erb"
-  end
-
-  after(:all) do
-    # Clear the temp directory upon exit
-    if Dir.exists?(@temp_directory)
-      FileUtils::remove_dir(@temp_directory)
-    end
-  end
-
-  describe "running on any version of the Windows OS", :windows_only do
-    let(:mock_bootstrap_context) { Chef::Knife::Core::WindowsBootstrapContext.new({ }, nil, { :knife => {} }) }
-    let(:mock_winrm) { Chef::Knife::Winrm.new }
-
-    before do
-      # Stub the bootstrap context and prevent config related sections
-      # from being populated, i.e. chef installation and first chef
-      # run sections
-      allow(mock_bootstrap_context).to receive(:validation_key).and_return("echo.validation_key")
-      allow(mock_bootstrap_context).to receive(:secret).and_return("echo.encrypted_data_bag_secret")
-      allow(mock_bootstrap_context).to receive(:config_content).and_return("echo.config_content")
-      allow(mock_bootstrap_context).to receive(:start_chef).and_return("echo.echo start_chef_command")
-      allow(mock_bootstrap_context).to receive(:run_list).and_return("echo.run_list")
-      allow(mock_bootstrap_context).to receive(:install_chef).and_return("echo.echo install_chef_command")
-
-      # Change the directories where bootstrap files will be created
-      allow(mock_bootstrap_context).to receive(:bootstrap_directory).and_return(@temp_directory.gsub(::File::SEPARATOR, ::File::ALT_SEPARATOR))
-      allow(mock_bootstrap_context).to receive(:local_download_path).and_return(@local_file_download_destination.gsub(::File::SEPARATOR, ::File::ALT_SEPARATOR))
-
-      # Prevent password prompt during bootstrap process
-      allow(mock_winrm.ui).to receive(:ask).and_return(nil)
-      allow(Chef::Knife::Winrm).to receive(:new).and_return(mock_winrm)
-
-      allow(Chef::Knife::Core::WindowsBootstrapContext).to receive(:new).and_return(mock_bootstrap_context)
-      Chef::Config[:knife] = {:winrm_transport => 'plaintext', :chef_node_name => 'foo.example.com', :winrm_authentication_protocol => 'negotiate'}
-    end
-
-    it "downloads the chef-client MSI from the default location during winrm bootstrap" do
-      run_download_scenario
-    end
-
-    context "when provided a custom msi_url to fetch from" do
-      let(:mock_bootstrap_context) { Chef::Knife::Core::WindowsBootstrapContext.new(
-        { :msi_url => "file:///C:/Windows/System32/xcopy.exe" }, nil, { :knife => {} }) }
-      it "downloads the chef-client MSI from a custom path during winrm bootstrap" do
-        run_download_scenario
-      end
-    end
-
-     context "when provided a custom msi_url with space in path to fetch from" do
-      let(:mock_bootstrap_context) { Chef::Knife::Core::WindowsBootstrapContext.new(
-        { :msi_url => "file:///C:/Program Files/Windows NT/Accessories/wordpad.exe" }, nil, { :knife => {} }) }
-      it "downloads the chef-client MSI from a custom path with spaces during winrm bootstrap" do
-        run_download_scenario
-      end
-    end
-  end
-
-  def download_succeeded?
-    File.exists?(@local_file_download_destination) && ! File.zero?(@local_file_download_destination)
-  end
-
-  # Remove file artifacts generated by individual test cases
-  def clean_test_case
-    if File.exists?(@local_file_download_destination)
-      File.delete(@local_file_download_destination)
-    end
-  end
-
-  def run_download_scenario
-    clean_test_case
-
-    winrm_bootstrapper = Chef::Knife::BootstrapWindowsWinrm.new([ "127.0.0.1" ])
-    winrm_bootstrapper.client_builder = instance_double("Chef::Knife::Bootstrap::ClientBuilder", :run => nil, :client_path => nil)
-
-    allow(WinRM::Connection).to receive(:new).and_return(Dummy::Connection.new)
-    allow(winrm_bootstrapper).to receive(:wait_for_remote_response)
-    allow(winrm_bootstrapper).to receive(:validate_options!)
-    allow(winrm_bootstrapper.ui).to receive(:ask).and_return(nil)
-    winrm_bootstrapper.config[:template_file] = @template_file_path
-    winrm_bootstrapper.config[:run_list] = []
-    # Execute the commands locally that would normally be executed via WinRM
-    allow(winrm_bootstrapper).to receive(:run_command) do |command|
-      system(command)
-    end
-
-    winrm_bootstrapper.run
-
-    # Download should succeed
-    expect(download_succeeded?).to be true
-  end
-end
-
-describe "bootstrap_install_command functionality through WinRM protocol" do
-  context "bootstrap_install_command option is not specified" do
-    let(:bootstrap) { Chef::Knife::BootstrapWindowsWinrm.new([]) }
-    before do
-      @template_input = sample_data('win_template_unrendered.txt')
-      @template_output = sample_data('win_template_rendered_without_bootstrap_install_command.txt')
-    end
-
-    it "bootstrap_install_command option is not rendered in the windows-chef-client-msi.erb template as its value is nil", :chef_lt_12_5_only => true do
-      expect(bootstrap.send(:render_template,@template_input)).to eq(
-        @template_output)
-    end
-
-    context "when running chef-client ~12.5", :chef_gte_12_5_only => true, :chef_lt_13_only => true do
-      let(:template_12_5_output) { sample_data('win_template_rendered_without_bootstrap_install_command_on_12_5_client.txt') }
-      it "bootstrap_install_command option is not rendered in the windows-chef-client-msi.erb template as its value is nil"  do
-        expect(bootstrap.send(:render_template,@template_input)).to eq(
-                                                                      template_12_5_output)
-      end
-    end
-
-    context "when running chef-client 13.0 or greater", :chef_gte_13_only => true, :chef_lt_14_only => true do
-      let(:template_13_output) { sample_data('win_template_rendered_without_bootstrap_install_command_on_13_client.txt') }
-      it "bootstrap_install_command option is not rendered in the windows-chef-client-msi.erb template as its value is nil"  do
-        expect(bootstrap.send(:render_template,@template_input)).to eq(
-                                                                      template_13_output)
-      end
-    end
-  end
-
-  context "bootstrap_install_command option is specified" do
-    let(:bootstrap) { Chef::Knife::BootstrapWindowsWinrm.new(['--bootstrap-install-command', 'chef-client -o recipe[cbk1::rec2]']) }
-    before do
-      bootstrap.config[:bootstrap_install_command] = "chef-client -o recipe[cbk1::rec2]"
-      @template_input = sample_data('win_template_unrendered.txt')
-      @template_output = sample_data('win_template_rendered_with_bootstrap_install_command.txt')
-    end
-
-    it "bootstrap_install_command option is rendered in the windows-chef-client-msi.erb template", :chef_lt_12_5_only => true do
-      expect(bootstrap.send(:render_template,@template_input)).to eq(
-        @template_output)
-    end
-
-    context "when running chef-client 12.5.0 or greater", :chef_gte_12_5_only => true, :chef_lt_14_only => true  do
-      let(:template_12_5_output) { sample_data('win_template_rendered_with_bootstrap_install_command_on_12_5_client.txt') }
-      it "bootstrap_install_command option is rendered in the windows-chef-client-msi.erb template" do
-        expect(bootstrap.send(:render_template,@template_input)).to eq(
-                                                                      template_12_5_output)
-      end
-    end
-
-    after do
-      bootstrap.config.delete(:bootstrap_install_command)
-      Chef::Config[:knife].delete(:bootstrap_install_command)
-    end
-  end
-end
-
-describe "bootstrap_install_command functionality through SSH protocol", :chef_lt_12_5_only => true do
-  context "bootstrap_install_command option is not specified" do
-    let(:bootstrap) { Chef::Knife::BootstrapWindowsSsh.new([]) }
-    before do
-      @template_input = sample_data('win_template_unrendered.txt')
-      @template_output = sample_data('win_template_rendered_without_bootstrap_install_command.txt')
-    end
-
-    it "bootstrap_install_command option is not rendered in the windows-chef-client-msi.erb template as its value is nil" do
-      expect(bootstrap.send(:render_template,@template_input)).to eq(
-        @template_output)
-    end
-  end
-
-  context "bootstrap_install_command option is specified" do
-    let(:bootstrap) { Chef::Knife::BootstrapWindowsSsh.new(['--bootstrap-install-command', 'chef-client -o recipe[cbk1::rec2]']) }
-    before do
-      bootstrap.config[:bootstrap_install_command] = "chef-client -o recipe[cbk1::rec2]"
-      @template_input = sample_data('win_template_unrendered.txt')
-      @template_output = sample_data('win_template_rendered_with_bootstrap_install_command.txt')
-    end
-
-    it "bootstrap_install_command option is rendered in the windows-chef-client-msi.erb template" do
-      expect(bootstrap.send(:render_template,@template_input)).to eq(
-        @template_output)
-    end
-
-    after do
-      bootstrap.config.delete(:bootstrap_install_command)
-      Chef::Config[:knife].delete(:bootstrap_install_command)
-    end
-  end
-end