bolt 2.5.0 → 2.6.0

data/lib/bolt/shell/powershell/snippets.rb

@@ -0,0 +1,273 @@
+# frozen_string_literal: true
+
+module Bolt
+  class Shell
+    class Powershell < Shell
+      module Snippets
+        class << self
+          def execute_process(command)
+            <<~PS
+            if ([Console]::InputEncoding -eq [System.Text.Encoding]::UTF8) {
+              [Console]::InputEncoding = New-Object System.Text.UTF8Encoding $False
+            }
+            if ([Console]::OutputEncoding -eq [System.Text.Encoding]::UTF8) {
+              [Console]::OutputEncoding = New-Object System.Text.UTF8Encoding $False
+            }
+            $OutputEncoding = [Console]::OutputEncoding
+            #{command}
+            if (-not $? -and ($LASTEXITCODE -eq $null)) { exit 1 }
+            exit $LASTEXITCODE
+            PS
+          end
+
+          def make_tempdir(parent)
+            <<~PS
+            $parent = #{parent}
+            $name = [System.IO.Path]::GetRandomFileName()
+            $path = Join-Path $parent $name -ErrorAction Stop
+            New-Item -ItemType Directory -Path $path -ErrorAction Stop | Out-Null
+            $path
+            PS
+          end
+
+          def rmdir(dir)
+            <<~PS
+            Remove-Item -Force -Recurse -Path "#{dir}"
+            PS
+          end
+
+          def run_script(arguments, script_path)
+            build_arg_list = arguments.map do |a|
+              "$invokeArgs.ArgumentList += @'\n#{a}\n'@"
+            end.join("\n")
+            <<~PS
+            $invokeArgs = @{
+              ScriptBlock = (Get-Command "#{script_path}").ScriptBlock
+              ArgumentList = @()
+            }
+            #{build_arg_list}
+
+            try
+            {
+              Invoke-Command @invokeArgs
+            }
+            catch
+            {
+              Write-Error $_.Exception
+              exit 1
+            }
+            PS
+          end
+
+          def ps_task(path, arguments)
+            <<~PS
+            $private:tempArgs = Get-ContentAsJson (
+              $utf8.GetString([System.Convert]::FromBase64String('#{Base64.encode64(JSON.dump(arguments))}'))
+            )
+            $allowedArgs = (Get-Command "#{path}").Parameters.Keys
+            $private:taskArgs = @{}
+            $private:tempArgs.Keys | ? { $allowedArgs -contains $_ } | % { $private:taskArgs[$_] = $private:tempArgs[$_] }
+            try { & "#{path}" @taskArgs } catch { Write-Error $_.Exception; exit 1 }
+            PS
+          end
+
+          def try_catch(command)
+            %(try { & "#{command}" } catch { Write-Error $_.Exception; exit 1 })
+          end
+
+          def shell_init
+            <<~PS
+            $ENV:PATH += ";${ENV:ProgramFiles}\\Puppet Labs\\Puppet\\bin\\;" +
+            "${ENV:ProgramFiles}\\Puppet Labs\\Puppet\\puppet\\bin;" +
+            "${ENV:ProgramFiles}\\Puppet Labs\\Puppet\\sys\\ruby\\bin\\"
+            $ENV:RUBYLIB = "${ENV:ProgramFiles}\\Puppet Labs\\Puppet\\puppet\\lib;" +
+            "${ENV:ProgramFiles}\\Puppet Labs\\Puppet\\facter\\lib;" +
+            "${ENV:ProgramFiles}\\Puppet Labs\\Puppet\\hiera\\lib;" +
+            $ENV:RUBYLIB
+
+            Add-Type -AssemblyName System.ServiceModel.Web, System.Runtime.Serialization
+            $utf8 = [System.Text.Encoding]::UTF8
+
+            function Write-Stream {
+            PARAM(
+              [Parameter(Position=0)] $stream,
+              [Parameter(ValueFromPipeline=$true)] $string
+            )
+            PROCESS {
+              $bytes = $utf8.GetBytes($string)
+              $stream.Write( $bytes, 0, $bytes.Length )
+            }
+            }
+
+            function Convert-JsonToXml {
+            PARAM([Parameter(ValueFromPipeline=$true)] [string[]] $json)
+            BEGIN {
+              $mStream = New-Object System.IO.MemoryStream
+            }
+            PROCESS {
+              $json | Write-Stream -Stream $mStream
+            }
+            END {
+              $mStream.Position = 0
+              try {
+                $jsonReader = [System.Runtime.Serialization.Json.JsonReaderWriterFactory]::CreateJsonReader($mStream,[System.Xml.XmlDictionaryReaderQuotas]::Max)
+                $xml = New-Object Xml.XmlDocument
+                $xml.Load($jsonReader)
+                $xml
+              } finally {
+                $jsonReader.Close()
+                $mStream.Dispose()
+              }
+            }
+            }
+
+            Function ConvertFrom-Xml {
+            [CmdletBinding(DefaultParameterSetName="AutoType")]
+            PARAM(
+              [Parameter(ValueFromPipeline=$true,Mandatory=$true,Position=1)] [Xml.XmlNode] $xml,
+              [Parameter(Mandatory=$true,ParameterSetName="ManualType")] [Type] $Type,
+              [Switch] $ForceType
+            )
+            PROCESS{
+              if (Get-Member -InputObject $xml -Name root) {
+                return $xml.root.Objects | ConvertFrom-Xml
+              } elseif (Get-Member -InputObject $xml -Name Objects) {
+                return $xml.Objects | ConvertFrom-Xml
+              }
+              $propbag = @{}
+              foreach ($name in Get-Member -InputObject $xml -MemberType Properties | Where-Object{$_.Name -notmatch "^(__.*|type)$"} | Select-Object -ExpandProperty name) {
+                Write-Debug "$Name Type: $($xml.$Name.type)" -Debug:$false
+                $propbag."$Name" = Convert-Properties $xml."$name"
+              }
+              if (!$Type -and $xml.HasAttribute("__type")) { $Type = $xml.__Type }
+              if ($ForceType -and $Type) {
+                try {
+                  $output = New-Object $Type -Property $propbag
+                } catch {
+                  $output = New-Object PSObject -Property $propbag
+                  $output.PsTypeNames.Insert(0, $xml.__type)
+                }
+              } elseif ($propbag.Count -ne 0) {
+                $output = New-Object PSObject -Property $propbag
+                if ($Type) {
+                  $output.PsTypeNames.Insert(0, $Type)
+                }
+              }
+              return $output
+            }
+            }
+
+            Function Convert-Properties {
+            PARAM($InputObject)
+            switch ($InputObject.type) {
+              "object" {
+                return (ConvertFrom-Xml -Xml $InputObject)
+              }
+              "string" {
+                $MightBeADate = $InputObject.get_InnerText() -as [DateTime]
+                ## Strings that are actually dates (*grumble* JSON is crap)
+                if ($MightBeADate -and $propbag."$Name" -eq $MightBeADate.ToString("G")) {
+                  return $MightBeADate
+                } else {
+                  return $InputObject.get_InnerText()
+                }
+              }
+              "number" {
+                $number = $InputObject.get_InnerText()
+                if ($number -eq ($number -as [int])) {
+                  return $number -as [int]
+                } elseif ($number -eq ($number -as [double])) {
+                  return $number -as [double]
+                } else {
+                  return $number -as [decimal]
+                }
+              }
+              "boolean" {
+                return [bool]::parse($InputObject.get_InnerText())
+              }
+              "null" {
+                return $null
+              }
+              "array" {
+                [object[]]$Items = $(foreach( $item in $InputObject.GetEnumerator() ) {
+                  Convert-Properties $item
+                })
+                return $Items
+              }
+              default {
+                return $InputObject
+              }
+            }
+            }
+
+            Function ConvertFrom-Json2 {
+            [CmdletBinding()]
+            PARAM(
+              [Parameter(ValueFromPipeline=$true,Mandatory=$true,Position=1)] [string] $InputObject,
+              [Parameter(Mandatory=$true)] [Type] $Type,
+              [Switch] $ForceType
+            )
+            PROCESS {
+              $null = $PSBoundParameters.Remove("InputObject")
+              [Xml.XmlElement]$xml = (Convert-JsonToXml $InputObject).Root
+              if ($xml) {
+                if ($xml.Objects) {
+                  $xml.Objects.Item.GetEnumerator() | ConvertFrom-Xml @PSBoundParameters
+                } elseif ($xml.Item -and $xml.Item -isnot [System.Management.Automation.PSParameterizedProperty]) {
+                  $xml.Item | ConvertFrom-Xml @PSBoundParameters
+                } else {
+                  $xml | ConvertFrom-Xml @PSBoundParameters
+                }
+              } else {
+                Write-Error "Failed to parse JSON with JsonReader" -Debug:$false
+              }
+            }
+            }
+
+            function ConvertFrom-PSCustomObject
+            {
+            PARAM([Parameter(ValueFromPipeline = $true)] $InputObject)
+            PROCESS {
+              if ($null -eq $InputObject) { return $null }
+
+              if ($InputObject -is [System.Collections.IEnumerable] -and $InputObject -isnot [string]) {
+                $collection = @(
+                  foreach ($object in $InputObject) { ConvertFrom-PSCustomObject $object }
+                )
+
+                $collection
+              } elseif ($InputObject -is [System.Management.Automation.PSCustomObject]) {
+                $hash = @{}
+                foreach ($property in $InputObject.PSObject.Properties) {
+                  $hash[$property.Name] = ConvertFrom-PSCustomObject $property.Value
+                }
+
+                $hash
+              } else {
+                $InputObject
+              }
+            }
+            }
+
+            function Get-ContentAsJson
+            {
+            [CmdletBinding()]
+            PARAM(
+              [Parameter(Mandatory = $true)] $Text,
+              [Parameter(Mandatory = $false)] [Text.Encoding] $Encoding = [Text.Encoding]::UTF8
+            )
+
+            # using polyfill cmdlet on PS2, so pass type info
+            if ($PSVersionTable.PSVersion -lt [Version]'3.0') {
+              $Text | ConvertFrom-Json2 -Type PSObject | ConvertFrom-PSCustomObject
+            } else {
+              $Text | ConvertFrom-Json | ConvertFrom-PSCustomObject
+            }
+            }
+            PS
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -2,6 +2,7 @@
 
 require 'open3'
 require 'fileutils'
+require 'tempfile'
 require 'bolt/node/output'
 require 'bolt/util'
 
@@ -44,7 +45,16 @@ module Bolt
         end
 
         def execute(command)
-          Open3.popen3(command)
+          if Bolt::Util.windows?
+            command += "\r\nif (!$?) { if($LASTEXITCODE) { exit $LASTEXITCODE } else { exit 1 } }"
+            script_file = Tempfile.new(['wrapper', '.ps1'], target.options['tmpdir'])
+            File.write(script_file, command)
+            script_file.close
+
+            command = ['powershell.exe', *Bolt::Shell::Powershell::PS_ARGS, script_file.path]
+          end
+
+          Open3.popen3(*command)
         end
 
         # This is used by the Bash shell to decide whether to `cd` before

data/lib/bolt/transport/winrm.rb

@@ -2,20 +2,10 @@
 
 require 'bolt/node/errors'
 require 'bolt/transport/base'
-require 'bolt/transport/powershell'
 
 module Bolt
   module Transport
-    class WinRM < Base
-      def provided_features
-        ['powershell']
-      end
-
-      def default_input_method(executable)
-        input_method ||= Powershell.powershell_file?(executable) ? 'powershell' : 'both'
-        input_method
-      end
-
+    class WinRM < Simple
       def initialize
         super
         require 'winrm'
@@ -36,113 +26,6 @@ module Bolt
           logger.info("Failed to close connection to #{target.safe_name} : #{e.message}")
         end
       end
-
-      def upload(target, source, destination, _options = {})
-        with_connection(target) do |conn|
-          conn.write_remote_file(source, destination)
-          Bolt::Result.for_upload(target, source, destination)
-        end
-      end
-
-      def run_command(target, command, _options = {})
-        with_connection(target) do |conn|
-          output = conn.execute(command)
-          Bolt::Result.for_command(target,
-                                   output.stdout.string,
-                                   output.stderr.string,
-                                   output.exit_code,
-                                   'command', command)
-        end
-      end
-
-      def run_script(target, script, arguments, _options = {})
-        # unpack any Sensitive data
-        arguments = unwrap_sensitive_args(arguments)
-        with_connection(target) do |conn|
-          conn.with_remote_tempdir do |dir|
-            remote_path = conn.write_remote_executable(dir, script)
-            if Powershell.powershell_file?(remote_path)
-              output = conn.execute(Powershell.run_script(arguments, remote_path))
-            else
-              path, args = *Powershell.process_from_extension(remote_path)
-              args += Powershell.escape_arguments(arguments)
-              output = conn.execute_process(path, args)
-            end
-            Bolt::Result.for_command(target,
-                                     output.stdout.string,
-                                     output.stderr.string,
-                                     output.exit_code,
-                                     'script', script)
-          end
-        end
-      end
-
-      def run_task(target, task, arguments, _options = {})
-        implementation = select_implementation(target, task)
-        executable = implementation['path']
-        input_method = implementation['input_method']
-        extra_files = implementation['files']
-        input_method ||= Powershell.powershell_file?(executable) ? 'powershell' : 'both'
-
-        # unpack any Sensitive data
-        arguments = unwrap_sensitive_args(arguments)
-        with_connection(target) do |conn|
-          conn.with_remote_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)
-              conn.mkdirs([task_dir] + extra_files.map { |file| File.join(dir, File.dirname(file['name'])) })
-              extra_files.each do |file|
-                conn.write_remote_file(file['path'], File.join(dir, file['name']))
-              end
-            end
-
-            remote_task_path = conn.write_remote_executable(task_dir, executable)
-
-            if Bolt::Task::STDIN_METHODS.include?(input_method)
-              stdin = JSON.dump(arguments)
-            end
-
-            if Bolt::Task::ENVIRONMENT_METHODS.include?(input_method)
-              envify_params(arguments).each do |(arg, val)|
-                cmd = Powershell.set_env(arg, val)
-                result = conn.execute(cmd)
-                if result.exit_code != 0
-                  raise Bolt::Node::EnvironmentVarError.new(arg, val)
-                end
-              end
-            end
-
-            conn.shell_init
-            output =
-              if Powershell.powershell_file?(remote_task_path) && stdin.nil?
-                conn.execute(Powershell.run_ps_task(arguments, remote_task_path, input_method))
-              else
-                if (interpreter = select_interpreter(remote_task_path, target.options['interpreters']))
-                  path = interpreter
-                  args = [remote_task_path]
-                else
-                  path, args = *Powershell.process_from_extension(remote_task_path)
-                end
-                conn.execute_process(path, args, stdin)
-              end
-
-            Bolt::Result.for_task(target, output.stdout.string,
-                                  output.stderr.string,
-                                  output.exit_code,
-                                  task.name)
-          end
-        end
-      end
-
-      def connected?(target)
-        with_connection(target) { true }
-      rescue Bolt::Node::ConnectError
-        false
-      end
     end
   end
 end

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

@@ -5,12 +5,10 @@ require 'bolt/node/output'
 
 module Bolt
   module Transport
-    class WinRM < Base
+    class WinRM < Simple
       class Connection
         attr_reader :logger, :target
 
-        DEFAULT_EXTENSIONS = ['.ps1', '.rb', '.pp'].freeze
-
         def initialize(target, transport_logger)
           raise Bolt::ValidationError, "Target #{target.safe_name} does not have a host" unless target.host
           @target = target
@@ -19,9 +17,6 @@ module Bolt
           @port = @target.port || default_port
           @user = @target.user
           # 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.safe_name]
           logger.debug("Initializing winrm connection to #{@target.safe_name}")
@@ -105,67 +100,48 @@ module Bolt
           @logger.debug { "Closed session" }
         end
 
-        def shell_init
-          return nil if @shell_initialized
-          result = execute(Powershell.shell_init)
-          if result.exit_code != 0
-            raise BaseError.new("Could not initialize shell: #{result.stderr.string}", "SHELL_INIT_ERROR")
-          end
-          @shell_initialized = true
-        end
-
         def execute(command)
-          result_output = Bolt::Node::Output.new
-
           @logger.debug { "Executing command: #{command}" }
 
-          output = @session.run(command) do |stdout, stderr|
-            result_output.stdout << stdout
-            @logger.debug { "stdout: #{stdout}" }
-            result_output.stderr << stderr
-            @logger.debug { "stderr: #{stderr}" }
-          end
-          result_output.exit_code = output.exitcode
-          if output.exitcode.zero?
-            @logger.debug { "Command returned successfully" }
-          else
-            @logger.info { "Command failed with exit code #{output.exitcode}" }
+          inp = StringIO.new
+          # This transport doesn't accept stdin, so close the stream to ensure
+          # it will fail if the shell attempts to provide stdin
+          inp.close
+
+          out_rd, out_wr = IO.pipe
+          err_rd, err_wr = IO.pipe
+          th = Thread.new do
+            result = @session.run(command)
+            out_wr << result.stdout
+            err_wr << result.stderr
+            out_wr.close
+            err_wr.close
+            result.exitcode
           end
-          result_output
+
+          [inp, out_rd, err_rd, th]
         rescue StandardError
           @logger.debug { "Command aborted" }
           raise
         end
 
-        def execute_process(path = '', arguments = [], stdin = nil)
-          execute(Powershell.execute_process(path, arguments, stdin))
-        end
-
-        def mkdirs(dirs)
-          result = execute(Powershell.mkdirs(dirs))
-          if result.exit_code != 0
-            message = "Could not create directories: #{result.stderr}"
-            raise Bolt::Node::FileError.new(message, 'MKDIR_ERROR')
-          end
-        end
-
-        def write_remote_file(source, destination)
+        def copy_file(source, destination)
           @logger.debug { "Uploading #{source}, to #{destination}" }
           if target.options['file-protocol'] == 'smb'
-            write_remote_file_smb(source, destination)
+            copy_file_smb(source, destination)
           else
-            write_remote_file_winrm(source, destination)
+            copy_file_winrm(source, destination)
           end
         end
 
-        def write_remote_file_winrm(source, destination)
+        def copy_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)
+        def copy_file_smb(source, destination)
           # lazy-load expensive gem code
           require 'ruby_smb'
 
@@ -185,7 +161,7 @@ module Bolt
           client = smb_client_login
           tree = client.tree_connect(path)
           begin
-            write_remote_file_smb_recursive(tree, source, dest)
+            copy_file_smb_recursive(tree, source, dest)
           ensure
             tree.disconnect!
           end
@@ -195,35 +171,8 @@ module Bolt
           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))
-          if result.exit_code != 0
-            raise Bolt::Node::FileError.new("Could not make tempdir: #{result.stderr}", 'TEMPDIR_ERROR')
-          end
-          result.stdout.string.chomp
-        end
-
-        def with_remote_tempdir
-          dir = make_tempdir
-          yield dir
-        ensure
-          execute(Powershell.rmdir(dir))
-        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 write_remote_executable(dir, file, filename = nil)
-          filename ||= File.basename(file)
-          validate_extensions(File.extname(filename))
-          remote_path = "#{dir}\\#{filename}"
-          write_remote_file(file, remote_path)
-          remote_path
+        def shell
+          @shell ||= Bolt::Shell::Powershell.new(target, self)
         end
 
         private
@@ -273,13 +222,13 @@ module Bolt
           )
         end
 
-        def write_remote_file_smb_recursive(tree, source, dest)
+        def copy_file_smb_recursive(tree, source, dest)
           if Dir.exist?(source)
             tree.open_directory(directory: dest, write: true, disposition: ::RubySMB::Dispositions::FILE_OPEN_IF)
 
             Dir.children(source).each do |child|
               child_dest = dest + '\\' + child
-              write_remote_file_smb_recursive(tree, File.join(source, child), child_dest)
+              copy_file_smb_recursive(tree, File.join(source, child), child_dest)
             end
             return
           end