bolt 1.12.0 → 1.13.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 05e284722c10c61a2fe08a01b920b18739b8cc31486762db9dfadba82288f6d6
-  data.tar.gz: 59e57d3df534fcbae81f2f5f44000e1f1930aec4029c8d664696e156a715a922
+  metadata.gz: 66234162abaa83dd3dd590b21dd87a54d10c3da44f0d50ccd8e28d82ddf76178
+  data.tar.gz: b056cb53e8fda46db48b7a7a1b63f8441f80342e11e5c0a7c50d1813cf852bbc
 SHA512:
-  metadata.gz: ea83de65334823f418383868b21cb5f23f501e11fbb525e5d9b9ebc8fac9f818322f56e4069f2697e9de48ce5631a349e5673cf16c0b5437e0f4799e654c6b39
-  data.tar.gz: b1d95304ae24c3f792ee9fecf9fe42073efc73f7fbd309654f78112886e5e55a2541913e1a1aa705c8e123113f53ba136f18731b39344d3b9bdd0ac31a96f496
+  metadata.gz: '079515ce4801e6913e2b75d276289985cf9eda0d9b60c10021a5b435c77ce69d0cc07d5a1708a4f7c43db4947fef918f5d14b8ccac8fdf6a55b5ccf5fce6cf62'
+  data.tar.gz: 94eba8ff4a83d463f4b5516eb69cd83d31b1fdc6c3673a0b0beda9ac5dc08becd9eb2d75953932c57345ab8099900884174df329d04f43637802df73a538a365

data/bolt-modules/boltlib/lib/puppet/functions/add_facts.rb

@@ -3,6 +3,8 @@
 require 'bolt/error'
 
 # Deep merges a hash of facts with the existing facts on a target.
+#
+# **NOTE:** Not available in apply block
 Puppet::Functions.create_function(:add_facts) do
   # @param target A target.
   # @param facts A hash of fact names to values that may include structured facts.
@@ -17,9 +19,8 @@ Puppet::Functions.create_function(:add_facts) do
 
   def add_facts(target, facts)
     unless Puppet[:tasks]
-      raise Puppet::ParseErrorWithIssue.from_issue_and_stack(
-        Puppet::Pops::Issues::TASK_OPERATION_NOT_SUPPORTED_WHEN_COMPILING, operation: 'add_facts'
-      )
+      raise Puppet::ParseErrorWithIssue
+        .from_issue_and_stack(Bolt::PAL::Issues::PLAN_OPERATION_NOT_SUPPORTED_WHEN_COMPILING, action: 'add_facts')
     end
 
     inventory = Puppet.lookup(:bolt_inventory) { nil }

data/bolt-modules/boltlib/lib/puppet/functions/add_to_group.rb

@@ -3,6 +3,8 @@
 require 'bolt/error'
 
 # Adds a target to specified inventory group.
+#
+# **NOTE:** Not available in apply block
 Puppet::Functions.create_function(:add_to_group) do
   # @param targets A pattern or array of patterns identifying a set of targets.
   # @param group The name of the group to add targets to.
@@ -20,6 +22,11 @@ Puppet::Functions.create_function(:add_to_group) do
   end
 
   def add_to_group(targets, group)
+    unless Puppet[:tasks]
+      raise Puppet::ParseErrorWithIssue
+        .from_issue_and_stack(Bolt::PAL::Issues::PLAN_OPERATION_NOT_SUPPORTED_WHEN_COMPILING, action: 'add_to_group')
+    end
+
     inventory = Puppet.lookup(:bolt_inventory) { nil }
 
     unless inventory && Puppet.features.bolt?

data/bolt-modules/boltlib/lib/puppet/functions/apply_prep.rb

@@ -10,6 +10,8 @@ require 'bolt/task'
 #
 # If no agent is detected on the target using the 'puppet_agent::version' task, it's installed
 # using 'puppet_agent::install' and the puppet service is stopped/disabled using the 'service' task.
+#
+# **NOTE:** Not available in apply block
 Puppet::Functions.create_function(:apply_prep) do
   # @param targets A pattern or array of patterns identifying a set of targets.
   # @example Prepare targets by name.
@@ -39,9 +41,15 @@ Puppet::Functions.create_function(:apply_prep) do
   end
 
   def apply_prep(target_spec)
+    unless Puppet[:tasks]
+      raise Puppet::ParseErrorWithIssue
+        .from_issue_and_stack(Bolt::PAL::Issues::PLAN_OPERATION_NOT_SUPPORTED_WHEN_COMPILING, action: 'apply_prep')
+    end
+
     applicator = Puppet.lookup(:apply_executor) { nil }
     executor = Puppet.lookup(:bolt_executor) { nil }
     inventory = Puppet.lookup(:bolt_inventory) { nil }
+
     unless applicator && executor && inventory && Puppet.features.bolt?
       raise Puppet::ParseErrorWithIssue.from_issue_and_stack(
         Puppet::Pops::Issues::TASK_MISSING_BOLT, action: _('apply_prep')

data/bolt-modules/boltlib/lib/puppet/functions/fail_plan.rb

@@ -6,6 +6,8 @@ require 'bolt/error'
 #
 # Plan authors should call this function when their plan is not successful. The
 # error may then be caught by another plans run_plan function or in bolt itself
+#
+# **NOTE:** Not available in apply block
 Puppet::Functions.create_function(:fail_plan) do
   # Fail a plan, generating an exception from the parameters.
   # @param msg An error message.
@@ -32,6 +34,11 @@ Puppet::Functions.create_function(:fail_plan) do
   end
 
   def from_args(msg, kind = nil, details = nil, issue_code = nil)
+    unless Puppet[:tasks]
+      raise Puppet::ParseErrorWithIssue
+        .from_issue_and_stack(Bolt::PAL::Issues::PLAN_OPERATION_NOT_SUPPORTED_WHEN_COMPILING, action: 'fail_plan')
+    end
+
     executor = Puppet.lookup(:bolt_executor) { nil }
     executor&.report_function_call('fail_plan')
 

data/bolt-modules/boltlib/lib/puppet/functions/get_resources.rb

@@ -7,6 +7,8 @@ require 'bolt/task'
 #
 # Requires the Puppet Agent be installed on the target, which can be accomplished with apply_prep
 # or by directly running the puppet_agent::install task.
+#
+# **NOTE:** Not available in apply block
 Puppet::Functions.create_function(:get_resources) do
   # @param targets A pattern or array of patterns identifying a set of targets.
   # @param resources A resource type or instance, or an array of such.
@@ -32,6 +34,11 @@ Puppet::Functions.create_function(:get_resources) do
   end
 
   def get_resources(target_spec, resources)
+    unless Puppet[:tasks]
+      raise Puppet::ParseErrorWithIssue
+        .from_issue_and_stack(Bolt::PAL::Issues::PLAN_OPERATION_NOT_SUPPORTED_WHEN_COMPILING, action: 'get_resources')
+    end
+
     applicator = Puppet.lookup(:apply_executor) { nil }
     executor = Puppet.lookup(:bolt_executor) { nil }
     inventory = Puppet.lookup(:bolt_inventory) { nil }

data/bolt-modules/boltlib/lib/puppet/functions/run_command.rb

@@ -4,6 +4,8 @@ require 'bolt/error'
 
 # Runs a command on the given set of targets and returns the result from each command execution.
 # This function does nothing if the list of targets is empty.
+#
+# **NOTE:** Not available in apply block
 Puppet::Functions.create_function(:run_command) do
   # Run a command.
   # @param command A command to run on target.
@@ -40,15 +42,13 @@ Puppet::Functions.create_function(:run_command) do
   end
 
   def run_command_with_description(command, targets, description = nil, options = nil)
-    options ||= {}
-    options = options.merge('_description' => description) if description
-
     unless Puppet[:tasks]
-      raise Puppet::ParseErrorWithIssue.from_issue_and_stack(
-        Puppet::Pops::Issues::TASK_OPERATION_NOT_SUPPORTED_WHEN_COMPILING, operation: 'run_command'
-      )
+      raise Puppet::ParseErrorWithIssue
+        .from_issue_and_stack(Bolt::PAL::Issues::PLAN_OPERATION_NOT_SUPPORTED_WHEN_COMPILING, action: 'run_command')
     end
 
+    options ||= {}
+    options = options.merge('_description' => description) if description
     executor = Puppet.lookup(:bolt_executor) { nil }
     inventory = Puppet.lookup(:bolt_inventory) { nil }
     unless executor && inventory && Puppet.features.bolt?

data/bolt-modules/boltlib/lib/puppet/functions/run_plan.rb

@@ -3,6 +3,8 @@
 require 'bolt/error'
 
 # Runs the `plan` referenced by its name. A plan is autoloaded from `<moduleroot>/plans`.
+#
+# **NOTE:** Not available in apply block
 Puppet::Functions.create_function(:run_plan, Puppet::Functions::InternalFunction) do
   # @param plan_name The plan to run.
   # @param named_args Arguments to the plan. Can also include additional options: '_catch_errors', '_run_as'.
@@ -18,9 +20,8 @@ Puppet::Functions.create_function(:run_plan, Puppet::Functions::InternalFunction
 
   def run_plan(scope, plan_name, named_args = {})
     unless Puppet[:tasks]
-      raise Puppet::ParseErrorWithIssue.from_issue_and_stack(
-        Puppet::Pops::Issues::TASK_OPERATION_NOT_SUPPORTED_WHEN_COMPILING, operation: 'run_plan'
-      )
+      raise Puppet::ParseErrorWithIssue
+        .from_issue_and_stack(Bolt::PAL::Issues::PLAN_OPERATION_NOT_SUPPORTED_WHEN_COMPILING, action: 'run_plan')
     end
 
     executor = Puppet.lookup(:bolt_executor) { nil }

data/bolt-modules/boltlib/lib/puppet/functions/run_script.rb

@@ -2,6 +2,8 @@
 
 # Uploads the given script to the given set of targets and returns the result of having each target execute the script.
 # This function does nothing if the list of targets is empty.
+#
+# **NOTE:** Not available in apply block
 Puppet::Functions.create_function(:run_script, Puppet::Functions::InternalFunction) do
   # Run a script.
   # @param script Path to a script to run on target. May be an absolute path or a modulename/filename selector for a
@@ -46,15 +48,13 @@ Puppet::Functions.create_function(:run_script, Puppet::Functions::InternalFuncti
   end
 
   def run_script_with_description(scope, script, targets, description = nil, options = nil)
-    options ||= {}
-    options = options.merge('_description' => description) if description
-
     unless Puppet[:tasks]
-      raise Puppet::ParseErrorWithIssue.from_issue_and_stack(
-        Puppet::Pops::Issues::TASK_OPERATION_NOT_SUPPORTED_WHEN_COMPILING, operation: 'run_script'
-      )
+      raise Puppet::ParseErrorWithIssue
+        .from_issue_and_stack(Bolt::PAL::Issues::PLAN_OPERATION_NOT_SUPPORTED_WHEN_COMPILING, action: 'run_script')
     end
 
+    options ||= {}
+    options = options.merge('_description' => description) if description
     executor = Puppet.lookup(:bolt_executor) { nil }
     inventory = Puppet.lookup(:bolt_inventory) { nil }
     unless executor && inventory && Puppet.features.bolt?

data/bolt-modules/boltlib/lib/puppet/functions/run_task.rb

@@ -6,6 +6,8 @@ require 'bolt/task'
 
 # Runs a given instance of a `Task` on the given set of targets and returns the result from each.
 # This function does nothing if the list of targets is empty.
+#
+# **NOTE:** Not available in apply block
 Puppet::Functions.create_function(:run_task) do
   # Run a task.
   # @param task_name The task to run.
@@ -67,13 +69,12 @@ Puppet::Functions.create_function(:run_task) do
   end
 
   def run_task_raw(task_name, targets, description = nil, task_args = nil, &block)
-    task_args ||= {}
     unless Puppet[:tasks]
-      raise Puppet::ParseErrorWithIssue.from_issue_and_stack(
-        Puppet::Pops::Issues::TASK_OPERATION_NOT_SUPPORTED_WHEN_COMPILING, operation: 'run_task'
-      )
+      raise Puppet::ParseErrorWithIssue
+        .from_issue_and_stack(Bolt::PAL::Issues::PLAN_OPERATION_NOT_SUPPORTED_WHEN_COMPILING, action: 'run_task')
     end
 
+    task_args ||= {}
     executor = Puppet.lookup(:bolt_executor) { nil }
     inventory = Puppet.lookup(:bolt_inventory) { nil }
     unless executor && inventory && Puppet.features.bolt?

data/bolt-modules/boltlib/lib/puppet/functions/set_feature.rb

@@ -9,11 +9,13 @@ require 'bolt/error'
 # - powershell
 # - shell
 # - puppet-agent
+#
+# **NOTE:** Not available in apply block
 Puppet::Functions.create_function(:set_feature) do
   # @param target The Target object to add features to. See {get_targets}.
   # @param feature The string identifying the feature.
   # @param value Whether the feature is supported.
-  # @return [Undef]
+  # @return The target with the updated feature
   # @example Add the puppet-agent feature to a target
   #   set_feature($target, 'puppet-agent', true)
   dispatch :set_feature do
@@ -24,9 +26,8 @@ Puppet::Functions.create_function(:set_feature) do
 
   def set_feature(target, feature, value = true)
     unless Puppet[:tasks]
-      raise Puppet::ParseErrorWithIssue.from_issue_and_stack(
-        Puppet::Pops::Issues::TASK_OPERATION_NOT_SUPPORTED_WHEN_COMPILING, operation: 'set_feature'
-      )
+      raise Puppet::ParseErrorWithIssue
+        .from_issue_and_stack(Bolt::PAL::Issues::PLAN_OPERATION_NOT_SUPPORTED_WHEN_COMPILING, action: 'set_feature')
     end
 
     inventory = Puppet.lookup(:bolt_inventory) { nil }

data/bolt-modules/boltlib/lib/puppet/functions/set_var.rb

@@ -3,6 +3,8 @@
 require 'bolt/error'
 
 # Sets a variable { key => value } for a target.
+#
+# **NOTE:** Not available in apply block
 Puppet::Functions.create_function(:set_var) do
   # @param target The Target object to set the variable for. See {get_targets}.
   # @param key The key for the variable.
@@ -18,9 +20,8 @@ Puppet::Functions.create_function(:set_var) do
 
   def set_var(target, key, value)
     unless Puppet[:tasks]
-      raise Puppet::ParseErrorWithIssue.from_issue_and_stack(
-        Puppet::Pops::Issues::TASK_OPERATION_NOT_SUPPORTED_WHEN_COMPILING, operation: 'set_var'
-      )
+      raise Puppet::ParseErrorWithIssue
+        .from_issue_and_stack(Bolt::PAL::Issues::PLAN_OPERATION_NOT_SUPPORTED_WHEN_COMPILING, action: 'set_var')
     end
 
     inventory = Puppet.lookup(:bolt_inventory) { nil }

data/bolt-modules/boltlib/lib/puppet/functions/upload_file.rb

@@ -4,6 +4,8 @@ require 'bolt/error'
 
 # Uploads the given file or directory to the given set of targets and returns the result from each upload.
 # This function does nothing if the list of targets is empty.
+#
+# **NOTE:** Not available in apply block
 Puppet::Functions.create_function(:upload_file, Puppet::Functions::InternalFunction) do
   # Upload a file.
   # @param source A source path, either an absolute path or a modulename/filename selector for a file in
@@ -50,15 +52,13 @@ Puppet::Functions.create_function(:upload_file, Puppet::Functions::InternalFunct
   end
 
   def upload_file_with_description(scope, source, destination, targets, description = nil, options = nil)
-    options ||= {}
-    options = options.merge('_description' => description) if description
-
     unless Puppet[:tasks]
-      raise Puppet::ParseErrorWithIssue.from_issue_and_stack(
-        Puppet::Pops::Issues::TASK_OPERATION_NOT_SUPPORTED_WHEN_COMPILING, operation: 'upload_file'
-      )
+      raise Puppet::ParseErrorWithIssue
+        .from_issue_and_stack(Bolt::PAL::Issues::PLAN_OPERATION_NOT_SUPPORTED_WHEN_COMPILING, action: 'upload_file')
     end
 
+    options ||= {}
+    options = options.merge('_description' => description) if description
     executor = Puppet.lookup(:bolt_executor) { nil }
     inventory = Puppet.lookup(:bolt_inventory) { nil }
     unless executor && inventory && Puppet.features.bolt?

data/bolt-modules/boltlib/lib/puppet/functions/wait_until_available.rb

@@ -3,6 +3,8 @@
 require 'bolt/util'
 
 # Wait until all targets accept connections.
+#
+# **NOTE:** Not available in apply block
 Puppet::Functions.create_function(:wait_until_available) do
   # Wait until targets are available.
   # @param targets A pattern identifying zero or more targets. See {get_targets} for accepted patterns.
@@ -17,14 +19,13 @@ Puppet::Functions.create_function(:wait_until_available) do
   end
 
   def wait_until_available(targets, options = nil)
-    options ||= {}
-
     unless Puppet[:tasks]
-      raise Puppet::ParseErrorWithIssue.from_issue_and_stack(
-        Puppet::Pops::Issues::TASK_OPERATION_NOT_SUPPORTED_WHEN_COMPILING, operation: 'wait_until_available'
-      )
+      raise Puppet::ParseErrorWithIssue
+        .from_issue_and_stack(Bolt::PAL::Issues::PLAN_OPERATION_NOT_SUPPORTED_WHEN_COMPILING,
+                              action: 'wait_until_available')
     end
 
+    options ||= {}
     executor = Puppet.lookup(:bolt_executor) { nil }
     inventory = Puppet.lookup(:bolt_inventory) { nil }
     unless executor && inventory && Puppet.features.bolt?

data/bolt-modules/boltlib/lib/puppet/functions/without_default_logging.rb

@@ -5,6 +5,8 @@
 # Messages for actions within this block will be logged at `info` level instead
 # of `notice`, so they will not be seen normally but # will still be present
 # when `verbose` logging is requested.
+#
+# **NOTE:** Not available in apply block
 Puppet::Functions.create_function(:without_default_logging) do
   # @param block The block where action logging is suppressed.
   # @return [Undef]
@@ -20,6 +22,12 @@ Puppet::Functions.create_function(:without_default_logging) do
   end
 
   def without_default_logging
+    unless Puppet[:tasks]
+      raise Puppet::ParseErrorWithIssue
+        .from_issue_and_stack(Bolt::PAL::Issues::PLAN_OPERATION_NOT_SUPPORTED_WHEN_COMPILING,
+                              action: 'without_default_logging')
+    end
+
     executor = Puppet.lookup(:bolt_executor) { nil }
     executor.report_function_call('without_default_logging')
 

data/lib/bolt/config.rb

@@ -36,29 +36,7 @@ module Bolt
 
     TRANSPORT_OPTIONS = %i[password run-as sudo-password extensions
                            private-key tty tmpdir user connect-timeout
-                           cacert token-file service-url].freeze
-
-    # TODO: move these to the transport themselves
-    TRANSPORT_SPECIFIC_DEFAULTS = {
-      ssh: {
-        'connect-timeout' => 10,
-        'host-key-check' => true,
-        'tty' => false
-      },
-      winrm: {
-        'connect-timeout' => 10,
-        'ssl' => true,
-        'ssl-verify' => true
-      },
-      pcp: {
-        'task-environment' => 'production'
-      },
-      local: {},
-      docker: {},
-      remote: {
-        'run-on' => 'localhost'
-      }
-    }.freeze
+                           cacert token-file service-url interpreters file-protocol smb-port].freeze
 
     def self.default
       new(Bolt::Boltdir.new('.'), {})
@@ -91,8 +69,9 @@ module Bolt
       @log = { 'console' => {} }
 
       @transports = {}
-      TRANSPORTS.each_key do |transport|
-        @transports[transport] = TRANSPORT_SPECIFIC_DEFAULTS[transport].dup
+
+      TRANSPORTS.each do |key, transport|
+        @transports[key] = transport.default_options
       end
 
       update_from_file(config_data)
@@ -114,6 +93,12 @@ module Bolt
       Bolt::Util.deep_clone(self)
     end
 
+    def normalize_interpreters(interpreters)
+      Bolt::Util.walk_keys(interpreters) do |key|
+        key.chars[0] == '.' ? key : '.' + key
+      end
+    end
+
     def normalize_log(target)
       return target if target == 'console'
       target = target[5..-1] if target.start_with?('file:')
@@ -168,7 +153,10 @@ module Bolt
       TRANSPORTS.each do |key, impl|
         if data[key.to_s]
           selected = impl.filter_options(data[key.to_s])
-          @transports[key].merge!(selected)
+          @transports[key] = Bolt::Util.deep_merge(@transports[key], selected)
+        end
+        if @transports[key]['interpreters']
+          @transports[key]['interpreters'] = normalize_interpreters(@transports[key]['interpreters'])
         end
       end
     end

data/lib/bolt/pal.rb

@@ -80,6 +80,7 @@ module Bolt
       end
 
       require 'bolt/pal/logging'
+      require 'bolt/pal/issues'
 
       # Now that puppet is loaded we can include puppet mixins in data types
       Bolt::ResultSet.include_iterable

data/lib/bolt/pal/issues.rb

@@ -0,0 +1,13 @@
+# 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
+    end
+  end
+end

data/lib/bolt/transport/base.rb

@@ -48,6 +48,10 @@ module Bolt
               "self.options() or self.filter_options(unfiltered) must be implemented by the transport class"
       end
 
+      def self.default_options
+        {}
+      end
+
       def self.filter_options(unfiltered)
         unfiltered.select { |k| options.include?(k) }
       end
@@ -87,6 +91,10 @@ module Bolt
         impl
       end
 
+      def select_interpreter(executable, interpreters)
+        interpreters[Pathname(executable).extname] if interpreters
+      end
+
       def reject_transport_options(target, options)
         if target.options['run-as']
           options.reject { |k, _v| k == '_run_as' }

data/lib/bolt/transport/docker.rb

@@ -8,7 +8,7 @@ module Bolt
   module Transport
     class Docker < Base
       def self.options
-        %w[service-url service-options tmpdir]
+        %w[service-url service-options tmpdir interpreters]
       end
 
       def provided_features
@@ -48,7 +48,7 @@ module Bolt
 
             _, stderr, exitcode = conn.execute('mv', tmpfile, destination, {})
             if exitcode != 0
-              message = "Could not move temporary file '#{tmpfile}' to #{destination}: #{stderr.join}"
+              message = "Could not move temporary file '#{tmpfile}' to #{destination}: #{stderr}"
               raise Bolt::Node::FileError.new(message, 'MV_ERROR')
             end
           end
@@ -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.join, stderr.join, exitcode)
+          Bolt::Result.for_command(target, stdout, stderr, exitcode)
         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.join, stderr.join, exitcode)
+            Bolt::Result.for_command(target, stdout, stderr, exitcode)
           end
         end
       end
@@ -87,7 +87,7 @@ module Bolt
         arguments = unwrap_sensitive_args(arguments)
         with_connection(target) do |conn|
           execute_options = {}
-
+          execute_options[:interpreter] = select_interpreter(executable, target.options['interpreters'])
           conn.with_remote_tempdir do |dir|
             if extra_files.empty?
               task_dir = dir
@@ -112,7 +112,7 @@ module Bolt
             end
 
             stdout, stderr, exitcode = conn.execute(remote_task_path, execute_options)
-            Bolt::Result.for_task(target, stdout.join, stderr.join, exitcode)
+            Bolt::Result.for_task(target, stdout, stderr, exitcode)
           end
         end
       end

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

@@ -27,6 +27,7 @@ module Bolt
         end
 
         def execute(*command, options)
+          command.unshift(options[:interpreter]) if options[:interpreter]
           if options[:environment]
             envs = options[:environment].map { |env, val| "#{env}=#{val}" }
             command = ['env'] + envs + command
@@ -39,6 +40,8 @@ module Bolt
           else
             @logger.info { "Command failed with exit code #{result[2]}" }
           end
+          result[0] = result[0].join.force_encoding('UTF-8')
+          result[1] = result[1].join.force_encoding('UTF-8')
           result
         rescue StandardError
           @logger.debug { "Command aborted" }
@@ -62,7 +65,7 @@ module Bolt
         def mkdirs(dirs)
           _, stderr, exitcode = execute('mkdir', '-p', *dirs, {})
           if exitcode != 0
-            message = "Could not create directories: #{stderr.join}"
+            message = "Could not create directories: #{stderr}"
             raise Bolt::Node::FileError.new(message, 'MKDIR_ERROR')
           end
         end
@@ -73,7 +76,7 @@ module Bolt
 
           stdout, stderr, exitcode = execute('mkdir', '-m', '700', tmppath, {})
           if exitcode != 0
-            raise Bolt::Node::FileError.new("Could not make tempdir: #{stderr.join}", 'TEMPDIR_ERROR')
+            raise Bolt::Node::FileError.new("Could not make tempdir: #{stderr}", 'TEMPDIR_ERROR')
           end
           tmppath || stdout.first
         end
@@ -85,7 +88,7 @@ module Bolt
           if dir
             _, stderr, exitcode = execute('rm', '-rf', dir, {})
             if exitcode != 0
-              @logger.warn("Failed to clean up tempdir '#{dir}': #{stderr.join}")
+              @logger.warn("Failed to clean up tempdir '#{dir}': #{stderr}")
             end
           end
         end
@@ -101,7 +104,7 @@ module Bolt
         def make_executable(path)
           _, stderr, exitcode = execute('chmod', 'u+x', path, {})
           if exitcode != 0
-            message = "Could not make file '#{path}' executable: #{stderr.join}"
+            message = "Could not make file '#{path}' executable: #{stderr}"
             raise Bolt::Node::FileError.new(message, 'CHMOD_ERROR')
           end
         end

data/lib/bolt/transport/local.rb

@@ -11,7 +11,13 @@ module Bolt
   module Transport
     class Local < Base
       def self.options
-        %w[tmpdir]
+        %w[tmpdir interpreters]
+      end
+
+      def self.default_options
+        {
+          'interpreters' => { '.rb' => RbConfig.ruby }
+        }
       end
 
       def provided_features
@@ -129,8 +135,10 @@ module Bolt
           copy_file(executable, script)
           File.chmod(0o750, script)
 
+          interpreter = select_interpreter(script, target.options['interpreters'])
+          interpreter_debug = interpreter ? " using '#{interpreter}' interpreter" : nil
           # log the arguments with sensitive data redacted, do NOT log unwrapped_arguments
-          logger.debug("Running '#{script}' with #{arguments}")
+          logger.debug("Running '#{script}' with #{arguments}#{interpreter_debug}")
           unwrapped_arguments = unwrap_sensitive_args(arguments)
 
           stdin = STDIN_METHODS.include?(input_method) ? JSON.dump(unwrapped_arguments) : nil
@@ -146,25 +154,32 @@ module Bolt
               environment_params = ""
             end
 
-            output =
-              if Powershell.powershell_file?(script) && stdin.nil?
-                command = Powershell.run_ps_task(arguments, script, input_method)
-                command = environment_params + Powershell.shell_init + command
+            if Powershell.powershell_file?(script) && stdin.nil?
+              command = Powershell.run_ps_task(arguments, script, input_method)
+              command = environment_params + Powershell.shell_init + command
+              interpreter ||= 'powershell.exe'
+              output =
                 if input_method == 'powershell'
-                  @conn.execute(command, dir: dir, env: "powershell.exe")
+                  @conn.execute(command, dir: dir, interpreter: interpreter)
                 else
-                  @conn.execute(command, dir: dir, stdin: stdin, env: "powershell.exe")
+                  @conn.execute(command, dir: dir, stdin: stdin, interpreter: interpreter)
                 end
+            end
+            unless output
+              if interpreter
+                env = ENVIRONMENT_METHODS.include?(input_method) ? envify_params(unwrapped_arguments) : nil
+                output = @conn.execute(script, stdin: stdin, env: env, dir: dir, interpreter: interpreter)
               else
                 path, args = *Powershell.process_from_extension(script)
                 command = args.unshift(path).join(' ')
                 command = environment_params + Powershell.shell_init + command
-                @conn.execute(command, dir: dir, stdin: stdin, env: "powershell.exe")
+                output = @conn.execute(command, dir: dir, stdin: stdin, interpreter: 'powershell.exe')
               end
+            end
           else
             # POSIX
             env = ENVIRONMENT_METHODS.include?(input_method) ? envify_params(unwrapped_arguments) : nil
-            output = @conn.execute(script, stdin: stdin, env: env, dir: dir)
+            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)
         end

data/lib/bolt/transport/local/shell.rb

@@ -8,6 +8,7 @@ module Bolt
     class Local
       class Shell
         def execute(*command, options)
+          command.unshift(options[:interpreter]) if options[:interpreter]
           command = [options[:env]] + command if options[:env]
 
           if options[:stdin]

data/lib/bolt/transport/orch.rb

@@ -29,6 +29,10 @@ module Bolt
         %w[service-url cacert token-file task-environment]
       end
 
+      def self.default_options
+        { 'task-environment' => 'production' }
+      end
+
       def provided_features
         ['puppet-agent']
       end

data/lib/bolt/transport/remote.rb

@@ -11,6 +11,10 @@ module Bolt
         unfiltered
       end
 
+      def self.default_options
+        { 'run-on' => 'localhost' }
+      end
+
       def self.validate(options)
         # This will fail when validating global config
         # unless options['device-type']

data/lib/bolt/transport/ssh.rb

@@ -10,7 +10,15 @@ module Bolt
     class SSH < Base
       def self.options
         %w[port user password sudo-password private-key host-key-check
-           connect-timeout tmpdir run-as tty run-as-command proxyjump]
+           connect-timeout tmpdir run-as tty run-as-command proxyjump interpreters]
+      end
+
+      def self.default_options
+        {
+          'connect-timeout' => 10,
+          'host-key-check' => true,
+          'tty' => false
+        }
       end
 
       def provided_features
@@ -169,6 +177,7 @@ module Bolt
               dir.chown(conn.run_as)
 
               execute_options[:sudoable] = true if conn.run_as
+              execute_options[:interpreter] = select_interpreter(executable, target.options['interpreters'])
               output = conn.execute(command, execute_options)
             end
             Bolt::Result.for_task(target, output.stdout.string,

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

@@ -227,6 +227,10 @@ module Bolt
           escalate = sudoable && run_as && @user != run_as
           use_sudo = escalate && @target.options['run-as-command'].nil?
 
+          if options[:interpreter]
+            command.is_a?(Array) ? command.unshift(options[:interpreter]) : [options[:interpreter], command]
+          end
+
           command_str = command.is_a?(String) ? command : Shellwords.shelljoin(command)
           if escalate
             if use_sudo

data/lib/bolt/transport/winrm.rb

@@ -8,7 +8,19 @@ module Bolt
   module Transport
     class WinRM < Base
       def self.options
-        %w[port user password connect-timeout ssl ssl-verify tmpdir cacert extensions]
+        %w[
+          port user password connect-timeout ssl ssl-verify tmpdir cacert
+          extensions interpreters file-protocol smb-port
+        ]
+      end
+
+      def self.default_options
+        {
+          'connect-timeout' => 10,
+          'ssl' => true,
+          'ssl-verify' => true,
+          'file-protocol' => 'winrm'
+        }
       end
 
       def provided_features
@@ -26,6 +38,10 @@ module Bolt
           raise Bolt::ValidationError, 'ssl option must be a Boolean true or false'
         end
 
+        if ssl_flag && (options['file-protocol'] == 'smb')
+          raise Bolt::ValidationError, 'SMB file transfers are not allowed with SSL enabled'
+        end
+
         ssl_verify_flag = options['ssl-verify']
         unless !!ssl_verify_flag == ssl_verify_flag
           raise Bolt::ValidationError, 'ssl-verify option must be a Boolean true or false'
@@ -135,7 +151,13 @@ module Bolt
               if Powershell.powershell_file?(remote_task_path) && stdin.nil?
                 conn.execute(Powershell.run_ps_task(arguments, remote_task_path, input_method))
               else
-                path, args = *Powershell.process_from_extension(remote_task_path)
+                interpreter = select_interpreter(remote_task_path, target.options['interpreters'])
+                if interpreter
+                  path = interpreter
+                  args = [remote_task_path]
+                else
+                  path, args = *Powershell.process_from_extension(remote_task_path)
+                end
                 conn.execute_process(path, args, stdin)
               end
 

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

@@ -2,6 +2,7 @@
 
 require 'bolt/node/errors'
 require 'bolt/node/output'
+require 'ruby_smb'
 
 module Bolt
   module Transport
@@ -17,9 +18,9 @@ module Bolt
           default_port = target.options['ssl'] ? HTTPS_PORT : HTTP_PORT
           @port = @target.port || default_port
           @user = @target.user
-
-          # Accept a single entry or a list, ensure each is prefixed with '.'
+          # Build set of extensions from extensions config as well as interpreters
           extensions = [target.options['extensions'] || []].flatten.map { |ext| ext[0] != '.' ? '.' + ext : ext }
+          extensions += target.options['interpreters'].keys if target.options['interpreters']
           @extensions = DEFAULT_EXTENSIONS.to_set.merge(extensions)
 
           @logger = Logging.logger[@target.host]
@@ -93,6 +94,7 @@ module Bolt
 
         def disconnect
           @session&.close
+          @client&.disconnect!
           @logger.debug { "Closed session" }
         end
 
@@ -141,12 +143,47 @@ module Bolt
         end
 
         def write_remote_file(source, destination)
+          if target.options['file-protocol'] == 'smb'
+            write_remote_file_smb(source, destination)
+          else
+            write_remote_file_winrm(source, destination)
+          end
+        end
+
+        def write_remote_file_winrm(source, destination)
           fs = ::WinRM::FS::FileManager.new(@connection)
           fs.upload(source, destination)
         rescue StandardError => e
           raise Bolt::Node::FileError.new(e.message, 'WRITE_ERROR')
         end
 
+        def write_remote_file_smb(source, destination)
+          win_dest = destination.tr('/', '\\')
+          if (md = win_dest.match(/^([a-z]):\\(.*)/i))
+            # if drive, use admin share for that drive, so path is '\\host\C$'
+            path = "\\\\#{@target.host}\\#{md[1]}$"
+            dest = md[2]
+          elsif (md = win_dest.match(/^(\\\\[^\\]+\\[^\\]+)\\(.*)/))
+            # if unc, path is '\\host\share'
+            path = md[1]
+            dest = md[2]
+          else
+            raise ArgumentError, "Unknown destination '#{destination}'"
+          end
+
+          client = smb_client_login
+          tree = client.tree_connect(path)
+          begin
+            write_remote_file_smb_recursive(tree, source, dest)
+          ensure
+            tree.disconnect!
+          end
+        rescue ::RubySMB::Error::UnexpectedStatusCode => e
+          raise Bolt::Node::FileError.new("SMB Error: #{e.message}", 'WRITE_ERROR')
+        rescue StandardError => e
+          raise Bolt::Node::FileError.new(e.message, 'WRITE_ERROR')
+        end
+
         def make_tempdir
           find_parent = target.options['tmpdir'] ? "\"#{target.options['tmpdir']}\"" : '[System.IO.Path]::GetTempPath()'
           result = execute(Powershell.make_tempdir(find_parent))
@@ -184,6 +221,79 @@ module Bolt
           write_remote_file(content, remote_path)
           remote_path
         end
+
+        private
+
+        def smb_client_login
+          return @client if @client
+
+          dispatcher = RubySMB::Dispatcher::Socket.new(smb_socket_connect)
+          @client = RubySMB::Client.new(dispatcher, smb1: false, smb2: true, username: @user, password: target.password)
+          status = @client.login
+          case status
+          when WindowsError::NTStatus::STATUS_SUCCESS
+            @logger.debug { "Connected to #{@client.dns_host_name}" }
+          when WindowsError::NTStatus::STATUS_LOGON_FAILURE
+            raise Bolt::Node::ConnectError.new(
+              "SMB authentication failed for #{target.host}",
+              'AUTH_ERROR'
+            )
+          else
+            raise Bolt::Node::ConnectError.new(
+              "Failed to connect to #{target.host} using SMB: #{status.description}",
+              'CONNECT_ERROR'
+            )
+          end
+
+          @client
+        end
+
+        SMB_PORT = 445
+
+        def smb_socket_connect
+          # It's lame that TCPSocket doesn't take a connect timeout
+          # Using Timeout.timeout is bad, but is done elsewhere...
+          Timeout.timeout(target.options['connect-timeout']) do
+            TCPSocket.new(target.host, target.options['smb-port'] || SMB_PORT)
+          end
+        rescue Errno::ECONNREFUSED => e
+          # handle this to prevent obscuring error message as SMB problem
+          raise Bolt::Node::ConnectError.new(
+            "Failed to connect to #{target.host} using SMB: #{e.message}",
+            'CONNECT_ERROR'
+          )
+        rescue Timeout::Error
+          raise Bolt::Node::ConnectError.new(
+            "Timeout after #{target.options['connect-timeout']} seconds connecting to #{target.host}",
+            'CONNECT_ERROR'
+          )
+        end
+
+        def write_remote_file_smb_recursive(tree, source, dest)
+          if Dir.exist?(source)
+            tree.open_directory(directory: dest, write: true, disposition: ::RubySMB::Dispositions::FILE_OPEN_IF)
+
+            (Dir.entries(source) - ['.', '..']).each do |child|
+              child_dest = dest + '\\' + child
+              write_remote_file_smb_recursive(tree, File.join(source, child), child_dest)
+            end
+            return
+          end
+
+          file = tree.open_file(filename: dest, write: true, disposition: ::RubySMB::Dispositions::FILE_OVERWRITE_IF)
+          begin
+            # `file` doesn't derive from IO, so can't use IO.copy_stream
+            File.open(source, 'rb') do |f|
+              pos = 0
+              while (buf = f.read(8 * 1024 * 1024))
+                file.write(data: buf, offset: pos)
+                pos += buf.length
+              end
+            end
+          ensure
+            file.close
+          end
+        end
       end
     end
   end

data/lib/bolt/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Bolt
-  VERSION = '1.12.0'
+  VERSION = '1.13.0'
 end

data/lib/bolt_server/schemas/ssh-run_task.json

@@ -56,6 +56,10 @@
         "sudo-password": {
           "type": "string",
           "description": "Password to use when changing users via run-as"
+        },
+        "interpreters": {
+          "type": "object",
+          "description": "Map of file extensions to remote executable"
         }
       },
       "oneOf": [

data/lib/bolt_server/schemas/winrm-run_task.json

@@ -47,8 +47,22 @@
         "extensions": {
           "type": "array",
           "description": "List of file extensions that are accepted for scripts or tasks"
+        },
+        "interpreters": {
+          "type": "object",
+          "description": "Map of file extensions to remote executable"
+        },
+        "file-protocol": {
+          "type": "string",
+          "enum": ["winrm", "smb"],
+          "description": "Protocol for file transfer, WinRM or SMB"
+        },
+        "smb-port": {
+          "type": "integer",
+          "description": "Port for SMB protocol"
         }
       },
+
       "required": ["hostname", "user", "password"],
       "additionalProperties": false
     },

data/lib/bolt_spec/plans.rb

@@ -32,6 +32,11 @@ require 'bolt/pal'
 #
 # Configuration
 #
+#  To configure Puppet and Bolt at the beginning of tests, add the following
+#  line to your spec_helper.rb:
+#
+#  BoltSpec::Plans.init
+#
 #  By default the plan helpers use the modulepath set up for rspec-puppet and
 #  an otherwise empty bolt config and inventory. To create your own values for
 #  these override the modulepath, config, or inventory methods.

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bolt
 version: !ruby/object:Gem::Version
-  version: 1.12.0
+  version: 1.13.0
 platform: ruby
 authors:
 - Puppet
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-02-21 00:00:00.000000000 Z
+date: 2019-02-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: addressable
@@ -184,6 +184,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '2.6'
+- !ruby/object:Gem::Dependency
+  name: ruby_smb
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
 - !ruby/object:Gem::Dependency
   name: terminal-table
   requirement: !ruby/object:Gem::Requirement
@@ -345,6 +359,7 @@ files:
 - lib/bolt/outputter/human.rb
 - lib/bolt/outputter/json.rb
 - lib/bolt/pal.rb
+- lib/bolt/pal/issues.rb
 - lib/bolt/pal/logging.rb
 - lib/bolt/plan_result.rb
 - lib/bolt/puppetdb.rb