kamal-backup 0.3.0.beta21 → 0.3.0

data/lib/kamal_backup/command.rb

@@ -1,8 +1,10 @@
-require "open3"
-require "pty"
-require "securerandom"
-require "shellwords"
-require_relative "errors"
+# frozen_string_literal: true
+
+require 'open3'
+require 'pty'
+require 'securerandom'
+require 'shellwords'
+require_relative 'errors'
 
 module KamalBackup
   class CommandSpec
@@ -17,12 +19,12 @@ module KamalBackup
         result[key.to_s] = value.to_s
       end
 
-      raise ArgumentError, "command argv cannot be empty" if @argv.empty?
+      raise ArgumentError, 'command argv cannot be empty' if @argv.empty?
     end
 
     def display(redactor)
       env_prefix = env.keys.sort.map { |key| "#{key}=#{redactor.redact_value(key, env[key])}" }
-      redactor.redact_string((env_prefix + [argv.shelljoin]).join(" "))
+      redactor.redact_string((env_prefix + [argv.shelljoin]).join(' '))
     end
   end
 
@@ -30,18 +32,18 @@ module KamalBackup
 
   class CommandOutput
     LEVELS = {
-      "DEBUG" => 0,
-      "INFO" => 1,
-      "WARN" => 2,
-      "ERROR" => 3,
-      "FATAL" => 4
+      'DEBUG' => 0,
+      'INFO' => 1,
+      'WARN' => 2,
+      'ERROR' => 3,
+      'FATAL' => 4
     }.freeze
     LEVEL_COLORS = {
-      "DEBUG" => :black,
-      "INFO" => :blue,
-      "WARN" => :yellow,
-      "ERROR" => :red,
-      "FATAL" => :red
+      'DEBUG' => :black,
+      'INFO' => :blue,
+      'WARN' => :yellow,
+      'ERROR' => :red,
+      'FATAL' => :red
     }.freeze
     COLOR_CODES = {
       black: 30,
@@ -71,11 +73,11 @@ module KamalBackup
     end
 
     def info(message, redactor:)
-      write_message("INFO", redactor.redact_string(message))
+      write_message('INFO', redactor.redact_string(message))
     end
 
     def error(message, redactor:)
-      write_message("ERROR", colorize(redactor.redact_string(message), :red, :bold))
+      write_message('ERROR', colorize(redactor.redact_string(message), :red, :bold))
     end
 
     def decorate(value, color, mode = nil)
@@ -87,19 +89,19 @@ module KamalBackup
       started_at = Process.clock_gettime(Process::CLOCK_MONOTONIC)
       display = spec.display(redactor)
 
-      write_message("INFO", "Running #{colorize(display, :yellow, :bold)} #{target_for(spec)}", id)
-      write_message("DEBUG", "Command: #{colorize(display, :blue)}", id)
+      write_message('INFO', "Running #{colorize(display, :yellow, :bold)} #{target_for(spec)}", id)
+      write_message('DEBUG', "Command: #{colorize(display, :blue)}", id)
 
       { id: id, started_at: started_at, redactor: redactor }
     end
 
-    def command_output(context, _stream, data, redactor:)
+    def command_output(context, stream, data, redactor:)
       raw = data.to_s
       return if raw.empty?
-      return unless log_level?("DEBUG")
+      return unless log_level?('DEBUG')
 
       synchronize do
-        key = [context.fetch(:id), _stream]
+        key = [context.fetch(:id), stream]
         @buffers[key] = "#{@buffers[key]}#{raw}"
         flush_complete_output_lines(context, key, redactor: redactor)
       end
@@ -107,106 +109,109 @@ module KamalBackup
 
     def command_exit(context, status)
       runtime = Process.clock_gettime(Process::CLOCK_MONOTONIC) - context.fetch(:started_at)
-      result = status.to_i.zero? ? "successful" : "failed"
+      result = status.to_i.zero? ? 'successful' : 'failed'
       result_color = status.to_i.zero? ? :green : :red
 
       synchronize do
         flush_output_buffers(context)
-        write_message_unlocked("INFO", "Finished in #{format("%.3f seconds", runtime)} with exit status #{status} (#{colorize(result, result_color, :bold)}).", context.fetch(:id))
+        message = "Finished in #{format('%.3f seconds', runtime)} with exit status #{status} " \
+                  "(#{colorize(result, result_color, :bold)})."
+        write_message_unlocked('INFO', message, context.fetch(:id))
       end
     end
 
     private
-      def write_message(level, message, id = nil)
-        return unless log_level?(level)
 
-        synchronize { write_message_unlocked(level, message, id) }
-      end
+    def write_message(level, message, id = nil)
+      return unless log_level?(level)
 
-      def write_message_unlocked(level, message, id = nil)
-        @io.puts(format_message(level, message, id)) if log_level?(level)
-      end
+      synchronize { write_message_unlocked(level, message, id) }
+    end
 
-      def synchronize(&block)
-        @mutex.synchronize(&block)
-      end
+    def write_message_unlocked(level, message, id = nil)
+      @io.puts(format_message(level, message, id)) if log_level?(level)
+    end
 
-      def flush_complete_output_lines(context, key, redactor:)
-        buffer = @buffers.fetch(key)
-        output = +""
+    def synchronize(&block)
+      @mutex.synchronize(&block)
+    end
 
-        while (index = buffer.index("\n"))
-          output << buffer.slice!(0..index)
-        end
+    def flush_complete_output_lines(context, key, redactor:)
+      buffer = @buffers.fetch(key)
+      output = +''
 
-        @buffers[key] = buffer
-        write_output(context, output, redactor: redactor, stream: key.last) unless output.empty?
+      while (index = buffer.index("\n"))
+        output << buffer.slice!(0..index)
       end
 
-      def flush_output_buffers(context)
-        id = context.fetch(:id)
-        keys = @buffers.keys.select { |key_id, _stream| key_id == id }
+      @buffers[key] = buffer
+      write_output(context, output, redactor: redactor, stream: key.last) unless output.empty?
+    end
+
+    def flush_output_buffers(context)
+      id = context.fetch(:id)
+      keys = @buffers.keys.select { |key_id, _stream| key_id == id }
 
-        keys.each do |key|
-          output = @buffers.delete(key)
-          next if output.to_s.empty?
+      keys.each do |key|
+        output = @buffers.delete(key)
+        next if output.to_s.empty?
 
-          write_output(context, output, redactor: context.fetch(:redactor), stream: key.last)
-        end
+        write_output(context, output, redactor: context.fetch(:redactor), stream: key.last)
       end
+    end
 
-      def write_output(context, output, redactor:, stream: nil)
-        color = stream == :stderr ? :red : :green
+    def write_output(context, output, redactor:, stream: nil)
+      color = stream == :stderr ? :red : :green
 
-        redactor.redact_string(output).each_line do |line|
-          write_message_unlocked("DEBUG", colorize("\t#{line}".chomp, color), context.fetch(:id))
-        end
-        @io.flush if @io.respond_to?(:flush)
+      redactor.redact_string(output).each_line do |line|
+        write_message_unlocked('DEBUG', colorize("\t#{line}".chomp, color), context.fetch(:id))
       end
+      @io.flush if @io.respond_to?(:flush)
+    end
 
-      def format_message(level, message, id = nil)
-        message = "[#{colorize(id, :green)}] #{message}" if id
-        "#{colorize(level.rjust(6), LEVEL_COLORS.fetch(level))} #{message}"
-      end
+    def format_message(level, message, id = nil)
+      message = "[#{colorize(id, :green)}] #{message}" if id
+      "#{colorize(level.rjust(6), LEVEL_COLORS.fetch(level))} #{message}"
+    end
 
-      def local_target
-        if remote_host = @env["KAMAL_HOST"].to_s
-          return "on #{colorize(remote_host, :blue)}" unless remote_host.empty?
-        end
+    def local_target
+      if (remote_host = @env['KAMAL_HOST'].to_s) && !remote_host.empty?
+        return "on #{colorize(remote_host, :blue)}"
+      end
 
-        user = @env["USER"].to_s.empty? ? @env["USERNAME"].to_s : @env["USER"].to_s
+      user = @env['USER'].to_s.empty? ? @env['USERNAME'].to_s : @env['USER'].to_s
 
-        if user.empty?
-          "on #{colorize("localhost", :blue)}"
-        else
-          "as #{colorize(user, :blue)}@#{colorize("localhost", :blue)}"
-        end
+      if user.empty?
+        "on #{colorize('localhost', :blue)}"
+      else
+        "as #{colorize(user, :blue)}@#{colorize('localhost', :blue)}"
       end
+    end
 
-      def target_for(spec)
-        if spec.host
-          "on #{colorize(spec.host, :blue)}"
-        else
-          local_target
-        end
+    def target_for(spec)
+      if spec.host
+        "on #{colorize(spec.host, :blue)}"
+      else
+        local_target
       end
+    end
 
-      def log_level?(level)
-        LEVELS.fetch(level) >= @verbosity
-      end
+    def log_level?(level)
+      LEVELS.fetch(level) >= @verbosity
+    end
 
-      def colorize(value, color, mode = nil)
-        string = value.to_s
-        return string unless colorize?
-        return string unless COLOR_CODES.key?(color)
+    def colorize(value, color, mode = nil)
+      string = value.to_s
+      return string unless colorize?
+      return string unless COLOR_CODES.key?(color)
 
-        prefix = mode == :bold ? "\e[1;" : "\e[0;"
-        "#{prefix}#{COLOR_CODES.fetch(color)};49m#{string}\e[0m"
-      end
+      prefix = mode == :bold ? "\e[1;" : "\e[0;"
+      "#{prefix}#{COLOR_CODES.fetch(color)};49m#{string}\e[0m"
+    end
 
-      def colorize?
-        @env["SSHKIT_COLOR"] || (@io.respond_to?(:tty?) && @io.tty?)
-      end
+    def colorize?
+      @env['SSHKIT_COLOR'] || (@io.respond_to?(:tty?) && @io.tty?)
+    end
   end
 
   class Command
@@ -222,13 +227,13 @@ module KamalBackup
       end
 
       def available?(name)
-        ENV.fetch("PATH", "").split(File::PATH_SEPARATOR).any? do |dir|
+        ENV.fetch('PATH', '').split(File::PATH_SEPARATOR).any? do |dir|
           path = File.join(dir, name)
           File.executable?(path) && !File.directory?(path)
         end
       end
 
-      def capture(spec, input: nil, redactor:, log: true, log_output: true, tee_stdout: nil, tee_stderr: nil)
+      def capture(spec, redactor:, input: nil, log: true, log_output: true, tee_stdout: nil, tee_stderr: nil)
         output = log ? self.output : nil
         return capture_quietly(spec, input: input, redactor: redactor) unless output || tee_stdout || tee_stderr
 
@@ -244,20 +249,19 @@ module KamalBackup
           tee_stderr: tee_stderr
         )
         output&.command_exit(context, status.exitstatus)
-        result = CommandResult.new(stdout: stdout, stderr: stderr, status: status.exitstatus, streamed: !!(tee_stdout || tee_stderr))
+        result = CommandResult.new(stdout: stdout, stderr: stderr, status: status.exitstatus,
+                                   streamed: !(tee_stdout || tee_stderr).nil?)
 
-        if status.success?
-          result
-        else
-          raise command_failure(spec, status.exitstatus, stdout, stderr, redactor)
-        end
+        raise command_failure(spec, status.exitstatus, stdout, stderr, redactor) unless status.success?
+
+        result
       rescue Errno::ENOENT => e
         raise command_not_found(spec, e)
       end
 
       def capture_pty(spec, redactor:, tee_stdout: nil)
-        output = +""
-        tee_buffer = +""
+        output = +''
+        tee_buffer = +''
         result = nil
 
         PTY.spawn(spec.env, *spec.argv) do |reader, writer, pid|
@@ -276,11 +280,9 @@ module KamalBackup
           end
 
           _, status = Process.wait2(pid)
-          result = CommandResult.new(stdout: output, stderr: "", status: status.exitstatus, streamed: !!tee_stdout)
+          result = CommandResult.new(stdout: output, stderr: '', status: status.exitstatus, streamed: !tee_stdout.nil?)
 
-          unless status.success?
-            raise command_failure(spec, status.exitstatus, output, output, redactor)
-          end
+          raise command_failure(spec, status.exitstatus, output, output, redactor) unless status.success?
         end
 
         result
@@ -288,9 +290,10 @@ module KamalBackup
         raise command_not_found(spec, e)
       end
 
-      def collect_stream(io, command_output: self.output, context: nil, stream: :stdout, log_output: true, tee_io: nil, redactor: nil)
-        captured_output = +""
-        tee_buffer = +""
+      def collect_stream(io, command_output: output, context: nil, stream: :stdout, log_output: true, tee_io: nil,
+                         redactor: nil)
+        captured_output = +''
+        tee_buffer = +''
 
         loop do
           chunk = io.readpartial(16 * 1024)
@@ -306,72 +309,73 @@ module KamalBackup
       end
 
       private
-        def tee_stream(io, redactor, buffer, chunk)
-          buffer << chunk
 
-          while (index = buffer.index("\n"))
-            io.print(redactor.redact_string(buffer.slice!(0..index)))
-          end
+      def tee_stream(io, redactor, buffer, chunk)
+        buffer << chunk
 
-          io.flush if io.respond_to?(:flush)
-          buffer
+        while (index = buffer.index("\n"))
+          io.print(redactor.redact_string(buffer.slice!(0..index)))
         end
 
-        def flush_tee_stream(io, redactor, buffer)
-          return if buffer.empty?
+        io.flush if io.respond_to?(:flush)
+        buffer
+      end
 
-          io.print(redactor.redact_string(buffer))
-          io.flush if io.respond_to?(:flush)
-        end
+      def flush_tee_stream(io, redactor, buffer)
+        return if buffer.empty?
 
-        def capture_quietly(spec, input:, redactor:)
-          stdout, stderr, status = Open3.capture3(spec.env, *spec.argv, stdin_data: input)
-          result = CommandResult.new(stdout: stdout, stderr: stderr, status: status.exitstatus, streamed: false)
+        io.print(redactor.redact_string(buffer))
+        io.flush if io.respond_to?(:flush)
+      end
 
-          if status.success?
-            result
-          else
-            raise command_failure(spec, status.exitstatus, stdout, stderr, redactor)
-          end
-        end
+      def capture_quietly(spec, input:, redactor:)
+        stdout, stderr, status = Open3.capture3(spec.env, *spec.argv, stdin_data: input)
+        result = CommandResult.new(stdout: stdout, stderr: stderr, status: status.exitstatus, streamed: false)
 
-        def popen_capture(spec, input:, redactor:, output:, context:, log_output:, tee_stdout:, tee_stderr:)
-          Open3.popen3(spec.env, *spec.argv) do |stdin, stdout, stderr, wait_thread|
-            stdin_writer = Thread.new do
-              stdin.write(input) if input
-            ensure
-              stdin.close unless stdin.closed?
-            end
-            stdout_reader = Thread.new do
-              collect_stream(stdout, command_output: output, context: context, stream: :stdout, log_output: log_output, tee_io: tee_stdout, redactor: redactor)
-            end
-            stderr_reader = Thread.new do
-              collect_stream(stderr, command_output: output, context: context, stream: :stderr, log_output: log_output, tee_io: tee_stderr, redactor: redactor)
-            end
+        raise command_failure(spec, status.exitstatus, stdout, stderr, redactor) unless status.success?
 
-            stdin_writer.join
-            [stdout_reader.value, stderr_reader.value, wait_thread.value]
+        result
+      end
+
+      def popen_capture(spec, input:, redactor:, output:, context:, log_output:, tee_stdout:, tee_stderr:)
+        Open3.popen3(spec.env, *spec.argv) do |stdin, stdout, stderr, wait_thread|
+          stdin_writer = Thread.new do
+            stdin.write(input) if input
+          ensure
+            stdin.close unless stdin.closed?
+          end
+          stdout_reader = Thread.new do
+            collect_stream(stdout, command_output: output, context: context, stream: :stdout, log_output: log_output,
+                                   tee_io: tee_stdout, redactor: redactor)
+          end
+          stderr_reader = Thread.new do
+            collect_stream(stderr, command_output: output, context: context, stream: :stderr, log_output: log_output,
+                                   tee_io: tee_stderr, redactor: redactor)
           end
-        end
 
-        def command_failure(spec, status, stdout, stderr, redactor)
-          CommandError.new(
-            "command failed (#{status}): #{spec.display(redactor)}\n#{redactor.redact_string(stderr)}",
-            command: spec,
-            status: status,
-            stdout: redactor.redact_string(stdout),
-            stderr: redactor.redact_string(stderr)
-          )
+          stdin_writer.join
+          [stdout_reader.value, stderr_reader.value, wait_thread.value]
         end
+      end
 
-        def command_not_found(spec, error)
-          CommandError.new(
-            "command not found: #{spec.argv.first}",
-            command: spec,
-            status: 127,
-            stderr: error.message
-          )
-        end
+      def command_failure(spec, status, stdout, stderr, redactor)
+        CommandError.new(
+          "command failed (#{status}): #{spec.display(redactor)}\n#{redactor.redact_string(stderr)}",
+          command: spec,
+          status: status,
+          stdout: redactor.redact_string(stdout),
+          stderr: redactor.redact_string(stderr)
+        )
+      end
+
+      def command_not_found(spec, error)
+        CommandError.new(
+          "command not found: #{spec.argv.first}",
+          command: spec,
+          status: 127,
+          stderr: error.message
+        )
+      end
     end
   end
 end