kamal-backup 0.3.0.beta6 → 0.3.0.beta8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 68d3201dc26c940938479dc76d1c0e17b206676ae69610d736a69879a78de21c
-  data.tar.gz: dd58ee38da83d4652515b108869e5fe441a25d80697b7db3ea1c606240a44766
+  metadata.gz: d920c58d8ff83794df465f0549d8599ea6a5e815b800221fa850ce024241abfa
+  data.tar.gz: feb8374a19862349d1fb0b3d55e3e697b45df66d58fc0c0f63ddba4767ed01f9
 SHA512:
-  metadata.gz: 37ca5f6463fe6eb76c2f6994a783e2180f3eecff24e834550743c1f9130e6ad3019ce1e296dc44ac523a36c065f1e05ac00aaaec7c7224254daea0c2d683d7a0
-  data.tar.gz: '0985cd5e2eb8a52db5dcc4265271eddde1513c8c8db80d0aec21ee3ca1be0bd42e2adcd60ffeb942aa7bb2d926cbad69f5d89051485ce64145f3f5c821abe3bb'
+  metadata.gz: 9e36489f2557dca0695be87b779a9b20f96148b141e67a9422bc8933c925ea68a17a73d221c56f4a51585258194752f0db4f0b6fed4a4845783334e6dc0d8e0e
+  data.tar.gz: f8bb63eb69f7da8bdfcc001e07c95495ac60fa6996eb4b4188cfb2a8bc453979176985703f897c8e5ac4a9b02faec5cf3d76aad15862b0c964d6c961c2910556

data/lib/kamal_backup/cli.rb

@@ -129,11 +129,13 @@ module KamalBackup
 
       def print_remote_version_status
         status = remote_version == VERSION ? "in sync" : "out of sync"
+        status_color = status == "in sync" ? :green : :red
+        status_output = CommandOutput.new(io: $stdout, env: command_env)
 
         puts("local: #{VERSION}")
         puts("remote: #{remote_version}")
-        puts("status: #{status}")
-        puts("fix: #{accessory_reboot_command}") if status == "out of sync"
+        puts("status: #{status_output.decorate(status, status_color, :bold)}")
+        puts("fix: #{status_output.decorate(accessory_reboot_command, :yellow, :bold)}") if status == "out of sync"
       end
 
       def validate_deploy_config
@@ -399,14 +401,17 @@ module KamalBackup
 
     def self.start(argv = ARGV, env: ENV)
       self.command_env = env
-      Command.with_output(CommandOutput.new(io: $stderr)) do
+      output = CommandOutput.new(io: $stderr, env: env)
+      Command.with_output(output) do
         super(normalize_global_options(argv))
       end
     rescue Error => e
-      warn("kamal-backup: #{Redactor.new(env: env).redact_string(e.message)}")
+      output ||= CommandOutput.new(io: $stderr, env: env)
+      output.error("(#{e.class}): #{e.message}", redactor: Redactor.new(env: env))
       exit(1)
     rescue Interrupt
-      warn("kamal-backup: interrupted")
+      output ||= CommandOutput.new(io: $stderr, env: env)
+      output.error("(Interrupt): interrupted", redactor: Redactor.new(env: env))
       exit(130)
     ensure
       self.command_env = nil

data/lib/kamal_backup/command.rb

@@ -27,14 +27,57 @@ module KamalBackup
   CommandResult = Struct.new(:stdout, :stderr, :status, :streamed, keyword_init: true)
 
   class CommandOutput
-    def initialize(io: $stdout)
+    LEVELS = {
+      "DEBUG" => 0,
+      "INFO" => 1,
+      "WARN" => 2,
+      "ERROR" => 3,
+      "FATAL" => 4
+    }.freeze
+    LEVEL_COLORS = {
+      "DEBUG" => :black,
+      "INFO" => :blue,
+      "WARN" => :yellow,
+      "ERROR" => :red,
+      "FATAL" => :red
+    }.freeze
+    COLOR_CODES = {
+      black: 30,
+      red: 31,
+      green: 32,
+      yellow: 33,
+      blue: 34,
+      magenta: 35,
+      cyan: 36,
+      white: 37,
+      light_black: 90,
+      light_red: 91,
+      light_green: 92,
+      light_yellow: 93,
+      light_blue: 94,
+      light_magenta: 95,
+      light_cyan: 96,
+      light_white: 97
+    }.freeze
+
+    def initialize(io: $stdout, env: ENV, verbosity: :info)
       @io = io
+      @env = env
+      @verbosity = LEVELS.fetch(verbosity.to_s.upcase)
       @mutex = Mutex.new
       @buffers = {}
     end
 
     def info(message, redactor:)
-      write_line("  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))
+    end
+
+    def decorate(value, color, mode = nil)
+      colorize(value, color, mode)
     end
 
     def command_start(spec, redactor:)
@@ -42,8 +85,8 @@ module KamalBackup
       started_at = Process.clock_gettime(Process::CLOCK_MONOTONIC)
       display = spec.display(redactor)
 
-      write_line("  INFO [#{id}] Running #{display} locally")
-      write_line(" DEBUG [#{id}] Command: #{display}")
+      write_message("INFO", "Running #{colorize(display, :yellow, :bold)} #{local_target}", id)
+      write_message("DEBUG", "Command: #{colorize(display, :blue)}", id)
 
       { id: id, started_at: started_at, redactor: redactor }
     end
@@ -51,6 +94,7 @@ module KamalBackup
     def command_output(context, _stream, data, redactor:)
       raw = data.to_s
       return if raw.empty?
+      return unless log_level?("DEBUG")
 
       synchronize do
         key = [context.fetch(:id), _stream]
@@ -62,16 +106,23 @@ 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_color = status.to_i.zero? ? :green : :red
 
       synchronize do
         flush_output_buffers(context)
-        @io.puts("  INFO [#{context.fetch(:id)}] Finished in #{format("%.3f seconds", runtime)} with exit status #{status} (#{result}).")
+        write_message_unlocked("INFO", "Finished in #{format("%.3f seconds", runtime)} with exit status #{status} (#{colorize(result, result_color, :bold)}).", context.fetch(:id))
       end
     end
 
     private
-      def write_line(message)
-        synchronize { @io.puts(message) }
+      def write_message(level, message, id = nil)
+        return unless log_level?(level)
+
+        synchronize { write_message_unlocked(level, message, id) }
+      end
+
+      def write_message_unlocked(level, message, id = nil)
+        @io.puts(format_message(level, message, id)) if log_level?(level)
       end
 
       def synchronize(&block)
@@ -87,7 +138,7 @@ module KamalBackup
         end
 
         @buffers[key] = buffer
-        write_output(context, output, redactor: redactor) unless output.empty?
+        write_output(context, output, redactor: redactor, stream: key.last) unless output.empty?
       end
 
       def flush_output_buffers(context)
@@ -98,17 +149,50 @@ module KamalBackup
           output = @buffers.delete(key)
           next if output.to_s.empty?
 
-          write_output(context, output, redactor: context.fetch(:redactor))
-          @io.puts unless output.end_with?("\n")
+          write_output(context, output, redactor: context.fetch(:redactor), stream: key.last)
         end
       end
 
-      def write_output(context, output, redactor:)
+      def write_output(context, output, redactor:, stream: nil)
+        color = stream == :stderr ? :red : :green
+
         redactor.redact_string(output).each_line do |line|
-          @io.print(" DEBUG [#{context.fetch(:id)}] \t#{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 local_target
+        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
+      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)
+
+        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
   end
 
   class Command

data/lib/kamal_backup/kamal_bridge.rb

@@ -215,9 +215,10 @@ module KamalBackup
       end
 
       def capture_kamal(argv, stream: false)
-        spec = CommandSpec.new(argv: argv)
+        spec = CommandSpec.new(argv: argv, env: kamal_stream_env(stream))
         options = {
           redactor: @redactor,
+          log: !stream,
           log_output: false,
           tee_stdout: stream ? @stdout : nil,
           tee_stderr: stream ? @stderr : nil
@@ -230,6 +231,20 @@ module KamalBackup
         end
       end
 
+      def kamal_stream_env(stream)
+        return {} unless stream
+
+        if @env["SSHKIT_COLOR"].to_s.empty?
+          stream_color? ? { "SSHKIT_COLOR" => "1" } : {}
+        else
+          { "SSHKIT_COLOR" => @env["SSHKIT_COLOR"] }
+        end
+      end
+
+      def stream_color?
+        [@stdout, @stderr].any? { |io| io.respond_to?(:tty?) && io.tty? }
+      end
+
       def parse_version_line(output)
         output.to_s.lines.map(&:strip).reverse.find { |line| line.match?(VERSION_LINE_PATTERN) }.to_s
       end

data/lib/kamal_backup/version.rb

@@ -1,3 +1,3 @@
 module KamalBackup
-  VERSION = "0.3.0.beta6"
+  VERSION = "0.3.0.beta8"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: kamal-backup
 version: !ruby/object:Gem::Version
-  version: 0.3.0.beta6
+  version: 0.3.0.beta8
 platform: ruby
 authors:
 - crmne