bolt 2.5.0 → 2.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 35079d3ff8276e6ebe7e1164e7336ef77b17d64c0f3c3df4a257b71fb3c6c599
-  data.tar.gz: ccc148bcec686d950741595e99dbcacd88825685d3dfb7641850d9ff54df02a6
+  metadata.gz: ca1602020625348ee5ba03e246feeb9263ca10fdcda10e13bba36eb674dcdfba
+  data.tar.gz: bdde3554a2406f427f57d02f2e0063e592b7ceba235656c406e9f1ece3899c75
 SHA512:
-  metadata.gz: 9f101955f9562b6e8365a277079fdaff192350c51e5505a36f5fad1be0736deb4f6ca9c458758177c8e5907cf9bbfb709e87bf3a6877075269250b98fd076b03
-  data.tar.gz: dfa5f451c469a9f787f4ed4be798af368463ee9d9f463c683a8c458ba6a552e5e161ddb13c99bc6e819cb95987ce73fca9b5194215a3863432e3e3cac82c709b
+  metadata.gz: 13bcc53364488a1f37ebc19821c6429bcbcc055a543f9b581352b03c403793579290af88be0b92416506c3ddd9f23e775c7d9b9a6d2369aed3c38b0ef162da8f
+  data.tar.gz: ea09c6b92cc08d1cd893c136775070df2f6d79097663c58a96212bfdcf23984fe39fd5690d706f4802a61cd384bfe8139e446914506938605ba6d4771f272d63

data/Puppetfile

@@ -30,10 +30,11 @@ mod 'puppetlabs-ruby_task_helper', '0.5.1'
 mod 'puppetlabs-ruby_plugin_helper', '0.1.0'
 
 # Plugin modules
+mod 'puppetlabs-aws_inventory', '0.5.0'
 mod 'puppetlabs-azure_inventory', '0.3.0'
+mod 'puppetlabs-gcloud_inventory', '0.1.0'
 mod 'puppetlabs-terraform', '0.5.0'
 mod 'puppetlabs-vault', '0.3.0'
-mod 'puppetlabs-aws_inventory', '0.5.0'
 mod 'puppetlabs-yaml', '0.2.0'
 
 # If we don't list these modules explicitly, r10k will purge them

data/lib/bolt/executor.rb

@@ -15,7 +15,6 @@ require 'bolt/transport/ssh'
 require 'bolt/transport/winrm'
 require 'bolt/transport/orch'
 require 'bolt/transport/local'
-require 'bolt/transport/local_windows'
 require 'bolt/transport/docker'
 require 'bolt/transport/remote'
 
@@ -24,7 +23,7 @@ module Bolt
     ssh: Bolt::Transport::SSH,
     winrm: Bolt::Transport::WinRM,
     pcp: Bolt::Transport::Orch,
-    local: Bolt::Util.windows? ? Bolt::Transport::LocalWindows : Bolt::Transport::Local,
+    local: Bolt::Transport::Local,
     docker: Bolt::Transport::Docker,
     remote: Bolt::Transport::Remote
   }.freeze

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

@@ -24,14 +24,14 @@ module Bolt
 
         def task_step(scope, step)
           task = step['task']
-          target = step['target']
+          targets = step['targets'] || step['target']
           description = step['description']
           params = step['parameters'] || {}
 
           args = if description
-                   [task, target, description, params]
+                   [task, targets, description, params]
                  else
-                   [task, target, params]
+                   [task, targets, params]
                  end
 
           scope.call_function('run_task', args)
@@ -48,15 +48,15 @@ module Bolt
 
         def script_step(scope, step)
           script = step['script']
-          target = step['target']
+          targets = step['targets'] || step['target']
           description = step['description']
           arguments = step['arguments'] || []
 
           options = { 'arguments' => arguments }
           args = if description
-                   [script, target, description, options]
+                   [script, targets, description, options]
                  else
-                   [script, target, options]
+                   [script, targets, options]
                  end
 
           scope.call_function('run_script', args)
@@ -64,10 +64,10 @@ module Bolt
 
         def command_step(scope, step)
           command = step['command']
-          target = step['target']
+          targets = step['targets'] || step['target']
           description = step['description']
 
-          args = [command, target]
+          args = [command, targets]
           args << description if description
           scope.call_function('run_command', args)
         end
@@ -75,10 +75,10 @@ module Bolt
         def upload_step(scope, step)
           source = step['source']
           destination = step['destination']
-          target = step['target']
+          targets = step['targets'] || step['target']
           description = step['description']
 
-          args = [source, destination, target]
+          args = [source, destination, targets]
           args << description if description
           scope.call_function('upload_file', args)
         end
@@ -88,11 +88,13 @@ module Bolt
         end
 
         def resources_step(scope, step)
+          targets = step['targets'] || step['target']
+
           # TODO: Only call apply_prep when needed
-          scope.call_function('apply_prep', step['target'])
+          scope.call_function('apply_prep', targets)
           manifest = generate_manifest(step['resources'])
 
-          apply_manifest(scope, step['target'], manifest)
+          apply_manifest(scope, targets, manifest)
         end
 
         def generate_manifest(resources)
@@ -127,16 +129,22 @@ module Bolt
           MANIFEST
         end
 
-        def apply_manifest(scope, target, manifest)
+        def apply_manifest(scope, targets, manifest)
           ast = @evaluator.parse_string(manifest)
           apply_block = ast.body.body
           applicator = Puppet.lookup(:apply_executor)
-          applicator.apply([target], apply_block, scope)
+          applicator.apply([targets], apply_block, scope)
         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)
+          if plan.steps.any? { |step| step.body.key?('target') }
+            msg = "The 'target' parameter for YAML plan steps is deprecated and will be removed "\
+                  "in a future version of Bolt. Use the 'targets' parameter instead."
+            @logger.warn(msg)
+          end
+
           plan_result = closure_scope.with_local_scope(args_hash) do |scope|
             plan.steps.each do |step|
               step_result = dispatch_step(scope, step)

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

@@ -6,13 +6,12 @@ module Bolt
   class PAL
     class YamlPlan
       class Step
-        attr_reader :name, :type, :body, :target
+        attr_reader :name, :type, :body, :targets
 
         def self.allowed_keys
-          Set['name', 'description', 'target']
+          Set['name', 'description', 'target', 'targets']
         end
 
-        COMMON_STEP_KEYS = %w[name description target].freeze
         STEP_KEYS = %w[command script task plan source destination eval resources].freeze
 
         def self.create(step_body, step_number)
@@ -38,7 +37,7 @@ module Bolt
         def initialize(step_body)
           @name = step_body['name']
           @description = step_body['description']
-          @target = step_body['target']
+          @targets = step_body['targets'] || step_body['target']
           @body = step_body
         end
 
@@ -82,6 +81,14 @@ module Bolt
 
           # Ensure all required keys are present
           missing_keys = required_keys - body.keys
+
+          # Handle cases where steps with a required 'targets' key are using the deprecated
+          # 'target' key instead.
+          # TODO: Remove this when 'target' is removed
+          if body.include?('target')
+            missing_keys -= ['targets']
+          end
+
           if missing_keys.any?
             error_message = "The #{step_type.inspect} step requires: #{missing_keys.to_a.inspect} key(s)"
             err = step_error(error_message, body['name'], step_number)

data/lib/bolt/pal/yaml_plan/step/command.rb

@@ -10,7 +10,7 @@ module Bolt
           end
 
           def self.required_keys
-            Set['target']
+            Set['targets']
           end
 
           def initialize(step_body)
@@ -23,7 +23,7 @@ module Bolt
             code << "$#{@name} = " if @name
 
             fn = 'run_command'
-            args = [@command, @target]
+            args = [@command, @targets]
             args << @description if @description
 
             code << function_call(fn, args)

data/lib/bolt/pal/yaml_plan/step/resources.rb

@@ -10,7 +10,7 @@ module Bolt
           end
 
           def self.required_keys
-            Set['target']
+            Set['targets']
           end
 
           def initialize(step_body)
@@ -68,14 +68,14 @@ module Bolt
 
             code.print "  "
             fn = 'apply_prep'
-            args = [@target]
+            args = [@targets]
             code << function_call(fn, args)
             code.print "\n"
 
             code.print "  "
             code.print "$#{@name} = " if @name
 
-            code.puts "apply(#{Bolt::Util.to_code(@target)}) {"
+            code.puts "apply(#{Bolt::Util.to_code(@targets)}) {"
 
             declarations = @normalized_resources.map do |resource|
               type = resource['type'].is_a?(EvaluableString) ? resource['type'].value : resource['type']

data/lib/bolt/pal/yaml_plan/step/script.rb

@@ -10,7 +10,7 @@ module Bolt
           end
 
           def self.required_keys
-            Set['target']
+            Set['targets']
           end
 
           def initialize(step_body)
@@ -28,7 +28,7 @@ module Bolt
             options['arguments'] = @arguments unless @arguments.empty?
 
             fn = 'run_script'
-            args = [@script, @target]
+            args = [@script, @targets]
             args << @description if @description
             args << options unless options.empty?
 

data/lib/bolt/pal/yaml_plan/step/task.rb

@@ -10,7 +10,7 @@ module Bolt
           end
 
           def self.required_keys
-            Set['target']
+            Set['targets']
           end
 
           def initialize(step_body)
@@ -24,7 +24,7 @@ module Bolt
             code << "$#{@name} = " if @name
 
             fn = 'run_task'
-            args = [@task, @target]
+            args = [@task, @targets]
             args << @description if @description
             args << @parameters unless @parameters.empty?
 

data/lib/bolt/pal/yaml_plan/step/upload.rb

@@ -10,7 +10,7 @@ module Bolt
           end
 
           def self.required_keys
-            Set['target', 'source', 'destination']
+            Set['destination', 'source', 'targets']
           end
 
           def initialize(step_body)
@@ -24,7 +24,7 @@ module Bolt
             code << "$#{@name} = " if @name
 
             fn = 'upload_file'
-            args = [@source, @destination, @target]
+            args = [@source, @destination, @targets]
             args << @description if @description
 
             code << function_call(fn, args)

data/lib/bolt/plugin.rb

@@ -143,7 +143,8 @@ module Bolt
     end
 
     RUBY_PLUGINS = %w[task pkcs7 prompt env_var].freeze
-    BUILTIN_PLUGINS = %w[task terraform pkcs7 prompt vault aws_inventory puppetdb azure_inventory yaml env_var].freeze
+    BUILTIN_PLUGINS = %w[task terraform pkcs7 prompt vault aws_inventory puppetdb azure_inventory
+                         yaml env_var gcloud_inventory].freeze
     DEFAULT_PLUGIN_HOOKS = { 'puppet_library' => { 'plugin' => 'puppet_agent', 'stop_service' => true } }.freeze
 
     attr_reader :pal, :plugin_context

data/lib/bolt/shell.rb

@@ -86,3 +86,4 @@ module Bolt
 end
 
 require 'bolt/shell/bash'
+require 'bolt/shell/powershell'

data/lib/bolt/shell/powershell.rb

@@ -0,0 +1,263 @@
+# frozen_string_literal: true
+
+require 'bolt/shell/powershell/snippets'
+
+module Bolt
+  class Shell
+    class Powershell < Shell
+      DEFAULT_EXTENSIONS = Set.new(%w[.ps1 .rb .pp])
+      PS_ARGS = %w[-NoProfile -NonInteractive -NoLogo -ExecutionPolicy Bypass -File].freeze
+
+      def initialize(target, conn)
+        super
+
+        extensions = [target.options['extensions'] || []].flatten.map { |ext| ext[0] != '.' ? '.' + ext : ext }
+        extensions += target.options['interpreters'].keys if target.options['interpreters']
+        @extensions = DEFAULT_EXTENSIONS + extensions
+      end
+
+      def provided_features
+        ['powershell']
+      end
+
+      def default_input_method(executable)
+        powershell_file?(executable) ? 'powershell' : 'both'
+      end
+
+      def powershell_file?(path)
+        File.extname(path).downcase == '.ps1'
+      end
+
+      def validate_extensions(ext)
+        unless @extensions.include?(ext)
+          raise Bolt::Node::FileError.new("File extension #{ext} is not enabled, "\
+                                          "to run it please add to 'winrm: extensions'", 'FILETYPE_ERROR')
+        end
+      end
+
+      def process_from_extension(path)
+        case Pathname(path).extname.downcase
+        when '.rb'
+          [
+            'ruby.exe',
+            %W[-S "#{path}"]
+          ]
+        when '.ps1'
+          [
+            'powershell.exe',
+            [*PS_ARGS, path]
+          ]
+        when '.pp'
+          [
+            'puppet.bat',
+            %W[apply "#{path}"]
+          ]
+        else
+          # Run the script via cmd, letting Windows extension handling determine how
+          [
+            'cmd.exe',
+            %W[/c "#{path}"]
+          ]
+        end
+      end
+
+      def escape_arguments(arguments)
+        arguments.map do |arg|
+          if arg =~ / /
+            "\"#{arg}\""
+          else
+            arg
+          end
+        end
+      end
+
+      def set_env(arg, val)
+        "[Environment]::SetEnvironmentVariable('#{arg}', @'\n#{val}\n'@)"
+      end
+
+      def quote_string(string)
+        "'" + string.gsub("'", "''") + "'"
+      end
+
+      def write_executable(dir, file, filename = nil)
+        filename ||= File.basename(file)
+        validate_extensions(File.extname(filename))
+        destination = "#{dir}\\#{filename}"
+        conn.copy_file(file, destination)
+        destination
+      end
+
+      def execute_process(path, arguments, stdin = nil)
+        quoted_args = arguments.map { |arg| quote_string(arg) }.join(' ')
+
+        quoted_path = if path =~ /^'.*'$/ || path =~ /^".*"$/
+                        path
+                      else
+                        quote_string(path)
+                      end
+        exec_cmd =
+          if stdin.nil?
+            "& #{quoted_path} #{quoted_args}"
+          else
+            <<~STR
+            $command_stdin = @'
+            #{stdin}
+            '@
+
+            $command_stdin | & #{quoted_path} #{quoted_args}
+            STR
+          end
+        Snippets.execute_process(exec_cmd)
+      end
+
+      def mkdirs(dirs)
+        mkdir_command = "mkdir -Force #{dirs.uniq.sort.join(',')}"
+        result = execute(mkdir_command)
+        if result.exit_code != 0
+          message = "Could not create directories: #{result.stderr.string}"
+          raise Bolt::Node::FileError.new(message, 'MKDIR_ERROR')
+        end
+      end
+
+      def make_tempdir
+        find_parent = target.options['tmpdir'] ? "\"#{target.options['tmpdir']}\"" : '[System.IO.Path]::GetTempPath()'
+        result = execute(Snippets.make_tempdir(find_parent))
+        if result.exit_code != 0
+          raise Bolt::Node::FileError.new("Could not make tempdir: #{result.stderr.string}", 'TEMPDIR_ERROR')
+        end
+        result.stdout.string.chomp
+      end
+
+      def rmdir(dir)
+        execute(Snippets.rmdir(dir))
+      end
+
+      def with_tempdir
+        dir = make_tempdir
+        yield dir
+      ensure
+        rmdir(dir)
+      end
+
+      def run_ps_task(task_path, arguments, input_method)
+        # NOTE: cannot redirect STDIN to a .ps1 script inside of PowerShell
+        # must create new powershell.exe process like other interpreters
+        # fortunately, using PS with stdin input_method should never happen
+        if input_method == 'powershell'
+          Snippets.ps_task(task_path, arguments)
+        else
+          Snippets.try_catch(task_path)
+        end
+      end
+
+      def upload(source, destination, _options = {})
+        conn.copy_file(source, destination)
+        Bolt::Result.for_upload(target, source, destination)
+      end
+
+      def run_command(command, _options = {})
+        output = execute(command)
+        Bolt::Result.for_command(target,
+                                 output.stdout.string,
+                                 output.stderr.string,
+                                 output.exit_code,
+                                 'command', command)
+      end
+
+      def run_script(script, arguments, _options = {})
+        # unpack any Sensitive data
+        arguments = unwrap_sensitive_args(arguments)
+        with_tempdir do |dir|
+          script_path = write_executable(dir, script)
+          command = if powershell_file?(script_path)
+                      Snippets.run_script(arguments, script_path)
+                    else
+                      path, args = *process_from_extension(script_path)
+                      args += escape_arguments(arguments)
+                      execute_process(path, args)
+                    end
+          output = execute(command)
+          Bolt::Result.for_command(target,
+                                   output.stdout.string,
+                                   output.stderr.string,
+                                   output.exit_code,
+                                   'script', script)
+        end
+      end
+
+      def run_task(task, arguments, _options = {})
+        implementation = select_implementation(target, task)
+        executable = implementation['path']
+        input_method = implementation['input_method']
+        extra_files = implementation['files']
+        input_method ||= powershell_file?(executable) ? 'powershell' : 'both'
+
+        # unpack any Sensitive data
+        arguments = unwrap_sensitive_args(arguments)
+        with_tempdir do |dir|
+          if extra_files.empty?
+            task_dir = dir
+          else
+            # TODO: optimize upload of directories
+            arguments['_installdir'] = dir
+            task_dir = File.join(dir, task.tasks_dir)
+            mkdirs([task_dir] + extra_files.map { |file| File.join(dir, File.dirname(file['name'])) })
+            extra_files.each do |file|
+              conn.copy_file(file['path'], File.join(dir, file['name']))
+            end
+          end
+
+          task_path = write_executable(task_dir, executable)
+
+          if Bolt::Task::STDIN_METHODS.include?(input_method)
+            stdin = JSON.dump(arguments)
+          end
+
+          command = if powershell_file?(task_path) && stdin.nil?
+                      run_ps_task(task_path, arguments, input_method)
+                    else
+                      if (interpreter = select_interpreter(task_path, target.options['interpreters']))
+                        path = interpreter
+                        args = [task_path]
+                      else
+                        path, args = *process_from_extension(task_path)
+                      end
+                      execute_process(path, args, stdin)
+                    end
+
+          env_assignments = if Bolt::Task::ENVIRONMENT_METHODS.include?(input_method)
+                              envify_params(arguments).map do |(arg, val)|
+                                set_env(arg, val)
+                              end
+                            else
+                              []
+                            end
+
+          output = execute([Snippets.shell_init, *env_assignments, command].join("\n"))
+
+          Bolt::Result.for_task(target, output.stdout.string,
+                                output.stderr.string,
+                                output.exit_code,
+                                task.name)
+        end
+      end
+
+      def execute(command)
+        inp, out, err, t = conn.execute(command)
+
+        result = Bolt::Node::Output.new
+        inp.close
+        out.binmode
+        err.binmode
+        stdout = Thread.new { result.stdout << out.read }
+        stderr = Thread.new { result.stderr << err.read }
+
+        stdout.join
+        stderr.join
+        result.exit_code = t.value.respond_to?(:exitstatus) ? t.value.exitstatus : t.value
+
+        result
+      end
+    end
+  end
+end