bolt 0.9.0 → 0.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 80377af090a1f1d5fd9515eac97623064459ce9f
-  data.tar.gz: 1b73aeaa5dce3a2c3b37581905212e00c0ed2afa
+  metadata.gz: d4e27492b22291a233b5fb9dfbb8e8648a15ce19
+  data.tar.gz: 9b2d163aa823b02cd7b6cfc6031846841d7c7b30
 SHA512:
-  metadata.gz: 445a3d714f38f2e8ab548df6c8b7b7ec777f407ec44625533c7fe1b1983210f5d82c648d149f9c1ba3de295b53422af27e89d1f1267ac2980d08bd12fabd4d66
-  data.tar.gz: d0ce607c758b9431c48e978d5ca1e67470a2afd3be1ce35e5694e5a3bed5f82487c5c082daaf19cf1880c2fac16ec9297efaf8105c4b9fc7ab8970dc69eab5ca
+  metadata.gz: b3d53aafec9ab3aa09d30dd5d45624aa74a20835373c70f174508f4986c33470b5b45350f40014e534b18f59a6267303395f2075cdb1269231b112c8d9ec1765
+  data.tar.gz: 664b5acf2aa442bf7e24dd76b61723819a4eb0523b34118bd0976f6c696db03319e979ad40521af7334bebf06cdd545b071b3eef87047b0b5ced11988f6e49a5

data/lib/bolt/cli.rb

@@ -97,9 +97,7 @@ HELP
     def initialize(argv)
       @argv    = argv
       @options = {
-        nodes: [],
-        insecure: false,
-        transport: 'ssh'
+        nodes: []
       }
       @config = Bolt::Config.new
       @parser = create_option_parser(@options)
@@ -137,7 +135,6 @@ HELP
             results[:password] = password
           end
         end
-        results[:concurrency] = 100
         opts.on('--private-key KEY',
                 "Private ssh key to authenticate with (Optional)") do |key|
           results[:key] = key
@@ -157,16 +154,10 @@ HELP
           results[:task_options] = parse_params(params)
         end
 
-        results[:format] = 'human'
         opts.on('--format FORMAT',
                 "Output format to use: human or json") do |format|
-          if %w[human json].include? format
-            results[:format] = format
-          else
-            raise Bolt::CLIError, "Unsupported format: #{format}"
-          end
+          results[:format] = format
         end
-        results[:insecure] = false
         opts.on('-k', '--insecure',
                 "Whether to connect insecurely ") do |insecure|
           results[:insecure] = insecure
@@ -183,10 +174,6 @@ HELP
                 "Program to execute for privilege escalation. " \
                 "Currently only sudo is supported.") do |program|
           options[:sudo] = program || 'sudo'
-          if options[:sudo] != 'sudo'
-            raise Bolt::CLIError,
-                  "Only 'sudo' is supported for privilege escalation."
-          end
         end
         opts.on('--sudo-password [PASSWORD]',
                 'Password for privilege escalation') do |password|
@@ -198,6 +185,10 @@ HELP
             results[:sudo_password] = password
           end
         end
+        opts.on('--configfile CONFIG_PATH',
+                'Specify where to load the config file from') do |path|
+          results[:configfile] = path
+        end
         opts.on_tail('--[no-]tty',
                      "Request a pseudo TTY on nodes that support it") do |tty|
           results[:tty] = tty
@@ -227,6 +218,7 @@ HELP
         parser.permute(@argv)
       end
 
+      # Shortcut to handle help before other errors may be generated
       options[:mode] = remaining.shift
 
       if options[:mode] == 'help'
@@ -234,24 +226,20 @@ HELP
         options[:mode] = remaining.shift
       end
 
-      options[:action] = remaining.shift
-      options[:object] = remaining.shift
-
-      if options[:debug]
-        @config[:log_level] = Logger::DEBUG
-      elsif options[:verbose]
-        @config[:log_level] = Logger::INFO
-      end
-
-      @config[:key] = options[:key]
-
-      @config[:format] = options[:format]
-
       if options[:help]
         print_help(options[:mode])
         raise Bolt::CLIExit
       end
 
+      @config.load_file(options[:configfile])
+      @config.update_from_cli(options)
+      @config.validate
+
+      # This section handles parsing non-flag options which are
+      # mode specific rather then part of the config
+      options[:action] = remaining.shift
+      options[:object] = remaining.shift
+
       task_options, remaining = remaining.partition { |s| s =~ /.+=/ }
       if options[:task_options]
         unless task_options.empty?
@@ -356,7 +344,7 @@ HELP
         raise Bolt::CLIError, "Option '--nodes' must be specified"
       end
 
-      if %w[task plan].include?(options[:mode]) && options[:modulepath].nil?
+      if %w[task plan].include?(options[:mode]) && @config[:modulepath].nil?
         raise Bolt::CLIError,
               "Option '--modulepath' must be specified when running" \
               " a task or plan"
@@ -372,11 +360,6 @@ HELP
     end
 
     def execute(options)
-      %i[concurrency user password tty insecure transport
-         sudo sudo_password run_as].each do |key|
-        config[key] = options[key]
-      end
-
       if options[:mode] == 'plan' || options[:mode] == 'task'
         begin
           require_relative '../../vendored/require_vendored'
@@ -420,7 +403,7 @@ HELP
             when 'task'
               task_name = options[:object]
 
-              path, metadata = load_task_data(task_name, options[:modulepath])
+              path, metadata = load_task_data(task_name, @config[:modulepath])
               input_method = metadata['input_method']
 
               input_method ||= 'both'
@@ -455,7 +438,7 @@ HELP
       result = Puppet.override(bolt_executor: executor) do
         run_plan(options[:object],
                  options[:task_options],
-                 options[:modulepath])
+                 @config[:modulepath])
       end
       outputter.print_plan(result)
     rescue Puppet::Error
@@ -527,7 +510,7 @@ HELP
           cli << "--#{setting}" << dir
         end
         Puppet.initialize_settings(cli)
-        Puppet::Pal.in_tmp_environment('bolt', modulepath: [BOLTLIB_PATH] + modulepath) do |pal|
+        Puppet::Pal.in_tmp_environment('bolt', modulepath: [BOLTLIB_PATH] + modulepath, facts: {}) do |pal|
           pal.with_script_compiler do |compiler|
             compiler.call_function('run_plan', plan, args)
           end

data/lib/bolt/config.rb

@@ -1,37 +1,140 @@
 require 'logger'
+require 'yaml'
 
 module Bolt
   Config = Struct.new(
     :concurrency,
     :format,
-    :insecure,
     :log_destination,
     :log_level,
-    :password,
-    :run_as,
-    :sudo,
-    :sudo_password,
+    :modulepath,
     :transport,
-    :key,
-    :tty,
-    :user
+    :transports
   ) do
+
     DEFAULTS = {
       concurrency: 100,
-      tty: false,
-      insecure: false,
       transport: 'ssh',
+      format: 'human',
       log_level: Logger::WARN,
       log_destination: STDERR
     }.freeze
 
+    TRANSPORT_OPTIONS = %i[insecure password run_as sudo sudo_password key tty user].freeze
+
+    TRANSPORT_DEFAULTS = {
+      insecure: false,
+      tty: false
+    }.freeze
+
+    TRANSPORTS = %i[ssh winrm pcp].freeze
+
     def initialize(**kwargs)
       super()
       DEFAULTS.merge(kwargs).each { |k, v| self[k] = v }
+
+      self[:transports] ||= {}
+      TRANSPORTS.each do |transport|
+        unless self[:transports][transport]
+          self[:transports][transport] = {}
+        end
+        TRANSPORT_DEFAULTS.each do |k, v|
+          unless self[:transports][transport][k]
+            self[:transports][transport][k] = v
+          end
+        end
+      end
+    end
+
+    def default_path
+      path = ['.puppetlabs', 'bolt.yml']
+      root_path = '~'
+      File.join(root_path, *path)
+    end
+
+    def read_config_file(path)
+      path_passed = path
+      path ||= default_path
+      path = File.expand_path(path)
+      # safe_load doesn't work with psych in ruby 2.0
+      # The user controls the configfile so this isn't a problem
+      # rubocop:disable YAMLLoad
+      File.open(path, "r:UTF-8") { |f| YAML.load(f.read) }
+    rescue Errno::ENOENT
+      if path_passed
+        raise Bolt::CLIError, "Could not read config file: #{path}"
+      end
+    # In older releases of psych SyntaxError is not a subclass of Exception
+    rescue Psych::SyntaxError
+      raise Bolt::CLIError, "Could not parse config file: #{path}"
+    rescue Psych::Exception
+      raise Bolt::CLIError, "Could not parse config file: #{path}"
+    rescue IOError, SystemCallError
+      raise Bolt::CLIError, "Could not read config file: #{path}"
     end
 
-    def escalate?
-      sudo || run_as
+    def update_from_file(data)
+      if data['modulepath']
+        self[:modulepath] = data['modulepath'].split(File::PATH_SEPARATOR)
+      end
+
+      if data['concurrency']
+        self[:concurrency] = data['concurrency']
+      end
+
+      if data['format']
+        self[:format] = data['format'] if data['format']
+      end
+
+      if data['ssh']
+        if data['ssh']['private-key']
+          self[:transports][:ssh][:key] = data['ssh']['private-key']
+        end
+        if data['ssh']['insecure']
+          self[:transports][:ssh][:insecure] = data['ssh']['insecure']
+        end
+      end
+      # if data['pcp']
+      # end
+      # if data['winrm']
+      # end
+    end
+
+    def load_file(path)
+      data = read_config_file(path)
+      update_from_file(data) if data
+    end
+
+    def update_from_cli(options)
+      %i[concurrency transport format modulepath].each do |key|
+        self[key] = options[key] if options[key]
+      end
+
+      if options[:debug]
+        self[:log_level] = Logger::DEBUG
+      elsif options[:verbose]
+        self[:log_level] = Logger::INFO
+      end
+
+      TRANSPORT_OPTIONS.each do |key|
+        # TODO: We should eventually make these transport specific
+        TRANSPORTS.each do |transport|
+          self[:transports][transport][key] = options[key] if options[key]
+        end
+      end
+    end
+
+    def validate
+      TRANSPORTS.each do |transport|
+        tconf = self[:transports][transport]
+        if tconf[:sudo] && tconf[:sudo] != 'sudo'
+          raise Bolt::CLIError, "Only 'sudo' is supported for privilege escalation."
+        end
+      end
+
+      unless %w[human json].include? self[:format]
+        raise Bolt::CLIError, "Unsupported format: '#{self[:format]}'"
+      end
     end
   end
 end

data/lib/bolt/node.rb

@@ -35,15 +35,17 @@ module Bolt
                    config: Bolt::Config.new)
       @host = host
       @port = port
-      @user = user || config[:user]
-      @password = password || config[:password]
-      @key = config[:key]
-      @tty = config[:tty]
-      @insecure = config[:insecure]
       @uri = uri
-      @sudo = config[:sudo]
-      @sudo_password = config[:sudo_password]
-      @run_as = config[:run_as]
+
+      transport_conf = config[:transports][protocol.to_sym]
+      @user = user || transport_conf[:user]
+      @password = password || transport_conf[:password]
+      @key = transport_conf[:key]
+      @tty = transport_conf[:tty]
+      @insecure = transport_conf[:insecure]
+      @sudo = transport_conf[:sudo]
+      @sudo_password = transport_conf[:sudo_password]
+      @run_as = transport_conf[:run_as]
 
       @logger = init_logger(config[:log_destination], config[:log_level])
       @transport_logger = init_logger(config[:log_destination], Logger::WARN)
@@ -73,7 +75,7 @@ module Bolt
     end
 
     def run_script(script, arguments)
-      @logger.info { "Running script: #{command}" }
+      @logger.info { "Running script: #{script}" }
       _run_script(script, arguments)
     end
 

data/lib/bolt/node/orch.rb

@@ -11,6 +11,10 @@ module Bolt
 
     def disconnect; end
 
+    def protocol
+      'pcp'
+    end
+
     def make_client
       OrchestratorClient.new({}, true)
     end

data/lib/bolt/node/ssh.rb

@@ -14,6 +14,10 @@ module Bolt
       }
     end
 
+    def protocol
+      'ssh'
+    end
+
     def connect
       options = {
         logger: @transport_logger,

data/lib/bolt/node/winrm.rb

@@ -1,9 +1,14 @@
 require 'winrm'
 require 'winrm-fs'
 require 'bolt/result'
+require 'base64'
 
 module Bolt
   class WinRM < Node
+    def protocol
+      'winrm'
+    end
+
     def initialize(host, port, user, password, shell: :powershell, **kwargs)
       super(host, port, user, password, **kwargs)
 
@@ -48,6 +53,9 @@ $ENV:RUBYLIB = "${ENV:ProgramFiles}\\Puppet Labs\\Puppet\\puppet\\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()]
@@ -140,6 +148,183 @@ function Invoke-Interpreter
     }
   }
 }
+
+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")
@@ -333,15 +518,25 @@ catch
       end
 
       with_remote_file(task) do |remote_path|
-        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
-          output = execute("try { &""#{remote_path}"" } catch { exit 1 }")
-        else
-          path, args = *process_from_extension(remote_path)
-          output = execute_process(path, args, stdin)
-        end
+        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::TaskResult.from_output(output)
       end
     # TODO: we should rely on the executor for this

data/lib/bolt/node_uri.rb

@@ -1,4 +1,4 @@
-require 'addressable'
+require 'addressable/uri'
 
 module Bolt
   class NodeURI

data/lib/bolt/version.rb

@@ -1,3 +1,3 @@
 module Bolt
-  VERSION = '0.9.0'.freeze
+  VERSION = '0.10.0'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bolt
 version: !ruby/object:Gem::Version
-  version: 0.9.0
+  version: 0.10.0
 platform: ruby
 authors:
 - Puppet
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-11-29 00:00:00.000000000 Z
+date: 2017-12-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: addressable