chef-apply 0.1.2 → 0.1.15

data/lib/chef_apply/action/install_chef/base.rb

@@ -20,24 +20,15 @@ require "fileutils"
 
 module ChefApply::Action::InstallChef
   class Base < ChefApply::Action::Base
-    MIN_CHEF_VERSION = Gem::Version.new("13.0.0")
+    MIN_14_VERSION = Gem::Version.new("14.1.1")
+    MIN_13_VERSION = Gem::Version.new("13.10.0")
 
     def perform_action
-      if target_host.installed_chef_version >= MIN_CHEF_VERSION
+      if check_minimum_chef_version!(target_host) == :minimum_version_met
         notify(:already_installed)
-        return
+      else
+        perform_local_install
       end
-      raise ClientOutdated.new(target_host.installed_chef_version, MIN_CHEF_VERSION)
-      # NOTE: 2018-05-10 below is an intentionally dead code path that
-      #       will get re-visited once we determine how we want automatic
-      #       upgrades to behave.
-      # @upgrading = true
-      # perform_local_install
-    rescue ChefApply::TargetHost::ChefNotInstalled
-      if config[:check_only]
-        raise ClientNotInstalled.new()
-      end
-      perform_local_install
     end
 
     def name
@@ -116,6 +107,31 @@ module ChefApply::Action::InstallChef
       remote_path
     end
 
+    def check_minimum_chef_version!(target)
+      begin
+        installed_version = target.installed_chef_version
+      rescue ChefApply::TargetHost::ChefNotInstalled
+        if config[:check_only]
+          raise ClientNotInstalled.new()
+        end
+        return :client_not_installed
+      end
+
+      case
+        when installed_version >= Gem::Version.new("14.0.0") && installed_version < MIN_14_VERSION
+          raise Client14Outdated.new(installed_version, MIN_14_VERSION)
+        when installed_version >= Gem::Version.new("13.0.0") && installed_version < MIN_13_VERSION
+          raise Client13Outdated.new(installed_version, MIN_13_VERSION, MIN_14_VERSION)
+        when installed_version < Gem::Version.new("13.0.0")
+          # If they have Chef < 13.0.0 installed we want to show them the easiest upgrade path -
+          # Chef 13 first and then Chef 14 since most customers cannot make the leap directly
+          # to 14.
+          raise Client13Outdated.new(installed_version, MIN_13_VERSION, MIN_14_VERSION)
+      end
+
+      :minimum_version_met
+    end
+
     def setup_remote_temp_path
       raise NotImplementedError
     end
@@ -129,9 +145,15 @@ module ChefApply::Action::InstallChef
     def initialize(); super("CHEFINS002"); end
   end
 
-  class ClientOutdated < ChefApply::ErrorNoLogs
+  class Client13Outdated < ChefApply::ErrorNoLogs
+    def initialize(current_version, min_13_version, min_14_version)
+      super("CHEFINS003", current_version, min_13_version, min_14_version)
+    end
+  end
+
+  class Client14Outdated < ChefApply::ErrorNoLogs
     def initialize(current_version, target_version)
-      super("CHEFINS003", current_version, target_version)
+      super("CHEFINS004", current_version, target_version)
     end
   end
 end

data/lib/chef_apply/cli.rb

@@ -1,4 +1,5 @@
 #
+#p
 # Copyright:: Copyright (c) 2018 Chef Software Inc.
 # License:: Apache License, Version 2.0
 #
@@ -15,30 +16,37 @@
 # limitations under the License.
 #
 require "mixlib/cli"
-require "chef/log"
+
+require "chef_apply/config"
 require "chef-config/config"
 require "chef-config/logger"
 
-require "chef_apply/cli_options"
+require "chef_apply/cli/validation"
+require "chef_apply/cli/options"
+require "chef_apply/cli/help"
 require "chef_apply/action/converge_target"
+require "chef_apply/action/generate_local_policy"
+require "chef_apply/action/generate_temp_cookbook"
 require "chef_apply/action/install_chef"
-require "chef_apply/config"
 require "chef_apply/error"
 require "chef_apply/log"
-require "chef_apply/recipe_lookup"
 require "chef_apply/target_host"
 require "chef_apply/target_resolver"
 require "chef_apply/telemeter"
-require "chef_apply/telemeter/sender"
-require "chef_apply/temp_cookbook"
-require "chef_apply/ui/terminal"
 require "chef_apply/ui/error_printer"
-require "chef_apply/version"
+require "chef_apply/ui/terminal"
 
 module ChefApply
   class CLI
+    attr_reader :temp_cookbook, :archive_file_location, :target_hosts
+
     include Mixlib::CLI
-    include ChefApply::CLIOptions
+    # Pulls in the CLI options and flags we have defined for this command.
+    include ChefApply::CLI::Options
+    # Argument validation and parsing behaviors
+    include ChefApply::CLI::Validation
+    # Help and version formatting
+    include ChefApply::CLI::Help
 
     RC_OK = 0
     RC_COMMAND_FAILED = 1
@@ -98,27 +106,11 @@ module ChefApply
         show_version
       else
         validate_params(cli_arguments)
-        configure_chef
-        target_hosts = TargetResolver.new(cli_arguments.shift,
-                                          parsed_options.delete(:protocol),
-                                          parsed_options).targets
-        temp_cookbook, initial_status_msg = generate_temp_cookbook(cli_arguments)
-        local_policy_path = nil
-        UI::Terminal.render_job(TS.generate_policyfile.generating) do |reporter|
-          local_policy_path = create_local_policy(temp_cookbook)
-          reporter.success(TS.generate_policyfile.success)
-        end
-        if target_hosts.length == 1
-          # Note: UX discussed determined that when running with a single target,
-          #       we'll use multiple lines to display status for the target.
-          run_single_target(initial_status_msg, target_hosts[0], local_policy_path)
-        else
-          @multi_target = true
-          # Multi-target will use one line per target.
-          run_multi_target(initial_status_msg, target_hosts, local_policy_path)
-        end
+        target_hosts = resolve_targets(cli_arguments.shift, parsed_options)
+        render_cookbook_setup(cli_arguments)
+        render_converge(target_hosts)
       end
-    rescue OptionParser::InvalidOption => e
+    rescue OptionParser::InvalidOption => e # from parse_options
       # Using nil here is a bit gross but it prevents usage from printing.
       ove = OptionValidationError.new("CHEFVAL010", nil,
                                       e.message.split(":")[1].strip, # only want the flag
@@ -131,181 +123,47 @@ module ChefApply
       temp_cookbook.delete unless temp_cookbook.nil?
     end
 
-    # Accepts a target_host and establishes the connection to that host
-    # while providing visual feedback via the Terminal API.
-    def connect_target(target_host, reporter = nil)
-      connect_message = T.status.connecting(target_host.user)
-      if reporter.nil?
-        UI::Terminal.render_job(connect_message, prefix: "[#{target_host.config[:host]}]") do |rep|
-          do_connect(target_host, rep, :success)
-        end
-      else
-        reporter.update(connect_message)
-        do_connect(target_host, reporter, :update)
-      end
-      target_host
+    def resolve_targets(host_spec, opts)
+      @target_hosts = TargetResolver.new(host_spec,
+                                         opts.delete(:protocol),
+                                         opts).targets
     end
 
-    def run_single_target(initial_status_msg, target_host, local_policy_path)
-      connect_target(target_host)
-      prefix = "[#{target_host.hostname}]"
-      UI::Terminal.render_job(TS.install_chef.verifying, prefix: prefix) do |reporter|
-        install(target_host, reporter)
+    def render_cookbook_setup(arguments)
+      UI::Terminal.render_job(TS.generate_temp_cookbook.generating) do |reporter|
+        @temp_cookbook = generate_temp_cookbook(arguments, reporter)
       end
-      UI::Terminal.render_job(initial_status_msg, prefix: "[#{target_host.hostname}]") do |reporter|
-        converge(reporter, local_policy_path, target_host)
+      UI::Terminal.render_job(TS.generate_temp_cookbook.generating) do |reporter|
+        @archive_file_location = generate_local_policy(reporter)
       end
     end
 
-    def run_multi_target(initial_status_msg, target_hosts, local_policy_path)
-      # Our multi-host UX does not show a line item per action,
-      # but rather a line-item per connection.
+    def render_converge(target_hosts)
       jobs = target_hosts.map do |target_host|
-        # This block will run in its own thread during render.
+        # Each block will run in its own thread during render.
         UI::Terminal::Job.new("[#{target_host.hostname}]", target_host) do |reporter|
           connect_target(target_host, reporter)
-          reporter.update(TS.install_chef.verifying)
           install(target_host, reporter)
-          reporter.update(initial_status_msg)
-          converge(reporter, local_policy_path, target_host)
+          converge(reporter, archive_file_location, target_host)
         end
       end
-      UI::Terminal.render_parallel_jobs(TS.converge.multi_header, jobs)
+      header = TS.converge.header(target_hosts.length, temp_cookbook.descriptor, temp_cookbook.from)
+      UI::Terminal.render_parallel_jobs(header, jobs)
       handle_job_failures(jobs)
     end
 
-    # The first param is always hostname. Then we either have
-    # 1. A recipe designation
-    # 2. A resource type and resource name followed by any properties
-    PROPERTY_MATCHER = /^([a-zA-Z0-9_]+)=(.+)$/
-    CB_MATCHER = '[\w\-]+'
-    def validate_params(params)
-      if params.size < 2
-        raise OptionValidationError.new("CHEFVAL002", self)
-      end
-      if params.size == 2
-        # Trying to specify a recipe to run remotely, no properties
-        cb = params[1]
-        if File.exist?(cb)
-          # This is a path specification, and we know it is valid
-        elsif cb =~ /^#{CB_MATCHER}$/ || cb =~ /^#{CB_MATCHER}::#{CB_MATCHER}$/
-          # They are specifying a cookbook as 'cb_name' or 'cb_name::recipe'
-        else
-          raise OptionValidationError.new("CHEFVAL004", self, cb)
-        end
-      elsif params.size >= 3
-        properties = params[3..-1]
-        properties.each do |property|
-          unless property =~ PROPERTY_MATCHER
-            raise OptionValidationError.new("CHEFVAL003", self, property)
-          end
-        end
-      end
-    end
-
-    # Now that we are leveraging Chef locally we want to perform some initial setup of it
-    def configure_chef
-      ChefConfig.logger = ChefApply::Log
-      # Setting the config isn't enough, we need to ensure the logger is initialized
-      # or automatic initialization will still go to stdout
-      Chef::Log.init(ChefApply::Log)
-      Chef::Log.level = ChefApply::Log.level
-    end
-
-    def format_properties(string_props)
-      properties = {}
-      string_props.each do |a|
-        key, value = PROPERTY_MATCHER.match(a)[1..-1]
-        value = transform_property_value(value)
-        properties[key] = value
-      end
-      properties
-    end
-
-    # Incoming properties are always read as a string from the command line.
-    # Depending on their type we should transform them so we do not try and pass
-    # a string to a resource property that expects an integer or boolean.
-    def transform_property_value(value)
-      case value
-      when /^0/
-        # when it is a zero leading value like "0777" don't turn
-        # it into a number (this is a mode flag)
-        value
-      when /^\d+$/
-        value.to_i
-      when /(^(\d+)(\.)?(\d+)?)|(^(\d+)?(\.)(\d+))/
-        value.to_f
-      when /true/i
-        true
-      when /false/i
-        false
-      else
-        value
-      end
-    end
-
-    # The user will either specify a single resource on the command line, or a recipe.
-    # We need to parse out those two different situations
-    def generate_temp_cookbook(cli_arguments)
-      temp_cookbook = TempCookbook.new
-      if recipe_strategy?(cli_arguments)
-        recipe_specifier = cli_arguments.shift
-        ChefApply::Log.debug("Beginning to look for recipe specified as #{recipe_specifier}")
-        if File.file?(recipe_specifier)
-          ChefApply::Log.debug("#{recipe_specifier} is a valid path to a recipe")
-          recipe_path = recipe_specifier
-        else
-          rl = RecipeLookup.new(parsed_options[:cookbook_repo_paths])
-          cookbook_path_or_name, optional_recipe_name = rl.split(recipe_specifier)
-          cookbook = rl.load_cookbook(cookbook_path_or_name)
-          recipe_path = rl.find_recipe(cookbook, optional_recipe_name)
-        end
-        temp_cookbook.from_existing_recipe(recipe_path)
-        initial_status_msg = TS.converge.converging_recipe(recipe_specifier)
-      else
-        resource_type = cli_arguments.shift
-        resource_name = cli_arguments.shift
-        temp_cookbook.from_resource(resource_type, resource_name, format_properties(cli_arguments))
-        full_rs_name = "#{resource_type}[#{resource_name}]"
-        ChefApply::Log.debug("Converging resource #{full_rs_name} on target")
-        initial_status_msg = TS.converge.converging_resource(full_rs_name)
-      end
-
-      [temp_cookbook, initial_status_msg]
-    end
-
-    def recipe_strategy?(cli_arguments)
-      cli_arguments.size == 1
-    end
-
-    def create_local_policy(local_cookbook)
-      require "chef-dk/ui"
-      require "chef-dk/policyfile_services/export_repo"
-      require "chef-dk/policyfile_services/install"
-      policyfile_installer = ChefDK::PolicyfileServices::Install.new(
-        ui: ChefDK::UI.null(),
-        root_dir: local_cookbook.path
-      )
-      begin
-        policyfile_installer.run
-      rescue ChefDK::PolicyfileInstallError => e
-        raise PolicyfileInstallError.new(e)
-      end
-      lock_path = File.join(local_cookbook.path, "Policyfile.lock.json")
-      es = ChefDK::PolicyfileServices::ExportRepo.new(policyfile: lock_path,
-                                                      root_dir: local_cookbook.path,
-                                                      export_dir: File.join(local_cookbook.path, "export"),
-                                                      archive: true,
-                                                      force: true)
-      es.run
-      es.archive_file_location
+    # Accepts a target_host and establishes the connection to that host
+    # while providing visual feedback via the Terminal API.
+    def connect_target(target_host, reporter)
+      connect_message = T.status.connecting(target_host.user)
+      reporter.update(connect_message)
+      do_connect(target_host, reporter)
     end
 
-    # Runs the InstallChef action and renders UI updates as
-    # the action reports back
     def install(target_host, reporter)
-      installer = Action::InstallChef.instance_for_target(target_host, check_only: !parsed_options[:install])
       context = TS.install_chef
+      reporter.update(context.verifying)
+      installer = Action::InstallChef.instance_for_target(target_host, check_only: !parsed_options[:install])
       installer.run do |event, data|
         case event
         when :installing
@@ -320,39 +178,82 @@ module ChefApply
         when :downloading
           reporter.update(context.downloading)
         when :already_installed
-          meth = @multi_target ? :update : :success
-          reporter.send(meth, context.already_present(target_host.installed_chef_version))
+          reporter.update(context.already_present(target_host.installed_chef_version))
         when :install_complete
-          meth = @multi_target ? :update : :success
           if installer.upgrading?
             message = context.upgrade_success(target_host.installed_chef_version, installer.version_to_install)
           else
             message = context.install_success(installer.version_to_install)
           end
-          reporter.send(meth, message)
+          reporter.update(message)
+        else
+          handle_message(event, data, reporter)
+        end
+      end
+    end
+
+    # Runs a GenerateCookbook action based on recipe/resource infoprovided
+    # and renders UI updates as the action reports back
+    def generate_temp_cookbook(arguments, reporter)
+      opts = if arguments.length == 1
+               { recipe_spec: arguments.shift,
+                 cookbook_repo_paths: parsed_options[:cookbook_repo_paths] }
+             else
+               { resource_type: arguments.shift,
+                 resource_name: arguments.shift,
+                 resource_properties: properties_from_string(arguments) }
+             end
+      action = ChefApply::Action::GenerateTempCookbook.from_options(opts)
+      action.run do |event, data|
+        case event
+        when :generating
+          reporter.update(TS.generate_temp_cookbook.generating)
+        when :success
+          reporter.success(TS.generate_temp_cookbook.success)
+        else
+          handle_message(event, data, reporter)
+        end
+      end
+      action.generated_cookbook
+    end
+
+    # Runs the GenerateLocalPolicy action and renders UI updates
+    # as the action reports back
+    def generate_local_policy(reporter)
+      action = Action::GenerateLocalPolicy.new(cookbook: temp_cookbook)
+      action.run do |event, data|
+        case event
+        when :generating
+          reporter.update(TS.generate_local_policy.generating)
+        when :exporting
+          reporter.update(TS.generate_local_policy.exporting)
+        when :success
+          reporter.success(TS.generate_local_policy.success)
         else
           handle_message(event, data, reporter)
         end
       end
+      action.archive_file_location
     end
 
     # Runs the Converge action and renders UI updates as
     # the action reports back
     def converge(reporter, local_policy_path, target_host)
+      reporter.update(TS.converge.converging(temp_cookbook.descriptor))
       converge_args = { local_policy_path: local_policy_path, target_host: target_host }
       converger = Action::ConvergeTarget.new(converge_args)
       converger.run do |event, data|
         case event
         when :success
-          reporter.success(TS.converge.success)
+          reporter.success(TS.converge.success(temp_cookbook.descriptor))
         when :converge_error
-          reporter.error(TS.converge.failure)
+          reporter.error(TS.converge.failure(temp_cookbook.descriptor))
         when :creating_remote_policy
           reporter.update(TS.converge.creating_remote_policy)
         when :uploading_trusted_certs
           reporter.update(TS.converge.uploading_trusted_certs)
         when :running_chef
-          reporter.update(TS.converge.running_chef)
+          reporter.update(TS.converge.converging(temp_cookbook.descriptor))
         when :reboot
           reporter.success(TS.converge.reboot)
         else
@@ -362,13 +263,14 @@ module ChefApply
     end
 
     def handle_perform_error(e)
+      require "chef_apply/errors/standard_error_resolver"
       id = e.respond_to?(:id) ? e.id : e.class.to_s
       # TODO: This is currently sending host information for certain ssh errors
       #       post release we need to scrub this data. For now I'm redacting the
       #       whole message.
       # message = e.respond_to?(:message) ? e.message : e.to_s
       Telemeter.capture(:error, exception: { id: id, message: "redacted" })
-      wrapper = ChefApply::StandardErrorResolver.wrap_exception(e)
+      wrapper = ChefApply::Errors::StandardErrorResolver.wrap_exception(e)
       capture_exception_backtrace(wrapper)
       # Now that our housekeeping is done, allow user-facing handling/formatting
       # in `run` to execute by re-raising
@@ -377,13 +279,16 @@ module ChefApply
 
     # When running multiple jobs, exceptions are captured to the
     # job to avoid interrupting other jobs in process.  This function
-    # collects them and raises a MultiJobFailure if failure has occurred;
-    # we do *not* differentiate between one failed jobs and multiple failed jobs
-    # - if you're in the 'multi-job' path (eg, multiple targets) we handle
-    # all errors the same to provide a consistent UX when running with mulitiple targets.
+    # collects them and raises directly (in the case of just one job in the list)
+    # or raises a MultiJobFailure (when more than one job was being run)
     def handle_job_failures(jobs)
       failed_jobs = jobs.select { |j| !j.exception.nil? }
       return if failed_jobs.empty?
+      if jobs.length == 1
+        # Don't provide a bad UX by showing a 'one or more jobs has failed'
+        # message when there was only one job.
+        raise jobs.first.exception
+      end
       raise ChefApply::MultiJobFailure.new(failed_jobs)
     end
 
@@ -399,72 +304,14 @@ module ChefApply
       UI::ErrorPrinter.write_backtrace(e, @argv)
     end
 
-    def show_help
-      UI::Terminal.output format_help
-    end
-
-    def do_connect(target_host, reporter, update_method)
+    def do_connect(target_host, reporter)
       target_host.connect!
-      reporter.send(update_method, T.status.connected)
+      reporter.update(T.status.connected)
     rescue StandardError => e
       message = ChefApply::UI::ErrorPrinter.error_summary(e)
       reporter.error(message)
       raise
     end
 
-    def format_help
-      help_text = banner.clone # This prevents us appending to the banner text
-      help_text << "\n"
-      help_text << format_flags
-    end
-
-    def format_flags
-      flag_text = "FLAGS:\n"
-      justify_length = 0
-      options.each_value do |spec|
-        justify_length = [justify_length, spec[:long].length + 4].max
-      end
-      options.sort.to_h.each_value do |flag_spec|
-        short = flag_spec[:short] || "  "
-        short = short[0, 2] # We only want the flag portion, not the capture portion (if present)
-        if short == "  "
-          short = "    "
-        else
-          short = "#{short}, "
-        end
-        flags = "#{short}#{flag_spec[:long]}"
-        flag_text << "    #{flags.ljust(justify_length)}    "
-        ml_padding = " " * (justify_length + 8)
-        first = true
-        flag_spec[:description].split("\n").each do |d|
-          flag_text << ml_padding unless first
-          first = false
-          flag_text << "#{d}\n"
-        end
-      end
-      flag_text
-    end
-
-    def usage
-      T.usage
-    end
-
-    def show_version
-      UI::Terminal.output T.version.show(ChefApply::VERSION)
-    end
-
-    class OptionValidationError < ChefApply::ErrorNoLogs
-      attr_reader :command
-      def initialize(id, calling_command, *args)
-        super(id, *args)
-        # TODO - this is getting cumbersome - move them to constructor options hash in base
-        @decorate = false
-        @command = calling_command
-      end
-    end
-
-    class PolicyfileInstallError < ChefApply::Error
-      def initialize(cause_err); super("CHEFPOLICY001", cause_err.message); end
-    end
   end
 end