chef 16.4.41-universal-mingw32 → 16.5.64-universal-mingw32

data/lib/chef/knife/bootstrap/chef_vault_handler.rb

@@ -112,7 +112,7 @@ class Chef
               if bootstrap_vault_item
                 bootstrap_vault_item
               else
-                json = bootstrap_vault_json ? bootstrap_vault_json : File.read(bootstrap_vault_file)
+                json = bootstrap_vault_json || File.read(bootstrap_vault_file)
                 Chef::JSONCompat.from_json(json)
               end
             end

data/lib/chef/knife/bootstrap/templates/chef-full.erb

@@ -172,8 +172,8 @@ do_download() {
   <%= @config[:bootstrap_install_command] %>
 <% else %>
   install_sh="<%= @config[:bootstrap_url] ? @config[:bootstrap_url] : "https://omnitruck.chef.io/chef/install.sh" %>"
-  if test -f /usr/bin/<%= Chef::Dist::CLIENT %>; then
-    echo "-----> Existing <%= Chef::Dist::PRODUCT %> installation detected"
+  if test -f /usr/bin/<%= ChefUtils::Dist::Infra::CLIENT %>; then
+    echo "-----> Existing <%= ChefUtils::Dist::Infra::PRODUCT %> installation detected"
   else
     echo "-----> Installing Chef Omnibus (<%= @config[:channel] %>/<%= version_to_install %>)"
     do_download ${install_sh} $tmp_dir/install.sh
@@ -237,6 +237,6 @@ mkdir -p /etc/chef/client.d
 <%= client_d %>
 <% end -%>
 
-echo "Starting the first <%= Chef::Dist::PRODUCT %> Client run..."
+echo "Starting the first <%= ChefUtils::Dist::Infra::PRODUCT %> Client run..."
 
 <%= start_chef %>

data/lib/chef/knife/bootstrap/templates/windows-chef-client-msi.erb

@@ -109,13 +109,13 @@ goto Version10.0
 goto chef_installed
 
 :chef_installed
-@echo Checking for existing <%= Chef::Dist::PRODUCT %> installation
-WHERE <%= Chef::Dist::CLIENT %> >nul 2>nul
+@echo Checking for existing <%= ChefUtils::Dist::Infra::PRODUCT %> installation
+WHERE <%= ChefUtils::Dist::Infra::CLIENT %> >nul 2>nul
 If !ERRORLEVEL!==0 (
-  @echo Existing <%= Chef::Dist::PRODUCT %> installation detected, skipping download
+  @echo Existing <%= ChefUtils::Dist::Infra::PRODUCT %> installation detected, skipping download
   goto key_create
 ) else (
-  @echo No existing installation of <%= Chef::Dist::PRODUCT %> detected
+  @echo No existing installation of <%= ChefUtils::Dist::Infra::PRODUCT %> detected
   goto install
 )
 
@@ -127,7 +127,7 @@ If !ERRORLEVEL!==0 (
   @rem Install Chef using the MSI installer
 
   @set "LOCAL_DESTINATION_MSI_PATH=<%= local_download_path %>"
-  @set "CHEF_CLIENT_MSI_LOG_PATH=%TEMP%\<%= Chef::Dist::CLIENT %>-msi%RANDOM%.log"
+  @set "CHEF_CLIENT_MSI_LOG_PATH=%TEMP%\<%= ChefUtils::Dist::Infra::CLIENT %>-msi%RANDOM%.log"
 
   @rem Clear any pre-existing downloads
   @echo Checking for existing downloaded package at "%LOCAL_DESTINATION_MSI_PATH%"
@@ -197,7 +197,7 @@ If !ERRORLEVEL!==0 (
   <%= install_chef %>
 
   @if ERRORLEVEL 1 (
-      echo <%= Chef::Dist::CLIENT %> package failed to install with status code !ERRORLEVEL!. > "&2"
+      echo <%= ChefUtils::Dist::Infra::CLIENT %> package failed to install with status code !ERRORLEVEL!. > "&2"
       echo See installation log for additional detail: %CHEF_CLIENT_MSI_LOG_PATH%. > "&2"
   ) else (
       @echo Installation completed successfully
@@ -274,5 +274,5 @@ echo Validation key written.
   <%= client_d %>
 <% end -%>
 
-@echo Starting <%= Chef::Dist::CLIENT %> to bootstrap the node...
+@echo Starting <%= ChefUtils::Dist::Infra::CLIENT %> to bootstrap the node...
 <%= start_chef %>

data/lib/chef/knife/client_create.rb

@@ -17,7 +17,7 @@
 #
 
 require_relative "../knife"
-require_relative "../dist"
+require "chef-utils/dist" unless defined?(ChefUtils::Dist)
 
 class Chef
   class Knife
@@ -30,7 +30,7 @@ class Chef
       option :file,
         short: "-f FILE",
         long: "--file FILE",
-        description: "Write the private key to a file if the #{Chef::Dist::SERVER_PRODUCT} generated one."
+        description: "Write the private key to a file if the #{ChefUtils::Dist::Server::PRODUCT} generated one."
 
       option :validator,
         long: "--validator",
@@ -45,7 +45,7 @@ class Chef
       option :prevent_keygen,
         short: "-k",
         long: "--prevent-keygen",
-        description: "Prevent #{Chef::Dist::SERVER_PRODUCT} from generating a default key pair for you. Cannot be passed with --public-key.",
+        description: "Prevent #{ChefUtils::Dist::Server::PRODUCT} from generating a default key pair for you. Cannot be passed with --public-key.",
         boolean: true
 
       banner "knife client create CLIENTNAME (options)"

data/lib/chef/knife/config_get.rb

@@ -18,110 +18,21 @@
 #
 
 require_relative "../knife"
+require_relative "./config_show"
 
 class Chef
   class Knife
-    class ConfigGet < Knife
-      banner "knife config get [OPTION...] (options)\nDisplays the value of Chef::Config[OPTION] (or all config values)"
+    class ConfigGet < ConfigShow
 
-      option :all,
-        short: "-a",
-        long: "--all",
-        description: "Include options that are not set in the configuration.",
-        default: false
+      # Handle the subclassing (knife doesn't do this :()
+      dependency_loaders.concat(superclass.dependency_loaders)
 
-      option :raw,
-        short: "-r",
-        long: "--raw",
-        description: "Display a each value with no formatting.",
-        default: false
+      banner "knife config get [OPTION...] (options)\nDisplays the value of Chef::Config[OPTION] (or all config values)"
+      category "deprecated"
 
       def run
-        if config[:format] == "summary" && !config[:raw]
-          # If using the default, human-readable output, also show which config files are being loaded.
-          # Some of this is a bit hacky since it duplicates
-          wcl = self.class.config_loader
-          if wcl.credentials_found
-            loading_from("credentials", ChefConfig::PathHelper.home(".chef", "credentials"))
-          end
-          if wcl.config_location
-            loading_from("configuration", wcl.config_location)
-          end
-
-          if Chef::Config[:config_d_dir]
-            wcl.find_dot_d(Chef::Config[:config_d_dir]).each do |path|
-              loading_from(".d/ configuration", path)
-            end
-          end
-        end
-
-        # Dump the whole config, including defaults is --all was given.
-        config_data = Chef::Config.save(config[:all])
-        # Two special cases, these are set during knife startup but we don't usually care about them.
-        unless config[:all]
-          config_data.delete(:color)
-          # Only keep these if true, false is much less important because it's the default.
-          config_data.delete(:local_mode) unless config_data[:local_mode]
-          config_data.delete(:enforce_default_paths) unless config_data[:enforce_default_paths]
-          config_data.delete(:enforce_path_sanity) unless config_data[:enforce_path_sanity]
-        end
-
-        # Extract the data to show.
-        output_data = {}
-        if @name_args.empty?
-          output_data = config_data
-        else
-          @name_args.each do |filter|
-            if filter =~ %r{^/(.*)/(i?)$}
-              # It's a regex.
-              filter_re = Regexp.new($1, $2 ? Regexp::IGNORECASE : 0)
-              config_data.each do |key, value|
-                output_data[key] = value if key.to_s&.match?(filter_re)
-              end
-            else
-              # It's a dotted path string.
-              filter_parts = filter.split(/\./)
-              extract = lambda do |memo, filter_part|
-                memo.is_a?(Hash) ? memo[filter_part.to_sym] : nil
-              end
-              # Check against both config_data and all of the data, so that even
-              # in non-all mode, if you ask for a key that isn't in the non-all
-              # data, it will check against the broader set.
-              output_data[filter] = filter_parts.inject(config_data, &extract) || filter_parts.inject(Chef::Config.save(true), &extract)
-            end
-          end
-        end
-
-        # Fix up some values.
-        output_data.each do |key, value|
-          if value == STDOUT
-            output_data[key] = "STDOUT"
-          elsif value == STDERR
-            output_data[key] = "STDERR"
-          end
-        end
-
-        # Show the data.
-        if config[:raw]
-          output_data.each_value do |value|
-            ui.msg(value)
-          end
-        else
-          ui.output(output_data)
-        end
-      end
-
-      private
-
-      # Display a banner about loading from a config file.
-      #
-      # @api private
-      # @param type_of_file [String] Description of the file for the banner.
-      # @param path [String] Path of the file.
-      # @return [nil]
-      def loading_from(type_of_file, path)
-        path = Pathname.new(path).realpath
-        ui.msg(ui.color("Loading from #{type_of_file} file #{path}", :yellow))
+        Chef::Log.warn("knife config get has been deprecated in favor of knife config show. This will be removed in the major release version!")
+        super
       end
     end
   end

data/lib/chef/knife/config_get_profile.rb

@@ -16,22 +16,22 @@
 #
 
 require_relative "../knife"
+require_relative "./config_use"
 
 class Chef
   class Knife
-    class ConfigGetProfile < Knife
-      banner "knife config get-profile"
+    class ConfigGetProfile < ConfigUse
 
-      # Disable normal config loading since this shouldn't fail if the profile
-      # doesn't exist of the config is otherwise corrupted.
-      def configure_chef
-        apply_computed_config
-      end
+      # Handle the subclassing (knife doesn't do this :()
+      dependency_loaders.concat(superclass.dependency_loaders)
+
+      banner "knife config get-profile"
+      category "deprecated"
 
       def run
-        ui.msg(self.class.config_loader.credentials_profile(config[:profile]))
+        Chef::Log.warn("knife config get-profiles has been deprecated in favor of knife config use. This will be removed in the major release version!")
+        super
       end
-
     end
   end
 end

data/lib/chef/knife/config_list.rb

@@ -0,0 +1,139 @@
+#
+# Copyright:: Copyright (c) 2018, Noah Kantrowitz
+# 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 "../knife"
+
+class Chef
+  class Knife
+    class ConfigList < Knife
+      banner "knife config list (options)"
+
+      TABLE_HEADER ||= [" Profile", "Client", "Key", "Server"].freeze
+
+      deps do
+        require_relative "../workstation_config_loader"
+        require "tty-screen" unless defined?(TTY::Screen)
+        require "tty-table" unless defined?(TTY::Table)
+      end
+
+      option :ignore_knife_rb,
+        short: "-i",
+        long: "--ignore-knife-rb",
+        description: "Ignore the current config.rb/knife.rb configuration.",
+        default: false
+
+      def configure_chef
+        apply_computed_config
+      end
+
+      def run
+        credentials_data = self.class.config_loader.parse_credentials_file
+        if credentials_data.nil? || credentials_data.empty?
+          # Should this just show the ambient knife.rb config as "default" instead?
+          ui.fatal("No profiles found, #{self.class.config_loader.credentials_file_path} does not exist or is empty")
+          exit 1
+        end
+
+        current_profile = self.class.config_loader.credentials_profile(config[:profile])
+        profiles = credentials_data.keys.map do |profile|
+          if config[:ignore_knife_rb]
+            # Don't do any fancy loading nonsense, just the raw data.
+            profile_data = credentials_data[profile]
+            {
+              profile: profile,
+              active: profile == current_profile,
+              client_name: profile_data["client_name"] || profile_data["node_name"],
+              client_key: profile_data["client_key"],
+              server_url: profile_data["chef_server_url"],
+            }
+          else
+            # Fancy loading nonsense so we get what the actual config would be.
+            # Note that this modifies the global config, after this, all bets are
+            # off as to whats in the config.
+            Chef::Config.reset
+            wcl = Chef::WorkstationConfigLoader.new(nil, Chef::Log, profile: profile)
+            wcl.load
+            {
+              profile: profile,
+              active: profile == current_profile,
+              client_name: Chef::Config[:node_name],
+              client_key: Chef::Config[:client_key],
+              server_url: Chef::Config[:chef_server_url],
+            }
+          end
+        end
+
+        # Try to reset the config.
+        unless config[:ignore_knife_rb]
+          Chef::Config.reset
+          apply_computed_config
+        end
+
+        if ui.interchange?
+          # Machine-readable output.
+          ui.output(profiles)
+        else
+          # Table output.
+          ui.output(render_table(profiles))
+        end
+      end
+
+      private
+
+      def render_table(profiles, padding: 1)
+        rows = []
+        # Render the data to a 2D array that will be used for the table.
+        profiles.each do |profile|
+          # Replace the home dir in the client key path with ~.
+          profile[:client_key] = profile[:client_key].to_s.gsub(/^#{Regexp.escape(Dir.home)}/, "~") if profile[:client_key]
+          profile[:profile] = "#{profile[:active] ? "*" : " "}#{profile[:profile]}"
+          rows << profile.values_at(:profile, :client_name, :client_key, :server_url)
+        end
+
+        table = TTY::Table.new(header: TABLE_HEADER, rows: rows)
+
+        # Rotate the table to vertical if the screen width is less than table width.
+        if table.width > TTY::Screen.width
+          table.orientation = :vertical
+          table.rotate
+          # Add a new line after each profile record.
+          table.render do |renderer|
+            renderer.border do
+              separator ->(row) { (row + 1) % TABLE_HEADER.size == 0 }
+            end
+            # Remove the leading space added of the first column.
+            renderer.filter = Proc.new do |val, row_index, col_index|
+              if col_index == 1 || (row_index) % TABLE_HEADER.size == 0
+                val.strip
+              else
+                val
+              end
+            end
+          end
+        else
+          table.render do |renderer|
+            renderer.border do
+              mid "-"
+            end
+            renderer.padding = [0, padding, 0, 0] # pad right with 2 characters
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/chef/knife/config_list_profiles.rb

@@ -16,112 +16,22 @@
 #
 
 require_relative "../knife"
+require_relative "./config_list"
 
 class Chef
   class Knife
-    class ConfigListProfiles < Knife
-      banner "knife config list-profiles (options)"
-
-      deps do
-        require_relative "../workstation_config_loader"
-      end
+    class ConfigListProfiles < ConfigList
 
-      option :ignore_knife_rb,
-        short: "-i",
-        long: "--ignore-knife-rb",
-        description: "Ignore the current config.rb/knife.rb configuration.",
-        default: false
+      # Handle the subclassing (knife doesn't do this :()
+      dependency_loaders.concat(superclass.dependency_loaders)
 
-      def configure_chef
-        apply_computed_config
-      end
+      banner "knife config list-profiles (options)"
+      category "deprecated"
 
       def run
-        credentials_data = self.class.config_loader.parse_credentials_file
-        if credentials_data.nil? || credentials_data.empty?
-          # Should this just show the ambient knife.rb config as "default" instead?
-          ui.fatal("No profiles found, #{self.class.config_loader.credentials_file_path} does not exist or is empty")
-          exit 1
-        end
-
-        current_profile = self.class.config_loader.credentials_profile(config[:profile])
-        profiles = credentials_data.keys.map do |profile|
-          if config[:ignore_knife_rb]
-            # Don't do any fancy loading nonsense, just the raw data.
-            profile_data = credentials_data[profile]
-            {
-              profile: profile,
-              active: profile == current_profile,
-              client_name: profile_data["client_name"] || profile_data["node_name"],
-              client_key: profile_data["client_key"],
-              server_url: profile_data["chef_server_url"],
-            }
-          else
-            # Fancy loading nonsense so we get what the actual config would be.
-            # Note that this modifies the global config, after this, all bets are
-            # off as to whats in the config.
-            Chef::Config.reset
-            wcl = Chef::WorkstationConfigLoader.new(nil, Chef::Log, profile: profile)
-            wcl.load
-            {
-              profile: profile,
-              active: profile == current_profile,
-              client_name: Chef::Config[:node_name],
-              client_key: Chef::Config[:client_key],
-              server_url: Chef::Config[:chef_server_url],
-            }
-          end
-        end
-
-        # Try to reset the config.
-        unless config[:ignore_knife_rb]
-          Chef::Config.reset
-          apply_computed_config
-        end
-
-        if ui.interchange?
-          # Machine-readable output.
-          ui.output(profiles)
-        else
-          # Table output.
-          ui.output(render_table(profiles))
-        end
-      end
-
-      private
-
-      def render_table(profiles, padding: 2)
-        # Replace the home dir in the client key path with ~.
-        profiles.each do |profile|
-          profile[:client_key] = profile[:client_key].to_s.gsub(/^#{Regexp.escape(Dir.home)}/, "~") if profile[:client_key]
-        end
-        # Render the data to a 2D array that will be used for the table.
-        table_data = [["", "Profile", "Client", "Key", "Server"]] + profiles.map do |profile|
-          [profile[:active] ? "*" : ""] + profile.values_at(:profile, :client_name, :client_key, :server_url).map(&:to_s)
-        end
-        # Compute column widths.
-        column_widths = Array.new(table_data.first.length) do |i|
-          table_data.map { |row| row[i].length + padding }.max
-        end
-        # Special case, the first col gets no padding (because indicator) and last
-        # get no padding because last.
-        column_widths[0] -= padding
-        column_widths[-1] -= padding
-        # Build the format string for each row.
-        format_string = column_widths.map { |w| "%-#{w}.#{w}s" }.join("")
-        format_string << "\n"
-        # Print the header row and a separator.
-        table = ui.color(format_string % table_data.first, :green)
-        table << "-" * column_widths.sum
-        table << "\n"
-        # Print the rest of the table.
-        table_data.drop(1).each do |row|
-          table << format_string % row
-        end
-        # Trim the last newline because ui.output adds one.
-        table.chomp!
+        Chef::Log.warn("knife config list-profiles has been deprecated in favor of knife config list. This will be removed in the major release version!")
+        super
       end
-
     end
   end
 end