bolt 2.30.0 → 2.34.0

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,10 +27,6 @@ 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
@@ -38,49 +34,6 @@ module Bolt
     def print_error
       raise NotImplementedError, "print_error() 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
-    end
   end
 end
 

data/lib/bolt/outputter/human.rb

@@ -45,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?
@@ -214,9 +214,10 @@ module Bolt
       end
 
       def print_tasks(tasks, modulepath)
+        command = Bolt::Util.powershell? ? 'Get-BoltTask -Task <TASK NAME>' : 'bolt task show <TASK NAME>'
         print_table(tasks)
         print_message("\nMODULEPATH:\n#{modulepath.join(File::PATH_SEPARATOR)}\n"\
-                        "\nUse `bolt task show <task-name>` to view "\
+                        "\nUse '#{command}' to view "\
                         "details and parameters for a specific task.")
       end
 
@@ -225,20 +226,26 @@ module Bolt
         # Building lots of strings...
         pretty_params = +""
         task_info = +""
-        usage = +"bolt task run --targets <node-name> #{task.name}"
+        usage = if Bolt::Util.powershell?
+                  +"Invoke-BoltTask -Name #{task.name} -Targets <targets>"
+                else
+                  +"bolt task run #{task.name} --targets <targets>"
+                end
 
         task.parameters&.each do |k, v|
           pretty_params << "- #{k}: #{v['type'] || 'Any'}\n"
           pretty_params << "    Default: #{v['default'].inspect}\n" if v.key?('default')
           pretty_params << "    #{v['description']}\n" if v['description']
-          usage << if v['type'].is_a?(Puppet::Pops::Types::POptionalType)
+          usage << if v['type'].start_with?("Optional")
                      " [#{k}=<value>]"
                    else
                      " #{k}=<value>"
                    end
         end
 
-        usage << " [--noop]" if task.supports_noop
+        if task.supports_noop
+          usage << Bolt::Util.powershell? ? '[-Noop]' : '[--noop]'
+        end
 
         task_info << "\n#{task.name}"
         task_info << " - #{task.description}" if task.description
@@ -248,7 +255,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
@@ -261,7 +268,11 @@ module Bolt
         # Building lots of strings...
         pretty_params = +""
         plan_info = +""
-        usage = +"bolt plan run #{plan['name']}"
+        usage = if Bolt::Util.powershell?
+                  +"Invoke-BoltPlan -Name #{plan['name']}"
+                else
+                  +"bolt plan run #{plan['name']}"
+                end
 
         plan['parameters'].each do |name, p|
           pretty_params << "- #{name}: #{p['type']}\n"
@@ -278,7 +289,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
@@ -287,16 +298,17 @@ module Bolt
       end
 
       def print_plans(plans, modulepath)
+        command = Bolt::Util.powershell? ? 'Get-BoltPlan -Name <PLAN NAME>' : 'bolt plan show <PLAN NAME>'
         print_table(plans)
         print_message("\nMODULEPATH:\n#{modulepath.join(File::PATH_SEPARATOR)}\n"\
-                        "\nUse `bolt plan show <plan-name>` to view "\
+                        "\nUse '#{command}' to view "\
                         "details and parameters for a specific plan.")
       end
 
       def print_topics(topics)
         print_message("Available topics are:")
         print_message(topics.join("\n"))
-        print_message("\nUse `bolt guide <topic>` to view a specific guide.")
+        print_message("\nUse 'bolt guide <TOPIC>' to view a specific guide.")
       end
 
       def print_guide(guide, _topic)
@@ -331,10 +343,28 @@ module Bolt
         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)
@@ -413,7 +443,7 @@ module Bolt
         @stream.puts(colorize(:red, indent(4, message)))
       end
 
-      def print_migrate_step(step)
+      def print_action_step(step)
         first, *remaining = wrap(step, 76).lines
 
         first     = indent(2, "→ #{first}")
@@ -423,7 +453,7 @@ module Bolt
         @stream.puts(step)
       end
 
-      def print_migrate_error(error)
+      def print_action_error(error)
         # Running everything through 'wrap' messes with newlines. Separating
         # into lines and wrapping each individually ensures separate errors are
         # distinguishable.

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
@@ -100,10 +100,19 @@ module Bolt
                        "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
 
@@ -137,10 +146,10 @@ module Bolt
       end
       alias print_error print_message
 
-      def print_migrate_step(step)
+      def print_action_step(step)
         $stderr.puts(step)
       end
-      alias print_migrate_error print_migrate_step
+      alias print_action_error print_action_step
     end
   end
 end