bolt 1.14.0 → 1.15.0

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

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require 'bolt/pal/yaml_plan'
+require 'bolt/pal/yaml_plan/evaluator'
+require 'psych'
+
+module Bolt
+  class PAL
+    class YamlPlan
+      class Loader
+        class PuppetVisitor < Psych::Visitors::NoAliasRuby
+          def self.create_visitor
+            class_loader = Psych::ClassLoader::Restricted.new([], [])
+            scanner = Psych::ScalarScanner.new(class_loader)
+            new(scanner, class_loader)
+          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)
+              # | style string or > style string
+              when Psych::Nodes::Scalar::LITERAL, Psych::Nodes::Scalar::FOLDED
+                CodeLiteral.new(node.value)
+              # This one shouldn't be possible
+              else
+                @ss.tokenize(node.value)
+              end
+            else
+              value = @ss.tokenize(node.value)
+              if value.is_a?(String)
+                BareString.new(value)
+              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.include?('legacy_filename')
+                         Psych.parse(yaml_string, filename: source_ref)
+                       else
+                         Psych.parse(yaml_string, source_ref)
+                       end
+          PuppetVisitor.create_visitor.accept(parse_tree)
+        end
+
+        def self.create(loader, typed_name, source_ref, yaml_string)
+          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
+            plan_definition = YamlPlan.new(typed_name, result).freeze
+          rescue Bolt::Error => e
+            raise Puppet::ParseError.new(e.message, source_ref)
+          end
+
+          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

data/lib/bolt/result.rb

@@ -5,7 +5,7 @@ require 'bolt/error'
 
 module Bolt
   class Result
-    attr_reader :target, :value
+    attr_reader :target, :value, :type, :object
 
     def self.from_exception(target, exception)
       @exception = exception
@@ -23,7 +23,7 @@ module Bolt
       Result.new(target, error: error)
     end
 
-    def self.for_command(target, stdout, stderr, exit_code)
+    def self.for_command(target, stdout, stderr, exit_code, type, command)
       value = {
         'stdout' => stdout,
         'stderr' => stderr,
@@ -37,10 +37,10 @@ module Bolt
           'details' => { 'exit_code' => exit_code }
         }
       end
-      new(target, value: value)
+      new(target, value: value, type: type, object: command)
     end
 
-    def self.for_task(target, stdout, stderr, exit_code)
+    def self.for_task(target, stdout, stderr, exit_code, task)
       begin
         value = JSON.parse(stdout)
         unless value.is_a? Hash
@@ -61,11 +61,11 @@ module Bolt
                             'msg' => msg,
                             'details' => { 'exit_code' => exit_code } }
       end
-      new(target, value: value)
+      new(target, value: value, type: 'task', object: task)
     end
 
     def self.for_upload(target, source, destination)
-      new(target, message: "Uploaded '#{source}' to '#{target.host}:#{destination}'")
+      new(target, message: "Uploaded '#{source}' to '#{target.host}:#{destination}'", type: 'upload', object: source)
     end
 
     # Satisfies the Puppet datatypes API
@@ -73,9 +73,11 @@ module Bolt
       new(target, value: value)
     end
 
-    def initialize(target, error: nil, message: nil, value: nil)
+    def initialize(target, error: nil, message: nil, value: nil, type: nil, object: nil)
       @target = target
       @value = value || {}
+      @type = type
+      @object = object
       @value_set = !value.nil?
       if error && !error.is_a?(Hash)
         raise "TODO: how did we get a string error"
@@ -90,12 +92,12 @@ module Bolt
 
     def status_hash
       { node: @target.name,
+        type: type,
+        object: object,
         status: ok? ? 'success' : 'failure',
         result: @value }
     end
 
-    # TODO: what to call this it's the value minus special keys
-    # This should be {} if a value was set otherwise it's nil
     def generic_value
       if @value_set
         value.reject { |k, _| %w[_error _output].include? k }
@@ -124,15 +126,11 @@ module Bolt
       to_json
     end
 
-    # TODO: remove in favor of ok?
-    def success?
-      ok?
-    end
-
     def ok?
       error_hash.nil?
     end
     alias ok ok?
+    alias success? ok?
 
     # This allows access to errors outside puppet compilation
     # it should be prefered over error in bolt code

data/lib/bolt/task.rb

@@ -21,12 +21,20 @@ module Bolt
     :metadata
   ) do
 
-    def initialize(task)
+    attr_reader :remote
+
+    def initialize(task, remote: false)
       super(nil, nil, [], {})
 
+      @remote = remote
+
       task.reject { |k, _| k == 'parameters' }.each { |k, v| self[k] = v }
     end
 
+    def remote_instance
+      self.class.new(to_h.each_with_object({}) { |(k, v), h| h[k.to_s] = v }, remote: true)
+    end
+
     def description
       metadata['description']
     end
@@ -67,13 +75,18 @@ module Bolt
     def select_implementation(target, additional_features = [])
       impl = if (impls = implementations)
                available_features = target.features + additional_features
-               impl = impls.find { |imp| Set.new(imp['requirements']).subset?(available_features) }
+               impl = impls.find do |imp|
+                 remote_impl = imp['remote']
+                 remote_impl = metadata['remote'] if remote_impl.nil?
+                 Set.new(imp['requirements']).subset?(available_features) && !!remote_impl == @remote
+               end
                raise NoImplementationError.new(target, self) unless impl
                impl = impl.dup
                impl['path'] = file_path(impl['name'])
                impl.delete('requirements')
                impl
              else
+               raise NoImplementationError.new(target, self) unless !!metadata['remote'] == @remote
                name = files.first['name']
                { 'name' => name, 'path' => file_path(name) }
              end

data/lib/bolt/task/puppet_server.rb

@@ -1,14 +1,18 @@
 # frozen_string_literal: true
 
-require 'bolt/task'
-
 module Bolt
   class Task
     class PuppetServer < Bolt::Task
-      def initialize(task_data, file_cache)
+      def remote_instance
+        self.class.new(to_h.each_with_object({}) { |(k, v), h| h[k.to_s] = v },
+                       @file_cache,
+                       remote: true)
+      end
+
+      def initialize(task, file_cache, **opts)
+        super(task, **opts)
         @file_cache = file_cache
-        task_data = update_file_data(task_data)
-        super(task_data)
+        update_file_data(task)
       end
 
       # puppetserver file entries have 'filename' rather then 'name'
@@ -17,7 +21,6 @@ module Bolt
         task_data
       end
 
-      # Compute local path and download files from puppetserver as needed
       def file_path(file_name)
         file = file_map[file_name]
         file['path'] ||= @file_cache.update_file(file)

data/lib/bolt/transport/docker.rb

@@ -59,7 +59,7 @@ module Bolt
       def run_command(target, command, _options = {})
         with_connection(target) do |conn|
           stdout, stderr, exitcode = conn.execute(*Shellwords.split(command), {})
-          Bolt::Result.for_command(target, stdout, stderr, exitcode)
+          Bolt::Result.for_command(target, stdout, stderr, exitcode, 'command', command)
         end
       end
 
@@ -71,7 +71,7 @@ module Bolt
           conn.with_remote_tempdir do |dir|
             remote_path = conn.write_remote_executable(dir, script)
             stdout, stderr, exitcode = conn.execute(remote_path, *arguments, {})
-            Bolt::Result.for_command(target, stdout, stderr, exitcode)
+            Bolt::Result.for_command(target, stdout, stderr, exitcode, 'script', script)
           end
         end
       end
@@ -112,7 +112,7 @@ module Bolt
             end
 
             stdout, stderr, exitcode = conn.execute(remote_task_path, execute_options)
-            Bolt::Result.for_task(target, stdout, stderr, exitcode)
+            Bolt::Result.for_task(target, stdout, stderr, exitcode, task.name)
           end
         end
       end

data/lib/bolt/transport/docker/connection.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require 'docker'
 require 'logging'
 require 'bolt/node/errors'
 
@@ -9,6 +8,9 @@ module Bolt
     class Docker < Base
       class Connection
         def initialize(target)
+          # lazy-load expensive gem code
+          require 'docker'
+
           @target = target
           @logger = Logging.logger[target.host]
         end

data/lib/bolt/transport/local.rb

@@ -78,7 +78,11 @@ module Bolt
       def run_command(target, command, _options = {})
         in_tmpdir(target.options['tmpdir']) do |dir|
           output = @conn.execute(command, dir: dir)
-          Bolt::Result.for_command(target, output.stdout.string, output.stderr.string, output.exit_code)
+          Bolt::Result.for_command(target,
+                                   output.stdout.string,
+                                   output.stderr.string,
+                                   output.exit_code,
+                                   'command', command)
         end
       end
 
@@ -106,7 +110,11 @@ module Bolt
             end
             output = @conn.execute(file, *arguments, dir: dir)
           end
-          Bolt::Result.for_command(target, output.stdout.string, output.stderr.string, output.exit_code)
+          Bolt::Result.for_command(target,
+                                   output.stdout.string,
+                                   output.stderr.string,
+                                   output.exit_code,
+                                   'script', script)
         end
       end
 
@@ -181,7 +189,7 @@ module Bolt
             env = ENVIRONMENT_METHODS.include?(input_method) ? envify_params(unwrapped_arguments) : nil
             output = @conn.execute(script, stdin: stdin, env: env, dir: dir, interpreter: interpreter)
           end
-          Bolt::Result.for_task(target, output.stdout.string, output.stderr.string, output.exit_code)
+          Bolt::Result.for_task(target, output.stdout.string, output.stderr.string, output.exit_code, task.name)
         end
       end
 

data/lib/bolt/transport/orch.rb

@@ -1,11 +1,9 @@
 # frozen_string_literal: true
 
 require 'base64'
-require 'concurrent'
 require 'find'
 require 'json'
 require 'minitar'
-require 'orchestrator_client'
 require 'pathname'
 require 'zlib'
 require 'bolt/transport/base'
@@ -40,6 +38,9 @@ module Bolt
       def self.validate(options); end
 
       def initialize(*args)
+        # lazy-load expensive gem code
+        require 'orchestrator_client'
+
         @connections = {}
         super
       end
@@ -66,7 +67,7 @@ module Bolt
         conn
       end
 
-      def process_run_results(targets, results)
+      def process_run_results(targets, results, task_name)
         targets_by_name = Hash[targets.map(&:host).zip(targets)]
         results.map do |node_result|
           target = targets_by_name[node_result['name']]
@@ -76,7 +77,7 @@ module Bolt
           # If it's finished or already has a proper error simply pass it to the
           # the result otherwise make sure an error is generated
           if state == 'finished' || (result && result['_error'])
-            Bolt::Result.new(target, value: result)
+            Bolt::Result.new(target, value: result, type: 'task', object: task_name)
           elsif state == 'skipped'
             Bolt::Result.new(
               target,
@@ -84,11 +85,12 @@ module Bolt
                 'kind' => 'puppetlabs.tasks/skipped-node',
                 'msg' => "Node #{target.host} was skipped",
                 'details' => {}
-              } }
+              } },
+              type: 'task', object: task_name
             )
           else
             # Make a generic error with a unkown exit_code
-            Bolt::Result.for_task(target, result.to_json, '', 'unknown')
+            Bolt::Result.for_task(target, result.to_json, '', 'unknown', task_name)
           end
         end
       end
@@ -103,7 +105,7 @@ module Bolt
                                options,
                                &callback)
         callback ||= proc {}
-        results.map! { |result| unwrap_bolt_result(result.target, result) }
+        results.map! { |result| unwrap_bolt_result(result.target, result, 'command', command) }
         results.each do |result|
           callback.call(type: :node_result, result: result)
         end
@@ -119,7 +121,7 @@ module Bolt
         }
         callback ||= proc {}
         results = run_task_job(targets, BOLT_SCRIPT_TASK, params, options, &callback)
-        results.map! { |result| unwrap_bolt_result(result.target, result) }
+        results.map! { |result| unwrap_bolt_result(result.target, result, 'script', script) }
         results.each do |result|
           callback.call(type: :node_result, result: result)
         end
@@ -198,7 +200,7 @@ module Bolt
           arguments = unwrap_sensitive_args(arguments)
           results = get_connection(targets.first.options).run_task(targets, task, arguments, options)
 
-          process_run_results(targets, results)
+          process_run_results(targets, results, task.name)
         rescue OrchestratorClient::ApiError => e
           targets.map do |target|
             Bolt::Result.new(target, error: e.data)
@@ -226,13 +228,17 @@ module Bolt
       # run_task generates a result that makes sense for a generic task which
       # needs to be unwrapped to extract stdout/stderr/exitcode.
       #
-      def unwrap_bolt_result(target, result)
+      def unwrap_bolt_result(target, result, type, obj)
         if result.error_hash
           # something went wrong return the failure
           return result
         end
 
-        Bolt::Result.for_command(target, result.value['stdout'], result.value['stderr'], result.value['exit_code'])
+        Bolt::Result.for_command(target,
+                                 result.value['stdout'],
+                                 result.value['stderr'],
+                                 result.value['exit_code'],
+                                 type, obj)
       end
     end
   end

data/lib/bolt/transport/remote.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'bolt/task/remote'
+require 'bolt/task'
 require 'bolt/transport/base'
 
 module Bolt
@@ -47,7 +47,7 @@ module Bolt
         transport = @executor.transport(proxy_target.protocol)
         arguments = arguments.merge('_target' => target.to_h.reject { |_, v| v.nil? })
 
-        remote_task = Bolt::Task::Remote.new(task.to_h)
+        remote_task = task.remote_instance
 
         result = transport.run_task(proxy_target, remote_task, arguments, options)
         Bolt::Result.new(target, value: result.value)

data/lib/bolt/transport/ssh.rb

@@ -108,7 +108,11 @@ module Bolt
         with_connection(target) do |conn|
           conn.running_as(options['_run_as']) do
             output = conn.execute(command, sudoable: true)
-            Bolt::Result.for_command(target, output.stdout.string, output.stderr.string, output.exit_code)
+            Bolt::Result.for_command(target,
+                                     output.stdout.string,
+                                     output.stderr.string,
+                                     output.exit_code,
+                                     'command', command)
           end
         end
       end
@@ -123,7 +127,11 @@ module Bolt
               remote_path = conn.write_remote_executable(dir, script)
               dir.chown(conn.run_as)
               output = conn.execute([remote_path, *arguments], sudoable: true)
-              Bolt::Result.for_command(target, output.stdout.string, output.stderr.string, output.exit_code)
+              Bolt::Result.for_command(target,
+                                       output.stdout.string,
+                                       output.stderr.string,
+                                       output.exit_code,
+                                       'script', script)
             end
           end
         end
@@ -184,7 +192,8 @@ module Bolt
             end
             Bolt::Result.for_task(target, output.stdout.string,
                                   output.stderr.string,
-                                  output.exit_code)
+                                  output.exit_code,
+                                  task.name)
           end
         end
       end