openbolt 5.0.0.rc1

data/lib/bolt/outputter/json.rb

@@ -0,0 +1,205 @@
+# frozen_string_literal: true
+
+require_relative '../../bolt/util/format'
+
+module Bolt
+  class Outputter
+    class JSON < Bolt::Outputter
+      def initialize(color, verbose, trace, spin, stream = $stdout)
+        super
+        @items_open = false
+        @object_open = false
+        @preceding_item = false
+      end
+
+      def print_head
+        @stream.puts '{ "items": ['
+        @preceding_item = false
+        @items_open = true
+        @object_open = true
+      end
+
+      def handle_event(event)
+        case event[:type]
+        when :node_result
+          print_result(event[:result])
+        when :message
+          print_message(event[:message])
+        when :verbose
+          print_message(event[:message]) if @verbose
+        end
+      end
+
+      def print_result(result)
+        @stream.puts ',' if @preceding_item
+        @stream.puts result.to_json
+        @preceding_item = true
+      end
+
+      def print_summary(results, elapsed_time)
+        @stream.puts "],\n"
+        @preceding_item = false
+        @items_open = false
+        @stream.puts format('"target_count": %<size>d, "elapsed_time": %<elapsed>d }',
+                            size: results.size,
+                            elapsed: elapsed_time)
+      end
+
+      def print_table(results)
+        @stream.puts results.to_json
+      end
+      alias print_module_list print_table
+      alias print_module_info print_table
+
+      # Print information about a task.
+      #
+      # @param task [Bolt::Task] The task information.
+      #
+      def print_task_info(task:)
+        path = task.files.first['path'].chomp("/tasks/#{task.files.first['name']}")
+        module_dir = if path.start_with?(Bolt::Config::Modulepath::MODULES_PATH)
+                       "built-in module"
+                     else
+                       path
+                     end
+        @stream.puts task.to_h.merge(module_dir: module_dir).to_json
+      end
+
+      # List available tasks.
+      #
+      # @param tasks [Array] A list of task names and descriptions.
+      # @param modulepath [Array] The modulepath.
+      #
+      def print_tasks(**kwargs)
+        print_table(**kwargs)
+      end
+
+      def print_plugin_list(plugins:, modulepath:)
+        plugins.delete(:validate_resolve_reference)
+        print_table('plugins' => plugins, 'modulepath' => modulepath)
+      end
+
+      def print_plan_info(plan)
+        path = plan.delete('module')
+        plan['module_dir'] = if path.start_with?(Bolt::Config::Modulepath::MODULES_PATH)
+                               "built-in module"
+                             else
+                               path
+                             end
+        @stream.puts plan.to_json
+      end
+
+      def print_policy_list(**kwargs)
+        print_table(**kwargs)
+      end
+
+      def print_plans(**kwargs)
+        print_table(**kwargs)
+      end
+
+      def print_new_plan(**kwargs)
+        print_table(**kwargs)
+      end
+
+      def print_new_policy(**kwargs)
+        print_table(**kwargs)
+      end
+
+      def print_apply_result(apply_result)
+        @stream.puts apply_result.to_json
+      end
+
+      def print_plan_result(result)
+        # Ruby JSON patches most objects to have a to_json method.
+        @stream.puts result.to_json
+      end
+
+      def print_result_set(result_set)
+        @stream.puts result_set.to_json
+      end
+
+      # Print available guide topics.
+      #
+      # @param topics [Array] The available topics.
+      #
+      def print_topics(**kwargs)
+        print_table(kwargs)
+      end
+
+      # Print the guide for the specified topic.
+      #
+      # @param guide [String] The guide.
+      # @param topic [String] The topic.
+      #
+      def print_guide(**kwargs)
+        @stream.puts(kwargs.to_json)
+      end
+
+      def print_plan_lookup(value)
+        @stream.puts(value.to_json)
+      end
+
+      def print_puppetfile_result(success, puppetfile, moduledir)
+        @stream.puts({ success: success,
+                       puppetfile: puppetfile,
+                       moduledir: moduledir.to_s }.to_json)
+      end
+
+      # Print target names and where they came from.
+      #
+      # @param adhoc [Hash] Adhoc targets provided on the command line.
+      # @param inventory [Hash] Targets provided from the inventory.
+      # @param targets [Array] All targets.
+      # @param count [Integer] Number of targets.
+      #
+      def print_targets(adhoc:, inventory:, targets:, count:, **_kwargs)
+        adhoc[:targets]     = adhoc[:targets].map { |t| t['name'] }
+        inventory[:targets] = inventory[:targets].map { |t| t['name'] }
+        targets             = targets.map { |t| t['name'] }
+        @stream.puts({ adhoc: adhoc, inventory: inventory, targets: targets, count: count }.to_json)
+      end
+
+      # Print target names and where they came from.
+      #
+      # @param adhoc [Hash] Adhoc targets provided on the command line.
+      # @param inventory [Hash] Targets provided from the inventory.
+      # @param targets [Array] All targets.
+      # @param count [Integer] Number of targets.
+      #
+      def print_target_info(adhoc:, inventory:, targets:, count:, **_kwargs)
+        @stream.puts({ adhoc: adhoc, inventory: inventory, targets: targets, count: count }.to_json)
+      end
+
+      # Print inventory group information.
+      #
+      # @param count [Integer] Number of groups in the inventory.
+      # @param groups [Array] Names of groups in the inventory.
+      #
+      def print_groups(count:, groups:, **_kwargs)
+        @stream.puts({ count: count, groups: groups }.to_json)
+      end
+
+      def fatal_error(err)
+        @stream.puts "],\n" if @items_open
+        @stream.puts '"_error": ' if @object_open
+        err_obj = err.to_h
+        if @trace && err.backtrace
+          err_obj[:details] ||= {}
+          err_obj[:details][:backtrace] = err.backtrace
+        end
+        @stream.puts err_obj.to_json
+        @stream.puts '}' if @object_open
+      end
+
+      def print_message(message)
+        $stderr.puts(Bolt::Util::Format.stringify(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

data/lib/bolt/outputter/logger.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require_relative '../../bolt/pal'
+
+module Bolt
+  class Outputter
+    class Logger < Bolt::Outputter
+      def initialize(verbose, trace)
+        super(false, verbose, trace, false)
+        @logger = Bolt::Logger.logger(self)
+      end
+
+      def handle_event(event)
+        case event[:type]
+        when :step_start
+          log_step_start(**event)
+        when :step_finish
+          log_step_finish(**event)
+        when :plan_start
+          log_plan_start(event)
+        when :plan_finish
+          log_plan_finish(event)
+        when :container_start
+          log_container_start(event)
+        when :container_finish
+          log_container_finish(event)
+        when :log, :message, :verbose
+          log_message(**event)
+        end
+      end
+
+      def log_step_start(description:, targets:, **_kwargs)
+        target_str = if targets.length > 5
+                       "#{targets.count} targets"
+                     else
+                       targets.map(&:safe_name).join(', ')
+                     end
+        @logger.info("Starting: #{description} on #{target_str}")
+      end
+
+      def log_step_finish(description:, result:, duration:, **_kwargs)
+        failures = result.error_set.length
+        plural = failures == 1 ? '' : 's'
+        @logger.info("Finished: #{description} with #{failures} failure#{plural} in #{duration.round(2)} sec")
+      end
+
+      def log_plan_start(event)
+        plan = event[:plan]
+        @logger.info("Starting: plan #{plan}")
+      end
+
+      def log_plan_finish(event)
+        plan = event[:plan]
+        duration = event[:duration]
+        @logger.info("Finished: plan #{plan} in #{duration.round(2)} sec")
+      end
+
+      def log_container_start(event)
+        @logger.info("Starting: run container '#{event[:image]}'")
+      end
+
+      def log_container_finish(event)
+        result = event[:result]
+        if result.success?
+          @logger.info("Finished: run container '#{result.object}' succeeded.")
+        else
+          @logger.info("Finished: run container '#{result.object}' failed.")
+        end
+      end
+
+      def log_message(level:, message:, **_kwargs)
+        @logger.send(level, message)
+      end
+    end
+  end
+end

data/lib/bolt/outputter/rainbow.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+require_relative '../../bolt/pal'
+require_relative '../../bolt/util/format'
+
+module Bolt
+  class Outputter
+    class Rainbow < Bolt::Outputter::Human
+      def initialize(color, verbose, trace, spin, stream = $stdout)
+        begin
+          require 'paint'
+          if Bolt::Util.windows?
+            # the Paint gem thinks that windows does not support ansi colors
+            # but windows 10 or later does
+            # we can display colors if we force mode to TRUE_COLOR
+            Paint.mode = 0xFFFFFF
+          end
+        rescue LoadError
+          raise "The 'paint' gem is required to use the rainbow outputter."
+        end
+        super
+        @line_color = 0
+        @color = 0
+        @state = :normal
+      end
+
+      # The algorithm is from lolcat (https://github.com/busyloop/lolcat)
+      # lolcat is released with WTFPL
+      def rainbow
+        red = Math.sin(0.3 * @color + 0) * 127 + 128
+        green = Math.sin(0.3 * @color + 2 * Math::PI / 3) * 127 + 128
+        blue  = Math.sin(0.3 * @color + 4 * Math::PI / 3) * 127 + 128
+        @color += 1 / 8.0
+        format("%<red>02X%<green>02X%<blue>02X", red: red, green: green, blue: blue)
+      end
+
+      def colorize(color, string)
+        if @color && @stream.isatty
+          if %i[green rainbow].include?(color)
+            a = string.chars.map do |c|
+              case @state
+              when :normal
+                case c
+                when "\e"
+                  @state = :ansi
+                when "\n"
+                  @line_color += 1
+                  @color = @line_color
+                  c
+                else
+                  Paint[c, rainbow]
+                end
+              when :ansi
+                @state = :normal if c == 'm'
+              end
+            end
+            a.join
+          else
+            "\033[#{COLORS[color]}m#{string}\033[0m"
+          end
+        else
+          string
+        end
+      end
+
+      def start_spin
+        return unless @spin && @stream.isatty && !@spinning
+        @spinning = true
+        @spin_thread = Thread.new do
+          loop do
+            sleep(0.1)
+            @stream.print(colorize(:rainbow, @pinwheel.rotate!.first + "\b"))
+          end
+        end
+      end
+
+      def print_summary(results, elapsed_time = nil)
+        ok_set = results.ok_set
+        unless ok_set.empty?
+          @stream.puts colorize(:rainbow, format('Successful on %<size>d target%<plural>s: %<names>s',
+                                                 size: ok_set.size,
+                                                 plural: ok_set.size == 1 ? '' : 's',
+                                                 names: ok_set.targets.map(&:safe_name).join(',')))
+        end
+
+        error_set = results.error_set
+        unless error_set.empty?
+          @stream.puts colorize(:red,
+                                format('Failed on %<size>d target%<plural>s: %<names>s',
+                                       size: error_set.size,
+                                       plural: error_set.size == 1 ? '' : 's',
+                                       names: error_set.targets.map(&:safe_name).join(',')))
+        end
+
+        total_msg = format('Ran on %<size>d target%<plural>s',
+                           size: results.size,
+                           plural: results.size == 1 ? '' : 's')
+        total_msg << " in #{duration_to_string(elapsed_time)}" unless elapsed_time.nil?
+        @stream.puts colorize(:rainbow, total_msg)
+      end
+
+      def print_guide(guide, _topic)
+        @stream.puts colorize(:rainbow, guide)
+      end
+
+      def print_topics(topics)
+        content  = String.new("Available topics are:\n")
+        content += topics.join("\n")
+        content += "\n\nUse `bolt guide <topic>` to view a specific guide."
+        @stream.puts colorize(:rainbow, content)
+      end
+
+      def print_message(message)
+        @stream.puts colorize(:rainbow, Bolt::Util::Format.stringify(message))
+      end
+    end
+  end
+end

data/lib/bolt/outputter.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Bolt
+  class Outputter
+    def self.for_format(format, color, verbose, trace, spin)
+      case format
+      when 'human'
+        Bolt::Outputter::Human.new(color, verbose, trace, spin)
+      when 'json'
+        Bolt::Outputter::JSON.new(color, verbose, trace, false)
+      when 'rainbow'
+        Bolt::Outputter::Rainbow.new(color, verbose, trace, spin)
+      when nil
+        raise "Cannot use outputter before parsing."
+      end
+    end
+
+    def initialize(color, verbose, trace, spin, stream = $stdout)
+      @color = color
+      @verbose = verbose
+      @trace = trace
+      @stream = stream
+      @spin = spin
+    end
+
+    def indent(indent, string)
+      indent = ' ' * indent
+      string.gsub(/^/, indent.to_s)
+    end
+
+    def print_message
+      raise NotImplementedError, "print_message() must be implemented by the outputter class"
+    end
+
+    def print_error
+      raise NotImplementedError, "print_error() must be implemented by the outputter class"
+    end
+
+    def start_spin; end
+
+    def stop_spin; end
+
+    def spin
+      start_spin
+      begin
+        yield
+      ensure
+        stop_spin
+      end
+    end
+  end
+end
+
+require_relative 'outputter/human'
+require_relative 'outputter/json'
+require_relative 'outputter/logger'
+require_relative 'outputter/rainbow'

data/lib/bolt/pal/issues.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Bolt
+  class PAL
+    module Issues
+      # Create issue using Issues api
+      PLAN_OPERATION_NOT_SUPPORTED_WHEN_COMPILING =
+        Puppet::Pops::Issues.issue :PLAN_OPERATION_NOT_SUPPORTED_WHEN_COMPILING, :action do
+          "Plan language function '#{action}' cannot be used from declarative manifest code or apply blocks"
+        end
+
+      # Inventory version 2
+      UNSUPPORTED_INVENTORY_VERSION =
+        Puppet::Pops::Issues.issue :UNSUPPORTED_INVENTORY_VERSION, :action do
+          "Plan language function '#{action}' cannot be used with Inventory v1"
+        end
+    end
+  end
+end

data/lib/bolt/pal/logging.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require_relative '../../bolt/util/puppet_log_level'
+
+Puppet::Util::Log.newdesttype :logging do
+  match "Logging::Logger"
+
+  # Bolt log levels don't match exactly with Puppet log levels, so we use
+  # an explicit mapping.
+  def initialize(logger)
+    @external_logger = logger
+  end
+
+  def handle(log)
+    @external_logger.send(Bolt::Util::PuppetLogLevel::MAPPING[log.level], log.to_s)
+  end
+end

data/lib/bolt/pal/yaml_plan/evaluator.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require_relative '../../../bolt/pal/yaml_plan'
+
+module Bolt
+  class PAL
+    class YamlPlan
+      class Evaluator
+        def initialize(analytics = Bolt::Analytics::NoopClient.new)
+          @logger = Bolt::Logger.logger(self)
+          @analytics = analytics
+          @evaluator = Puppet::Pops::Parser::EvaluatingParser.new
+        end
+
+        # This is the method that Puppet calls to evaluate the plan. The name
+        # makes more sense for .pp plans.
+        #
+        def evaluate_block_with_bindings(closure_scope, args_hash, plan)
+          plan_result = closure_scope.with_local_scope(args_hash) do |scope|
+            plan.steps.each do |step|
+              step_result = step.evaluate(scope, self)
+
+              scope.setvar(step.body['name'], step_result) if step.body['name']
+            end
+
+            evaluate_code_blocks(scope, plan.return)
+          end
+
+          throw :return, Puppet::Pops::Evaluator::Return.new(plan_result, nil, nil)
+        end
+
+        # Recursively evaluate any EvaluableString instances in the object.
+        #
+        def evaluate_code_blocks(scope, value)
+          # XXX We should establish a local scope here probably
+          case value
+          when Array
+            value.map { |element| evaluate_code_blocks(scope, element) }
+          when Hash
+            value.each_with_object({}) do |(k, v), o|
+              key = k.is_a?(EvaluableString) ? k.value : k
+              o[key] = evaluate_code_blocks(scope, v)
+            end
+          when EvaluableString
+            begin
+              value.evaluate(scope, @evaluator)
+            rescue StandardError => e
+              raise format_evaluate_error(e, value)
+            end
+          else
+            value
+          end
+        end
+
+        # Occasionally the Closure will ask us to evaluate what it assumes are
+        # AST objects. Because we've sidestepped the AST, they aren't, so just
+        # return the values as already evaluated.
+        #
+        def evaluate(value, _scope)
+          value
+        end
+
+        def format_evaluate_error(error, value)
+          # The Puppet::PreformattedError includes the line number of the
+          # evaluable string that caused the error, while the value includes the
+          # line number of the YAML plan that the string began on. To get the
+          # actual line number of the error, add these two numbers together.
+          line = error.line + value.line
+
+          # If the evaluable string is not a scalar literal, correct for it
+          # being on the same line as the step key.
+          line -= 1 if value.is_a?(BareString)
+
+          Bolt::PlanFailure.new(
+            error.basic_message,
+            'bolt/evaluation-error',
+            { file: value.file, line: line }
+          )
+        end
+      end
+    end
+  end
+end

data/lib/bolt/pal/yaml_plan/loader.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+require_relative '../../../bolt/pal/yaml_plan'
+require_relative '../../../bolt/pal/yaml_plan/evaluator'
+require 'psych'
+
+module Bolt
+  class PAL
+    class YamlPlan
+      class Loader
+        class PuppetVisitor < Psych::Visitors::NoAliasRuby
+          def initialize(scanner, class_loader, file)
+            super(scanner, class_loader)
+            @file = file
+          end
+
+          def self.create_visitor(source_ref)
+            class_loader = Psych::ClassLoader::Restricted.new([], [])
+            scanner = Psych::ScalarScanner.new(class_loader)
+            new(scanner, class_loader, source_ref)
+          end
+
+          def deserialize(node)
+            if node.quoted
+              case node.style
+              when Psych::Nodes::Scalar::SINGLE_QUOTED
+                # Single-quoted strings are treated literally
+                # @ss is a ScalarScanner, from the base ToRuby visitor class
+                node.value
+              when Psych::Nodes::Scalar::DOUBLE_QUOTED
+                DoubleQuotedString.new(node.value, @file, node.start_line + 1)
+              # | style string
+              when Psych::Nodes::Scalar::LITERAL
+                CodeLiteral.new(node.value, @file, node.start_line + 1)
+              # > style string
+              else
+                @ss.tokenize(node.value)
+              end
+            else
+              value = @ss.tokenize(node.value)
+              if value.is_a?(String)
+                BareString.new(value, @file, node.start_line + 1)
+              else
+                value
+              end
+            end
+          end
+        end
+
+        def self.parse_plan(yaml_string, source_ref)
+          # This passes the filename as the second arg for compatibility with Psych used with ruby < 2.6
+          # This can be removed when we remove support for ruby 2.5
+          parse_tree = if Psych.method(:parse).parameters.rassoc(:filename) == %i[key filename]
+                         Psych.parse(yaml_string, filename: source_ref)
+                       else
+                         Psych.parse(yaml_string, source_ref)
+                       end
+          PuppetVisitor.create_visitor(source_ref).accept(parse_tree)
+        end
+
+        def self.from_string(name, yaml_string, source_ref)
+          result = parse_plan(yaml_string, source_ref)
+          unless result.is_a?(Hash)
+            type = result.class.name
+            raise ArgumentError, "The data loaded from #{source_ref} does not contain an object - its type is #{type}"
+          end
+
+          begin
+            YamlPlan.new(name, result).freeze
+          rescue Bolt::Error => e
+            raise Puppet::ParseError.new(e.message, source_ref)
+          end
+        end
+
+        def self.create(loader, typed_name, source_ref, yaml_string)
+          plan_definition = from_string(typed_name.name, yaml_string, source_ref)
+          created = create_function_class(plan_definition)
+          closure_scope = nil
+
+          created.new(closure_scope, loader.private_loader)
+        end
+
+        def self.create_function_class(plan_definition)
+          Puppet::Functions.create_function(plan_definition.name, Puppet::Functions::PuppetFunction) do
+            closure = Puppet::Pops::Evaluator::Closure::Named.new(plan_definition.name,
+                                                                  YamlPlan::Evaluator.new,
+                                                                  plan_definition)
+            init_dispatch(closure)
+          end
+        end
+      end
+    end
+  end
+end