bolt 0.16.1 → 0.16.2

data/lib/bolt/node/ssh.rb

@@ -1,356 +0,0 @@
-require 'json'
-require 'shellwords'
-require 'logging'
-require 'net/ssh'
-require 'net/scp'
-require 'bolt/node/output'
-
-module Bolt
-  class SSH < Node
-    class RemoteTempdir
-      def initialize(node, path)
-        @node = node
-        @owner = node.user
-        @path = path
-        @logger = node.logger
-      end
-
-      def to_s
-        @path
-      end
-
-      def chown(owner)
-        return if owner.nil? || owner == @owner
-
-        @owner = owner
-        result = @node.execute("chown -R '#{@owner}': '#{@path}'", sudoable: true, run_as: 'root')
-        if result.exit_code != 0
-          message = "Could not change owner of '#{@path}' to #{@owner}: #{result.stderr.string}"
-          raise Bolt::Node::FileError.new(message, 'CHOWN_ERROR')
-        end
-      end
-
-      def delete
-        result = @node.execute("rm -rf '#{@path}'", sudoable: true, run_as: @owner)
-        if result.exit_code != 0
-          @logger.warn("Failed to clean up tempdir '#{@path}': #{result.stderr.string}")
-        end
-      end
-    end
-
-    def self.initialize_transport(logger)
-      require 'net/ssh/krb'
-    rescue LoadError
-      logger.debug {
-        "Authentication method 'gssapi-with-mic' is not available"
-      }
-    end
-
-    def initialize(target)
-      super(target)
-      @user = @user || Net::SSH::Config.for(target.host)[:user] || Etc.getlogin
-    end
-
-    def protocol
-      'ssh'
-    end
-
-    if !!File::ALT_SEPARATOR
-      require 'ffi'
-      module Win
-        extend FFI::Library
-        ffi_lib 'user32'
-        ffi_convention :stdcall
-        attach_function :FindWindow, :FindWindowW, %i[buffer_in buffer_in], :int
-      end
-    end
-
-    def connect
-      transport_logger = Logging.logger[Net::SSH]
-      transport_logger.level = :warn
-      options = {
-        logger: transport_logger,
-        non_interactive: true
-      }
-
-      options[:port] = @target.port if @target.port
-      options[:password] = @password if @password
-      options[:keys] = @key if @key
-      options[:verify_host_key] = if @host_key_check
-                                    Net::SSH::Verifiers::Secure.new
-                                  else
-                                    Net::SSH::Verifiers::Lenient.new
-                                  end
-      options[:timeout] = @connect_timeout if @connect_timeout
-
-      # Mirroring:
-      # https://github.com/net-ssh/net-ssh/blob/master/lib/net/ssh/authentication/agent.rb#L80
-      # https://github.com/net-ssh/net-ssh/blob/master/lib/net/ssh/authentication/pageant.rb#L403
-      if defined?(UNIXSocket) && UNIXSocket
-        if ENV['SSH_AUTH_SOCK'].to_s.empty?
-          @logger.debug { "Disabling use_agent in net-ssh: ssh-agent is not available" }
-          options[:use_agent] = false
-        end
-      elsif !!File::ALT_SEPARATOR
-        pageant_wide = 'Pageant'.encode('UTF-16LE')
-        if Win.FindWindow(pageant_wide, pageant_wide).to_i == 0
-          @logger.debug { "Disabling use_agent in net-ssh: pageant process not running" }
-          options[:use_agent] = false
-        end
-      end
-
-      @session = Net::SSH.start(@target.host, @user, options)
-      @logger.debug { "Opened session" }
-    rescue Net::SSH::AuthenticationFailed => e
-      raise Bolt::Node::ConnectError.new(
-        e.message,
-        'AUTH_ERROR'
-      )
-    rescue Net::SSH::HostKeyError => e
-      raise Bolt::Node::ConnectError.new(
-        "Host key verification failed for #{uri}: #{e.message}",
-        'HOST_KEY_ERROR'
-      )
-    rescue Net::SSH::ConnectionTimeout
-      raise Bolt::Node::ConnectError.new(
-        "Timeout after #{@connect_timeout} seconds connecting to #{uri}",
-        'CONNECT_ERROR'
-      )
-    rescue StandardError => e
-      raise Bolt::Node::ConnectError.new(
-        "Failed to connect to #{uri}: #{e.message}",
-        'CONNECT_ERROR'
-      )
-    end
-
-    def disconnect
-      if @session && !@session.closed?
-        @session.close
-        @logger.debug { "Closed session" }
-      end
-    end
-
-    def sudo_prompt
-      '[sudo] Bolt needs to run as another user, password: '
-    end
-
-    def handled_sudo(channel, data)
-      if data == sudo_prompt
-        if @sudo_password
-          channel.send_data "#{@sudo_password}\n"
-          channel.wait
-          return true
-        else
-          raise Bolt::Node::EscalateError.new(
-            "Sudo password for user #{@user} was not provided for #{uri}",
-            'NO_PASSWORD'
-          )
-        end
-      elsif data =~ /^#{@user} is not in the sudoers file\./
-        @logger.debug { data }
-        raise Bolt::Node::EscalateError.new(
-          "User #{@user} does not have sudo permission on #{uri}",
-          'SUDO_DENIED'
-        )
-      elsif data =~ /^Sorry, try again\./
-        @logger.debug { data }
-        raise Bolt::Node::EscalateError.new(
-          "Sudo password for user #{@user} not recognized on #{uri}",
-          'BAD_PASSWORD'
-        )
-      end
-      false
-    end
-
-    def execute(command, sudoable: false, **options)
-      result_output = Bolt::Node::Output.new
-      run_as = options[:run_as] || @run_as
-      use_sudo = sudoable && run_as && @user != run_as
-      if use_sudo
-        command = "sudo -S -u #{run_as} -p '#{sudo_prompt}' #{command}"
-      end
-
-      @logger.debug { "Executing: #{command}" }
-
-      session_channel = @session.open_channel do |channel|
-        # Request a pseudo tty
-        channel.request_pty if @tty
-
-        channel.exec(command) do |_, success|
-          unless success
-            raise Bolt::Node::ConnectError.new(
-              "Could not execute command: #{command.inspect}",
-              'EXEC_ERROR'
-            )
-          end
-
-          channel.on_data do |_, data|
-            unless use_sudo && handled_sudo(channel, data)
-              result_output.stdout << data
-            end
-            @logger.debug { "stdout: #{data}" }
-          end
-
-          channel.on_extended_data do |_, _, data|
-            unless use_sudo && handled_sudo(channel, data)
-              result_output.stderr << data
-            end
-            @logger.debug { "stderr: #{data}" }
-          end
-
-          channel.on_request("exit-status") do |_, data|
-            result_output.exit_code = data.read_long
-          end
-
-          if options[:stdin]
-            channel.send_data(options[:stdin])
-            channel.eof!
-          end
-        end
-      end
-      session_channel.wait
-
-      if result_output.exit_code == 0
-        @logger.debug { "Command returned successfully" }
-      else
-        @logger.info { "Command failed with exit code #{result_output.exit_code}" }
-      end
-      result_output
-    end
-
-    def upload(source, destination, options = {})
-      @run_as = options['_run_as'] || @conf_run_as
-      with_remote_tempdir do |dir|
-        basename = File.basename(destination)
-        tmpfile = "#{dir}/#{basename}"
-        write_remote_file(source, tmpfile)
-        # pass over file ownership if we're using run-as to be a different user
-        dir.chown(@run_as)
-        result = execute("mv '#{tmpfile}' '#{destination}'", sudoable: true)
-        if result.exit_code != 0
-          message = "Could not move temporary file '#{tmpfile}' to #{destination}: #{result.stderr.string}"
-          raise FileError.new(message, 'MV_ERROR')
-        end
-      end
-      Bolt::Result.for_upload(@target, source, destination)
-    ensure
-      @run_as = @conf_run_as
-    end
-
-    def write_remote_file(source, destination)
-      @session.scp.upload!(source, destination)
-    rescue StandardError => e
-      raise FileError.new(e.message, 'WRITE_ERROR')
-    end
-
-    def make_tempdir
-      if @tmpdir
-        tmppath = "#{@tmpdir}/#{SecureRandom.uuid}"
-        command = "mkdir -m 700 #{tmppath}"
-      else
-        command = 'mktemp -d'
-      end
-      result = execute(command)
-      if result.exit_code != 0
-        raise FileError.new("Could not make tempdir: #{result.stderr.string}", 'TEMPDIR_ERROR')
-      end
-      path = tmppath || result.stdout.string.chomp
-      RemoteTempdir.new(self, path)
-    end
-
-    # A helper to create and delete a tempdir on the remote system. Yields the
-    # directory name.
-    def with_remote_tempdir
-      dir = make_tempdir
-      yield dir
-    ensure
-      dir.delete if dir
-    end
-
-    def write_remote_executable(dir, file, filename = nil)
-      filename ||= File.basename(file)
-      remote_path = "#{dir}/#{filename}"
-      write_remote_file(file, remote_path)
-      make_executable(remote_path)
-      remote_path
-    end
-
-    def make_executable(path)
-      result = execute("chmod u+x '#{path}'")
-      if result.exit_code != 0
-        raise FileError.new("Could not make file '#{path}' executable: #{result.stderr.string}", 'CHMOD_ERROR')
-      end
-    end
-
-    def make_wrapper_stringio(task_path, stdin)
-      StringIO.new(<<-SCRIPT)
-#!/bin/sh
-'#{task_path}' <<EOF
-#{stdin}
-EOF
-SCRIPT
-    end
-
-    def run_command(command, options = {})
-      @run_as = options['_run_as'] || @conf_run_as
-      output = execute(command, sudoable: true)
-      Bolt::Result.for_command(@target, output.stdout.string, output.stderr.string, output.exit_code)
-    ensure
-      @run_as = @conf_run_as
-    end
-
-    def run_script(script, arguments, options = {})
-      @run_as = options['_run_as'] || @conf_run_as
-      with_remote_tempdir do |dir|
-        remote_path = write_remote_executable(dir, script)
-        dir.chown(@run_as)
-        output = execute("'#{remote_path}' #{Shellwords.join(arguments)}",
-                         sudoable: true)
-        Bolt::Result.for_command(@target, output.stdout.string, output.stderr.string, output.exit_code)
-      end
-    ensure
-      @run_as = @conf_run_as
-    end
-
-    def run_task(task, input_method, arguments, options = {})
-      @run_as = options['_run_as'] || @conf_run_as
-      export_args = {}
-      stdin, output = nil
-
-      if STDIN_METHODS.include?(input_method)
-        stdin = JSON.dump(arguments)
-      end
-
-      if ENVIRONMENT_METHODS.include?(input_method)
-        export_args = arguments.map do |env, val|
-          "PT_#{env}='#{val}'"
-        end.join(' ')
-      end
-
-      command = export_args.empty? ? '' : "#{export_args} "
-
-      execute_options = {}
-
-      with_remote_tempdir do |dir|
-        remote_task_path = write_remote_executable(dir, task)
-        if @run_as && stdin
-          wrapper = make_wrapper_stringio(remote_task_path, stdin)
-          remote_wrapper_path = write_remote_executable(dir, wrapper, 'wrapper.sh')
-          command += "'#{remote_wrapper_path}'"
-        else
-          command += "'#{remote_task_path}'"
-          execute_options[:stdin] = stdin
-        end
-        dir.chown(@run_as)
-
-        execute_options[:sudoable] = true if @run_as
-        output = execute(command, **execute_options)
-      end
-      Bolt::Result.for_task(@target, output.stdout.string,
-                            output.stderr.string,
-                            output.exit_code)
-    ensure
-      @run_as = @conf_run_as
-    end
-  end
-end

data/lib/bolt/node/winrm.rb

@@ -1,598 +0,0 @@
-require 'winrm'
-require 'winrm-fs'
-require 'logging'
-require 'bolt/result'
-require 'base64'
-require 'set'
-
-module Bolt
-  class WinRM < Node
-    def protocol
-      'winrm'
-    end
-
-    HTTP_PORT = 5985
-    HTTPS_PORT = 5986
-
-    def port
-      default_port = @ssl ? HTTPS_PORT : HTTP_PORT
-      @target.port || default_port
-    end
-
-    def initialize(target)
-      super(target)
-      @extensions = DEFAULT_EXTENSIONS.to_set.merge(@extensions || [])
-      @logger.debug { "WinRM initialized for #{@extensions.to_a} extensions" }
-    end
-
-    def connect
-      if @ssl
-        scheme = 'https'
-        transport = :ssl
-      else
-        scheme = 'http'
-        transport = :negotiate
-      end
-      endpoint = "#{scheme}://#{@target.host}:#{port}/wsman"
-      options = { endpoint: endpoint,
-                  user: @user,
-                  password: @password,
-                  retry_limit: 1,
-                  transport: transport,
-                  ca_trust_path: @cacert }
-
-      Timeout.timeout(@connect_timeout) do
-        @connection = ::WinRM::Connection.new(options)
-        transport_logger = Logging.logger[::WinRM]
-        transport_logger.level = :warn
-        @connection.logger = transport_logger
-
-        @session = @connection.shell(:powershell)
-        @session.run('$PSVersionTable.PSVersion')
-        @logger.debug { "Opened session" }
-      end
-    rescue Timeout::Error
-      # If we're using the default port with SSL, a timeout probably means the
-      # host doesn't support SSL.
-      if @ssl && port == HTTPS_PORT
-        theres_your_problem = "\nUse --no-ssl if this host isn't configured to use SSL for WinRM"
-      end
-      raise Bolt::Node::ConnectError.new(
-        "Timeout after #{@connect_timeout} seconds connecting to #{endpoint}#{theres_your_problem}",
-        'CONNECT_ERROR'
-      )
-    rescue ::WinRM::WinRMAuthorizationError
-      raise Bolt::Node::ConnectError.new(
-        "Authentication failed for #{endpoint}",
-        'AUTH_ERROR'
-      )
-    rescue OpenSSL::SSL::SSLError => e
-      # If we're using SSL with the default non-SSL port, mention that as a likely problem
-      if @ssl && port == HTTP_PORT
-        theres_your_problem = "\nAre you using SSL to connect to a non-SSL port?"
-      end
-      raise Bolt::Node::ConnectError.new(
-        "Failed to connect to #{endpoint}: #{e.message}#{theres_your_problem}",
-        "CONNECT_ERROR"
-      )
-    rescue StandardError => e
-      raise Bolt::Node::ConnectError.new(
-        "Failed to connect to #{endpoint}: #{e.message}",
-        'CONNECT_ERROR'
-      )
-    end
-
-    def disconnect
-      @session.close if @session
-      @logger.debug { "Closed session" }
-    end
-
-    def shell_init
-      return nil if @shell_initialized
-      result = execute(<<-PS)
-
-$ENV:PATH += ";${ENV:ProgramFiles}\\Puppet Labs\\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 Invoke-Interpreter
-{
-  [CmdletBinding()]
-  Param (
-    [Parameter()]
-    [String]
-    $Path,
-
-    [Parameter()]
-    [String]
-    $Arguments,
-
-    [Parameter()]
-    [Int32]
-    $Timeout,
-
-    [Parameter()]
-    [String]
-    $StdinInput = $Null
-  )
-
-  try
-  {
-    if (-not (Get-Command $Path -ErrorAction SilentlyContinue))
-    {
-      throw "Could not find executable '$Path' in ${ENV:PATH} on target node"
-    }
-
-    $startInfo = New-Object System.Diagnostics.ProcessStartInfo($Path, $Arguments)
-    $startInfo.UseShellExecute = $false
-    $startInfo.WorkingDirectory = Split-Path -Parent (Get-Command $Path).Path
-    $startInfo.CreateNoWindow = $true
-    if ($StdinInput) { $startInfo.RedirectStandardInput = $true }
-    $startInfo.RedirectStandardOutput = $true
-    $startInfo.RedirectStandardError = $true
-
-    $stdoutHandler = { if (-not ([String]::IsNullOrEmpty($EventArgs.Data))) { $Host.UI.WriteLine($EventArgs.Data) } }
-    $stderrHandler = { if (-not ([String]::IsNullOrEmpty($EventArgs.Data))) { $Host.UI.WriteErrorLine($EventArgs.Data) } }
-    $invocationId = [Guid]::NewGuid().ToString()
-
-    $process = New-Object System.Diagnostics.Process
-    $process.StartInfo = $startInfo
-    $process.EnableRaisingEvents = $true
-
-    # https://msdn.microsoft.com/en-us/library/system.diagnostics.process.standarderror(v=vs.110).aspx#Anchor_2
-    $stdoutEvent = Register-ObjectEvent -InputObject $process -EventName 'OutputDataReceived' -Action $stdoutHandler
-    $stderrEvent = Register-ObjectEvent -InputObject $process -EventName 'ErrorDataReceived' -Action $stderrHandler
-    $exitedEvent = Register-ObjectEvent -InputObject $process -EventName 'Exited' -SourceIdentifier $invocationId
-
-    $process.Start() | Out-Null
-
-    $process.BeginOutputReadLine()
-    $process.BeginErrorReadLine()
-
-    if ($StdinInput)
-    {
-      $process.StandardInput.WriteLine($StdinInput)
-      $process.StandardInput.Close()
-    }
-
-    # park current thread until the PS event is signaled upon process exit
-    # OR the timeout has elapsed
-    $waitResult = Wait-Event -SourceIdentifier $invocationId -Timeout $Timeout
-    if (! $process.HasExited)
-    {
-      $Host.UI.WriteErrorLine("Process $Path did not complete in $Timeout seconds")
-      return 1
-    }
-
-    return $process.ExitCode
-  }
-  catch
-  {
-    $Host.UI.WriteErrorLine($_)
-    return 1
-  }
-  finally
-  {
-    @($stdoutEvent, $stderrEvent, $exitedEvent) |
-      ? { $_ -ne $Null } |
-      % { Unregister-Event -SourceIdentifier $_.Name }
-
-    if ($process -ne $Null)
-    {
-      if (($process.Handle -ne $Null) -and (! $process.HasExited))
-      {
-        try { $process.Kill() } catch { $Host.UI.WriteErrorLine("Failed To Kill Process $Path") }
-      }
-      $process.Dispose()
-    }
-  }
-}
-
-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
-      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}" }
-      end
-      result_output
-    end
-    private :execute
-
-    # 10 minutes in seconds
-    DEFAULT_EXECUTION_TIMEOUT = 10 * 60
-
-    def execute_process(path = '', arguments = [], stdin = nil,
-                        timeout = DEFAULT_EXECUTION_TIMEOUT)
-      quoted_args = arguments.map do |arg|
-        "'" + arg.gsub("'", "''") + "'"
-      end.join(',')
-
-      execute(<<-PS)
-$quoted_array = @(
-  #{quoted_args}
-)
-
-$invokeArgs = @{
-  Path = "#{path}"
-  Arguments = $quoted_array -Join ' '
-  Timeout = #{timeout}
-  #{stdin.nil? ? '' : "StdinInput = @'\n" + stdin + "\n'@"}
-}
-
-# winrm gem checks $? prior to using $LASTEXITCODE
-# making it necessary to exit with the desired code to propagate status properly
-exit $(Invoke-Interpreter @invokeArgs)
-PS
-    end
-
-    DEFAULT_EXTENSIONS = ['.ps1', '.rb', '.pp'].freeze
-
-    PS_ARGS = %w[
-      -NoProfile -NonInteractive -NoLogo -ExecutionPolicy Bypass
-    ].freeze
-
-    def powershell_file?(path)
-      Pathname(path).extname.casecmp('.ps1').zero?
-    end
-
-    def process_from_extension(path)
-      case Pathname(path).extname.downcase
-      when '.rb'
-        [
-          'ruby.exe',
-          ['-S', "\"#{path}\""]
-        ]
-      when '.ps1'
-        [
-          'powershell.exe',
-          [*PS_ARGS, '-File', "\"#{path}\""]
-        ]
-      when '.pp'
-        [
-          'puppet.bat',
-          ['apply', "\"#{path}\""]
-        ]
-      else
-        # Run the script via cmd, letting Windows extension handling determine how
-        [
-          'cmd.exe',
-          ['/c', "\"#{path}\""]
-        ]
-      end
-    end
-
-    def upload(source, destination, _options = nil)
-      write_remote_file(source, destination)
-      Bolt::Result.for_upload(@target, source, destination)
-    end
-
-    def write_remote_file(source, destination)
-      fs = ::WinRM::FS::FileManager.new(@connection)
-      # TODO: raise FileError here if this fails
-      fs.upload(source, destination)
-    end
-
-    def make_tempdir
-      find_parent = @tmpdir ? "\"#{@tmpdir}\"" : '[System.IO.Path]::GetTempPath()'
-      result = execute(<<-PS)
-$parent = #{find_parent}
-$name = [System.IO.Path]::GetRandomFileName()
-$path = Join-Path $parent $name
-New-Item -ItemType Directory -Path $path | Out-Null
-$path
-PS
-      if result.exit_code != 0
-        raise FileError.new("Could not make tempdir: #{result.stderr}", 'TEMPDIR_ERROR')
-      end
-      result.stdout.string.chomp
-    end
-
-    def with_remote_file(file)
-      ext = File.extname(file)
-      unless @extensions.include?(ext)
-        raise FileError.new("File extension #{ext} is not enabled, "\
-                            "to run it please add to 'winrm: extensions'", 'FILETYPE_ERROR')
-      end
-      file_base = File.basename(file)
-      dir = make_tempdir
-      dest = "#{dir}\\#{file_base}"
-      begin
-        write_remote_file(file, dest)
-        shell_init
-        yield dest
-      ensure
-        execute(<<-PS)
-Remove-Item -Force "#{dest}"
-Remove-Item -Force "#{dir}"
-PS
-      end
-    end
-
-    def run_command(command, _options = nil)
-      output = execute(command)
-      Bolt::Result.for_command(@target, output.stdout.string, output.stderr.string, output.exit_code)
-    end
-
-    def run_script(script, arguments, _options = nil)
-      with_remote_file(script) do |remote_path|
-        if powershell_file?(remote_path)
-          mapped_args = arguments.map do |a|
-            "$invokeArgs.ArgumentList += @'\n#{a}\n'@"
-          end.join("\n")
-          output = execute(<<-PS)
-$invokeArgs = @{
-  ScriptBlock = (Get-Command "#{remote_path}").ScriptBlock
-  ArgumentList = @()
-}
-#{mapped_args}
-
-try
-{
-  Invoke-Command @invokeArgs
-}
-catch
-{
-  exit 1
-}
-          PS
-        else
-          path, args = *process_from_extension(remote_path)
-          args += escape_arguments(arguments)
-          output = execute_process(path, args)
-        end
-        Bolt::Result.for_command(@target, output.stdout.string, output.stderr.string, output.exit_code)
-      end
-    end
-
-    def run_task(task, input_method, arguments, _options = nil)
-      if STDIN_METHODS.include?(input_method)
-        stdin = JSON.dump(arguments)
-      end
-
-      if ENVIRONMENT_METHODS.include?(input_method)
-        arguments.each do |(arg, val)|
-          cmd = "[Environment]::SetEnvironmentVariable('PT_#{arg}', '#{val}')"
-          result = execute(cmd)
-          if result.exit_code != 0
-            raise EnvironmentVarError(var, value)
-          end
-        end
-      end
-
-      with_remote_file(task) do |remote_path|
-        output =
-          if powershell_file?(remote_path) && stdin.nil?
-            # 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'
-              execute(<<-PS)
-$private:taskArgs = Get-ContentAsJson (
-  $utf8.GetString([System.Convert]::FromBase64String('#{Base64.encode64(JSON.dump(arguments))}'))
-)
-try { & "#{remote_path}" @taskArgs } catch { exit 1 }
-              PS
-            else
-              execute(%(try { & "#{remote_path}" } catch { exit 1 }))
-            end
-          else
-            path, args = *process_from_extension(remote_path)
-            execute_process(path, args, stdin)
-          end
-        Bolt::Result.for_task(@target, output.stdout.string,
-                              output.stderr.string,
-                              output.exit_code)
-      end
-    end
-
-    def escape_arguments(arguments)
-      arguments.map do |arg|
-        if arg =~ / /
-          "\"#{arg}\""
-        else
-          arg
-        end
-      end
-    end
-  end
-end