tapsoob 0.6.2-java → 0.7.0-java

data/lib/tapsoob/progress/multi_bar.rb

@@ -2,8 +2,10 @@
 
 module Tapsoob
   module Progress
-    # MultiBar manages multiple progress bars in parallel
-    # Each bar gets its own line in the terminal
+    # MultiBar manages multiple progress bars in parallel with a clean interface:
+    # - N progress bar lines (constantly updating)
+    # - 1 separator line
+    # - 1 info message line (shows latest INFO, gets replaced)
     class MultiBar
       def initialize(max_bars = 4)
         @max_bars = max_bars
@@ -12,13 +14,33 @@ module Tapsoob
         @active = true
         @out = STDOUT
         @last_update = Time.now
-        @reserved_lines = 0  # Track how many lines we've actually reserved
         @max_title_width = 14  # Minimum width, will grow with longer titles
+        @initialized = false
+        @total_lines = 0  # Total lines: max_bars + separator + info line
+        @info_message = ""  # Current info message to display
+        @start_time = Time.now  # Track total elapsed time
+        @terminal_width = get_terminal_width
+      end
+
+      # Get terminal width, default to 160 if can't detect
+      def get_terminal_width
+        require 'io/console'
+        IO.console&.winsize&.[](1) || 160
+      rescue
+        160
       end
 
       # Create a new progress bar and return it
       def create_bar(title, total)
         @mutex.synchronize do
+          # Initialize display area on first bar creation
+          unless @initialized
+            @total_lines = @max_bars + 2  # bars + separator + info line
+            @total_lines.times { @out.print "\n" }
+            @out.flush
+            @initialized = true
+          end
+
           # Remove any existing bar with the same title to prevent duplicates
           @bars.reject! { |b| b.title == title }
 
@@ -26,20 +48,20 @@ module Tapsoob
           @max_title_width = [@max_title_width, title.length].max
 
           bar = ThreadSafeBar.new(title, total, self)
-
-          # Reserve a line for this new bar during active updates
-          # Cap at 2 * max_bars to show active workers + some recent finished bars
-          if @reserved_lines < @max_bars * 2
-            @out.print "\n"
-            @out.flush
-            @reserved_lines += 1
-          end
-
           @bars << bar
           bar
         end
       end
 
+      # Update the info message line (called from outside for INFO logs)
+      def set_info(message)
+        @mutex.synchronize do
+          return unless @active
+          @info_message = message
+          redraw_all if @initialized
+        end
+      end
+
       # Get the current maximum title width for alignment
       # Note: Always called from within synchronized methods, so no mutex needed
       def max_title_width
@@ -73,18 +95,26 @@ module Tapsoob
         end
       end
 
-      # Stop all progress bars and keep them visible
+      # Stop all progress bars and clear them from display
       def stop
         @mutex.synchronize do
+          return unless @active  # Already stopped
           @active = false
 
-          # Final cleanup: remove any duplicate titles (keep the last occurrence of each unique title)
-          @bars = @bars.reverse.uniq { |bar| bar.title }.reverse
+          # Clear all lines (progress bars + separator + info line)
+          if @total_lines > 0 && @initialized
+            # Move cursor up to first line
+            @out.print "\e[#{@total_lines}A"
+
+            # Clear each line
+            @total_lines.times do
+              @out.print "\r\e[2K\n"
+            end
+
+            # Move cursor back to start
+            @out.print "\e[#{@total_lines}A\r"
+          end
 
-          # Final redraw to show completed state (skip active check)
-          redraw_all(true)
-          # Move cursor past all bars
-          @out.print "\n"
           @out.flush
         end
       end
@@ -97,62 +127,64 @@ module Tapsoob
       end
 
       def redraw_all(force = false)
-        return unless force || @active
+        return unless @active
         return if @bars.empty?
 
-        if force && !@active
-          render_final_display
-        else
-          render_active_display
-        end
+        render_active_display
       end
 
-      # Final display: show all completed bars
-      def render_final_display
-        # Clear the reserved lines first
-        if @reserved_lines > 0
-          @out.print "\r\e[#{@reserved_lines}A"
-          @reserved_lines.times { @out.print "\r\e[K\n" }
-        end
-
-        # Print all bars (adds new lines as needed)
-        @bars.each do |bar|
-          @out.print "\r\e[K"
-          bar.render_to(@out)
-          @out.print "\n"
-        end
-
-        @out.flush
+      # Format elapsed time as HH:MM:SS
+      def format_elapsed_time
+        elapsed = Time.now - @start_time
+        hours = (elapsed / 3600).to_i
+        minutes = ((elapsed % 3600) / 60).to_i
+        seconds = (elapsed % 60).to_i
+        sprintf("%02d:%02d:%02d", hours, minutes, seconds)
       end
 
-      # Normal operation: show active bars + recent finished in reserved space
+      # Render the complete display: progress bars + separator + info line
       def render_active_display
-        return if @reserved_lines == 0
+        return if @total_lines == 0
 
-        # Partition bars in a single pass for efficiency
-        active_bars, finished_bars = @bars.partition { |b| !b.finished? }
+        # Show the last N bars (finished or not) - creates a rolling window effect
+        # As new tables start, old completed ones scroll off the top
+        bars_to_draw = @bars.last(@max_bars)
 
-        # Build display: active bars first, then recent finished to fill remaining space
-        # Ensure we don't request negative count from .last()
-        remaining_space = [@reserved_lines - active_bars.length, 0].max
-        bars_to_draw = active_bars + finished_bars.last(remaining_space)
+        # Move cursor up to first line
+        @out.print "\e[#{@total_lines}A"
 
-        # If we have more bars than reserved lines, show only the most recent
-        bars_to_draw = bars_to_draw.last(@reserved_lines) if bars_to_draw.length > @reserved_lines
-
-        # Move up and redraw in reserved space
-        @out.print "\r\e[#{@reserved_lines}A"
-        @reserved_lines.times do |i|
+        # Draw progress bars (they handle their own width)
+        @max_bars.times do |i|
           @out.print "\r\e[K"
           bars_to_draw[i].render_to(@out) if i < bars_to_draw.length
           @out.print "\n"
         end
 
+        # Draw separator line using box drawing character
+        @out.print "\r\e[K"
+        @out.print "─" * @terminal_width
+        @out.print "\n"
+
+        # Draw info message line with elapsed time on the right
+        @out.print "\r\e[K"
+        unless @info_message.empty?
+          elapsed_str = "Elapsed: #{format_elapsed_time}"
+          # Calculate space to right-align elapsed time
+          available_width = @terminal_width - @info_message.length - elapsed_str.length - 2
+          if available_width > 0
+            @out.print @info_message
+            @out.print " " * available_width
+            @out.print elapsed_str
+          else
+            # If too long, just show message
+            @out.print @info_message[0...(@terminal_width - elapsed_str.length - 2)]
+            @out.print "  " + elapsed_str
+          end
+        end
+        @out.print "\n"
+
         @out.flush
       end
     end
   end
 end
-
-# Backward compatibility alias
-MultiProgressBar = Tapsoob::Progress::MultiBar

data/lib/tapsoob/progress/thread_safe_bar.rb

@@ -85,6 +85,3 @@ module Tapsoob
     end
   end
 end
-
-# Backward compatibility alias
-ThreadSafeProgressBar = Tapsoob::Progress::ThreadSafeBar

data/lib/tapsoob/progress_event.rb

@@ -0,0 +1,109 @@
+# -*- encoding : utf-8 -*-
+require 'json'
+
+module Tapsoob
+  module ProgressEvent
+    @last_progress_time = {}
+    @progress_throttle = 0.5  # Emit progress at most every 0.5 seconds per table
+    @enabled = false  # Only emit when CLI progress bars are disabled
+
+    def self.enabled=(value)
+      @enabled = value
+    end
+
+    def self.enabled?
+      @enabled
+    end
+
+    # Emit structured JSON progress events to STDERR for machine parsing
+    # Only emits when enabled (typically when CLI progress bars are disabled)
+    def self.emit(event_type, data = {})
+      return unless @enabled
+      event = {
+        event: event_type,
+        timestamp: Time.now.utc.iso8601
+      }.merge(data)
+
+      STDERR.puts "PROGRESS: #{JSON.generate(event)}"
+      STDERR.flush
+    end
+
+    # Check if enough time has passed to emit a progress event for this table
+    def self.should_emit_progress?(table_name)
+      now = Time.now
+      last_time = @last_progress_time[table_name]
+
+      if last_time.nil? || (now - last_time) >= @progress_throttle
+        @last_progress_time[table_name] = now
+        true
+      else
+        false
+      end
+    end
+
+    # Clear throttle state for a table (call when table completes)
+    def self.clear_throttle(table_name)
+      @last_progress_time.delete(table_name)
+    end
+
+    # Schema events
+    def self.schema_start(table_count)
+      emit('schema_start', tables: table_count)
+    end
+
+    def self.schema_complete(table_count)
+      emit('schema_complete', tables: table_count)
+    end
+
+    # Data events
+    def self.data_start(table_count, record_count)
+      emit('data_start', tables: table_count, records: record_count)
+    end
+
+    def self.data_complete(table_count, record_count)
+      emit('data_complete', tables: table_count, records: record_count)
+    end
+
+    # Table-level events
+    def self.table_start(table_name, record_count, workers: 1)
+      clear_throttle(table_name)  # Reset throttle for new table
+      emit('table_start', table: table_name, records: record_count, workers: workers)
+    end
+
+    def self.table_progress(table_name, current, total)
+      # Throttle progress events to avoid spam
+      return unless should_emit_progress?(table_name)
+
+      percentage = total > 0 ? ((current.to_f / total) * 100).round(1) : 0
+      emit('table_progress', table: table_name, current: current, total: total, percentage: percentage)
+    end
+
+    def self.table_complete(table_name, record_count)
+      clear_throttle(table_name)  # Clean up throttle state
+      emit('table_complete', table: table_name, records: record_count)
+    end
+
+    # Index events
+    def self.indexes_start(table_count)
+      emit('indexes_start', tables: table_count)
+    end
+
+    def self.indexes_complete(table_count)
+      emit('indexes_complete', tables: table_count)
+    end
+
+    # Sequence events
+    def self.sequences_start
+      emit('sequences_start')
+    end
+
+    def self.sequences_complete
+      emit('sequences_complete')
+    end
+
+    # Error events
+    def self.error(message, context = {})
+      emit('error', { message: message }.merge(context))
+    end
+  end
+end

data/lib/tapsoob/version.rb

@@ -1,4 +1,4 @@
 # -*- encoding : utf-8 -*-
 module Tapsoob
-  VERSION = "0.6.2".freeze
+  VERSION = "0.7.0".freeze
 end

data/lib/tasks/tapsoob.rake

@@ -19,7 +19,7 @@ namespace :tapsoob do
     FileUtils.mkpath "#{dump_path}/indexes"
 
     # Run operation
-    Tapsoob::Operation.factory(:pull, database_uri, dump_path, opts).run
+    Tapsoob::Operation::Base.factory(:pull, database_uri, dump_path, opts).run
 
     # Invoke cleanup task
     Rake::Task["tapsoob:clean"].reenable
@@ -53,7 +53,7 @@ namespace :tapsoob do
     end
 
     # Run operation
-    Tapsoob::Operation.factory(:push, database_uri, dump_path, opts).run
+    Tapsoob::Operation::Base.factory(:push, database_uri, dump_path, opts).run
   end
 
   desc "Cleanup old dumps"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: tapsoob
 version: !ruby/object:Gem::Version
-  version: 0.6.2
+  version: 0.7.0
 platform: java
 authors:
 - Félix Bellanger
 - Michael Chrisco
 bindir: bin
 cert_chain: []
-date: 2025-10-29 00:00:00.000000000 Z
+date: 2025-10-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sequel
@@ -102,13 +102,22 @@ files:
 - lib/tapsoob/cli/schema.rb
 - lib/tapsoob/config.rb
 - lib/tapsoob/data_stream.rb
+- lib/tapsoob/data_stream/base.rb
+- lib/tapsoob/data_stream/file_partition.rb
+- lib/tapsoob/data_stream/interleaved.rb
+- lib/tapsoob/data_stream/keyed.rb
+- lib/tapsoob/data_stream/keyed_partition.rb
 - lib/tapsoob/errors.rb
 - lib/tapsoob/log.rb
 - lib/tapsoob/operation.rb
+- lib/tapsoob/operation/base.rb
+- lib/tapsoob/operation/pull.rb
+- lib/tapsoob/operation/push.rb
 - lib/tapsoob/progress.rb
 - lib/tapsoob/progress/bar.rb
 - lib/tapsoob/progress/multi_bar.rb
 - lib/tapsoob/progress/thread_safe_bar.rb
+- lib/tapsoob/progress_event.rb
 - lib/tapsoob/railtie.rb
 - lib/tapsoob/schema.rb
 - lib/tapsoob/utils.rb