bolt 2.29.0 → 2.33.2

data/lib/bolt/module_installer/specs/git_spec.rb

@@ -0,0 +1,179 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'set'
+
+require 'bolt/error'
+
+# This class represents a Git module specification.
+#
+module Bolt
+  class ModuleInstaller
+    class Specs
+      class GitSpec
+        NAME_REGEX    = %r{\A(?:[a-zA-Z0-9]+[-/])?(?<name>[a-z][a-z0-9_]*)\z}.freeze
+        REQUIRED_KEYS = Set.new(%w[git ref]).freeze
+
+        attr_reader :git, :ref, :type
+
+        def initialize(init_hash)
+          @name       = parse_name(init_hash['name'])
+          @git, @repo = parse_git(init_hash['git'])
+          @ref        = init_hash['ref']
+          @type       = :git
+        end
+
+        def self.implements?(hash)
+          REQUIRED_KEYS == hash.keys.to_set
+        end
+
+        # Parses the name into owner and name segments, and formats the full
+        # name.
+        #
+        private def parse_name(name)
+          return unless name
+
+          unless (match = name.match(NAME_REGEX))
+            raise Bolt::ValidationError,
+                  "Invalid name for Git module specification: #{name}. Name must match "\
+                  "'name' or 'owner/name'. Owner segment may only include letters or digits. "\
+                  "Name segment must start with a lowercase letter and may only include "\
+                  "lowercase letters, digits, and underscores."
+          end
+
+          match[:name]
+        end
+
+        # Gets the repo from the git URL.
+        #
+        private def parse_git(git)
+          repo = if git.start_with?('git@github.com:')
+                   git.split('git@github.com:').last.split('.git').first
+                 elsif git.start_with?('https://github.com')
+                   git.split('https://github.com/').last.split('.git').first
+                 else
+                   raise Bolt::ValidationError,
+                         "Invalid git source: #{git}. Only GitHub modules are supported."
+                 end
+
+          [git, repo]
+        end
+
+        # Returns true if the specification is satisfied by the module.
+        #
+        def satisfied_by?(mod)
+          @type == mod.type && @git == mod.git
+        end
+
+        # Returns a hash matching the module spec in bolt-project.yaml
+        #
+        def to_hash
+          {
+            'git' => @git,
+            'ref' => @ref
+          }
+        end
+
+        # Returns a PuppetfileResolver::Model::GitModule object for resolving.
+        #
+        def to_resolver_module
+          require 'puppetfile-resolver'
+
+          PuppetfileResolver::Puppetfile::GitModule.new(name).tap do |mod|
+            mod.remote = @git
+            mod.ref    = sha
+          end
+        end
+
+        # Resolves the module's title from the module metadata. This is lazily
+        # resolved since Bolt does not always need to know a Git module's name.
+        #
+        def name
+          @name ||= begin
+            url      = "https://raw.githubusercontent.com/#{@repo}/#{sha}/metadata.json"
+            response = make_request(:Get, url)
+
+            case response
+            when Net::HTTPOK
+              body = JSON.parse(response.body)
+
+              unless body.key?('name')
+                raise Bolt::Error.new(
+                  "Missing name in metadata.json at #{git}. This is not a valid module.",
+                  "bolt/missing-module-name-error"
+                )
+              end
+
+              parse_name(body['name'])
+            else
+              raise Bolt::Error.new(
+                "Missing metadata.json at #{git}. This is not a valid module.",
+                "bolt/missing-module-metadata-error"
+              )
+            end
+          end
+        end
+
+        # Resolves the SHA for the specified ref. This is lazily resolved since
+        # Bolt does not always need to know a Git module's SHA.
+        #
+        def sha
+          @sha ||= begin
+            url      = "https://api.github.com/repos/#{@repo}/commits/#{ref}"
+            headers  = ENV['GITHUB_TOKEN'] ? { "Authorization" => "token #{ENV['GITHUB_TOKEN']}" } : {}
+            response = make_request(:Get, url, headers)
+
+            case response
+            when Net::HTTPOK
+              body = JSON.parse(response.body)
+              body['sha']
+            when Net::HTTPUnauthorized
+              raise Bolt::Error.new(
+                "Invalid token at GITHUB_TOKEN, unable to resolve git modules.",
+                "bolt/invalid-git-token-error"
+              )
+            when Net::HTTPForbidden
+              message = "GitHub API rate limit exceeded, unable to resolve git modules. "
+
+              unless ENV['GITHUB_TOKEN']
+                message += "To increase your rate limit, set the GITHUB_TOKEN environment "\
+                          "variable with a GitHub personal access token."
+              end
+
+              raise Bolt::Error.new(message, 'bolt/github-api-rate-limit-error')
+            when Net::HTTPNotFound
+              raise Bolt::Error.new(
+                "#{git} is not a git repository.",
+                "bolt/missing-git-repository-error"
+              )
+            else
+              raise Bolt::Error.new(
+                "Ref #{ref} at #{git} is not a commit, tag, or branch.",
+                "bolt/invalid-git-ref-error"
+              )
+            end
+          end
+        end
+
+        # Makes a generic HTTP request.
+        #
+        private def make_request(verb, url, headers = {})
+          require 'net/http'
+
+          uri      = URI.parse(url)
+          opts     = { use_ssl: uri.scheme == 'https' }
+
+          Net::HTTP.start(uri.host, uri.port, opts) do |client|
+            request = Net::HTTP.const_get(verb).new(uri, headers)
+            client.request(request)
+          end
+        rescue StandardError => e
+          raise Bolt::Error.new(
+            "Failed to connect to #{uri}: #{e.message}",
+            "bolt/http-connect-error"
+          )
+        end
+      end
+    end
+  end
+end

data/lib/bolt/outputter.rb

@@ -27,55 +27,12 @@ module Bolt
       string.gsub(/^/, indent.to_s)
     end
 
-    def print_message_event(event)
-      print_message(stringify(event[:message]))
-    end
-
     def print_message
       raise NotImplementedError, "print_message() must be implemented by the outputter class"
     end
 
-    def stringify(message)
-      formatted = format_message(message)
-      if formatted.is_a?(Hash) || formatted.is_a?(Array)
-        ::JSON.pretty_generate(formatted)
-      else
-        formatted
-      end
-    end
-
-    def format_message(message)
-      case message
-      when Array
-        message.map { |item| format_message(item) }
-      when Bolt::ApplyResult
-        format_apply_result(message)
-      when Bolt::Result, Bolt::ResultSet
-        # This is equivalent to to_s, but formattable
-        message.to_data
-      when Bolt::RunFailure
-        formatted_resultset = message.result_set.to_data
-        message.to_h.merge('result_set' => formatted_resultset)
-      when Hash
-        message.each_with_object({}) do |(k, v), h|
-          h[format_message(k)] = format_message(v)
-        end
-      when Integer, Float, NilClass
-        message
-      else
-        message.to_s
-      end
-    end
-
-    def format_apply_result(result)
-      logs = result.resource_logs&.map do |log|
-        # Omit low-level info/debug messages
-        next if %w[info debug].include?(log['level'])
-        indent(2, format_log(log))
-      end
-      hash = result.to_data
-      hash['logs'] = logs unless logs.empty?
-      hash
+    def print_error
+      raise NotImplementedError, "print_error() must be implemented by the outputter class"
     end
   end
 end

data/lib/bolt/outputter/human.rb

@@ -5,9 +5,12 @@ require 'bolt/pal'
 module Bolt
   class Outputter
     class Human < Bolt::Outputter
-      COLORS = { red: "31",
-                 green: "32",
-                 yellow: "33" }.freeze
+      COLORS = {
+        red:    "31",
+        green:  "32",
+        yellow: "33",
+        cyan:   "36"
+      }.freeze
 
       def print_head; end
 
@@ -31,6 +34,10 @@ module Bolt
         string.sub(/\s\z/, '')
       end
 
+      def wrap(string, width = 80)
+        string.gsub(/(.{1,#{width}})(\s+|\Z)/, "\\1\n")
+      end
+
       def handle_event(event)
         case event[:type]
         when :enable_default_output
@@ -38,7 +45,7 @@ module Bolt
         when :disable_default_output
           @disable_depth += 1
         when :message
-          print_message_event(event)
+          print_message(event[:message])
         end
 
         if enabled?
@@ -48,9 +55,9 @@ module Bolt
           when :node_result
             print_result(event[:result]) if @verbose
           when :step_start
-            print_step_start(event) if plan_logging?
+            print_step_start(**event) if plan_logging?
           when :step_finish
-            print_step_finish(event) if plan_logging?
+            print_step_finish(**event) if plan_logging?
           when :plan_start
             print_plan_start(event)
           when :plan_finish
@@ -188,7 +195,7 @@ module Bolt
         @stream.puts total_msg
       end
 
-      def print_table(results)
+      def print_table(results, padding_left = 0, padding_right = 3)
         # lazy-load expensive gem code
         require 'terminal-table'
 
@@ -198,8 +205,8 @@ module Bolt
             border_x: '',
             border_y: '',
             border_i: '',
-            padding_left: 0,
-            padding_right: 3,
+            padding_left: padding_left,
+            padding_right: padding_right,
             border_top: false,
             border_bottom: false
           }
@@ -241,7 +248,7 @@ module Bolt
         task_info << "MODULE:\n"
 
         path = task.files.first['path'].chomp("/tasks/#{task.files.first['name']}")
-        task_info << if path.start_with?(Bolt::PAL::MODULES_PATH)
+        task_info << if path.start_with?(Bolt::Config::Modulepath::MODULES_PATH)
                        "built-in module"
                      else
                        path
@@ -271,7 +278,7 @@ module Bolt
         plan_info << "MODULE:\n"
 
         path = plan['module']
-        plan_info << if path.start_with?(Bolt::PAL::MODULES_PATH)
+        plan_info << if path.start_with?(Bolt::Config::Modulepath::MODULES_PATH)
                        "built-in module"
                      else
                        path
@@ -299,9 +306,9 @@ module Bolt
       def print_module_list(module_list)
         module_list.each do |path, modules|
           if (mod = modules.find { |m| m[:internal_module_group] })
-            @stream.puts(mod[:internal_module_group])
+            @stream.puts(colorize(:cyan, mod[:internal_module_group]))
           else
-            @stream.puts(path)
+            @stream.puts(colorize(:cyan, path))
           end
 
           if modules.empty?
@@ -317,17 +324,35 @@ module Bolt
               [m[:name], version]
             end
 
-            print_table(module_info)
+            print_table(module_info, 2, 1)
           end
 
           @stream.write("\n")
         end
       end
 
-      def print_targets(targets)
-        count = "#{targets.count} target#{'s' unless targets.count == 1}"
-        @stream.puts targets.map(&:name).join("\n")
-        @stream.puts colorize(:green, count)
+      def print_targets(target_list, inventoryfile)
+        adhoc = colorize(:yellow, "(Not found in inventory file)")
+
+        targets  = []
+        targets += target_list[:inventory].map { |target| [target.name, nil] }
+        targets += target_list[:adhoc].map { |target| [target.name, adhoc] }
+
+        if targets.any?
+          print_table(targets, 0, 2)
+          @stream.puts
+        end
+
+        @stream.puts "INVENTORY FILE:"
+        if File.exist?(inventoryfile)
+          @stream.puts inventoryfile
+        else
+          @stream.puts wrap("Tried to load inventory from #{inventoryfile}, but the file does not exist")
+        end
+
+        @stream.puts "\nTARGET COUNT:"
+        @stream.puts "#{targets.count} total, #{target_list[:inventory].count} from inventory, "\
+                     "#{target_list[:adhoc].count} adhoc"
       end
 
       def print_target_info(targets)
@@ -394,6 +419,41 @@ module Bolt
         @stream.puts(message)
       end
 
+      def print_error(message)
+        @stream.puts(colorize(:red, message))
+      end
+
+      def print_prompt(prompt)
+        @stream.print(colorize(:cyan, indent(4, prompt)))
+      end
+
+      def print_prompt_error(message)
+        @stream.puts(colorize(:red, indent(4, message)))
+      end
+
+      def print_action_step(step)
+        first, *remaining = wrap(step, 76).lines
+
+        first     = indent(2, "→ #{first}")
+        remaining = remaining.map { |line| indent(4, line) }
+        step      = [first, *remaining, "\n"].join
+
+        @stream.puts(step)
+      end
+
+      def print_action_error(error)
+        # Running everything through 'wrap' messes with newlines. Separating
+        # into lines and wrapping each individually ensures separate errors are
+        # distinguishable.
+        first, *remaining = error.lines
+        first = colorize(:red, indent(2, "→ #{wrap(first, 76)}"))
+        wrapped = remaining.map { |l| wrap(l) }
+        to_print = wrapped.map { |line| colorize(:red, indent(4, line)) }
+        step = [first, *to_print, "\n"].join
+
+        @stream.puts(step)
+      end
+
       def duration_to_string(duration)
         hrs = (duration / 3600).floor
         mins = ((duration % 3600) / 60).floor

data/lib/bolt/outputter/json.rb

@@ -22,7 +22,7 @@ module Bolt
         when :node_result
           print_result(event[:result])
         when :message
-          print_message_event(event)
+          print_message(event[:message])
         end
       end
 
@@ -48,7 +48,7 @@ module Bolt
 
       def print_task_info(task)
         path = task.files.first['path'].chomp("/tasks/#{task.files.first['name']}")
-        module_dir = if path.start_with?(Bolt::PAL::MODULES_PATH)
+        module_dir = if path.start_with?(Bolt::Config::Modulepath::MODULES_PATH)
                        "built-in module"
                      else
                        path
@@ -62,7 +62,7 @@ module Bolt
 
       def print_plan_info(plan)
         path = plan.delete('module')
-        plan['module_dir'] = if path.start_with?(Bolt::PAL::MODULES_PATH)
+        plan['module_dir'] = if path.start_with?(Bolt::Config::Modulepath::MODULES_PATH)
                                "built-in module"
                              else
                                path
@@ -97,13 +97,22 @@ module Bolt
       def print_puppetfile_result(success, puppetfile, moduledir)
         @stream.puts({ "success": success,
                        "puppetfile": puppetfile,
-                       "moduledir": moduledir }.to_json)
+                       "moduledir": moduledir.to_s }.to_json)
       end
 
-      def print_targets(targets)
+      def print_targets(target_list, inventoryfile)
         @stream.puts ::JSON.pretty_generate(
-          "targets": targets.map(&:name),
-          "count": targets.count
+          "inventory": {
+            "targets": target_list[:inventory].map(&:name),
+            "count": target_list[:inventory].count,
+            "file": inventoryfile.to_s
+          },
+          "adhoc": {
+            "targets": target_list[:adhoc].map(&:name),
+            "count": target_list[:adhoc].count
+          },
+          "targets": target_list.values.flatten.map(&:name),
+          "count": target_list.values.flatten.count
         )
       end
 
@@ -135,6 +144,12 @@ module Bolt
       def print_message(message)
         $stderr.puts(message)
       end
+      alias print_error print_message
+
+      def print_action_step(step)
+        $stderr.puts(step)
+      end
+      alias print_action_error print_action_step
     end
   end
 end