chef 16.18.0-universal-mingw32 → 17.0.242-universal-mingw32

data/lib/chef/knife/core/bootstrap_context.rb

@@ -1,264 +0,0 @@
-#
-# Author:: Daniel DeLeo (<dan@chef.io>)
-# Copyright:: Copyright (c) Chef Software Inc.
-# License:: Apache License, Version 2.0
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-
-require_relative "../../run_list"
-require_relative "../../util/path_helper"
-require "pathname" unless defined?(Pathname)
-require "chef-utils/dist" unless defined?(ChefUtils::Dist)
-
-class Chef
-  class Knife
-    module Core
-      # Instances of BootstrapContext are the context objects (i.e., +self+) for
-      # bootstrap templates. For backwards compatibility, they +must+ set the
-      # following instance variables:
-      # * @config   - a hash of knife's config values
-      # * @run_list - the run list for the node to bootstrap
-      #
-      class BootstrapContext
-
-        attr_accessor :client_pem
-        attr_accessor :config
-        attr_accessor :chef_config
-
-        def initialize(config, run_list, chef_config, secret = nil)
-          @config       = config
-          @run_list     = run_list
-          @chef_config  = chef_config
-          @secret       = secret
-        end
-
-        def bootstrap_environment
-          config[:environment]
-        end
-
-        def validation_key
-          if chef_config[:validation_key] &&
-              File.exist?(File.expand_path(chef_config[:validation_key]))
-            IO.read(File.expand_path(chef_config[:validation_key]))
-          else
-            false
-          end
-        end
-
-        def client_d
-          @client_d ||= client_d_content
-        end
-
-        def encrypted_data_bag_secret
-          @secret
-        end
-
-        # Contains commands and content, see trusted_certs_content
-        # @todo Rename to trusted_certs_script
-        def trusted_certs
-          @trusted_certs ||= trusted_certs_content
-        end
-
-        def get_log_location
-          if !(chef_config[:config_log_location].class == IO ) && (chef_config[:config_log_location].nil? || chef_config[:config_log_location].to_s.empty?)
-            "STDOUT"
-          elsif chef_config[:config_log_location].equal?(:win_evt)
-            raise "The value :win_evt is not supported for config_log_location on Linux Platforms \n"
-          elsif chef_config[:config_log_location].equal?(:syslog)
-            ":syslog"
-          elsif chef_config[:config_log_location].equal?(STDOUT)
-            "STDOUT"
-          elsif chef_config[:config_log_location].equal?(STDERR)
-            "STDERR"
-          elsif chef_config[:config_log_location]
-            %Q{"#{chef_config[:config_log_location]}"}
-          else
-            "STDOUT"
-          end
-        end
-
-        def config_content
-          client_rb = <<~CONFIG
-            chef_server_url  "#{chef_config[:chef_server_url]}"
-            validation_client_name "#{chef_config[:validation_client_name]}"
-          CONFIG
-
-          unless chef_config[:chef_license].nil?
-            client_rb << "chef_license \"#{chef_config[:chef_license]}\"\n"
-          end
-
-          unless chef_config[:config_log_level].nil? || chef_config[:config_log_level].empty?
-            client_rb << %Q{log_level   :#{chef_config[:config_log_level]}\n}
-          end
-
-          client_rb << "log_location   #{get_log_location}\n"
-
-          if config[:chef_node_name]
-            client_rb << %Q{node_name "#{config[:chef_node_name]}"\n}
-          else
-            client_rb << "# Using default node name (fqdn)\n"
-          end
-
-          # We configure :verify_api_cert only when it's overridden on the CLI
-          # or when specified in the knife config.
-          if !config[:node_verify_api_cert].nil? || config.key?(:verify_api_cert)
-            value = config[:node_verify_api_cert].nil? ? config[:verify_api_cert] : config[:node_verify_api_cert]
-            client_rb << %Q{verify_api_cert #{value}\n}
-          end
-
-          # We configure :ssl_verify_mode only when it's overridden on the CLI
-          # or when specified in the knife config.
-          if config[:node_ssl_verify_mode] || config.key?(:ssl_verify_mode)
-            value = case config[:node_ssl_verify_mode]
-                    when "peer"
-                      :verify_peer
-                    when "none"
-                      :verify_none
-                    when nil
-                      config[:ssl_verify_mode]
-                    else
-                      nil
-                    end
-
-            if value
-              client_rb << %Q{ssl_verify_mode :#{value}\n}
-            end
-          end
-
-          if config[:ssl_verify_mode]
-            client_rb << %Q{ssl_verify_mode :#{config[:ssl_verify_mode]}\n}
-          end
-
-          if config[:bootstrap_proxy]
-            client_rb << %Q{http_proxy        "#{config[:bootstrap_proxy]}"\n}
-            client_rb << %Q{https_proxy       "#{config[:bootstrap_proxy]}"\n}
-          end
-
-          if config[:bootstrap_proxy_user]
-            client_rb << %Q{http_proxy_user   "#{config[:bootstrap_proxy_user]}"\n}
-            client_rb << %Q{https_proxy_user  "#{config[:bootstrap_proxy_user]}"\n}
-          end
-
-          if config[:bootstrap_proxy_pass]
-            client_rb << %Q{http_proxy_pass   "#{config[:bootstrap_proxy_pass]}"\n}
-            client_rb << %Q{https_proxy_pass  "#{config[:bootstrap_proxy_pass]}"\n}
-          end
-
-          if config[:bootstrap_no_proxy]
-            client_rb << %Q{no_proxy       "#{config[:bootstrap_no_proxy]}"\n}
-          end
-
-          if encrypted_data_bag_secret
-            client_rb << %Q{encrypted_data_bag_secret "/etc/chef/encrypted_data_bag_secret"\n}
-          end
-
-          unless trusted_certs.empty?
-            client_rb << %Q{trusted_certs_dir "/etc/chef/trusted_certs"\n}
-          end
-
-          if chef_config[:fips]
-            client_rb << "fips true\n"
-          end
-
-          unless chef_config[:file_cache_path].nil?
-            client_rb << "file_cache_path \"#{chef_config[:file_cache_path]}\"\n"
-          end
-
-          unless chef_config[:file_backup_path].nil?
-            client_rb << "file_backup_path \"#{chef_config[:file_backup_path]}\"\n"
-          end
-
-          client_rb
-        end
-
-        def start_chef
-          # If the user doesn't have a client path configure, let bash use the PATH for what it was designed for
-          client_path = chef_config[:chef_client_path] || ChefUtils::Dist::Infra::CLIENT
-          s = "#{client_path} -j /etc/chef/first-boot.json"
-          if config[:verbosity] && config[:verbosity] >= 3
-            s << " -l trace"
-          elsif config[:verbosity] && config[:verbosity] >= 2
-            s << " -l debug"
-          end
-          s << " -E #{bootstrap_environment}" unless bootstrap_environment.nil?
-          s << " --no-color" unless config[:color]
-          s
-        end
-
-        #
-        # Returns the version of Chef to install (as recognized by the Omnitruck API)
-        #
-        # @return [String] download version string
-        def version_to_install
-          return config[:bootstrap_version] if config[:bootstrap_version]
-
-          if config[:channel] == "stable"
-            Chef::VERSION.split(".").first
-          else
-            "latest"
-          end
-        end
-
-        def first_boot
-          (config[:first_boot_attributes] = Mash.new(config[:first_boot_attributes]) || Mash.new).tap do |attributes|
-            if config[:policy_name] && config[:policy_group]
-              attributes[:policy_name] = config[:policy_name]
-              attributes[:policy_group] = config[:policy_group]
-            else
-              attributes[:run_list] = @run_list
-            end
-            attributes.delete(:run_list) if attributes[:policy_name] && !attributes[:policy_name].empty?
-            attributes.merge!(tags: config[:tags]) if config[:tags] && !config[:tags].empty?
-          end
-        end
-
-        private
-
-        # Returns a string for copying the trusted certificates on the workstation to the system being bootstrapped
-        # This string should contain both the commands necessary to both create the files, as well as their content
-        def trusted_certs_content
-          content = ""
-          if chef_config[:trusted_certs_dir]
-            Dir.glob(File.join(Chef::Util::PathHelper.escape_glob_dir(chef_config[:trusted_certs_dir]), "*.{crt,pem}")).each do |cert|
-              content << "cat > /etc/chef/trusted_certs/#{File.basename(cert)} <<'EOP'\n" +
-                IO.read(File.expand_path(cert)) + "\nEOP\n"
-            end
-          end
-          content
-        end
-
-        def client_d_content
-          content = ""
-          if chef_config[:client_d_dir] && File.exist?(chef_config[:client_d_dir])
-            root = Pathname(chef_config[:client_d_dir])
-            root.find do |f|
-              relative = f.relative_path_from(root)
-              if f != root
-                file_on_node = "/etc/chef/client.d/#{relative}"
-                if f.directory?
-                  content << "mkdir #{file_on_node}\n"
-                else
-                  content << "cat > #{file_on_node} <<'EOP'\n" +
-                    f.read.gsub("'", "'\\\\''") + "\nEOP\n"
-                end
-              end
-            end
-          end
-          content
-        end
-
-      end
-    end
-  end
-end

data/lib/chef/knife/core/cookbook_scm_repo.rb

@@ -1,159 +0,0 @@
-#
-# Author:: Daniel DeLeo (<dan@chef.io>)
-# Copyright:: Copyright (c) Chef Software Inc.
-# License:: Apache License, Version 2.0
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-
-require_relative "../../mixin/shell_out"
-
-class Chef
-  class Knife
-    class CookbookSCMRepo
-
-      DIRTY_REPO = /^\s+M/.freeze
-
-      include Chef::Mixin::ShellOut
-
-      attr_reader :repo_path
-      attr_reader :default_branch
-      attr_reader :use_current_branch
-      attr_reader :ui
-
-      def initialize(repo_path, ui, opts = {})
-        @repo_path = repo_path
-        @ui = ui
-        @default_branch = "master"
-        @use_current_branch = false
-        apply_opts(opts)
-      end
-
-      def sanity_check
-        unless ::File.directory?(repo_path)
-          ui.error("The cookbook repo path #{repo_path} does not exist or is not a directory")
-          exit 1
-        end
-        unless git_repo?(repo_path)
-          ui.error "The cookbook repo #{repo_path} is not a git repository."
-          ui.info("Use `git init` to initialize a git repo")
-          exit 1
-        end
-        if use_current_branch
-          @default_branch = get_current_branch
-        end
-        unless branch_exists?(default_branch)
-          ui.error "The default branch '#{default_branch}' does not exist"
-          ui.info "If this is a new git repo, make sure you have at least one commit before installing cookbooks"
-          exit 1
-        end
-        cmd = git("status --porcelain")
-        if DIRTY_REPO.match?(cmd.stdout)
-          ui.error "You have uncommitted changes to your cookbook repo (#{repo_path}):"
-          ui.msg cmd.stdout
-          ui.info "Commit or stash your changes before importing cookbooks"
-          exit 1
-        end
-        # TODO: any untracked files in the cookbook directory will get nuked later
-        # make this an error condition also.
-        true
-      end
-
-      def reset_to_default_state
-        ui.info("Checking out the #{default_branch} branch.")
-        git("checkout #{default_branch}")
-      end
-
-      def prepare_to_import(cookbook_name)
-        branch = "chef-vendor-#{cookbook_name}"
-        if branch_exists?(branch)
-          ui.info("Pristine copy branch (#{branch}) exists, switching to it.")
-          git("checkout #{branch}")
-        else
-          ui.info("Creating pristine copy branch #{branch}")
-          git("checkout -b #{branch}")
-        end
-      end
-
-      def finalize_updates_to(cookbook_name, version)
-        if update_count = updated?(cookbook_name)
-          ui.info "#{update_count} files updated, committing changes"
-          git("add #{cookbook_name}")
-          git("commit -m \"Import #{cookbook_name} version #{version}\" -- #{cookbook_name}")
-          ui.info("Creating tag cookbook-site-imported-#{cookbook_name}-#{version}")
-          git("tag -f cookbook-site-imported-#{cookbook_name}-#{version}")
-          true
-        else
-          ui.info("No changes made to #{cookbook_name}")
-          false
-        end
-      end
-
-      def merge_updates_from(cookbook_name, version)
-        branch = "chef-vendor-#{cookbook_name}"
-        Dir.chdir(repo_path) do
-          if system("git merge #{branch}")
-            ui.info("Cookbook #{cookbook_name} version #{version} successfully installed")
-          else
-            ui.error("You have merge conflicts - please resolve manually")
-            ui.info("Merge status (cd #{repo_path}; git status):")
-            system("git status")
-            exit 3
-          end
-        end
-      end
-
-      def updated?(cookbook_name)
-        update_count = git("status --porcelain -- #{cookbook_name}").stdout.strip.lines.count
-        update_count == 0 ? nil : update_count
-      end
-
-      def branch_exists?(branch_name)
-        git("branch --no-color").stdout.lines.any? { |l| l =~ /\s#{Regexp.escape(branch_name)}(?:\s|$)/ }
-      end
-
-      def get_current_branch
-        ref = git("symbolic-ref HEAD").stdout
-        ref.chomp.split("/")[2]
-      end
-
-      private
-
-      def git_repo?(directory)
-        if File.directory?(File.join(directory, ".git"))
-          true
-        elsif File.dirname(directory) == directory
-          false
-        else
-          git_repo?(File.dirname(directory))
-        end
-      end
-
-      def apply_opts(opts)
-        opts.each do |option, value|
-          case option.to_s
-          when "default_branch"
-            @default_branch = value
-          when "use_current_branch"
-            @use_current_branch = value
-          end
-        end
-      end
-
-      def git(command)
-        shell_out!("git #{command}", cwd: repo_path)
-      end
-
-    end
-  end
-end

data/lib/chef/knife/core/formatting_options.rb

@@ -1,49 +0,0 @@
-#
-# Author:: Nicolas DUPEUX (<nicolas.dupeux@arkea.com>)
-# 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.
-#
-
-class Chef
-  class Knife
-    module Core
-
-      # This module may be included into a knife subcommand class to automatically
-      # add configuration options used by the StatusPresenter and NodePresenter.
-      module FormattingOptions
-        # @private
-        # Would prefer to do this in a rational way, but can't be done b/c of
-        # Mixlib::CLI's design :(
-        def self.included(includer)
-          includer.class_eval do
-            option :medium_output,
-              short: "-m",
-              long: "--medium",
-              boolean: true,
-              default: false,
-              description: "Include normal attributes in the output"
-
-            option :long_output,
-              short: "-l",
-              long: "--long",
-              boolean: true,
-              default: false,
-              description: "Include all attributes in the output"
-          end
-        end
-      end
-    end
-  end
-end

data/lib/chef/knife/core/gem_glob_loader.rb

@@ -1,138 +0,0 @@
-# Author:: Christopher Brown (<cb@chef.io>)
-# Author:: Daniel DeLeo (<dan@chef.io>)
-# Copyright:: Copyright (c) Chef Software Inc.
-# License:: Apache License, Version 2.0
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-
-require_relative "../../version"
-require_relative "../../util/path_helper"
-class Chef
-  class Knife
-    class SubcommandLoader
-      class GemGlobLoader < Chef::Knife::SubcommandLoader
-        MATCHES_CHEF_GEM ||= %r{/chef-\d+\.\d+\.\d+}.freeze
-        MATCHES_THIS_CHEF_GEM ||= %r{/chef-#{Chef::VERSION}(-\w+)?(-\w+)?/}.freeze
-
-        def subcommand_files
-          @subcommand_files ||= (gem_and_builtin_subcommands.values + site_subcommands).flatten.uniq
-        end
-
-        # Returns a Hash of paths to knife commands built-in to chef, or installed via gem.
-        # If rubygems is not installed, falls back to globbing the knife directory.
-        # The Hash is of the form {"relative/path" => "/absolute/path"}
-        #--
-        # Note: the "right" way to load the plugins is to require the relative path, i.e.,
-        #   require 'chef/knife/command'
-        # but we're getting frustrated by bugs at every turn, and it's slow besides. So
-        # subcommand loader has been modified to load the plugins by using Kernel.load
-        # with the absolute path.
-        def gem_and_builtin_subcommands
-          require "rubygems" unless defined?(Gem)
-          find_subcommands_via_rubygems
-        rescue LoadError
-          find_subcommands_via_dirglob
-        end
-
-        def find_subcommands_via_dirglob
-          # The "require paths" of the core knife subcommands bundled with chef
-          files = Dir[File.join(Chef::Util::PathHelper.escape_glob_dir(File.expand_path("../../knife", __dir__)), "*.rb")]
-          subcommand_files = {}
-          files.each do |knife_file|
-            rel_path = knife_file[/#{CHEF_ROOT}#{Regexp.escape(File::SEPARATOR)}(.*)\.rb/, 1]
-            subcommand_files[rel_path] = knife_file
-          end
-          subcommand_files
-        end
-
-        def find_subcommands_via_rubygems
-          files = find_files_latest_gems "chef/knife/*.rb"
-          subcommand_files = {}
-          files.each do |file|
-            rel_path = file[/(#{Regexp.escape File.join('chef', 'knife', '')}.*)\.rb/, 1]
-
-            # When not installed as a gem (ChefDK/appbundler in particular), AND
-            # a different version of Chef is installed via gems, `files` will
-            # include some files from the 'other' Chef install. If this contains
-            # a knife command that doesn't exist in this version of Chef, we will
-            # get a LoadError later when we try to require it.
-            next if from_different_chef_version?(file)
-
-            subcommand_files[rel_path] = file
-          end
-
-          subcommand_files.merge(find_subcommands_via_dirglob)
-        end
-
-        private
-
-        def find_files_latest_gems(glob, check_load_path = true)
-          files = []
-
-          if check_load_path
-            files = $LOAD_PATH.map do |load_path|
-              Dir["#{File.expand_path glob, Chef::Util::PathHelper.escape_glob_dir(load_path)}#{Gem.suffix_pattern}"]
-            end.flatten.select { |file| File.file? file.untaint }
-          end
-
-          gem_files = latest_gem_specs.map do |spec|
-            # Gem::Specification#matches_for_glob wasn't added until RubyGems 1.8
-            if spec.respond_to? :matches_for_glob
-              spec.matches_for_glob("#{glob}#{Gem.suffix_pattern}")
-            else
-              check_spec_for_glob(spec, glob)
-            end
-          end.flatten
-
-          files.concat gem_files
-          files.uniq! if check_load_path
-
-          files
-        end
-
-        def latest_gem_specs
-          @latest_gem_specs ||= if Gem::Specification.respond_to? :latest_specs
-                                  Gem::Specification.latest_specs(true) # find prerelease gems
-                                else
-                                  Gem.source_index.latest_specs(true)
-                                end
-        end
-
-        def check_spec_for_glob(spec, glob)
-          dirs = if spec.require_paths.size > 1
-                   "{#{spec.require_paths.join(",")}}"
-                 else
-                   spec.require_paths.first
-                 end
-
-          glob = File.join(Chef::Util::PathHelper.escape_glob_dir(spec.full_gem_path, dirs), glob)
-
-          Dir[glob].map(&:untaint)
-        end
-
-        def from_different_chef_version?(path)
-          matches_any_chef_gem?(path) && !matches_this_chef_gem?(path)
-        end
-
-        def matches_any_chef_gem?(path)
-          path =~ MATCHES_CHEF_GEM
-        end
-
-        def matches_this_chef_gem?(path)
-          path =~ MATCHES_THIS_CHEF_GEM
-        end
-      end
-    end
-  end
-end