chef-config 16.3.38 → 16.5.64

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3482b9ead58c2925bbfd764052e0fd08cccc21b1b5779df6165822285e54e776
-  data.tar.gz: 22742eaed3c541ba8252694d3c829e66943b13a3f544a1afd48759317cca0786
+  metadata.gz: 98200061cdf7f6987f89d2810c4f4cf06e73e946703207b1e03270bed58c2a72
+  data.tar.gz: 4c97416eaa59a81959b65596d40efe4f24e10e6e8dc1e5f9f26d5467c0f13385
 SHA512:
-  metadata.gz: e605107108e2f6b6c738b4a94c0131b650b8ef9f774ef707eb25b3734d5a143ba2d8d610e34535e4a733055ddacce43d8664bea295485e82149e81a748d8d18c
-  data.tar.gz: ba863e9355cbe3336ee2d06cb588f7a8b0ecd40127ea486d998f4c836ada7ed315762bf72703e8659ea037b3a431278a3509c9150ea8c01c67c107d618c7f3ef
+  metadata.gz: 7a3923de2e675cd239dde70ac73595d043da585f5350f083c093fbefe6bd86a5fdd29165e7229fc2ba082018ac645420eb6991db993ea626735cd882ff0ac047
+  data.tar.gz: b0270e4feee69bde6219ec09e07529a40e0b1849ba42ea1066638b74754c7e45c6fdb6d73ec2fb0c78c727f77c131a86d4a0399d5f4fe1b46243a8765e1e6def

data/lib/chef-config/config.rb

@@ -20,8 +20,8 @@
 # limitations under the License.
 
 require "mixlib/config" unless defined?(Mixlib::Config)
-require "pathname" unless defined?(Pathname)
-require "chef-utils" unless defined?(ChefUtils::CANARY)
+autoload :Pathname, "pathname"
+autoload :ChefUtils, "chef-utils"
 
 require_relative "fips"
 require_relative "logger"
@@ -29,12 +29,14 @@ require_relative "windows"
 require_relative "path_helper"
 require_relative "mixin/fuzzy_hostname_matcher"
 
-require "mixlib/shellout" unless defined?(Mixlib::ShellOut::DEFAULT_READ_TIMEOUT)
-require "uri" unless defined?(URI)
-require "addressable/uri" unless defined?(Addressable::URI)
-require "openssl" unless defined?(OpenSSL)
-require "yaml"
-require_relative "dist"
+module Mixlib
+  autoload :ShellOut, "mixlib/shellout"
+end
+autoload :URI, "uri"
+autoload :Addressable, "addressable/uri"
+autoload :OpenSSL, "openssl"
+autoload :YAML, "yaml"
+require "chef-utils/dist" unless defined?(ChefUtils::Dist)
 
 module ChefConfig
 
@@ -74,42 +76,66 @@ module ChefConfig
       path
     end
 
-    # On *nix, /etc/chef
-    def self.etc_chef_dir(is_windows = ChefUtils.windows?)
-      path = is_windows ? c_chef_dir : PathHelper.join("/etc", ChefConfig::Dist::DIR_SUFFIX)
-      PathHelper.cleanpath(path)
+    # On *nix, /etc/chef, on Windows C:\chef
+    #
+    # @param windows [Boolean] optional flag to force to windows or unix-style
+    # @return [String] the platform-specific path
+    #
+    def self.etc_chef_dir(windows: ChefUtils.windows?)
+      path = windows ? c_chef_dir : PathHelper.join("/etc", ChefUtils::Dist::Infra::DIR_SUFFIX, windows: windows)
+      PathHelper.cleanpath(path, windows: windows)
     end
 
-    # On *nix, /var/chef
-    def self.var_chef_dir(is_windows = ChefUtils.windows?)
-      path = is_windows ? c_chef_dir : PathHelper.join("/var", ChefConfig::Dist::DIR_SUFFIX)
-      PathHelper.cleanpath(path)
+    # On *nix, /var/chef, on Windows C:\chef
+    #
+    # @param windows [Boolean] optional flag to force to windows or unix-style
+    # @return [String] the platform-specific path
+    #
+    def self.var_chef_dir(windows: ChefUtils.windows?)
+      path = windows ? c_chef_dir : PathHelper.join("/var", ChefUtils::Dist::Infra::DIR_SUFFIX, windows: windows)
+      PathHelper.cleanpath(path, windows: windows)
     end
 
-    # On *nix, the root of /var/, used to test if we can create and write in /var/chef
-    def self.var_root_dir(is_windows = ChefUtils.windows?)
-      path = is_windows ? c_chef_dir : "/var"
-      PathHelper.cleanpath(path)
+    # On *nix, /var, on Windows C:\
+    #
+    # @param windows [Boolean] optional flag to force to windows or unix-style
+    # @return [String] the platform-specific path
+    #
+    def self.var_root_dir(windows: ChefUtils.windows?)
+      path = windows ? "C:\\" : "/var"
+      PathHelper.cleanpath(path, windows: windows)
     end
 
     # On windows, C:/chef/
-    def self.c_chef_dir
+    #
+    # (should only be called in a windows-context)
+    #
+    # @return [String] the platform-specific path
+    #
+    def self.c_chef_dir(windows: ChefUtils.windows?)
       drive = windows_installation_drive || "C:"
-      path = PathHelper.join(drive, ChefConfig::Dist::DIR_SUFFIX)
-      PathHelper.cleanpath(path)
+      PathHelper.join(drive, ChefUtils::Dist::Infra::DIR_SUFFIX, windows: windows)
     end
 
-    def self.c_opscode_dir
+    # On windows, C:/opscode
+    #
+    # (should only be called in a windows-context)
+    #
+    # @return [String] the platform-specific path
+    #
+    def self.c_opscode_dir(windows: ChefUtils.windows?)
       drive = windows_installation_drive || "C:"
-      path = PathHelper.join(drive, ChefConfig::Dist::LEGACY_CONF_DIR, ChefConfig::Dist::DIR_SUFFIX)
-      PathHelper.cleanpath(path)
+      PathHelper.join(drive, ChefUtils::Dist::Org::LEGACY_CONF_DIR, ChefUtils::Dist::Infra::DIR_SUFFIX, windows: windows)
     end
 
     # the drive where Chef is installed on a windows host. This is determined
     # either by the drive containing the current file or by the SYSTEMDRIVE ENV
     # variable
     #
+    # (should only be called in a windows-context)
+    #
     # @return [String] the drive letter
+    #
     def self.windows_installation_drive
       if ChefUtils.windows?
         drive = File.expand_path(__FILE__).split("/", 2)[0]
@@ -164,7 +190,7 @@ module ChefConfig
       if config_file
         PathHelper.dirname(PathHelper.canonical_path(config_file, false))
       else
-        PathHelper.join(PathHelper.cleanpath(user_home), ChefConfig::Dist::USER_CONF_DIR, "")
+        PathHelper.join(PathHelper.cleanpath(user_home), ChefUtils::Dist::Infra::USER_CONF_DIR, "")
       end
     end
 
@@ -243,7 +269,7 @@ module ChefConfig
         end
         path = new_path
       end
-      ChefConfig.logger.info("Auto-discovered #{ChefConfig::Dist::SHORT} repository at #{path}")
+      ChefConfig.logger.info("Auto-discovered #{ChefUtils::Dist::Infra::SHORT} repository at #{path}")
       path
     end
 
@@ -341,12 +367,12 @@ module ChefConfig
         # Otherwise, we'll create .chef under the user's home directory and use that as
         # the cache path.
         unless path_accessible?(primary_cache_path) || path_accessible?(primary_cache_root)
-          secondary_cache_path = PathHelper.join(user_home, ChefConfig::Dist::USER_CONF_DIR)
-          secondary_cache_path = target_mode? ? "#{secondary_cache_path}/#{target_mode.host}" : secondary_cache_path
+          secondary_cache_path = PathHelper.join(user_home, ChefUtils::Dist::Infra::USER_CONF_DIR)
+          secondary_cache_path = target_mode? ? PathHelper.join(secondary_cache_path, target_mode.host) : secondary_cache_path
           ChefConfig.logger.trace("Unable to access cache at #{primary_cache_path}. Switching cache to #{secondary_cache_path}")
           secondary_cache_path
         else
-          target_mode? ? "#{primary_cache_path}/#{target_mode.host}" : primary_cache_path
+          target_mode? ? PathHelper.join(primary_cache_path, target_mode.host) : primary_cache_path
         end
       end
     end
@@ -355,7 +381,7 @@ module ChefConfig
     #
     # @param path [String]
     def self.path_accessible?(path)
-      File.exists?(path) && File.readable?(path) && File.writable?(path)
+      File.exist?(path) && File.readable?(path) && File.writable?(path)
     end
 
     # Where cookbook files are stored on the server (by content checksum)
@@ -372,7 +398,7 @@ module ChefConfig
     # If your `file_cache_path` resides on a NFS (or non-flock()-supporting
     # fs), it's recommended to set this to something like
     # '/tmp/chef-client-running.pid'
-    default(:lockfile) { PathHelper.join(file_cache_path, "#{ChefConfig::Dist::CLIENT}-running.pid") }
+    default(:lockfile) { PathHelper.join(file_cache_path, "#{ChefUtils::Dist::Infra::CLIENT}-running.pid") }
 
     ## Daemonization Settings ##
     # What user should Chef run as?
@@ -769,7 +795,7 @@ module ChefConfig
       if chef_server_url.to_s =~ %r{/organizations/(.*)$}
         "#{$1}-validator"
       else
-        "#{ChefConfig::Dist::SHORT}-validator"
+        "#{ChefUtils::Dist::Infra::SHORT}-validator"
       end
     end
 
@@ -843,7 +869,7 @@ module ChefConfig
     default :profile, nil
 
     default :chef_guid_path do
-      PathHelper.join(config_dir, "#{ChefConfig::Dist::SHORT}_guid")
+      PathHelper.join(config_dir, "#{ChefUtils::Dist::Infra::SHORT}_guid")
     end
 
     default :chef_guid, nil
@@ -1052,7 +1078,7 @@ module ChefConfig
       # generated by the DataCollector when Chef is run in Solo mode. This
       # allows users to associate their Solo nodes with faux organizations
       # without the nodes being connected to an actual Chef Server.
-      default :organization, "#{ChefConfig::Dist::SHORT}_solo"
+      default :organization, "#{ChefUtils::Dist::Infra::SHORT}_solo"
     end
 
     configurable(:http_proxy)
@@ -1078,13 +1104,6 @@ module ChefConfig
       export_no_proxy(no_proxy) if key?(:no_proxy) && no_proxy
     end
 
-    # Character classes for Addressable
-    # See https://www.ietf.org/rfc/rfc3986.txt 3.2.1
-    # The user part may not have a : in it
-    USER = Addressable::URI::CharacterClasses::UNRESERVED + Addressable::URI::CharacterClasses::SUB_DELIMS
-    # The password part may have any valid USERINFO characters
-    PASSWORD = USER + "\\:"
-
     # Builds a proxy uri and exports it to the appropriate environment variables. Examples:
     #   http://username:password@hostname:port
     #   https://username@hostname:port
@@ -1096,15 +1115,22 @@ module ChefConfig
     #   pass = password
     # @api private
     def self.export_proxy(scheme, path, user, pass)
+      # Character classes for Addressable
+      # See https://www.ietf.org/rfc/rfc3986.txt 3.2.1
+      # The user part may not have a : in it
+      user_class = Addressable::URI::CharacterClasses::UNRESERVED + Addressable::URI::CharacterClasses::SUB_DELIMS
+      # The password part may have any valid USERINFO characters
+      password_class = user_class + "\\:"
+
       path = "#{scheme}://#{path}" unless path.include?("://")
       # URI.split returns the following parts:
       # [scheme, userinfo, host, port, registry, path, opaque, query, fragment]
       uri = Addressable::URI.encode(path, Addressable::URI)
 
       if user && !user.empty?
-        userinfo = Addressable::URI.encode_component(user, USER)
+        userinfo = Addressable::URI.encode_component(user, user_class)
         if pass
-          userinfo << ":#{Addressable::URI.encode_component(pass, PASSWORD)}"
+          userinfo << ":#{Addressable::URI.encode_component(pass, password_class)}"
         end
         uri.userinfo = userinfo
       end

data/lib/chef-config/mixin/credentials.rb

@@ -15,8 +15,9 @@
 # limitations under the License.
 #
 
-require "tomlrb"
+autoload :Tomlrb, "tomlrb"
 require_relative "../path_helper"
+require "chef-utils/dist" unless defined?(ChefUtils::Dist)
 
 module ChefConfig
   module Mixin
@@ -36,7 +37,7 @@ module ChefConfig
       #   normally set via a command-line option.
       # @return [String]
       def credentials_profile(profile = nil)
-        context_file = PathHelper.home(ChefConfig::Dist::USER_CONF_DIR, "context").freeze
+        context_file = PathHelper.home(ChefUtils::Dist::Infra::USER_CONF_DIR, "context").freeze
         if !profile.nil?
           profile
         elsif ENV.include?("CHEF_PROFILE")
@@ -53,7 +54,7 @@ module ChefConfig
       # @since 14.4
       # @return [String]
       def credentials_file_path
-        PathHelper.home(ChefConfig::Dist::USER_CONF_DIR, "credentials").freeze
+        PathHelper.home(ChefUtils::Dist::Infra::USER_CONF_DIR, "credentials").freeze
       end
 
       # Load and parse the credentials file.
@@ -84,17 +85,17 @@ module ChefConfig
       # @return [void]
       def load_credentials(profile = nil)
         profile = credentials_profile(profile)
-        config = parse_credentials_file
-        return if config.nil? # No credentials, nothing to do here.
+        cred_config = parse_credentials_file
+        return if cred_config.nil? # No credentials, nothing to do here.
 
-        if config[profile].nil?
+        if cred_config[profile].nil?
           # Unknown profile name. For "default" just silently ignore, otherwise
           # raise an error.
           return if profile == "default"
 
           raise ChefConfig::ConfigurationError, "Profile #{profile} doesn't exist. Please add it to #{credentials_file_path}."
         end
-        apply_credentials(config[profile], profile)
+        apply_credentials(cred_config[profile], profile)
       end
     end
   end

data/lib/chef-config/mixin/train_transport.rb

@@ -0,0 +1,141 @@
+# Author:: Bryan McLellan <btm@loftninjas.org>
+# 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_relative "credentials"
+autoload :Train, "train"
+require_relative "../config"
+require "chef-utils/dist" unless defined?(ChefUtils::Dist)
+
+module ChefConfig
+  module Mixin
+    module TrainTransport
+      include ChefConfig::Mixin::Credentials
+
+      attr_accessor :logger
+
+      def initialize(logger)
+        @logger = logger
+      end
+
+      #
+      # Returns a RFC099 credentials profile as a hash
+      #
+      def load_credentials(profile)
+        # Tomlrb.load_file returns a hash with keys as strings
+        credentials = parse_credentials_file
+        if contains_split_fqdn?(credentials, profile)
+          logger.warn("Credentials file #{credentials_file_path} contains target '#{profile}' as a Hash, expected a string.")
+          logger.warn("Hostnames must be surrounded by single quotes, e.g. ['host.example.org']")
+        end
+
+        # host names must be specified in credentials file as ['foo.example.org'] with quotes
+        if !credentials.nil? && !credentials[profile].nil?
+          credentials[profile].map { |k, v| [k.to_sym, v] }.to_h # return symbolized keys to match Train.options()
+        else
+          nil
+        end
+      end
+
+      # Toml creates hashes when a key is separated by periods, e.g.
+      # [host.example.org] => { host: { example: { org: {} } } }
+      #
+      # Returns true if the above example is true
+      #
+      # A hostname has to be specified as ['host.example.org']
+      # This will be a common mistake so we should catch it
+      #
+      def contains_split_fqdn?(hash, fqdn)
+        fqdn.split(".").reduce(hash) do |h, k|
+          v = h[k]
+          if Hash === v
+            v
+          else
+            break false
+          end
+        end
+      end
+
+      # ChefConfig::Mixin::Credentials.credentials_file_path is designed around knife,
+      # overriding it here.
+      #
+      # Credentials file preference:
+      #
+      # 1) target_mode.credentials_file
+      # 2) /etc/chef/TARGET_MODE_HOST/credentials
+      # 3) #credentials_file_path from parent ($HOME/.chef/credentials)
+      #
+      def credentials_file_path
+        tm_config = config.target_mode
+        profile = tm_config.host
+
+        credentials_file =
+          if tm_config.credentials_file && File.exist?(tm_config.credentials_file)
+            tm_config.credentials_file
+          elsif File.exist?(config.platform_specific_path("#{ChefConfig::Config.etc_chef_dir}/#{profile}/credentials"))
+            config.platform_specific_path("#{ChefConfig::Config.etc_chef_dir}/#{profile}/credentials")
+          else
+            super
+          end
+
+        raise ArgumentError, "No credentials file found for target '#{profile}'" unless credentials_file
+        raise ArgumentError, "Credentials file specified for target mode does not exist: '#{credentials_file}'" unless File.exist?(credentials_file)
+
+        logger.debug("Loading credentials file '#{credentials_file}' for target '#{profile}'")
+
+        credentials_file
+      end
+
+      def build_transport
+        return nil unless config.target_mode?
+
+        # TODO: Consider supporting parsing the protocol from a URI passed to `--target`
+        #
+        train_config = {}
+
+        # Load the target_mode config context from config, and place any valid settings into the train configuration
+        tm_config = config.target_mode
+        protocol = tm_config.protocol
+        train_config = tm_config.to_hash.select { |k| Train.options(protocol).key?(k) }
+        logger.trace("Using target mode options from #{ChefUtils::Dist::Infra::PRODUCT} config file: #{train_config.keys.join(", ")}") if train_config
+
+        # Load the credentials file, and place any valid settings into the train configuration
+        credentials = load_credentials(tm_config.host)
+        if credentials
+          valid_settings = credentials.select { |k| Train.options(protocol).key?(k) }
+          valid_settings[:enable_password] = credentials[:enable_password] if credentials.key?(:enable_password)
+          train_config.merge!(valid_settings)
+          logger.trace("Using target mode options from credentials file: #{valid_settings.keys.join(", ")}") if valid_settings
+        end
+
+        train_config[:logger] = logger
+
+        # Train handles connection retries for us
+        Train.create(protocol, train_config)
+      rescue SocketError => e # likely a dns failure, not caught by train
+        e.message.replace "Error connecting to #{train_config[:target]} - #{e.message}"
+        raise e
+      rescue Train::PluginLoadError
+        logger.error("Invalid target mode protocol: #{protocol}")
+        exit(1)
+      end
+
+      def config
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/lib/chef-config/path_helper.rb

@@ -26,14 +26,14 @@ module ChefConfig
     # Maximum characters in a standard Windows path (260 including drive letter and NUL)
     WIN_MAX_PATH = 259
 
-    def self.dirname(path)
-      if ChefUtils.windows?
+    def self.dirname(path, windows: ChefUtils.windows?)
+      if windows
         # Find the first slash, not counting trailing slashes
         end_slash = path.size
         loop do
-          slash = path.rindex(/[#{Regexp.escape(File::SEPARATOR)}#{Regexp.escape(path_separator)}]/, end_slash - 1)
+          slash = path.rindex(/[#{Regexp.escape(File::SEPARATOR)}#{Regexp.escape(path_separator(windows: windows))}]/, end_slash - 1)
           if !slash
-            return end_slash == path.size ? "." : path_separator
+            return end_slash == path.size ? "." : path_separator(windows: windows)
           elsif slash == end_slash - 1
             end_slash = slash
           else
@@ -47,29 +47,28 @@ module ChefConfig
 
     BACKSLASH = '\\'.freeze
 
-    def self.path_separator
-      if ChefUtils.windows?
-        File::ALT_SEPARATOR || BACKSLASH
+    def self.path_separator(windows: ChefUtils.windows?)
+      if windows
+        BACKSLASH
       else
         File::SEPARATOR
       end
     end
 
-    path_separator_regex = [Regexp.escape(File::SEPARATOR), Regexp.escape(path_separator)].uniq.join
+    def self.join(*args, windows: ChefUtils.windows?)
+      path_separator_regex = Regexp.escape(windows ? "#{File::SEPARATOR}#{BACKSLASH}" : File::SEPARATOR)
+      trailing_slashes_regex = /[#{path_separator_regex}]+$/.freeze
+      leading_slashes_regex = /^[#{path_separator_regex}]+/.freeze
 
-    TRAILING_SLASHES_REGEX = /[#{path_separator_regex}]+$/.freeze
-    LEADING_SLASHES_REGEX = /^[#{path_separator_regex}]+/.freeze
-
-    def self.join(*args)
       args.flatten.inject do |joined_path, component|
-        joined_path = joined_path.sub(TRAILING_SLASHES_REGEX, "")
-        component = component.sub(LEADING_SLASHES_REGEX, "")
-        joined_path + "#{path_separator}#{component}"
+        joined_path = joined_path.sub(trailing_slashes_regex, "")
+        component = component.sub(leading_slashes_regex, "")
+        joined_path + "#{path_separator(windows: windows)}#{component}"
       end
     end
 
-    def self.validate_path(path)
-      if ChefUtils.windows?
+    def self.validate_path(path, windows: ChefUtils.windows?)
+      if 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."
           ChefConfig.logger.error(msg)
@@ -108,14 +107,14 @@ module ChefConfig
     end
 
     # Produces a comparable path.
-    def self.canonical_path(path, add_prefix = true)
+    def self.canonical_path(path, add_prefix = true, windows: ChefUtils.windows?)
       # First remove extra separators and resolve any relative paths
       abs_path = File.absolute_path(path)
 
-      if ChefUtils.windows?
+      if 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)
+        abs_path.gsub!(::File::SEPARATOR, path_separator(windows: windows))
         if add_prefix && abs_path !~ /^\\\\?\\/
           abs_path.insert(0, "\\\\?\\")
         end
@@ -126,36 +125,67 @@ module ChefConfig
       abs_path
     end
 
-    # This is the INVERSE of Pathname#cleanpath, it converts forward
-    # slashes to backslashes for Windows.  Since the Ruby API and the
-    # Windows APIs all consume forward slashes, this helper function
-    # should only be used for *DISPLAY* logic to send strings back
-    # to the user with backslashes.  Internally, filename paths should
-    # generally be stored with forward slashes for consistency.  It is
-    # not necessary or desired to blindly convert pathnames to have
-    # backslashes on Windows.
+    # The built in ruby Pathname#cleanpath method does not clean up forward slashes and
+    # backslashes.  This is a wrapper around that which does.  In general this is NOT
+    # recommended for internal use within ruby/chef since ruby does not care about forward slashes
+    # vs. backslashes, even on Windows.  Where this generally matters is when being rendered
+    # to the user, or being rendered into things like the windows PATH or to commands that
+    # are being executed.  In some cases it may be easier on windows to render paths to
+    # unix-style for being eventually eval'd by ruby in the future (templates being rendered
+    # with code to be consumed by ruby) where forcing unix-style forward slashes avoids the
+    # issue of needing to escape the backslashes in rendered strings.  This has a boolean
+    # operator to force windows-style or non-windows style operation, where the default is
+    # determined by the underlying node['platform'] value.
+    #
+    # In general if you don't know if you need this routine, do not use it, best practice
+    # within chef/ruby itself is not to care.  Only use it to force windows or unix style
+    # when it really matters.
     #
-    # Generally, if the user isn't going to be seeing it, you should be
-    # using Pathname#cleanpath instead of this function.
-    def self.cleanpath(path)
+    # @param path [String] the path to clean
+    # @param windows [Boolean] optional flag to force to windows or unix-style
+    # @return [String] cleaned path
+    #
+    def self.cleanpath(path, windows: ChefUtils.windows?)
       path = Pathname.new(path).cleanpath.to_s
-      # ensure all forward slashes are backslashes
-      if ChefUtils.windows?
-        path = path.gsub(File::SEPARATOR, path_separator)
+      if windows
+        # ensure all forward slashes are backslashes
+        path.gsub(File::SEPARATOR, path_separator(windows: windows))
+      else
+        # ensure all backslashes are forward slashes
+        path.gsub(BACKSLASH, File::SEPARATOR)
       end
-      path
     end
 
-    def self.paths_eql?(path1, path2)
-      canonical_path(path1) == canonical_path(path2)
+    # This is not just escaping for something like use in Regexps, or in globs.  For the former
+    # just use Regexp.escape.  For the latter, use escape_glob_dir below.
+    #
+    # This is escaping where the path to be rendered is being put into a ruby file which will
+    # later be read back by ruby (or something similar) so we need quadruple backslashes.
+    #
+    # In order to print:
+    #
+    #   file_cache_path "C:\\chef"
+    #
+    # We need to convert "C:\chef" to "C:\\\\chef" to interpolate into a string which is rendered
+    # into the output file with that line in it.
+    #
+    # @param path [String] the path to escape
+    # @return [String] the escaped path
+    #
+    def self.escapepath(path)
+      path.gsub(BACKSLASH, BACKSLASH * 4)
+    end
+
+    def self.paths_eql?(path1, path2, windows: ChefUtils.windows?)
+      canonical_path(path1, windows: windows) == canonical_path(path2, windows: windows)
     end
 
     # @deprecated 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))
+    def self.escape_glob(*parts, windows: ChefUtils.windows?)
+      path = cleanpath(join(*parts, windows: windows), windows: windows)
       path.gsub(/[\\\{\}\[\]\*\?]/) { |x| "\\" + x }
     end
 
@@ -166,8 +196,8 @@ module ChefConfig
       path.gsub(/[\\\{\}\[\]\*\?]/) { |x| "\\" + x }
     end
 
-    def self.relative_path_from(from, to)
-      Pathname.new(cleanpath(to)).relative_path_from(Pathname.new(cleanpath(from)))
+    def self.relative_path_from(from, to, windows: ChefUtils.windows?)
+      Pathname.new(cleanpath(to, windows: windows)).relative_path_from(Pathname.new(cleanpath(from, windows: windows)))
     end
 
     # Set the project-specific home directory environment variable.
@@ -213,11 +243,11 @@ module ChefConfig
     #
     # 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)
+    def self.all_homes(*args, windows: ChefUtils.windows?)
       paths = []
       paths << ENV[@@per_tool_home_environment] if defined?(@@per_tool_home_environment) && @@per_tool_home_environment && ENV[@@per_tool_home_environment]
       paths << ENV["CHEF_HOME"] if ENV["CHEF_HOME"]
-      if ChefUtils.windows?
+      if windows
         # By default, Ruby uses the the following environment variables to determine Dir.home:
         # HOME
         # HOMEDRIVE HOMEPATH
@@ -246,7 +276,7 @@ module ChefConfig
       # 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 }
+      paths = paths.map { |home_path| home_path.gsub(path_separator(windows: windows), ::File::SEPARATOR) if home_path }
 
       # Filter out duplicate paths and paths that don't exist.
       valid_paths = paths.select { |home_path| home_path && Dir.exist?(home_path.force_encoding("utf-8")) }

data/lib/chef-config/version.rb

@@ -15,5 +15,5 @@
 
 module ChefConfig
   CHEFCONFIG_ROOT = File.expand_path("..", __dir__)
-  VERSION = "16.3.38".freeze
+  VERSION = "16.5.64".freeze
 end

data/lib/chef-config/workstation_config_loader.rb

@@ -59,7 +59,7 @@ module ChefConfig
         @chef_config_dir = false
         full_path = working_directory.split(File::SEPARATOR)
         (full_path.length - 1).downto(0) do |i|
-          candidate_directory = File.join(full_path[0..i] + [ChefConfig::Dist::USER_CONF_DIR])
+          candidate_directory = File.join(full_path[0..i] + [ChefUtils::Dist::Infra::USER_CONF_DIR])
           if File.exist?(candidate_directory) && File.directory?(candidate_directory)
             @chef_config_dir = candidate_directory
             break
@@ -129,7 +129,7 @@ module ChefConfig
         candidate_configs << File.join(chef_config_dir, "knife.rb")
       end
       # Look for $HOME/.chef/knife.rb
-      PathHelper.home(ChefConfig::Dist::USER_CONF_DIR) do |dot_chef_dir|
+      PathHelper.home(ChefUtils::Dist::Infra::USER_CONF_DIR) do |dot_chef_dir|
         candidate_configs << File.join(dot_chef_dir, "config.rb")
         candidate_configs << File.join(dot_chef_dir, "knife.rb")
       end
@@ -140,13 +140,11 @@ module ChefConfig
     end
 
     def working_directory
-      a = if ChefUtils.windows?
-            env["CD"]
-          else
-            env["PWD"]
-          end || Dir.pwd
-
-      a
+      if ChefUtils.windows?
+        env["CD"]
+      else
+        env["PWD"]
+      end || Dir.pwd
     end
 
     def apply_credentials(creds, profile)
@@ -186,7 +184,7 @@ module ChefConfig
     end
 
     def home_chef_dir
-      @home_chef_dir ||= PathHelper.home(ChefConfig::Dist::USER_CONF_DIR)
+      @home_chef_dir ||= PathHelper.home(ChefUtils::Dist::Infra::USER_CONF_DIR)
     end
 
     def apply_config(config_content, config_file_path)

data/spec/unit/config_spec.rb

@@ -170,7 +170,7 @@ RSpec.describe ChefConfig::Config do
           apply_config
           expect(described_class[:data_bag_path]).to eq("#{current_directory}/data_bags")
           expect(described_class[:cookbook_path]).to eq("#{current_directory}/cookbooks")
-          expect(described_class[:chef_repo_path]).to eq("#{current_directory}")
+          expect(described_class[:chef_repo_path]).to eq(current_directory)
         end
       end
 
@@ -222,13 +222,70 @@ RSpec.describe ChefConfig::Config do
       ChefConfig::Config.add_formatter(:doc, "/var/log/formatter.log")
       expect(ChefConfig::Config.formatters).to eq([[:doc, "/var/log/formatter.log"]])
     end
+  end
+
+  describe "#var_chef_path" do
+    let (:dirname) { ChefUtils::Dist::Infra::DIR_SUFFIX }
+
+    context "on unix", :unix_only do
+      it "var_chef_dir is /var/chef" do
+        expect(ChefConfig::Config.var_chef_dir).to eql("/var/#{dirname}")
+      end
+
+      it "var_root_dir is /var" do
+        expect(ChefConfig::Config.var_root_dir).to eql("/var")
+      end
+
+      it "etc_chef_dir is /etc/chef" do
+        expect(ChefConfig::Config.etc_chef_dir).to eql("/etc/#{dirname}")
+      end
+    end
+
+    context "on windows", :windows_only do
+      it "var_chef_dir is C:\\chef" do
+        expect(ChefConfig::Config.var_chef_dir).to eql("C:\\#{dirname}")
+      end
+
+      it "var_root_dir is C:\\" do
+        expect(ChefConfig::Config.var_root_dir).to eql("C:\\")
+      end
+
+      it "etc_chef_dir is C:\\chef" do
+        expect(ChefConfig::Config.etc_chef_dir).to eql("C:\\#{dirname}")
+      end
+    end
 
+    context "when forced to unix" do
+      it "var_chef_dir is /var/chef" do
+        expect(ChefConfig::Config.var_chef_dir(windows: false)).to eql("/var/#{dirname}")
+      end
+
+      it "var_root_dir is /var" do
+        expect(ChefConfig::Config.var_root_dir(windows: false)).to eql("/var")
+      end
+
+      it "etc_chef_dir is /etc/chef" do
+        expect(ChefConfig::Config.etc_chef_dir(windows: false)).to eql("/etc/#{dirname}")
+      end
+    end
+
+    context "when forced to windows" do
+      it "var_chef_dir is C:\\chef" do
+        expect(ChefConfig::Config.var_chef_dir(windows: true)).to eql("C:\\#{dirname}")
+      end
+
+      it "var_root_dir is C:\\" do
+        expect(ChefConfig::Config.var_root_dir(windows: true)).to eql("C:\\")
+      end
+
+      it "etc_chef_dir is C:\\chef" do
+        expect(ChefConfig::Config.etc_chef_dir(windows: true)).to eql("C:\\#{dirname}")
+      end
+    end
   end
 
   [ false, true ].each do |is_windows|
-
     context "On #{is_windows ? "Windows" : "Unix"}" do
-
       before :each do
         allow(ChefUtils).to receive(:windows?).and_return(is_windows)
       end
@@ -430,8 +487,8 @@ RSpec.describe ChefConfig::Config do
 
         describe "ChefConfig::Config[:cache_path]" do
           let(:target_mode_host) { "fluffy.kittens.org" }
-          let(:target_mode_primary_cache_path) { "#{primary_cache_path}/#{target_mode_host}" }
-          let(:target_mode_secondary_cache_path) { "#{secondary_cache_path}/#{target_mode_host}" }
+          let(:target_mode_primary_cache_path) { ChefUtils.windows? ? "#{primary_cache_path}\\#{target_mode_host}" : "#{primary_cache_path}/#{target_mode_host}" }
+          let(:target_mode_secondary_cache_path) { ChefUtils.windows? ? "#{secondary_cache_path}\\#{target_mode_host}" : "#{secondary_cache_path}/#{target_mode_host}" }
 
           before do
             if is_windows

data/spec/unit/path_helper_spec.rb

@@ -23,9 +23,8 @@ RSpec.describe ChefConfig::PathHelper do
 
   let(:path_helper) { described_class }
 
-  shared_examples_for "common_functionality" do
-    describe "join" do
-
+  context "common functionality" do
+    context "join" do
       it "joins starting with '' resolve to absolute paths" do
         expect(path_helper.join("", "a", "b")).to eq("#{path_helper.path_separator}a#{path_helper.path_separator}b")
       end
@@ -33,10 +32,9 @@ RSpec.describe ChefConfig::PathHelper do
       it "joins ending with '' add a / to the end" do
         expect(path_helper.join("a", "b", "")).to eq("a#{path_helper.path_separator}b#{path_helper.path_separator}")
       end
-
     end
 
-    describe "dirname" do
+    context "dirname" do
       it "dirname('abc') is '.'" do
         expect(path_helper.dirname("abc")).to eq(".")
       end
@@ -55,42 +53,109 @@ RSpec.describe ChefConfig::PathHelper do
     end
   end
 
+  context "forcing windows/non-windows" do
+    context "forcing windows" do
+      it "path_separator is \\" do
+        expect(path_helper.path_separator(windows: true)).to eq('\\')
+      end
+
+      context "platform-specific #join behavior" do
+        it "joins components on Windows when some end with unix separators" do
+          expected = "C:\\foo\\bar\\baz"
+          expect(path_helper.join('C:\\foo/', "bar", "baz", windows: true)).to eq(expected)
+        end
+
+        it "joins components when some end with separators" do
+          expected = "C:\\foo\\bar\\baz"
+          expect(path_helper.join('C:\\foo\\', "bar", "baz", windows: true)).to eq(expected)
+        end
+
+        it "joins components when some end and start with separators" do
+          expected = "C:\\foo\\bar\\baz"
+          expect(path_helper.join('C:\\foo\\', "bar/", "/baz", windows: true)).to eq(expected)
+        end
+
+        it "joins components that don't end in separators" do
+          expected = "C:\\foo\\bar\\baz"
+          expect(path_helper.join('C:\\foo', "bar", "baz", windows: true)).to eq(expected)
+        end
+      end
+
+      it "cleanpath changes slashes into backslashes and leaves backslashes alone" do
+        expect(path_helper.cleanpath('/a/b\\c/d/', windows: true)).to eq('\\a\\b\\c\\d')
+      end
+
+      it "cleanpath does not remove leading double backslash" do
+        expect(path_helper.cleanpath('\\\\a/b\\c/d/', windows: true)).to eq('\\\\a\\b\\c\\d')
+      end
+    end
+
+    context "forcing unix" do
+      it "path_separator is /" do
+        expect(path_helper.path_separator(windows: false)).to eq("/")
+      end
+
+      it "cleanpath removes extra slashes alone" do
+        expect(path_helper.cleanpath("/a///b/c/d/", windows: false)).to eq("/a/b/c/d")
+      end
+
+      context "platform-specific #join behavior" do
+        it "joins components when some end with separators" do
+          expected = "/foo/bar/baz"
+          expect(path_helper.join("/foo/", "bar", "baz", windows: false)).to eq(expected)
+        end
+
+        it "joins components when some end and start with separators" do
+          expected = "/foo/bar/baz"
+          expect(path_helper.join("/foo/", "bar/", "/baz", windows: false)).to eq(expected)
+        end
+
+        it "joins components that don't end in separators" do
+          expected = "/foo/bar/baz"
+          expect(path_helper.join("/foo", "bar", "baz", windows: false)).to eq(expected)
+        end
+      end
+
+      it "cleanpath changes backslashes into slashes and leaves slashes alone" do
+        expect(path_helper.cleanpath('/a/b\\c/d/', windows: false)).to eq("/a/b/c/d")
+      end
+
+      it "cleanpath does not remove leading double backslash" do
+        expect(path_helper.cleanpath('\\\\a/b\\c/d/', windows: false)).to eq("//a/b/c/d")
+      end
+    end
+  end
+
   context "on windows", :windows_only do
 
     before(:each) do
       allow(ChefUtils).to receive(:windows?).and_return(true)
     end
 
-    include_examples("common_functionality")
-
     it "path_separator is \\" do
       expect(path_helper.path_separator).to eq('\\')
     end
 
-    describe "platform-specific #join behavior" do
-
+    context "platform-specific #join behavior" do
       it "joins components on Windows when some end with unix separators" do
-        expect(path_helper.join('C:\\foo/', "bar", "baz")).to eq('C:\\foo\\bar\\baz')
+        expected = "C:\\foo\\bar\\baz"
+        expect(path_helper.join('C:\\foo/', "bar", "baz")).to eq(expected)
       end
 
       it "joins components when some end with separators" do
-        expected = path_helper.cleanpath("/foo/bar/baz")
-        expected = "C:#{expected}"
+        expected = "C:\\foo\\bar\\baz"
         expect(path_helper.join('C:\\foo\\', "bar", "baz")).to eq(expected)
       end
 
       it "joins components when some end and start with separators" do
-        expected = path_helper.cleanpath("/foo/bar/baz")
-        expected = "C:#{expected}"
+        expected = "C:\\foo\\bar\\baz"
         expect(path_helper.join('C:\\foo\\', "bar/", "/baz")).to eq(expected)
       end
 
       it "joins components that don't end in separators" do
-        expected = path_helper.cleanpath("/foo/bar/baz")
-        expected = "C:#{expected}"
+        expected = "C:\\foo\\bar\\baz"
         expect(path_helper.join('C:\\foo', "bar", "baz")).to eq(expected)
       end
-
     end
 
     it "cleanpath changes slashes into backslashes and leaves backslashes alone" do
@@ -100,17 +165,13 @@ RSpec.describe ChefConfig::PathHelper do
     it "cleanpath does not remove leading double backslash" do
       expect(path_helper.cleanpath('\\\\a/b\\c/d/')).to eq('\\\\a\\b\\c\\d')
     end
-
   end
 
   context "on unix", :unix_only do
-
     before(:each) do
       allow(ChefUtils).to receive(:windows?).and_return(false)
     end
 
-    include_examples("common_functionality")
-
     it "path_separator is /" do
       expect(path_helper.path_separator).to eq("/")
     end
@@ -119,8 +180,7 @@ RSpec.describe ChefConfig::PathHelper do
       expect(path_helper.cleanpath("/a///b/c/d/")).to eq("/a/b/c/d")
     end
 
-    describe "platform-specific #join behavior" do
-
+    context "platform-specific #join behavior" do
       it "joins components when some end with separators" do
         expected = path_helper.cleanpath("/foo/bar/baz")
         expect(path_helper.join("/foo/", "bar", "baz")).to eq(expected)
@@ -135,12 +195,19 @@ RSpec.describe ChefConfig::PathHelper do
         expected = path_helper.cleanpath("/foo/bar/baz")
         expect(path_helper.join("/foo", "bar", "baz")).to eq(expected)
       end
+    end
 
+    it "cleanpath changes backslashes into slashes and leaves slashes alone" do
+      expect(path_helper.cleanpath('/a/b\\c/d/', windows: false)).to eq("/a/b/c/d")
     end
 
+    # NOTE: this seems a bit weird to me, but this is just the way Pathname#cleanpath works
+    it "cleanpath does not remove leading double backslash" do
+      expect(path_helper.cleanpath('\\\\a/b\\c/d/')).to eq("//a/b/c/d")
+    end
   end
 
-  describe "validate_path" do
+  context "validate_path" do
     context "on windows" do
       before(:each) do
         # pass by default
@@ -171,7 +238,7 @@ RSpec.describe ChefConfig::PathHelper do
     end
   end
 
-  describe "windows_max_length_exceeded?" do
+  context "windows_max_length_exceeded?" do
     it "returns true if the path is too long (259 + NUL) for the API" do
       expect(path_helper.windows_max_length_exceeded?("C:\\" + "a" * 250 + "\\" + "b" * 6)).to be_truthy
     end
@@ -185,7 +252,7 @@ RSpec.describe ChefConfig::PathHelper do
     end
   end
 
-  describe "printable?" do
+  context "printable?" do
     it "returns true if the string contains no non-printable characters" do
       expect(path_helper.printable?("C:\\Program Files (x86)\\Microsoft Office\\Files.lst")).to be_truthy
     end
@@ -208,7 +275,7 @@ RSpec.describe ChefConfig::PathHelper do
     end
   end
 
-  describe "canonical_path" do
+  context "canonical_path" do
     context "on windows", :windows_only do
       it "returns an absolute path with backslashes instead of slashes" do
         expect(path_helper.canonical_path("\\\\?\\C:/windows/win.ini")).to eq("\\\\?\\c:\\windows\\win.ini")
@@ -230,25 +297,25 @@ RSpec.describe ChefConfig::PathHelper do
     end
   end
 
-  describe "paths_eql?" do
+  context "paths_eql?" do
     it "returns true if the paths are the same" do
-      allow(path_helper).to receive(:canonical_path).with("bandit").and_return("c:/bandit/bandit")
-      allow(path_helper).to receive(:canonical_path).with("../bandit/bandit").and_return("c:/bandit/bandit")
+      allow(path_helper).to receive(:canonical_path).with("bandit", windows: ChefUtils.windows?).and_return("c:/bandit/bandit")
+      allow(path_helper).to receive(:canonical_path).with("../bandit/bandit", windows: ChefUtils.windows?).and_return("c:/bandit/bandit")
       expect(path_helper.paths_eql?("bandit", "../bandit/bandit")).to be_truthy
     end
 
     it "returns false if the paths are different" do
-      allow(path_helper).to receive(:canonical_path).with("bandit").and_return("c:/Bo/Bandit")
-      allow(path_helper).to receive(:canonical_path).with("../bandit/bandit").and_return("c:/bandit/bandit")
+      allow(path_helper).to receive(:canonical_path).with("bandit", windows: ChefUtils.windows?).and_return("c:/Bo/Bandit")
+      allow(path_helper).to receive(:canonical_path).with("../bandit/bandit", windows: ChefUtils.windows?).and_return("c:/bandit/bandit")
       expect(path_helper.paths_eql?("bandit", "../bandit/bandit")).to be_falsey
     end
   end
 
-  describe "escape_glob" do
+  context "escape_glob" do
     it "escapes characters reserved by glob" do
       path = "C:\\this\\*path\\[needs]\\escaping?"
       escaped_path = "C:\\\\this\\\\\\*path\\\\\\[needs\\]\\\\escaping\\?"
-      expect(path_helper.escape_glob(path)).to eq(escaped_path)
+      expect(path_helper.escape_glob(path, windows: true)).to eq(escaped_path)
     end
 
     context "when given more than one argument" do
@@ -259,14 +326,12 @@ RSpec.describe ChefConfig::PathHelper do
                        else
                          "this/\\*path/\\[needs\\]/escaping\\?"
                        end
-        expect(path_helper).to receive(:join).with(*args).and_call_original
-        expect(path_helper).to receive(:cleanpath).and_call_original
         expect(path_helper.escape_glob(*args)).to eq(escaped_path)
       end
     end
   end
 
-  describe "escape_glob_dir" do
+  context "escape_glob_dir" do
     it "escapes characters reserved by glob without using backslashes for path separators" do
       path = "C:/this/*path/[needs]/escaping?"
       escaped_path = "C:/this/\\*path/\\[needs\\]/escaping\\?"
@@ -283,7 +348,7 @@ RSpec.describe ChefConfig::PathHelper do
     end
   end
 
-  describe "all_homes" do
+  context "all_homes" do
     before do
       stub_const("ENV", env)
       allow(ChefUtils).to receive(:windows?).and_return(is_windows)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: chef-config
 version: !ruby/object:Gem::Version
-  version: 16.3.38
+  version: 16.5.64
 platform: ruby
 authors:
 - Adam Jacob
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-07-25 00:00:00.000000000 Z
+date: 2020-09-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: chef-utils
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 16.3.38
+        version: 16.5.64
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 16.3.38
+        version: 16.5.64
 - !ruby/object:Gem::Dependency
   name: mixlib-shellout
   requirement: !ruby/object:Gem::Requirement
@@ -174,13 +174,13 @@ files:
 - chef-config.gemspec
 - lib/chef-config.rb
 - lib/chef-config/config.rb
-- lib/chef-config/dist.rb
 - lib/chef-config/exceptions.rb
 - lib/chef-config/fips.rb
 - lib/chef-config/logger.rb
 - lib/chef-config/mixin/credentials.rb
 - lib/chef-config/mixin/dot_d.rb
 - lib/chef-config/mixin/fuzzy_hostname_matcher.rb
+- lib/chef-config/mixin/train_transport.rb
 - lib/chef-config/path_helper.rb
 - lib/chef-config/version.rb
 - lib/chef-config/windows.rb

data/lib/chef-config/dist.rb

@@ -1,26 +0,0 @@
-module ChefConfig
-  class Dist
-    # The chef executable name.
-    EXEC = "chef".freeze
-
-    # The client's alias (chef-client)
-    CLIENT = "chef-client".freeze
-
-    # A short name for the product
-    SHORT = "chef".freeze
-
-    # The suffix for Chef's /etc/chef, /var/chef and C:\\Chef directories
-    # "cinc" => /etc/cinc, /var/cinc, C:\\cinc
-    DIR_SUFFIX = "chef".freeze
-
-    # The user's configuration directory
-    USER_CONF_DIR = ".chef".freeze
-
-    # The legacy conf folder: C:/opscode/chef. Specifically the "opscode" part
-    # DIR_SUFFIX is appended to it in code where relevant
-    LEGACY_CONF_DIR = "opscode".freeze
-
-    # Enable forcing Chef EULA
-    ENFORCE_LICENSE = true
-  end
-end