openbolt 5.0.0.rc1

data/lib/bolt/transport/orch.rb

@@ -0,0 +1,271 @@
+# frozen_string_literal: true
+
+require 'base64'
+require 'find'
+require 'json'
+require 'pathname'
+require_relative '../../bolt/transport/base'
+require_relative 'orch/connection'
+
+module Bolt
+  module Transport
+    class Orch < Base
+      BOLT_COMMAND_TASK = Struct.new(:name).new('bolt_shim::command').freeze
+      BOLT_SCRIPT_TASK = Struct.new(:name).new('bolt_shim::script').freeze
+      BOLT_UPLOAD_TASK = Struct.new(:name).new('bolt_shim::upload').freeze
+
+      attr_writer :plan_context
+
+      def provided_features
+        ['puppet-agent']
+      end
+
+      def initialize(*args)
+        # lazy-load expensive gem code
+        require 'orchestrator_client'
+
+        @connections = {}
+        super
+      end
+
+      def finish_plan(result)
+        if result.is_a? Bolt::PlanResult
+          @connections.each_value do |conn|
+            conn.finish_plan(result)
+          rescue StandardError => e
+            @logger.trace("Failed to finish plan on #{conn.key}: #{e.message}")
+          end
+        end
+      end
+
+      # It's safe to create connections here for now because the
+      # batches/threads are per connection.
+      def get_connection(conn_opts)
+        key = Connection.get_key(conn_opts)
+        unless (conn = @connections[key])
+          conn = @connections[key] = Connection.new(conn_opts, @plan_context, logger)
+        end
+        conn
+      end
+
+      def process_run_results(targets, results, task_name, position = [])
+        targets_by_name = Hash[targets.map { |t| t.host || t.name }.zip(targets)]
+        results.map do |node_result|
+          target = targets_by_name[node_result['name']]
+          state = node_result['state']
+          result = node_result['result']
+
+          # If it's finished or already has a proper error simply pass it to the
+          # the result otherwise make sure an error is generated
+          if state == 'finished' || (result && result['_error'])
+            if result['_error']
+              unless result['_error'].is_a?(Hash)
+                result['_error'] = { 'kind' => 'puppetlabs.tasks/task-error',
+                                     'issue_code' => 'TASK_ERROR',
+                                     'msg' => result['_error'],
+                                     'details' => {} }
+              end
+
+              result['_error']['details'] ||= {}
+              unless result['_error']['details'].is_a?(Hash)
+                deets = result['_error']['details']
+                result['_error']['details'] = { 'msg' => deets }
+              end
+              file_line = %w[file line].zip(position).to_h.compact
+              result['_error']['details'].merge!(file_line) unless result['_error']['details']['file']
+            end
+
+            Bolt::Result.new(target, value: result, action: 'task', object: task_name)
+          elsif state == 'skipped'
+            details = %w[file line].zip(position).to_h.compact
+            Bolt::Result.new(
+              target,
+              value: { '_error' => {
+                'kind' => 'puppetlabs.tasks/skipped-node',
+                'msg' => "Target #{target.safe_name} was skipped",
+                'details' => details
+              } },
+              action: 'task', object: task_name
+            )
+          else
+            # Make a generic error with a unkown exit_code
+            Bolt::Result.for_task(target, result.to_json, '', 'unknown', task_name, position)
+          end
+        end
+      end
+
+      def batch_command(targets, command, options = {}, position = [], &callback)
+        if options[:env_vars] && !options[:env_vars].empty?
+          raise NotImplementedError, "pcp transport does not support setting environment variables"
+        end
+
+        params = {
+          'command' => command
+        }
+        results = run_task_job(targets,
+                               BOLT_COMMAND_TASK,
+                               params,
+                               options,
+                               position,
+                               &callback)
+        callback ||= proc {}
+        results.map! { |result| unwrap_bolt_result(result.target, result, 'command', command) }
+        results.each do |result|
+          callback.call(type: :node_result, result: result)
+        end
+      end
+
+      def batch_script(targets, script, arguments, options = {}, position = [], &callback)
+        if options[:env_vars] && !options[:env_vars].empty?
+          raise NotImplementedError, "pcp transport does not support setting environment variables"
+        end
+
+        content = File.open(script, &:read)
+        content = Base64.encode64(content)
+        params = {
+          'content' => content,
+          'arguments' => arguments,
+          'name' => Pathname(script).basename.to_s
+        }
+        callback ||= proc {}
+        results = run_task_job(targets, BOLT_SCRIPT_TASK, params, options, position, &callback)
+        results.map! { |result| unwrap_bolt_result(result.target, result, 'script', script) }
+        results.each do |result|
+          callback.call(type: :node_result, result: result)
+        end
+      end
+
+      def pack(directory)
+        # lazy-load expensive gem code
+        require 'minitar'
+        require 'zlib'
+
+        start_time = Time.now
+        io = StringIO.new
+        output = Minitar::Output.new(Zlib::GzipWriter.new(io))
+        Find.find(directory) do |file|
+          next unless File.file?(file)
+
+          tar_path = Pathname.new(file).relative_path_from(Pathname.new(directory))
+          @logger.trace("Packing #{file} to #{tar_path}")
+          stat = File.stat(file)
+          content = File.binread(file)
+          output.tar.add_file_simple(
+            tar_path.to_s,
+            data: content,
+            size: content.size,
+            mode: stat.mode & 0o777,
+            mtime: stat.mtime
+          )
+        end
+
+        duration = Time.now - start_time
+        @logger.trace("Packed upload in #{duration * 1000} ms")
+
+        output.close
+        io.string
+      ensure
+        # Closes both tar and sgz.
+        output&.close
+      end
+
+      def batch_upload(targets, source, destination, options = {}, position = [], &callback)
+        stat = File.stat(source)
+        content = if stat.directory?
+                    pack(source)
+                  else
+                    File.open(source, &:read)
+                  end
+        content = Base64.encode64(content)
+        mode = File.stat(source).mode
+        params = {
+          'path' => destination,
+          'content' => content,
+          'mode' => mode,
+          'directory' => stat.directory?
+        }
+        callback ||= proc {}
+        results = run_task_job(targets, BOLT_UPLOAD_TASK, params, options, position, &callback)
+        results.map! do |result|
+          if result.error_hash
+            result
+          else
+            Bolt::Result.for_upload(result.target, source, destination)
+          end
+        end
+        results.each do |result|
+          callback&.call(type: :node_result, result: result)
+        end
+      end
+
+      def batch_download(targets, *_args)
+        error = {
+          'kind'    => 'bolt/not-supported-error',
+          'msg'     => 'pcp transport does not support downloading files',
+          'details' => {}
+        }
+
+        targets.map do |target|
+          Bolt::Result.new(target, error: error, action: 'download')
+        end
+      end
+
+      def batches(targets)
+        targets.group_by { |target| Connection.get_key(target.options) }.values
+      end
+
+      def run_task_job(targets, task, arguments, options, position)
+        targets.each do |target|
+          yield(type: :node_start, target: target) if block_given?
+        end
+
+        begin
+          # unpack any Sensitive data
+          arguments = unwrap_sensitive_args(arguments)
+          results = get_connection(targets.first.options).run_task(targets, task, arguments, options)
+
+          process_run_results(targets, results, task.name, position)
+        rescue OrchestratorClient::ApiError => e
+          targets.map do |target|
+            Bolt::Result.new(target, error: e.data)
+          end
+        rescue StandardError => e
+          targets.map do |target|
+            Bolt::Result.from_exception(target, e, action: 'task')
+          end
+        end
+      end
+
+      def batch_task(targets, task, arguments, options = {}, position = [], &callback)
+        callback ||= proc {}
+        results = run_task_job(targets, task, arguments, options, position, &callback)
+        results.each do |result|
+          callback.call(type: :node_result, result: result)
+        end
+      end
+
+      def batch_task_with(_targets, _task, _target_mapping, _options = {}, _position = [])
+        raise NotImplementedError, "pcp transport does not support run_task_with()"
+      end
+
+      def batch_connected?(targets)
+        resp = get_connection(targets.first.options).query_inventory(targets)
+        resp['items'].all? { |node| node['connected'] }
+      end
+
+      # run_task generates a result that makes sense for a generic task which
+      # needs to be unwrapped to extract stdout/stderr/exitcode.
+      #
+      def unwrap_bolt_result(target, result, action, obj)
+        if result.error_hash
+          # something went wrong return the failure
+          return result
+        end
+
+        # If we get here, there's no error so we don't need the file or line
+        # number
+        Bolt::Result.for_command(target, result.value, action, obj, [])
+      end
+    end
+  end
+end

data/lib/bolt/transport/podman/connection.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+require 'logging'
+require_relative '../../../bolt/node/errors'
+
+module Bolt
+  module Transport
+    class Podman < Docker
+      class Connection < Connection
+        attr_reader :user, :target
+
+        def initialize(target)
+          raise Bolt::ValidationError, "Target #{target.safe_name} does not have a host" unless target.host
+          @target = target
+          @user = ENV['USER'] || Etc.getlogin
+          @logger = Bolt::Logger.logger(target.safe_name)
+          @container_info = {}
+          @logger.trace("Initializing podman connection to #{target.safe_name}")
+        end
+
+        def run_cmd(cmd, env_vars)
+          Bolt::Util.exec_podman(cmd, env_vars)
+        end
+
+        def shell
+          @shell ||= if Bolt::Util.windows?
+                       Bolt::Shell::Powershell.new(target, self)
+                     else
+                       Bolt::Shell::Bash.new(target, self)
+                     end
+        end
+
+        def reset_cwd?
+          true
+        end
+
+        def connect
+          # We don't actually have a connection, but we do need to
+          # check that the container exists and is running.
+          ps = execute_local_json_command('ps')
+          container = Array(ps).find { |item|
+            item["ID"].to_s.eql?(@target.host) ||
+              item["Id"].to_s.start_with?(@target.host) ||
+              Array(item["Names"]).include?(@target.host)
+          }
+          raise "Could not find a container with name or ID matching '#{@target.host}'" if container.nil?
+          # Now find the indepth container information
+          id = container["ID"] || container["Id"]
+          output = execute_local_json_command('inspect', [id])
+          # Store the container information for later
+          @container_info = output.first
+          @logger.trace { "Opened session" }
+          true
+        rescue StandardError => e
+          raise Bolt::Node::ConnectError.new(
+            "Failed to connect to #{target.safe_name}: #{e.message}",
+            'CONNECT_ERROR'
+          )
+        end
+
+        # Executes a command inside the target container. This is called from the shell class.
+        #
+        # @param command [string] The command to run
+        def execute(command)
+          args = []
+          args += %w[--interactive]
+          args += %w[--tty] if target.options['tty']
+          args += @env_vars if @env_vars
+
+          if target.options['shell-command'] && !target.options['shell-command'].empty?
+            # escape any double quotes in command
+            command = command.gsub('"', '\"')
+            command = "#{target.options['shell-command']} \"#{command}\""
+          end
+
+          podman_command = %w[podman exec] + args + [container_id] + Shellwords.split(command)
+          @logger.trace { "Executing: #{podman_command.join(' ')}" }
+
+          Open3.popen3(*podman_command)
+        rescue StandardError
+          @logger.trace { "Command aborted" }
+          raise
+        end
+
+        # Converts the JSON encoded STDOUT string from the podman cli into ruby objects
+        #
+        # @param stdout [String] The string to convert
+        # @return [Object] Ruby object representation of the JSON string
+        private def extract_json(stdout)
+          # Podman renders the output in pretty JSON, which results in a newline
+          # appearing in the output before the closing bracket.
+          # should we only get a single line with no newline at all, we also
+          # assume it is a single minified JSON object
+          stdout.strip!
+          newline = stdout.index("\n") || -1
+          bracket = stdout.index('}') || -1
+          JSON.parse(stdout) if bracket > newline
+        end
+      end
+    end
+  end
+end

data/lib/bolt/transport/podman.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'shellwords'
+require_relative '../../bolt/transport/base'
+
+module Bolt
+  module Transport
+    class Podman < Docker
+      def with_connection(target)
+        conn = Connection.new(target)
+        conn.connect
+        yield conn
+      end
+    end
+  end
+end
+
+require_relative 'podman/connection'

data/lib/bolt/transport/remote.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require_relative '../../bolt/task'
+require_relative '../../bolt/transport/base'
+
+module Bolt
+  module Transport
+    class Remote < Base
+      # TODO: this should have access to inventory so target doesn't have to
+      def initialize(executor)
+        super()
+
+        @executor = executor
+      end
+
+      def get_proxy(target)
+        inventory = target.inventory
+        raise "Target was created without inventory? Not get_targets?" unless inventory
+        proxy = inventory.get_targets(target.options['run-on'] || 'localhost').first
+
+        if proxy.transport == 'remote'
+          msg = "#{proxy.name} is not a valid run-on target for #{target.name} since is also remote."
+          raise Bolt::Error.new(msg, 'bolt/invalid-remote-target')
+        end
+        proxy
+      end
+
+      # Cannot batch because arugments differ
+      def run_task(target, task, arguments, options = {}, position = [])
+        proxy_target = get_proxy(target)
+        transport = @executor.transport(proxy_target.transport)
+        arguments = arguments.merge('_target' => target.to_h.compact)
+
+        remote_task = task.remote_instance
+
+        result = transport.run_task(proxy_target, remote_task, arguments, options, position)
+        Bolt::Result.new(target, value: result.value, action: 'task', object: task.name)
+      end
+    end
+  end
+end

data/lib/bolt/transport/simple.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require 'logging'
+require_relative '../../bolt/result'
+require_relative '../../bolt/shell'
+require_relative '../../bolt/transport/base'
+
+module Bolt
+  module Transport
+    # A simple transport has a single connection per target and delegates its
+    # operation to a target-specific shell.
+    class Simple < Base
+      def with_connection(_target)
+        raise NotImplementedError, "with_connection() must be implemented by the transport class"
+      end
+
+      def connected?(target)
+        with_connection(target) { true }
+      rescue Bolt::Node::ConnectError
+        false
+      end
+
+      def run_command(target, command, options = {}, position = [])
+        with_connection(target) do |conn|
+          conn.shell.run_command(command, options, position)
+        end
+      end
+
+      def upload(target, source, destination, options = {})
+        with_connection(target) do |conn|
+          conn.shell.upload(source, destination, options)
+        end
+      end
+
+      def download(target, source, destination, options = {})
+        with_connection(target) do |conn|
+          conn.shell.download(source, destination, options)
+        end
+      end
+
+      def run_script(target, script, arguments, options = {}, position = [])
+        with_connection(target) do |conn|
+          conn.shell.run_script(script, arguments, options, position)
+        end
+      end
+
+      def run_task(target, task, arguments, options = {}, position = [])
+        with_connection(target) do |conn|
+          conn.shell.run_task(task, arguments, options, position)
+        end
+      end
+    end
+  end
+end