bolt 0.16.0 → 0.16.1

data/lib/bolt/node.rb

@@ -8,8 +8,8 @@ module Bolt
     STDIN_METHODS       = %w[both stdin].freeze
     ENVIRONMENT_METHODS = %w[both environment].freeze
 
-    def self.from_target(target, **kwargs)
-      klass = case target.protocol || kwargs[:config][:transport]
+    def self.from_target(target)
+      klass = case target.protocol
               when 'winrm'
                 Bolt::WinRM
               when 'pcp'
@@ -17,19 +17,19 @@ module Bolt
               else
                 Bolt::SSH
               end
-      klass.new(target, **kwargs)
+      klass.new(target)
     end
 
     def self.initialize_transport(_logger); end
 
     attr_reader :logger, :user, :password, :connect_timeout, :target, :run_as
 
-    def initialize(target, config: Bolt::Config.new)
+    def initialize(target)
       @target = target
 
-      transport_conf = config[:transports][protocol.to_sym]
-      @user = @target.user || transport_conf[:user]
-      @password = @target.password || transport_conf[:password]
+      transport_conf = target.options
+      @user = @target.user
+      @password = @target.password
       @key = transport_conf[:key]
       @cacert = transport_conf[:cacert]
       @tty = transport_conf[:tty]
@@ -38,6 +38,7 @@ module Bolt
       @connect_timeout = transport_conf[:connect_timeout]
       @sudo_password = transport_conf[:sudo_password]
       @run_as = transport_conf[:run_as]
+      @conf_run_as = transport_conf[:run_as]
       @tmpdir = transport_conf[:tmpdir]
       @service_url = transport_conf[:service_url]
       @token_file = transport_conf[:token_file]
@@ -51,8 +52,8 @@ module Bolt
       @target.uri
     end
 
-    def upload(_source, _destination)
-      raise NotImplementedError, 'transports must implement upload(source, destination)'
+    def upload(_source, _destination, _options = nil)
+      raise NotImplementedError, 'transports must implement upload(source, destination, options = nil)'
     end
 
     def run_command(_command, _options = nil)

data/lib/bolt/node/ssh.rb

@@ -7,6 +7,37 @@ 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
@@ -15,9 +46,9 @@ module Bolt
       }
     end
 
-    def initialize(target, **kwargs)
-      super(target, **kwargs)
-      @conf_run_as = @run_as
+    def initialize(target)
+      super(target)
+      @user = @user || Net::SSH::Config.for(target.host)[:user] || Etc.getlogin
     end
 
     def protocol
@@ -133,14 +164,10 @@ module Bolt
 
     def execute(command, sudoable: false, **options)
       result_output = Bolt::Node::Output.new
-      use_sudo = sudoable && @run_as
+      run_as = options[:run_as] || @run_as
+      use_sudo = sudoable && run_as && @user != run_as
       if use_sudo
-        user_clause = if @run_as
-                        "-u #{@run_as}"
-                      else
-                        ''
-                      end
-        command = "sudo -S #{user_clause} -p '#{sudo_prompt}' #{command}"
+        command = "sudo -S -u #{run_as} -p '#{sudo_prompt}' #{command}"
       end
 
       @logger.debug { "Executing: #{command}" }
@@ -191,9 +218,23 @@ module Bolt
       result_output
     end
 
-    def upload(source, destination)
-      write_remote_file(source, destination)
+    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)
@@ -203,7 +244,6 @@ module Bolt
     end
 
     def make_tempdir
-      tmppath = nil
       if @tmpdir
         tmppath = "#{@tmpdir}/#{SecureRandom.uuid}"
         command = "mkdir -m 700 #{tmppath}"
@@ -214,33 +254,31 @@ module Bolt
       if result.exit_code != 0
         raise FileError.new("Could not make tempdir: #{result.stderr.string}", 'TEMPDIR_ERROR')
       end
-      tmppath || result.stdout.string.chomp
+      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
-      begin
-        yield dir
-      ensure
-        output =  execute("rm -rf '#{dir}'")
-        if output.exit_code != 0
-          logger.warn("Failed to clean up tempdir '#{dir}': #{output.stderr.string}")
-        end
-      end
+      yield dir
+    ensure
+      dir.delete if dir
     end
 
-    def with_remote_script(dir, file)
-      remote_path = "#{dir}/#{File.basename(file)}"
+    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)
-      yield remote_path
+      remote_path
     end
 
-    def with_remote_file(file)
-      with_remote_tempdir do |dir|
-        with_remote_script(dir, file) do |remote_path|
-          yield 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
 
@@ -253,35 +291,6 @@ EOF
 SCRIPT
     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 with_task_wrapper(remote_task, dir, stdin)
-      wrapper = make_wrapper_stringio(remote_task, stdin)
-      command = "#{dir}/wrapper.sh"
-      write_remote_file(wrapper, command)
-      make_executable(command)
-      yield command
-    end
-
-    def with_remote_task(task_file, stdin)
-      with_remote_tempdir do |dir|
-        with_remote_script(dir, task_file) do |remote_task|
-          if stdin
-            with_task_wrapper(remote_task, dir, stdin) do |command|
-              yield command
-            end
-          else
-            yield remote_task
-          end
-        end
-      end
-    end
-
     def run_command(command, options = {})
       @run_as = options['_run_as'] || @conf_run_as
       output = execute(command, sudoable: true)
@@ -292,7 +301,9 @@ SCRIPT
 
     def run_script(script, arguments, options = {})
       @run_as = options['_run_as'] || @conf_run_as
-      with_remote_file(script) do |remote_path|
+      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)
@@ -318,16 +329,22 @@ SCRIPT
 
       command = export_args.empty? ? '' : "#{export_args} "
 
-      if @run_as
-        with_remote_task(task, stdin) do |remote_path|
-          command += "'#{remote_path}'"
-          output = execute(command, sudoable: true)
-        end
-      else
-        with_remote_file(task) do |remote_path|
-          command += "'#{remote_path}'"
-          output = execute(command, stdin: stdin)
+      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,

data/lib/bolt/node/winrm.rb

@@ -19,8 +19,8 @@ module Bolt
       @target.port || default_port
     end
 
-    def initialize(target, **kwargs)
-      super(target, **kwargs)
+    def initialize(target)
+      super(target)
       @extensions = DEFAULT_EXTENSIONS.to_set.merge(@extensions || [])
       @logger.debug { "WinRM initialized for #{@extensions.to_a} extensions" }
     end
@@ -461,7 +461,7 @@ PS
       end
     end
 
-    def upload(source, destination)
+    def upload(source, destination, _options = nil)
       write_remote_file(source, destination)
       Bolt::Result.for_upload(@target, source, destination)
     end

data/lib/bolt/outputter/human.rb

@@ -170,7 +170,7 @@ module Bolt
       def fatal_error(e)
         @stream.puts(colorize(:red, e.message))
         if e.is_a? Bolt::RunFailure
-          @stream.puts ::JSON.pretty_generate(e.resultset)
+          @stream.puts ::JSON.pretty_generate(e.result_set)
         end
       end
     end

data/lib/bolt/pal.rb

@@ -47,7 +47,13 @@ module Bolt
       r = Puppet::Pal.in_tmp_environment('bolt', modulepath: [BOLTLIB_PATH] + @config[:modulepath], facts: {}) do |pal|
         pal.with_script_compiler do |compiler|
           begin
-            yield compiler
+            result = yield compiler
+            # TODO: remove after PUP-8441 adds to_json to Errors
+            # This hack won't handle nested errors
+            if result.is_a? Puppet::DataTypes::Error
+              result = result._pcore_init_hash
+            end
+            result
           rescue Puppet::PreformattedError => err
             # Puppet sometimes rescues exceptions notes the location and reraises
             # For now return the original error. Exception cause support was added in Ruby 2.1
@@ -79,12 +85,12 @@ module Bolt
       r
     end
 
-    def with_bolt_executor(executor, &block)
-      Puppet.override(bolt_executor: executor, &block)
+    def with_bolt_executor(executor, inventory, &block)
+      Puppet.override({ bolt_executor: executor, bolt_inventory: inventory }, &block)
     end
 
-    def in_plan_compiler(executor)
-      with_bolt_executor(executor) do
+    def in_plan_compiler(executor, inventory)
+      with_bolt_executor(executor, inventory) do
         with_puppet_settings do |opts|
           in_bolt_compiler(opts) do |compiler|
             yield compiler
@@ -93,8 +99,8 @@ module Bolt
       end
     end
 
-    def in_task_compiler(executor)
-      with_bolt_executor(executor) do
+    def in_task_compiler(executor, inventory)
+      with_bolt_executor(executor, inventory) do
         in_bolt_compiler do |compiler|
           yield compiler
         end
@@ -158,14 +164,14 @@ module Bolt
       }
     end
 
-    def run_task(object, targets, params, executor, &eventblock)
-      in_task_compiler(executor) do |compiler|
+    def run_task(object, targets, params, executor, inventory, &eventblock)
+      in_task_compiler(executor, inventory) do |compiler|
         compiler.call_function('run_task', object, targets, params, &eventblock)
       end
     end
 
-    def run_plan(object, params, executor)
-      in_plan_compiler(executor) do |compiler|
+    def run_plan(object, params, executor = nil, inventory = nil)
+      in_plan_compiler(executor, inventory) do |compiler|
         compiler.call_function('run_plan', object, params)
       end
     end

data/lib/bolt/result.rb

@@ -109,6 +109,14 @@ module Bolt
       eql?(other)
     end
 
+    def to_json(opts = nil)
+      status_hash.to_json(opts)
+    end
+
+    def to_s
+      to_json
+    end
+
     # TODO: remove in favor of ok?
     def success?
       ok?
@@ -130,10 +138,7 @@ module Bolt
     # Is it crazy for this to behave differently outside a compiler?
     def error
       if error_hash
-        Puppet::DataTypes::Error.new(error_hash['msg'],
-                                     error_hash['kind'],
-                                     nil, nil,
-                                     error_hash['details'])
+        Puppet::DataTypes::Error.from_asserted_hash(error_hash)
 
       end
     end

data/lib/bolt/target.rb

@@ -24,6 +24,21 @@ module Bolt
       @options = options || {}
     end
 
+    def update_conf(conf)
+      @protocol = conf[:transport]
+
+      t_conf = conf[:transports][protocol.to_sym]
+      # Override url methods
+      url_keys = %i[user password port]
+      @user = t_conf[:user]
+      @password = t_conf[:password]
+      @port = t_conf[:port]
+
+      @options = t_conf.reject { |k, _| url_keys.include?(k) }.merge(@options)
+
+      self
+    end
+
     def parse(string)
       if string =~ %r{^[^:]+://}
         Addressable::URI.parse(string)
@@ -35,7 +50,7 @@ module Bolt
     private :parse
 
     def eql?(other)
-      self.class.equal?(other.class) && @uri == other.uri && @options == other.options
+      self.class.equal?(other.class) && @uri == other.uri
     end
     alias == eql?
 
@@ -51,30 +66,30 @@ module Bolt
       @uri_obj.hostname
     end
 
-    def port
-      @uri_obj.port
-    end
-
     # name is currently just uri but should be be used instead to identify the
     # Target ouside the transport or uri options.
     def name
       uri
     end
 
+    def port
+      @uri_obj.port || @port
+    end
+
+    def protocol
+      @uri_obj.scheme || @protocol
+    end
+
     def user
       Addressable::URI.unencode_component(
-        @uri_obj.user
+        @uri_obj.user || @user
       )
     end
 
     def password
       Addressable::URI.unencode_component(
-        @uri_obj.password
+        @uri_obj.password || @password
       )
     end
-
-    def protocol
-      @uri_obj.scheme
-    end
   end
 end