chef-cli 1.0.3

data/lib/chef-cli/chef_runner.rb

@@ -0,0 +1,114 @@
+#
+# Copyright:: Copyright (c) 2014-2019 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 "exceptions"
+require_relative "service_exceptions"
+require "chef/policy_builder/dynamic"
+require "chef"
+
+require_relative "command/generator_commands/chef_exts/quieter_doc_formatter"
+require_relative "command/generator_commands/chef_exts/recipe_dsl_ext"
+
+module ChefCLI
+
+  # An adapter to chef's APIs to kick off a chef-client run.
+  class ChefRunner
+
+    attr_reader :cookbook_path
+    attr_reader :run_list
+
+    def initialize(cookbook_path, run_list)
+      @cookbook_path = File.expand_path(cookbook_path)
+      @run_list = run_list
+      @formatter = nil
+      @ohai = nil
+    end
+
+    def converge
+      configure
+      Chef::Runner.new(run_context).converge
+    rescue Chef::Exceptions::CookbookNotFound => e
+      message = "Could not find cookbook(s) to satisfy run list #{run_list.inspect} in #{cookbook_path}"
+      raise CookbookNotFound.new(message, e)
+    rescue => e
+      raise ChefConvergeError.new("#{ChefCLI::Dist::INFRA_PRODUCT} failed to converge: #{e} from file #{e.backtrace.first}", e)
+    end
+
+    def run_context
+      @run_context ||= policy.setup_run_context
+    end
+
+    def policy
+      return @policy_builder if @policy_builder
+
+      @policy_builder = Chef::PolicyBuilder::Dynamic.new("chef-cli", ohai.data, {}, nil, event_dispatcher)
+      @policy_builder.load_node
+      @policy_builder.build_node
+      @policy_builder.node.run_list(*run_list)
+      @policy_builder.expand_run_list
+      @policy_builder
+    end
+
+    def event_dispatcher
+      @event_dispatcher ||=
+        Chef::EventDispatch::Dispatcher.new.tap do |d|
+          d.register(doc_formatter)
+        end
+    end
+
+    def doc_formatter
+      Chef::Formatters.new(:chefcli_doc, stdout, stderr)
+    end
+
+    def configure
+      Chef::Config.solo_legacy_mode = true
+      Chef::Config.cookbook_path = cookbook_path
+      Chef::Config.color = true
+      Chef::Config.diff_disabled = true
+
+      # If the user has set policyfile configuration in the workstation config
+      # file, the underlying chef-client code may enable policyfile mode and
+      # then fail because chef-solo doesn't support policyfiles.
+      Chef::Config.use_policyfile = false
+      Chef::Config.policy_name = nil
+      Chef::Config.policy_group = nil
+      Chef::Config.deployment_group = nil
+
+      # atomic file operations on Windows require Administrator privileges to be able to read the SACL from a file
+      # Using file_staging_uses_destdir(true) will get us inherited permissions indirectly on tempfile creation
+      Chef::Config.file_atomic_update = false if Chef::Platform.windows?
+      Chef::Config.file_staging_uses_destdir = true # Default in Chef 12+
+    end
+
+    def ohai
+      return @ohai if @ohai
+
+      @ohai = Ohai::System.new
+      @ohai.all_plugins(%w{platform platform_version})
+      @ohai
+    end
+
+    def stdout
+      $stdout
+    end
+
+    def stderr
+      $stderr
+    end
+
+  end
+end

data/lib/chef-cli/chef_server_api_multi.rb

@@ -0,0 +1,73 @@
+#
+# Copyright:: Copyright (c) 2017 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 "chef/server_api"
+
+module ChefCLI
+
+  # A wrapper for `Chef::ServerAPI` that supports multi-threading by creating a
+  # `Chef::ServerAPI` object per-thread.
+  #
+  # This is intended to be used for downloading cookbooks from the Chef Infa Server,
+  # where the API of the Chef Infra Server requires each file to be downloaded
+  # individually.
+  #
+  # It also configures `Chef::ServerAPI` to enable keepalives by default. To
+  # disable them, `keepalives: false` must be set in the options to the
+  # constructor.
+  class ChefServerAPIMulti
+
+    KEEPALIVES_TRUE = { keepalives: true }.freeze
+
+    attr_reader :url
+    attr_reader :opts
+
+    def initialize(url, opts)
+      @url = url
+      @opts = KEEPALIVES_TRUE.merge(opts)
+    end
+
+    def head(*args)
+      client_for_thread.head(*args)
+    end
+
+    def get(*args)
+      client_for_thread.get(*args)
+    end
+
+    def put(*args)
+      client_for_thread.put(*args)
+    end
+
+    def post(*args)
+      client_for_thread.post(*args)
+    end
+
+    def delete(*args)
+      client_for_thread.delete(*args)
+    end
+
+    def streaming_request(*args, &block)
+      client_for_thread.streaming_request(*args, &block)
+    end
+
+    def client_for_thread
+      Thread.current[:chef_server_api_multi] ||= Chef::ServerAPI.new(@url, @opts)
+    end
+
+  end
+end

data/lib/chef-cli/cli.rb

@@ -0,0 +1,206 @@
+#
+# Copyright:: Copyright (c) 2014-2019 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 "mixlib/cli" unless defined?(Mixlib::CLI)
+require_relative "version"
+require_relative "commands_map"
+require_relative "builtin_commands"
+require_relative "helpers"
+require_relative "ui"
+require_relative "dist"
+require "chef/util/path_helper"
+require "chef/mixin/shell_out"
+require "bundler"
+
+module ChefCLI
+  class CLI
+    include Mixlib::CLI
+    include ChefCLI::Helpers
+    include Chef::Mixin::ShellOut
+
+    banner(<<~BANNER)
+      Usage:
+          chef -h/--help
+          chef -v/--version
+          chef command [arguments...] [options...]
+    BANNER
+
+    option :version,
+      short: "-v",
+      long: "--version",
+      description: "Show #{ChefCLI::Dist::PRODUCT} version",
+      boolean: true
+
+    option :help,
+      short: "-h",
+      long: "--help",
+      description: "Show this message",
+      boolean: true
+
+    attr_reader :argv
+
+    def initialize(argv)
+      @argv = argv
+      super() # mixlib-cli #initialize doesn't allow arguments
+    end
+
+    def run(enforce_license: false)
+      sanity_check!
+
+      subcommand_name, *subcommand_params = argv
+
+      #
+      # Runs the appropriate subcommand if the given parameters contain any
+      # subcommands.
+      #
+      if subcommand_name.nil? || option?(subcommand_name)
+        handle_options
+      elsif have_command?(subcommand_name)
+        subcommand = instantiate_subcommand(subcommand_name)
+        exit_code = subcommand.run_with_default_options(enforce_license, subcommand_params)
+        exit normalized_exit_code(exit_code)
+      else
+        err "Unknown command `#{subcommand_name}'."
+        show_help
+        exit 1
+      end
+    rescue OptionParser::InvalidOption => e
+      err(e.message)
+      show_help
+      exit 1
+    end
+
+    # If no subcommand is given, then this class is handling the CLI request.
+    def handle_options
+      parse_options(argv)
+      if config[:version]
+        show_version
+      else
+        show_help
+      end
+      exit 0
+    end
+
+    def show_version
+      msg("#{ChefCLI::Dist::PRODUCT} version: #{ChefCLI::VERSION}")
+      { "#{ChefCLI::Dist::INFRA_CLIENT_PRODUCT}": "#{ChefCLI::Dist::INFRA_CLIENT_CLI}",
+        "#{ChefCLI::Dist::INSPEC_PRODUCT}": "#{ChefCLI::Dist::INSPEC_CLI}",
+        "Test Kitchen": "kitchen",
+        "Foodcritic": "foodcritic",
+        "Cookstyle": "cookstyle",
+      }.each do |name, cli|
+        result = Bundler.with_clean_env { shell_out("#{cli} --version") }
+        if result.exitstatus != 0
+          msg("#{name} version: ERROR")
+        else
+          version = result.stdout.lines.first.scan(/(?:master\s)?[\d+\.\(\)]+\S+/).join("\s")
+          msg("#{name} version: #{version}")
+        end
+      end
+    end
+
+    def show_help
+      msg(banner)
+      msg("\nAvailable Commands:")
+
+      justify_length = subcommands.map(&:length).max + 2
+      subcommand_specs.each do |name, spec|
+        next if spec.hidden
+        msg("    #{"#{name}".ljust(justify_length)}#{spec.description}")
+      end
+    end
+
+    def exit(n)
+      Kernel.exit(n)
+    end
+
+    def commands_map
+      ChefCLI.commands_map
+    end
+
+    def have_command?(name)
+      commands_map.have_command?(name)
+    end
+
+    def subcommands
+      commands_map.command_names
+    end
+
+    def subcommand_specs
+      commands_map.command_specs
+    end
+
+    def option?(param)
+      param =~ /^-/
+    end
+
+    def instantiate_subcommand(name)
+      commands_map.instantiate(name)
+    end
+
+    private
+
+    def normalized_exit_code(maybe_integer)
+      if maybe_integer.kind_of?(Integer) && (0..255).cover?(maybe_integer)
+        maybe_integer
+      else
+        0
+      end
+    end
+
+    # Find PATH or Path correctly if we are on Windows
+    def path_key
+      env.keys.grep(/\Apath\Z/i).first
+    end
+
+    # upcase drive letters for comparison since ruby has a String#capitalize function
+    def drive_upcase(path)
+      if Chef::Platform.windows? && path[0] =~ /^[A-Za-z]$/ && path[1, 2] == ":\\"
+        path.capitalize
+      else
+        path
+      end
+    end
+
+    def env
+      ENV
+    end
+
+    # catch the cases where users setup only the embedded_bin_dir in their path, or
+    # when they have the embedded_bin_dir before the omnibus_bin_dir -- both of which will
+    # defeat appbundler and interact very badly with our intent.
+    def sanity_check!
+      # When installed outside of omnibus, trust the user to configure their PATH
+      return true unless omnibus_install?
+      paths = env[path_key].split(File::PATH_SEPARATOR)
+      paths.map! { |p| drive_upcase(Chef::Util::PathHelper.cleanpath(p)) }
+      embed_index = paths.index(drive_upcase(Chef::Util::PathHelper.cleanpath(omnibus_embedded_bin_dir)))
+      bin_index = paths.index(drive_upcase(Chef::Util::PathHelper.cleanpath(omnibus_bin_dir)))
+      if embed_index
+        if bin_index
+          if embed_index < bin_index
+            err("WARN: #{omnibus_embedded_bin_dir} is before #{omnibus_bin_dir} in your #{path_key}, please reverse that order.")
+            err("WARN: consider using `#{ChefCLI::Dist::EXEC} shell-init <shell>` command to setup your environment correctly.")
+          end
+        else
+          err("WARN: only #{omnibus_embedded_bin_dir} is present in your path, you must add #{omnibus_bin_dir} before that directory.")
+          err("WARN: consider using `#{ChefCLI::Dist::EXEC} shell-init <shell>` command to setup your environment correctly.")
+        end
+      end
+    end
+  end
+end

data/lib/chef-cli/command/base.rb

@@ -0,0 +1,89 @@
+#
+# Copyright:: Copyright (c) 2014-2019 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 "mixlib/cli" unless defined?(Mixlib::CLI)
+require_relative "../helpers"
+require_relative "../version"
+require "chef/exceptions"
+require "license_acceptance/acceptor"
+require "license_acceptance/cli_flags/mixlib_cli"
+require_relative "../dist"
+
+module ChefCLI
+  module Command
+    class Base
+      include Mixlib::CLI
+      include ChefCLI::Helpers
+      include LicenseAcceptance::CLIFlags::MixlibCLI
+
+      option :help,
+        short: "-h",
+        long: "--help",
+        description: "Show this message",
+        boolean: true
+
+      option :version,
+        short: "-v",
+        long: "--version",
+        description: "Show #{ChefCLI::Dist::PRODUCT} version",
+        boolean: true
+
+      def initialize
+        super
+      end
+
+      #
+      # optparser overwrites -h / --help options with its own.
+      # In order to control this behavior, make sure the default options are
+      # handled here.
+      #
+      def run_with_default_options(enforce_license, params = [ ])
+        if needs_help?(params)
+          msg(opt_parser.to_s)
+          0
+        elsif needs_version?(params)
+          msg("#{ChefCLI::Dist::PRODUCT} version: #{ChefCLI::VERSION}")
+          0
+        else
+          check_license_acceptance if enforce_license
+          run(params)
+        end
+      rescue Chef::Exceptions::ConfigurationError => e
+        err("ERROR: #{e.message}\n")
+        1
+      rescue OptionParser::InvalidOption, OptionParser::MissingArgument => e
+        err("ERROR: #{e.message}\n")
+        msg(opt_parser)
+        1
+      end
+
+      def needs_help?(params)
+        params.include?("-h") || params.include?("--help")
+      end
+
+      def needs_version?(params)
+        params.include?("-v") || params.include?("--version")
+      end
+
+      def check_license_acceptance
+        # TODO - is this the right version?
+        LicenseAcceptance::Acceptor.check_and_persist!("chef-workstation", ChefCLI::VERSION.to_s)
+      end
+
+    end
+  end
+end