bolt 0.0.1 → 0.5.0

data/lib/bolt/executor.rb

@@ -0,0 +1,71 @@
+require 'concurrent'
+require 'bolt/result'
+
+module Bolt
+  class Executor
+    def self.from_uris(uris)
+      new(uris.map { |uri| Bolt::Node.from_uri(uri) })
+    end
+
+    def initialize(nodes, max_threads = 100)
+      @nodes = nodes
+      @poolsize = [nodes.length, max_threads].min
+    end
+
+    def on_each
+      results = Concurrent::Map.new
+
+      pool = Concurrent::FixedThreadPool.new(@poolsize)
+      @nodes.each { |node|
+        pool.post do
+          results[node] =
+            begin
+              node.connect
+              yield node
+            rescue StandardError => ex
+              node.logger.error(ex)
+              Bolt::ExceptionResult.new(ex)
+            ensure
+              node.disconnect
+            end
+        end
+      }
+      pool.shutdown
+      pool.wait_for_termination
+
+      results_to_hash(results)
+    end
+
+    def run_command(command)
+      on_each do |node|
+        node.run_command(command)
+      end
+    end
+
+    def run_script(script)
+      on_each do |node|
+        node.run_script(script)
+      end
+    end
+
+    def run_task(task, input_method, arguments)
+      on_each do |node|
+        node.run_task(task, input_method, arguments)
+      end
+    end
+
+    def file_upload(source, destination)
+      on_each do |node|
+        node.upload(source, destination)
+      end
+    end
+
+    private
+
+    def results_to_hash(results)
+      result_hash = {}
+      results.each_pair { |k, v| result_hash[k] = v }
+      result_hash
+    end
+  end
+end

data/lib/bolt/node.rb

@@ -0,0 +1,79 @@
+require 'logger'
+require 'bolt/node_uri'
+require 'bolt/node/formatter'
+require 'bolt/result'
+
+module Bolt
+  class Node
+    STDIN_METHODS       = %w[both stdin].freeze
+    ENVIRONMENT_METHODS = %w[both environment].freeze
+
+    def self.from_uri(uri_string, default_user = nil, default_password = nil,
+                      **kwargs)
+      uri = NodeURI.new(uri_string)
+      klass = case uri.scheme
+              when 'winrm'
+                Bolt::WinRM
+              when 'pcp'
+                Bolt::Orch
+              else
+                Bolt::SSH
+              end
+      klass.new(uri.hostname,
+                uri.port,
+                uri.user || default_user || Bolt.config[:user],
+                uri.password || default_password || Bolt.config[:password],
+                uri: uri_string, **kwargs)
+    end
+
+    attr_reader :logger, :host, :uri, :user, :password
+
+    def initialize(host, port = nil, user = nil,
+                   password = nil, tty: false, uri: nil,
+                   log_level: Bolt.log_level || Logger::WARN)
+      @host = host
+      @user = user
+      @port = port
+      @password = password
+      @tty = tty
+      @uri = uri
+
+      @logger = init_logger(level: log_level)
+      @transport_logger = init_logger(level: Logger::WARN)
+    end
+
+    def init_logger(destination: STDERR, level: Logger::WARN)
+      logger = Logger.new(destination)
+      logger.level = level
+      logger.formatter = Bolt::Node::Formatter.new(@host)
+      logger
+    end
+
+    def upload(source, destination)
+      @logger.debug { "Uploading #{source} to #{destination}" }
+      result = _upload(source, destination)
+      if result.success?
+        Bolt::Result.new("Uploaded '#{source}' to '#{host}:#{destination}'")
+      else
+        result.to_result
+      end
+    end
+
+    def run_command(command)
+      @logger.info { "Running command: #{command}" }
+      _run_command(command).to_command_result
+    end
+
+    def run_script(script)
+      _run_script(script).to_command_result
+    end
+
+    def run_task(task, input_method, arguments)
+      _run_task(task, input_method, arguments).to_task_result
+    end
+  end
+end
+
+require 'bolt/node/ssh'
+require 'bolt/node/winrm'
+require 'bolt/node/orch'

data/lib/bolt/node/formatter.rb

@@ -0,0 +1,15 @@
+require 'logger'
+
+module Bolt
+  class Node
+    class Formatter < Logger::Formatter
+      def initialize(host)
+        @host = host
+      end
+
+      def call(severity, time, _progname, msg)
+        "#{format_datetime(time)} #{severity} #{@host}: #{msg2str(msg)}\n"
+      end
+    end
+  end
+end

data/lib/bolt/node/orch.rb

@@ -0,0 +1,118 @@
+require 'base64'
+require 'json'
+require 'orchestrator_client'
+
+module Bolt
+  class Orch < Node
+    CONF_FILE = File.expand_path('~/.puppetlabs/client-tools/orchestrator.conf')
+    BOLT_MOCK_FILE = 'bolt/tasks/init'.freeze
+
+    def connect; end
+
+    def disconnect; end
+
+    def make_client
+      OrchestratorClient.new({}, true)
+    end
+
+    def client
+      @client ||= make_client
+    end
+
+    # This avoids a refactor to pass more task data around
+    def task_name_from_path(path)
+      path = File.absolute_path(path)
+      parts = path.split(File::Separator)
+      if parts.length < 3 || parts[-2] != 'tasks'
+        raise ArgumentError, "Task path was not inside a module."
+      end
+      mod = parts[-3]
+      name = File.basename(path).split('.')[0]
+      if name == 'init'
+        mod
+      else
+        "#{mod}::#{name}"
+      end
+    end
+
+    def _run_task(task, _input_method, arguments)
+      body = { task: task_name_from_path(task),
+               params: arguments,
+               scope: {
+                 nodes: [@host]
+               } }
+      # Should we handle errors here or let them propagate?
+      results = client.run_task(body)
+      node_result = results[0]
+      state = node_result['state']
+      result = node_result['result']
+
+      result_output = Bolt::Node::ResultOutput.new
+      result_output.stdout << result.to_json
+      if state == 'finished'
+        Bolt::Node::Success.new(result.to_json, result_output)
+      else
+        # Try to extract the exit_code from _error
+        begin
+          exit_code = result['_error']['details']['exit_code'] || 'unknown'
+        rescue NoMethodError
+          exit_code = 'unknown'
+        end
+        Bolt::Node::Failure.new(exit_code, result_output)
+      end
+    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(result)
+      task_result = JSON.parse(result.output.stdout.string)
+      if task_result['exit_code'].nil?
+        # something went wrong return the failure
+        return result
+      end
+
+      # Otherwise create a new result with the captured output
+      result_output = Bolt::Node::ResultOutput.new
+      result_output.stdout << task_result['stdout']
+      result_output.stderr << task_result['stderr']
+      if (task_result['exit_code']).zero?
+        Bolt::Node::Success.new(task_result['stdout'], result_output)
+      else
+        Bolt::Node::Failure.new(task_result['exit_code'], result_output)
+      end
+    end
+
+    def _run_command(command, options = {})
+      result = _run_task(BOLT_MOCK_FILE,
+                         'stdin',
+                         action: 'command',
+                         command: command,
+                         options: options)
+      unwrap_bolt_result(result)
+    end
+
+    def _upload(source, destination)
+      content = File.open(source, &:read)
+      content = Base64.encode64(content)
+      mode = File.stat(source).mode
+      params = {
+        action: 'upload',
+        path: destination,
+        content: content,
+        mode: mode
+      }
+      _run_task(BOLT_MOCK_FILE, 'stdin', params)
+    end
+
+    def _run_script(script)
+      content = File.open(script, &:read)
+      content = Base64.encode64(content)
+      params = {
+        action: 'script',
+        content: content
+      }
+      unwrap_bolt_result(_run_task(BOLT_MOCK_FILE, 'stdin', params))
+    end
+  end
+end

data/lib/bolt/node/result.rb

@@ -0,0 +1,110 @@
+require 'json'
+require 'bolt/result'
+
+module Bolt
+  class Node
+    class ResultOutput
+      attr_reader :stdout, :stderr
+
+      def initialize
+        @stdout = StringIO.new
+        @stderr = StringIO.new
+      end
+    end
+
+    class Result
+      attr_reader :output
+
+      def initialize(output)
+        @output = output
+      end
+
+      def output_string
+        str = StringIO.new
+        print_to_stream(str)
+        str.string
+      end
+
+      def to_result
+        Bolt::Result.new
+      end
+
+      def to_command_result
+        Bolt::CommandResult.new(output.stdout.string,
+                                output.stderr.string,
+                                exit_code)
+      end
+
+      def exit_code
+        0
+      end
+    end
+
+    class Success < Result
+      attr_reader :value
+
+      def initialize(value = '', output = nil)
+        super(output)
+        @value = value
+      end
+
+      def success?
+        true
+      end
+
+      def then
+        yield @value
+      end
+
+      def to_task_result
+        Bolt::TaskSuccess.new(output.stdout.string,
+                              output.stderr.string,
+                              exit_code)
+      end
+    end
+
+    class Failure < Result
+      attr_reader :exit_code
+
+      def initialize(exit_code, output)
+        super(output)
+        @exit_code = exit_code
+      end
+
+      def success?
+        false
+      end
+
+      def then
+        self
+      end
+
+      def to_task_result
+        Bolt::TaskFailure.new(output.stdout.string,
+                              output.stderr.string,
+                              exit_code)
+      end
+    end
+
+    class ExceptionFailure < Failure
+      attr_reader :exception
+
+      def initialize(exception)
+        super(1, nil)
+        @exception = exception
+      end
+
+      def to_result
+        Bolt::ExceptionResult.new(@exception)
+      end
+
+      def to_task_result
+        to_result
+      end
+
+      def to_command_result
+        to_result
+      end
+    end
+  end
+end

data/lib/bolt/node/ssh.rb

@@ -0,0 +1,145 @@
+require 'net/ssh'
+require 'net/sftp'
+require 'json'
+require 'bolt/node/result'
+
+module Bolt
+  class SSH < Node
+    def connect
+      options = { logger: @transport_logger,
+                  non_interactive: true }
+      options[:port] = @port if @port
+      options[:password] = @password if @password
+
+      @session = Net::SSH.start(@host, @user, options)
+      @logger.debug { "Opened session" }
+    end
+
+    def disconnect
+      if @session && !@session.closed?
+        @session.close
+        @logger.debug { "Closed session" }
+      end
+    end
+
+    def execute(command, options = {})
+      result_output = Bolt::Node::ResultOutput.new
+      status = {}
+
+      @logger.debug { "Executing: #{command}" }
+
+      session_channel = @session.open_channel do |channel|
+        # Request a pseudo tty
+        channel.request_pty if @tty
+
+        channel.exec(command) do |_, success|
+          raise "could not execute command: #{command.inspect}" unless success
+
+          channel.on_data do |_, data|
+            result_output.stdout << data
+            @logger.debug { "stdout: #{data}" }
+          end
+
+          channel.on_extended_data do |_, _, data|
+            result_output.stderr << data
+            @logger.debug { "stderr: #{data}" }
+          end
+
+          channel.on_request("exit-status") do |_, data|
+            status[:exit_code] = data.read_long
+          end
+
+          if options[:stdin]
+            channel.send_data(options[:stdin])
+            channel.eof!
+          end
+        end
+      end
+      session_channel.wait
+
+      if status[:exit_code].zero?
+        @logger.debug { "Command returned successfully" }
+        Bolt::Node::Success.new(result_output.stdout.string, result_output)
+      else
+        @logger.info { "Command failed with exit code #{status[:exit_code]}" }
+        Bolt::Node::Failure.new(status[:exit_code], result_output)
+      end
+    end
+
+    def _upload(source, destination)
+      Net::SFTP::Session.new(@session).connect! do |sftp|
+        sftp.upload!(source, destination)
+      end
+      Bolt::Node::Success.new
+    rescue StandardError => e
+      Bolt::Node::ExceptionFailure.new(e)
+    end
+
+    def make_tempdir
+      Bolt::Node::Success.new(@session.exec!('mktemp -d').chomp)
+    rescue StandardError => e
+      Bolt::Node::ExceptionFailure.new(e)
+    end
+
+    def with_remote_file(file)
+      remote_path = ''
+      dir = ''
+      result = nil
+
+      make_tempdir.then do |value|
+        dir = value
+        remote_path = "#{dir}/#{File.basename(file)}"
+        Bolt::Node::Success.new
+      end.then do
+        _upload(file, remote_path)
+      end.then do
+        execute("chmod u+x '#{remote_path}'")
+      end.then do
+        result = yield remote_path
+      end.then do
+        execute("rm -f '#{remote_path}'")
+      end.then do
+        execute("rmdir '#{dir}'")
+        result
+      end
+    end
+
+    def _run_command(command)
+      execute(command)
+    end
+
+    def _run_script(script)
+      @logger.info { "Running script '#{script}'" }
+      with_remote_file(script) do |remote_path|
+        execute("'#{remote_path}'")
+      end
+    end
+
+    def _run_task(task, input_method, arguments)
+      export_args = {}
+      stdin = nil
+
+      @logger.info { "Running task '#{task}'" }
+      @logger.debug { "arguments: #{arguments}\ninput_method: #{input_method}" }
+
+      if STDIN_METHODS.include?(input_method)
+        stdin = JSON.dump(arguments)
+      end
+
+      if ENVIRONMENT_METHODS.include?(input_method)
+        export_args = arguments.map do |env, val|
+          "PT_#{env}='#{val}'"
+        end.join(' ')
+      end
+
+      with_remote_file(task) do |remote_path|
+        command = if export_args.empty?
+                    "'#{remote_path}'"
+                  else
+                    "export #{export_args} && '#{remote_path}'"
+                  end
+        execute(command, stdin: stdin)
+      end
+    end
+  end
+end