bolt 0.8.0 → 0.9.0

data/lib/bolt/node/winrm.rb

@@ -38,7 +38,7 @@ module Bolt
     end
 
     def shell_init
-      return Bolt::Node::Success.new if @shell_initialized
+      return nil if @shell_initialized
       result = execute(<<-PS)
 
 $ENV:PATH += ";${ENV:ProgramFiles}\\Puppet Labs\\Puppet\\bin\\;" +
@@ -141,13 +141,14 @@ function Invoke-Interpreter
   }
 }
 PS
+      if result.exit_code != 0
+        raise BaseError.new("Could not initialize shell: #{result.stderr.string}", "SHELL_INIT_ERROR")
+      end
       @shell_initialized = true
-
-      result
     end
 
     def execute(command, _ = {})
-      result_output = Bolt::Node::ResultOutput.new
+      result_output = Bolt::Node::Output.new
 
       @logger.debug { "Executing command: #{command}" }
 
@@ -157,13 +158,13 @@ PS
         result_output.stderr << stderr
         @logger.debug { "stderr: #{stderr}" }
       end
+      result_output.exit_code = output.exitcode
       if output.exitcode.zero?
         @logger.debug { "Command returned successfully" }
-        Bolt::Node::Success.new(result_output.stdout.string, result_output)
       else
         @logger.info { "Command failed with exit code #{output.exitcode}" }
-        Bolt::Node::Failure.new(output.exitcode, result_output)
       end
+      result_output
     end
 
     # 10 minutes in seconds
@@ -199,6 +200,10 @@ PS
       -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'
@@ -220,12 +225,18 @@ PS
     end
 
     def _upload(source, destination)
+      write_remote_file(source, destination)
+      Bolt::Result.new
+    # TODO: we should rely on the executor for this
+    rescue StandardError => ex
+      Bolt::Result.from_exception(ex)
+    end
+
+    def write_remote_file(source, destination)
       @logger.debug { "Uploading #{source} to #{destination}" }
       fs = ::WinRM::FS::FileManager.new(@connection)
+      # TODO: raise FileError here if this fails
       fs.upload(source, destination)
-      Bolt::Node::Success.new
-    rescue StandardError => ex
-      Bolt::Node::ExceptionFailure.new(ex)
     end
 
     def make_tempdir
@@ -236,46 +247,71 @@ $path = Join-Path $parent $name
 New-Item -ItemType Directory -Path $path | Out-Null
 $path
 PS
-      result.then { |stdout| Bolt::Node::Success.new(stdout.chomp) }
+      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)
-      dest = ''
-      dir = ''
-      result = nil
-
-      make_tempdir.then do |value|
-        dir = value
-        ext = File.extname(file)
-        ext = VALID_EXTENSIONS.include?(ext) ? ext : '.ps1'
-        dest = "#{dir}\\#{File.basename(file, '.*')}#{ext}"
-        Bolt::Node::Success.new
-      end.then do
-        _upload(file, dest)
-      end.then do
+      ext = File.extname(file)
+      ext = VALID_EXTENSIONS.include?(ext) ? ext : '.ps1'
+      file_base = File.basename(file, '.*')
+      dir = make_tempdir
+      dest = "#{dir}\\#{file_base}#{ext}"
+      begin
+        write_remote_file(file, dest)
         shell_init
-      end.then do
-        result = yield dest
-      end.then do
+        yield dest
+      ensure
         execute(<<-PS)
 Remove-Item -Force "#{dest}"
 Remove-Item -Force "#{dir}"
 PS
-        result
       end
     end
 
     def _run_command(command)
-      execute(command)
+      output = execute(command)
+      Bolt::CommandResult.from_output(output)
+    # TODO: we should rely on the executor for this
+    rescue StandardError => e
+      Bolt::Result.from_exception(e)
     end
 
     def _run_script(script, arguments)
       @logger.info { "Running script '#{script}'" }
       with_remote_file(script) do |remote_path|
-        path, args = *process_from_extension(remote_path)
-        args += escape_arguments(arguments)
-        execute_process(path, args)
+        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::CommandResult.from_output(output)
       end
+    # TODO: we should rely on the executor for this
+    rescue StandardError => e
+      Bolt::Result.from_exception(e)
     end
 
     def _run_task(task, input_method, arguments)
@@ -287,20 +323,30 @@ PS
       end
 
       if ENVIRONMENT_METHODS.include?(input_method)
-        arguments.reduce(Bolt::Node::Success.new) do |result, (arg, val)|
-          result.then do
-            cmd = "[Environment]::SetEnvironmentVariable('PT_#{arg}', '#{val}')"
-            execute(cmd)
+        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
-      else
-        Bolt::Node::Success.new
-      end.then do
-        with_remote_file(task) do |remote_path|
+      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)
-          execute_process(path, args, stdin)
+          output = execute_process(path, args, stdin)
         end
+        Bolt::TaskResult.from_output(output)
       end
+    # TODO: we should rely on the executor for this
+    rescue StandardError => e
+      Bolt::Result.from_exception(e)
     end
 
     def escape_arguments(arguments)

data/lib/bolt/outputter/human.rb

@@ -1,22 +1,79 @@
 module Bolt
   class Outputter
     class Human < Bolt::Outputter
+      COLORS = { red: "31",
+                 green: "32",
+                 yellow: "33" }.freeze
+
       def print_head; end
 
+      def colorize(color, string)
+        if @stream.isatty
+          "\033[#{COLORS[color]}m#{string}\033[0m"
+        else
+          string
+        end
+      end
+
+      def indent(indent, string)
+        indent = ' ' * indent
+        string.gsub(/^/, indent.to_s)
+      end
+
+      def remove_trail(string)
+        string.sub(/\s\z/, '')
+      end
+
+      def print_event(node, event)
+        case event[:type]
+        when :node_start
+          print_start(node)
+        when :node_result
+          print_result(node, event[:result])
+        end
+      end
+
+      def print_start(node)
+        @stream.puts(colorize(:green, "Started on #{node.host}..."))
+      end
+
       def print_result(node, result)
-        color = result.success? ? "\033[32m" : "\033[31m"
-        @stream.print color if @stream.isatty
-        @stream.puts "#{node.host}:"
-        @stream.print "\033[0m" if @stream.isatty
-        @stream.puts
-        @stream.puts result.message
-        @stream.puts
+        if result.success?
+          @stream.puts(colorize(:green, "Finished on #{node.host}:"))
+        else
+          @stream.puts(colorize(:red, "Failed on #{node.host}:"))
+        end
+
+        if result.error
+          if result.error['msg']
+            @stream.puts(colorize(:red, remove_trail(indent(2, result.error['msg']))))
+          else
+            @stream.puts(colorize(:red, remove_trail(indent(2, result.error))))
+          end
+        end
+
+        if result.message
+          @stream.puts(remove_trail(indent(2, result.message)))
+        end
+
+        if result.instance_of? Bolt::TaskResult
+          @stream.puts(indent(2, ::JSON.pretty_generate(result.value)))
+        elsif result.instance_of? Bolt::CommandResult
+          unless result.stdout.strip.empty?
+            @stream.puts(indent(2, "STDOUT:"))
+            @stream.puts(indent(4, result.stdout))
+          end
+          unless result.stderr.strip.empty?
+            @stream.puts(indent(2, "STDERR:"))
+            @stream.puts(indent(4, result.stderr))
+          end
+        end
       end
 
       def print_summary(results, elapsed_time)
         @stream.puts format("Ran on %d node%s in %.2f seconds",
                             results.size,
-                            results.size > 1 ? 's' : '',
+                            results.size == 1 ? '' : 's',
                             elapsed_time)
       end
 

data/lib/bolt/outputter/json.rb

@@ -15,10 +15,17 @@ module Bolt
         @object_open = true
       end
 
+      def print_event(node, event)
+        case event[:type]
+        when :node_result
+          print_result(node, event[:result])
+        end
+      end
+
       def print_result(node, result)
         item = {
           name: node.uri,
-          status: result.is_a?(Bolt::ErrorResult) ? 'failure' : 'success',
+          status: result.success? ? 'success' : 'failure',
           result: result.to_result
         }
 

data/lib/bolt/result.rb

@@ -1,72 +1,74 @@
 require 'json'
+require 'bolt/error'
 
 module Bolt
   class Result
-    attr_reader :message
+    attr_reader :message, :error
 
-    def initialize(message)
-      @message = message
+    def self.from_exception(exception)
+      @exception = exception
+      if @exception.is_a?(Bolt::Error)
+        error = @exception.to_h
+      else
+        error = {
+          'kind' => 'puppetlabs.tasks/exception-error',
+          'issue_code' => 'EXCEPTION',
+          'msg' => exception.message,
+          'details' => { 'class' => exception.class.to_s }
+        }
+        error['details']['stack_trace'] = exception.backtrace.join('\n') if exception.backtrace
+      end
+      Result.new(error)
     end
 
-    def value
-      nil
+    def initialize(error = nil, message = nil)
+      @error = error
+      @message = message
     end
 
-    def error
+    def value
       nil
     end
 
     def to_h
-      { 'value' => value }
-    end
-
-    def to_result
-      value
-    end
-
-    def success?
-      true
-    end
-  end
-
-  class ErrorResult < Result
-    def initialize(message, issue_code, kind)
-      super(message)
-      @issue_code = issue_code
-      @kind = kind
-    end
-
-    def to_h
-      {
-        'error' => {
-          'issue_code' => @issue_code,
-          'kind' => @kind,
-          'msg' => @message
-        }
-      }
+      h = {}
+      if value
+        h['value'] = value
+        h['value']['_output'] = message if message
+      elsif message
+        h['value'] = { '_output' => message }
+      end
+      h['error'] = error if error
+      h
     end
 
     def to_result
-      {
-        '_error' => {
-          'issue_code' => @issue_code,
-          'kind' => @kind,
-          'msg' => @message
-        }
-      }
+      # TODO: This should be to_h but we need to update the plan functions to
+      # use this hash instead
+      special_keys = {}
+      special_keys['_error'] = error if error
+      special_keys['_output'] = message if message
+      val = value || {}
+      val.merge(special_keys)
     end
 
     def success?
-      false
+      error.nil?
     end
   end
 
   class CommandResult < Result
     attr_reader :stdout, :stderr, :exit_code
 
+    def self.from_output(output)
+      new(output.stdout.string,
+          output.stderr.string,
+          output.exit_code)
+    end
+
     def initialize(stdout, stderr, exit_code)
-      @stdout = stdout
-      @stderr = stderr
+      @stdout = stdout || ""
+      @stderr = stderr || ""
       @exit_code = exit_code
     end
 
@@ -78,111 +80,59 @@ module Bolt
       }
     end
 
-    def to_result
-      value
-    end
-
     def success?
-      @exit_code.zero?
+      @exit_code == 0
     end
 
-    def message
-      [stdout, stderr].join("\n")
+    def error
+      unless success?
+        {
+          'kind' => 'puppetlabs.tasks/command-error',
+          'issue_code' => 'COMMAND_ERROR',
+          'msg' => "The command failed with exit code #{@exit_code}",
+          'details' => { 'exit_code' => @exit_code }
+        }
+      end
     end
   end
 
   class TaskResult < CommandResult
-    attr_reader :error
+    attr_reader :value
 
     def initialize(stdout, stderr, exit_code)
       super(stdout, stderr, exit_code)
-      @object = output_to_json_hash(stdout)
-      @error = @object.delete('_error') if @object
-    end
-
-    def value
-      @object || @stdout
-    end
-
-    def to_result
-      result = @object
-      result['_error'] = @error if @error
-      result
+      @value = parse_output(stdout)
+      @message = @value.delete('_output')
+      @error = @value.delete('_error')
     end
 
-    def to_h
-      hash = super
-      hash['error'] = error if error
-      hash
+    def error
+      unless success?
+        return @error if @error
+        msg = if !@stdout.empty?
+                "The task failed with exit code #{@exit_code}"
+              else
+                "The task failed with exit code #{@exit_code}:\n#{@stderr}"
+              end
+        { 'kind' => 'puppetlabs.tasks/task-error',
+          'issue_code' => 'TASK_ERROR',
+          'msg' => msg,
+          'details' => { 'exit_code' => @exit_code } }
+      end
     end
 
     private
 
-    def output_to_json_hash(output)
+    def parse_output(output)
       begin
         obj = JSON.parse(output)
         unless obj.is_a? Hash
           obj = nil
         end
       rescue JSON::ParserError
-        nil
+        obj = nil
       end
       obj || { '_output' => output }
     end
   end
-
-  class TaskSuccess < TaskResult
-    def success?
-      true
-    end
-  end
-
-  class TaskFailure < TaskResult
-    def initialize(stdout, stderr, exit_code)
-      super(stdout, stderr, exit_code)
-      @error ||= generate_error
-    end
-
-    def success?
-      false
-    end
-
-    private
-
-    def generate_error
-      {
-        'kind' => 'puppetlabs.tasks/task-error',
-        'issue_code' => 'TASK_ERROR',
-        'msg' => "The task failed with exit code #{@exit_code}",
-        'details' => { 'exit_code' => @exit_code }
-      }
-    end
-  end
-
-  class ExceptionResult < Result
-    def initialize(exception)
-      @exception = exception
-    end
-
-    def error
-      {
-        'kind' => 'puppetlabs.tasks/exception-error',
-        'issue_code' => 'EXCEPTION',
-        'msg' => @exception.message,
-        'details' => { 'stack_trace' => @exception.backtrace.join('\n') }
-      }
-    end
-
-    def to_h
-      { 'error' => error }
-    end
-
-    def message
-      @exception.message
-    end
-
-    def success?
-      false
-    end
-  end
 end