bolt 2.5.0 → 2.6.0

data/lib/bolt/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bolt
 version: !ruby/object:Gem::Version
-  version: 2.5.0
+  version: 2.6.0
 platform: ruby
 authors:
 - Puppet
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-04-13 00:00:00.000000000 Z
+date: 2020-04-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: addressable
@@ -80,6 +80,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3'
+- !ruby/object:Gem::Dependency
+  name: jwt
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.2'
 - !ruby/object:Gem::Dependency
   name: logging
   requirement: !ruby/object:Gem::Requirement
@@ -471,6 +485,8 @@ files:
 - lib/bolt/shell.rb
 - lib/bolt/shell/bash.rb
 - lib/bolt/shell/bash/tmpdir.rb
+- lib/bolt/shell/powershell.rb
+- lib/bolt/shell/powershell/snippets.rb
 - lib/bolt/target.rb
 - lib/bolt/task.rb
 - lib/bolt/task/puppet_server.rb
@@ -480,10 +496,8 @@ files:
 - lib/bolt/transport/docker/connection.rb
 - lib/bolt/transport/local.rb
 - lib/bolt/transport/local/connection.rb
-- lib/bolt/transport/local_windows.rb
 - lib/bolt/transport/orch.rb
 - lib/bolt/transport/orch/connection.rb
-- lib/bolt/transport/powershell.rb
 - lib/bolt/transport/remote.rb
 - lib/bolt/transport/simple.rb
 - lib/bolt/transport/ssh.rb

data/lib/bolt/transport/local_windows.rb

@@ -1,189 +0,0 @@
-# frozen_string_literal: true
-
-require 'json'
-require 'fileutils'
-require 'open3'
-require 'tmpdir'
-require 'bolt/node/output'
-require 'bolt/transport/base'
-require 'bolt/transport/powershell'
-require 'bolt/util'
-
-module Bolt
-  module Transport
-    class LocalWindows < Base
-      def provided_features
-        ['powershell']
-      end
-
-      def default_input_method(executable)
-        input_method ||= Powershell.powershell_file?(executable) ? 'powershell' : 'both'
-        input_method
-      end
-
-      def in_tmpdir(base)
-        args = base ? [nil, base] : []
-        dir = begin
-                Dir.mktmpdir(*args)
-              rescue StandardError => e
-                raise Bolt::Node::FileError.new("Could not make tempdir: #{e.message}", 'TEMPDIR_ERROR')
-              end
-
-        yield dir
-      ensure
-        FileUtils.remove_entry dir if dir
-      end
-      private :in_tmpdir
-
-      def copy_file(source, destination)
-        logger.debug { "Uploading #{source}, to #{destination}" }
-        FileUtils.cp_r(source, destination, remove_destination: true)
-      rescue StandardError => e
-        raise Bolt::Node::FileError.new(e.message, 'WRITE_ERROR')
-      end
-
-      def with_tmpscript(script, base)
-        in_tmpdir(base) do |dir|
-          dest = File.join(dir, File.basename(script))
-          copy_file(script, dest)
-          File.chmod(0o750, dest)
-          yield dest, dir
-        end
-      end
-      private :with_tmpscript
-
-      def execute(*command, options)
-        # Interpreter can be an array or string. It will be appended to the command array.
-        command.unshift(options[:interpreter]).flatten! if options[:interpreter]
-        command = [options[:env]] + command if options[:env]
-
-        if options[:stdin]
-          stdout, stderr, rc = Open3.capture3(*command, stdin_data: options[:stdin], chdir: options[:dir])
-        else
-          stdout, stderr, rc = Open3.capture3(*command, chdir: options[:dir])
-        end
-
-        result_output = Bolt::Node::Output.new
-        result_output.stdout << stdout unless stdout.nil?
-        result_output.stderr << stderr unless stderr.nil?
-        result_output.exit_code = rc.exitstatus
-        result_output
-      end
-
-      def upload(target, source, destination, _options = {})
-        copy_file(source, destination)
-        Bolt::Result.for_upload(target, source, destination)
-      end
-
-      def run_command(target, command, _options = {})
-        in_tmpdir(target.options['tmpdir']) do |dir|
-          output = execute(command, dir: dir)
-          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 = {})
-        with_tmpscript(File.absolute_path(script), target.options['tmpdir']) do |file, dir|
-          logger.debug "Running '#{file}' with #{arguments.to_json}"
-
-          # unpack any Sensitive data AFTER we log
-          arguments = unwrap_sensitive_args(arguments)
-          if Powershell.powershell_file?(file)
-            command = Powershell.run_script(arguments, file)
-            interpreter = ['powershell.exe', *Powershell.ps_args]
-            output = execute(command, dir: dir, interpreter: interpreter)
-          else
-            path, args = *Powershell.process_from_extension(file)
-            args += Powershell.escape_arguments(arguments)
-            command = args.unshift(path).join(' ')
-            output = execute(command, dir: dir)
-          end
-          Bolt::Result.for_command(target,
-                                   output.stdout.string,
-                                   output.stderr.string,
-                                   output.exit_code,
-                                   'script', script)
-        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']
-
-        in_tmpdir(target.options['tmpdir']) do |dir|
-          if extra_files.empty?
-            script = File.join(dir, File.basename(executable))
-          else
-            arguments['_installdir'] = dir
-            script_dest = File.join(dir, task.tasks_dir)
-            FileUtils.mkdir_p([script_dest] + extra_files.map { |file| File.join(dir, File.dirname(file['name'])) })
-
-            script = File.join(script_dest, File.basename(executable))
-            extra_files.each do |file|
-              dest = File.join(dir, file['name'])
-              copy_file(file['path'], dest)
-              File.chmod(0o750, dest)
-            end
-          end
-
-          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.to_json}#{interpreter_debug}")
-          unwrapped_arguments = unwrap_sensitive_args(arguments)
-
-          stdin = Bolt::Task::STDIN_METHODS.include?(input_method) ? JSON.dump(unwrapped_arguments) : nil
-          if Bolt::Task::ENVIRONMENT_METHODS.include?(input_method)
-            environment_params = envify_params(unwrapped_arguments).each_with_object([]) do |(arg, val), list|
-              list << Powershell.set_env(arg, val)
-            end
-            environment_params = environment_params.join("\n") + "\n"
-          else
-            environment_params = ""
-          end
-
-          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', *Powershell.ps_args]
-            output =
-              if input_method == 'powershell'
-                execute(command, dir: dir, interpreter: interpreter)
-              else
-                execute(command, dir: dir, stdin: stdin, interpreter: interpreter)
-              end
-          end
-          unless output
-            if interpreter
-              env = Bolt::Task::ENVIRONMENT_METHODS.include?(input_method) ? envify_params(unwrapped_arguments) : nil
-              output = 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
-              output = execute(command, dir: dir, stdin: stdin, interpreter: 'powershell.exe')
-            end
-          end
-          Bolt::Result.for_task(target,
-                                output.stdout.string,
-                                output.stderr.string,
-                                output.exit_code,
-                                task.name)
-        end
-      end
-
-      def connected?(_targets)
-        true
-      end
-    end
-  end
-end

data/lib/bolt/transport/powershell.rb

@@ -1,337 +0,0 @@
-# frozen_string_literal: true
-
-module Bolt
-  module Transport
-    module Powershell
-      class << self
-        def ps_args
-          %w[-NoProfile -NonInteractive -NoLogo -ExecutionPolicy Bypass]
-        end
-
-        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 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 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
-              "@'\n#{stdin}\n'@ | & #{quoted_path} #{quoted_args}"
-            end
-          <<-PS
-$OutputEncoding = [Console]::OutputEncoding
-#{exec_cmd}
-if (-not $? -and ($LASTEXITCODE -eq $null)) { exit 1 }
-exit $LASTEXITCODE
-PS
-        end
-
-        def mkdirs(dirs)
-          "mkdir -Force #{dirs.uniq.sort.join(',')}"
-        end
-
-        def make_tempdir(parent)
-          <<-PS
-$parent = #{parent}
-$name = [System.IO.Path]::GetRandomFileName()
-$path = Join-Path $parent $name
-New-Item -ItemType Directory -Path $path | Out-Null
-$path
-PS
-        end
-
-        def rmdir(dir)
-          <<-PS
-Remove-Item -Force -Recurse -Path "#{dir}"
-PS
-        end
-
-        def run_script(arguments, script_path)
-          mapped_args = arguments.map do |a|
-            "$invokeArgs.ArgumentList += @'\n#{a}\n'@"
-          end.join("\n")
-          <<-PS
-$invokeArgs = @{
-  ScriptBlock = (Get-Command "#{script_path}").ScriptBlock
-  ArgumentList = @()
-}
-#{mapped_args}
-
-try
-{
-  Invoke-Command @invokeArgs
-}
-catch
-{
-  Write-Error $_.Exception
-  exit 1
-}
-PS
-        end
-
-        def run_ps_task(arguments, task_path, 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'
-            <<-PS
-$private:tempArgs = Get-ContentAsJson (
-  $utf8.GetString([System.Convert]::FromBase64String('#{Base64.encode64(JSON.dump(arguments))}'))
-)
-$allowedArgs = (Get-Command "#{task_path}").Parameters.Keys
-$private:taskArgs = @{}
-$private:tempArgs.Keys | ? { $allowedArgs -contains $_ } | % { $private:taskArgs[$_] = $private:tempArgs[$_] }
-try { & "#{task_path}" @taskArgs } catch { Write-Error $_.Exception; exit 1 }
-PS
-          else
-            %(try { & "#{task_path}" } catch { Write-Error $_.Exception; exit 1 })
-          end
-        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