massive-import 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: d69a58e87200826ed11aae6cc340efb71e41adb4bb153d86c9eb8a8d806efa17
+  data.tar.gz: 6068985e427a84ea61c715f916720c7a36452c78a8a23fc33c70aba07c80339c
+SHA512:
+  metadata.gz: 2906b06253e68135693037f38c9f95d2a67c253d449a90688ea2a8c2f395b99459a9d4038e072446c18f7b3ad370e16528f06657122f6a175f4a662669e9751a
+  data.tar.gz: b3f72a3b62433ad7239847f7f3ebcf854b90e6270153ae83cc5cd1e683a33c02a0ac7bd10bdfafc5200286ec32fccc17a4817f3401fd36e45405d6a17b48d496

data/VERSION

@@ -0,0 +1 @@
+0.0.2

data/lib/massive-import/dashboard_server.rb

@@ -0,0 +1,180 @@
+require 'webrick'
+require 'cgi'
+
+module MassiveImport
+  class DashboardServer
+    def start(**options)
+      port = options.fetch(:dashboard_port, (ENV["dashboard_port"] || 9292).to_i)
+      host = options.fetch(:dashboard_host, ENV["dashboard_host"] || "127.0.0.1")
+
+      logger = WEBrick::Log.new($stdout, WEBrick::Log::INFO)
+      server = WEBrick::HTTPServer.new(
+        BindAddress: host,
+        Port: port,
+        Logger: logger,
+        AccessLog: []
+      )
+
+      server.mount_proc('/') do |request, response|
+        dispatch(request, response, logger) do
+          home(request)
+        end
+      end
+
+      server.mount_proc('/imports') do |request, response|
+        dispatch(request, response, logger) do
+          import(request)
+        end
+      end
+
+      %w[INT TERM].each { |signal| trap(signal) { server.shutdown } }
+
+      server.start
+    end
+
+    def dispatch(request, response, logger)
+      unless request.request_method == 'GET'
+        respond(response, 405, layout(request, 'Method not allowed', '<h1>405 Method Not Allowed</h1>'))
+        return
+      end
+
+      title, content = yield
+
+      if content
+        respond(response, 200, layout(request, title, content))
+      else
+        respond(response, 404, layout(request, 'Not found', '<h1>404 Not Found</h1><p><a href="/">Back to imports</a></p>'))
+      end
+    rescue => e
+      logger.info("Unhandled exception: message=#{e.message}")
+      logger.info("Unhandled exception: trace=#{e.backtrace}")
+      respond(response, 500, layout(request, 'Error', "<h1>500 Internal Server Error</h1><p><a href=\"/\">Back to imports</a></p>"))
+    end
+
+    def home(request)
+      render_imports if request.path_info == '/'
+    end
+
+    def import(request)
+      render_import($1.to_i) if request.path_info =~ %r{\A/(\d+)\z}
+    end
+
+    def respond(response, status, body)
+      response.status = status
+      response['Content-Type'] = 'text/html; charset=utf-8'
+      response.body = body
+    end
+
+    def render_imports
+      imports = Import.order(id: :desc).to_a
+      return ['Imports', '<h1>Imports</h1><p>No imports found.</p>'] if imports.empty?
+
+      headers = ['ID', 'Status', 'Processor', 'Attempt', 'Total', 'Batched', 'Concurrency', 'Batch size']
+      rows = imports.map do |imp|
+        [
+          %(<a href="/imports/#{imp.id}">##{imp.id}</a>),
+          h(imp.status),
+          h(imp.processor_class),
+          "#{imp.attempt} / #{imp.max_attempts}",
+          imp.total_records,
+          "#{imp.batch_records} / #{imp.total_records}",
+          "#{imp.current_batch_concurrency} / #{imp.max_batch_concurrency}",
+          imp.batch_size
+        ]
+      end
+
+      ['Imports', "<h1>Imports</h1>#{table(headers, rows)}"]
+    end
+
+    def render_import(id)
+      imp = Import.find_by(id: id)
+      return ['Not found', '<h1>Import not found</h1><p><a href="/">Back to imports</a></p>'] unless imp
+
+      batch_stats  = Batch.where(import_id: imp.id).group(:status).count
+      record_stats = Record.where(import_id: imp.id).group(:status).count
+      batches = Batch.where(import_id: imp.id).order(id: :desc).limit(100).to_a
+
+      summary_headers = ['Processor', 'Attempt', 'Total records', 'Batched records', 'Concurrency', 'Batch size']
+      summary_values = [
+        h(imp.processor_class),
+        "#{imp.attempt} / #{imp.max_attempts}",
+        imp.total_records,
+        "#{imp.batch_records} / #{imp.total_records}",
+        "#{imp.current_batch_concurrency} / #{imp.max_batch_concurrency}",
+        imp.batch_size
+      ]
+
+      content = +''
+      content << %(<p><a href="/">&larr; All imports</a></p>)
+      content << "<h1>Import ##{imp.id} (#{h(imp.status)})</h1>"
+      content << table(summary_headers, [summary_values])
+
+      content << '<h2>Batches by status</h2>'
+      content << stats_table(batch_stats)
+      content << '<h2>Records by status</h2>'
+      content << stats_table(record_stats)
+      content << '<h2>Recent 100 batches</h2>'
+      content << batches_table(batches)
+
+      ["Import ##{imp.id}", content]
+    end
+
+    def stats_table(stats)
+      return '<p>None.</p>' if stats.empty?
+
+      rows = stats.map { |status, count| [h(status), count] }
+      rows << ['<strong>Total</strong>', "<strong>#{stats.values.sum}</strong>"]
+
+      table(['Status', 'Count'], rows)
+    end
+
+    def batches_table(batches)
+      return '<p>No batches yet.</p>' if batches.empty?
+
+      rows = batches.map do |b|
+        started = b.started_at ? Time.at(b.started_at.to_i).strftime('%Y-%m-%d %H:%M:%S') : '-'
+        ["##{b.id}", b.attempt, h(b.status), b.start_id, b.end_id, started]
+      end
+
+      table(['Batch', 'Attempt', 'Status', 'Start ID', 'End ID', 'Started'], rows)
+    end
+
+    def table(headers, rows)
+      head = headers.empty? ? '' : "<thead><tr>#{headers.map { |header| "<th>#{header}</th>" }.join}</tr></thead>"
+      body = rows.map do |cells|
+        "<tr>#{cells.map { |cell| "<td>#{cell}</td>" }.join}</tr>"
+      end.join
+
+      <<~TABLE
+        <table border="1" cellpadding="4" cellspacing="0">
+          #{head}
+          <tbody>#{body}</tbody>
+        </table>
+      TABLE
+    end
+
+    def h(text)
+      CGI.escapeHTML(text.to_s)
+    end
+
+    def layout(request, title, content)
+      refresh = request.query['refresh'].to_i
+      refresh_html = +''
+      refresh_html << %(<meta http-equiv="refresh" content="#{refresh}">) if refresh > 0
+
+      <<~HTML
+        <!DOCTYPE html>
+        <html lang="en">
+        <head>
+          <meta charset="utf-8">
+          #{refresh_html}
+          <title>#{h(title)}</title>
+        </head>
+        <body>
+          #{content}
+        </body>
+        </html>
+      HTML
+    end
+  end
+end

data/lib/massive-import/migration.rb

@@ -0,0 +1,39 @@
+# class CreateMassiveImportTables < ActiveRecord::Migration[8.1]
+#   def change
+#     create_table :massive_import_imports do |t|
+#       t.column :attempt, :tinyint, null: false, default: 1
+#       t.column :status, :string, limit: 50, default: 'PENDING'
+#       t.column :total_records, :bigint, null: false, default: 0
+#       t.column :batch_records, :bigint, null: false, default: 0
+#       t.column :max_batch_concurrency, :smallint, null: false, default: 5
+#       t.column :current_batch_concurrency, :smallint, null: false, default: 0
+#       t.column :max_attempts, :tinyint, null: false, default: 3
+#       t.column :batch_size, :smallint, null: false, default: 50
+#       t.column :end_id, :bigint, null: false, default: 0
+#       t.text :processor_class
+#       t.column :planner_locked_until, :bigint
+#       t.text :planner_token
+#     end
+#
+#     create_table :massive_import_batches do |t|
+#       t.column :import_id, :bigint, null: false
+#       t.column :attempt, :tinyint, null: false, default: 1
+#       t.column :status, :string, limit: 50, default: 'PENDING'
+#       t.column :start_id, :bigint, null: false, default: 0
+#       t.column :end_id, :bigint, null: false, default: 0
+#       t.column :started_at, :bigint
+#       t.text :token
+#     end
+#
+#     add_index :massive_import_batches, [:import_id, :attempt, :status], name: 'idx_import_attempt_status'
+#
+#     create_table :massive_import_records do |t|
+#       t.column :import_id, :bigint, null: false
+#       t.column :attempt, :tinyint, null: false, default: 1
+#       t.column :status, :string, limit: 50, default: 'PENDING'
+#       t.json   :data
+#     end
+#
+#     add_index :massive_import_records, [:import_id, :attempt, :status], name: 'idx_import_attempt_status'
+#   end
+# end

data/lib/massive-import/planner_job.rb

@@ -0,0 +1,177 @@
+require 'securerandom'
+
+module MassiveImport
+  class PlannerJob
+    include Sidekiq::Job
+    sidekiq_retry_in do |count, exception, jobhash|
+      MassiveImport.configuration.planning_interval + rand(1..10)
+    end
+
+    def perform(args)
+      import_id = args['import_id']
+      return unless import_id
+
+      import = Import.find_by(id: import_id, status: 'RUNNING')
+      return unless import
+
+      token = SecureRandom.hex
+      lock_acquired = acquire_planner_lock(import, token)
+      return unless lock_acquired
+
+      if import.total_records == 0
+        import.update_columns(status: 'COMPLETED')
+        return
+      end
+
+      recover_timedout_batches(import)
+
+      batch_stats = Batch.where(import_id: import.id, attempt: import.attempt).group(:status).count
+      pending_batches = batch_stats.fetch('PENDING', 0)
+      running_batches = batch_stats.fetch('RUNNING', 0)
+      batches_created = 0
+
+      if pending_batches * 2 <= import.max_batch_concurrency
+        batches_created = create_batches(import, token)
+        return if batches_created < 0
+
+        if batches_created == 0 && pending_batches == 0 && running_batches == 0
+          import.reload
+          done = handle_attempt_completion(import, token)
+          return if done
+        end
+      end
+
+      import.reload
+      dispatch_workers(import, import.max_batch_concurrency, token)
+      enqueue_self(import)
+    ensure
+      release_planner_lock(import, token) if lock_acquired
+    end
+
+    private
+
+    def acquire_planner_lock(import, token)
+      now = Time.current.to_i
+      lease = MassiveImport.configuration.planner_lease
+
+      Import
+        .where(id: import.id, status: 'RUNNING')
+        .where("planner_locked_until IS NULL OR planner_locked_until < ?", now)
+        .update_all(planner_locked_until: now + lease, planner_token: token) > 0
+    end
+
+    def release_planner_lock(import, token)
+      Import
+        .where(id: import.id, planner_token: token)
+        .update_all(planner_locked_until: nil, planner_token: nil)
+    end
+
+    def recover_timedout_batches(import)
+      updated = Batch
+        .where(import_id: import.id, attempt: import.attempt, status: 'RUNNING')
+        .where('started_at < ?', Time.current.to_i - MassiveImport.configuration.batch_timeout)
+        .update_all(status: 'PENDING', started_at: nil)
+
+      if updated > 0
+        Import.where(id: import.id)
+              .where("current_batch_concurrency > 0")
+              .update_all(["current_batch_concurrency = GREATEST(0, current_batch_concurrency - ?)", updated])
+        import.reload
+      end
+    end
+
+    def dispatch_workers(import, requested_count, token)
+      slots_available = import.max_batch_concurrency - import.current_batch_concurrency
+      workers_to_enqueue = [requested_count, slots_available].min
+
+      workers_to_enqueue.times do
+        enqueue_processor(import, token)
+      end
+    end
+
+    def enqueue_processor(import, token)
+      updated = Import
+        .where(id: import.id, status: 'RUNNING', planner_token: token)
+        .where("current_batch_concurrency < max_batch_concurrency")
+        .update_all("current_batch_concurrency = current_batch_concurrency + 1")
+
+      if updated > 0
+        ProcessorJob
+          .set(queue: MassiveImport.configuration.queue_name)
+          .perform_async({ 'import_id' => import.id })
+      end
+    end
+
+    def enqueue_self(import)
+      self.class.set(queue: MassiveImport.configuration.queue_name)
+        .perform_in(MassiveImport.configuration.planning_interval, { 'import_id' => import.id })
+    end
+
+    def create_batches(import, token)
+      return 0 if (import.batch_records >= import.total_records)
+
+      batch_size = import.batch_size
+      end_id = import.end_id
+      new_batches = []
+      new_batch_records = 0
+      import.max_batch_concurrency.times do
+        records = Record
+                    .where(import_id: import.id, attempt: import.attempt, status: 'PENDING')
+                    .where("id > ?", end_id)
+                    .order(:id)
+                    .limit(batch_size)
+                    .pluck(:id)
+
+        break if records.empty?
+
+        end_id = records[-1]
+        new_batch_records += records.size
+
+        new_batches << {
+          import_id: import.id,
+          attempt: import.attempt,
+          status: 'PENDING',
+          start_id: records[0],
+          end_id: end_id
+        }
+      end
+      return 0 if new_batches.empty?
+
+      committed =
+        ActiveRecord::Base.transaction do
+          updated = Import
+            .where(id: import.id, status: 'RUNNING', planner_token: token)
+            .update_all(["end_id = ?, batch_records = batch_records + ?", end_id, new_batch_records])
+
+          raise ActiveRecord::Rollback unless updated > 0
+
+          Batch.insert_all(new_batches)
+        end
+
+      return -1 unless committed
+      new_batches.size
+    end
+
+    def handle_attempt_completion(import, token)
+      batch_records = import.batch_records
+      total_records = import.total_records
+      return false if batch_records < total_records
+
+      retry_count = Record.where(import_id: import.id, attempt: import.attempt + 1, status: 'PENDING').count
+      if retry_count == 0 || import.attempt >= import.max_attempts
+        updated = Import
+          .where(id: import.id, status: 'RUNNING', planner_token: token)
+          .update_all(status: 'COMPLETED')
+        return updated > 0
+      end
+
+      updated = Import
+        .where(id: import.id, status: 'RUNNING', planner_token: token)
+        .update_all(["attempt = attempt + 1, end_id = 0, batch_records = 0, total_records = ?", retry_count])
+      return false unless updated > 0
+
+      enqueue_self(import)
+      true
+    end
+  end
+end

data/lib/massive-import/processor_job.rb

@@ -0,0 +1,102 @@
+require 'securerandom'
+
+module MassiveImport
+  class ProcessorJob
+    include Sidekiq::Job
+    sidekiq_options retry: false
+
+    VALID_RECORD_STATUSES = ['COMPLETED', 'INVALID']
+
+    def perform(args)
+      batch_claimed = false
+      import_id = args['import_id']
+      return unless import_id
+
+      import = Import.find_by(id: import_id, status: 'RUNNING')
+      return unless import
+
+      token = SecureRandom.hex
+      batch = claim_batch(import, token)
+      return unless batch
+
+      batch_claimed = true
+      process_batch(import, batch, token)
+    rescue
+      decrement_current_concurrency(import_id) unless batch_claimed
+      raise
+    end
+
+    def claim_batch(import, token)
+      ActiveRecord::Base.transaction do
+        batch = Batch
+          .lock("FOR UPDATE SKIP LOCKED")
+          .find_by(import_id: import.id, status: 'PENDING', attempt: import.attempt)
+
+        if batch
+          batch.update_columns(status: 'RUNNING', started_at: Time.current.to_i, token: token)
+          batch
+        else
+          decrement_current_concurrency(import.id)
+          nil
+        end
+      end
+    end
+
+    def decrement_current_concurrency(import_id)
+      Import
+        .where(id: import_id)
+        .where("current_batch_concurrency > 0")
+        .update_all("current_batch_concurrency = GREATEST(0, current_batch_concurrency - 1)")
+    end
+
+    def process_batch(import, batch, token)
+      processor_instance = (import.processor_class.constantize.new rescue nil)
+
+      Record.where(import_id: import.id, attempt: import.attempt, status: 'PENDING', id: (batch.start_id..batch.end_id))
+            .find_in_batches(batch_size: 50) do |slice|
+        
+        updated = Batch.where(id: batch.id, status: 'RUNNING', token: token).update_all(started_at: Time.current.to_i)
+        return unless updated > 0
+
+        records_by_status = Hash.new { |h, k| h[k] = [] }
+
+        slice.each do |record|
+          status = process_record(processor_instance, record)
+          records_by_status[status] << record.id
+        end
+
+        update_record_statuses(import, records_by_status)
+      end
+
+      ActiveRecord::Base.transaction do
+        updated = Batch
+          .where(id: batch.id, status: 'RUNNING', token: token)
+          .update_all(status: 'COMPLETED')
+        raise ActiveRecord::Rollback unless updated > 0
+        decrement_current_concurrency(import.id)
+      end
+    end
+
+    def process_record(processor_instance, record)
+      return 'INVALID' unless processor_instance && processor_instance.respond_to?(:process)
+      status = processor_instance.process(record.data)
+      VALID_RECORD_STATUSES.include?(status) ? status : 'RETRY'
+    rescue
+      'RETRY'
+    end
+
+    def update_record_statuses(import, records_by_status)
+      records_by_status.each do |record_status, ids|
+        if record_status == 'RETRY'
+          Record.where(import_id: import.id, attempt: import.attempt, id: ids)
+                .update_all("status = 'PENDING', attempt = attempt + 1")
+        else
+          Record.where(import_id: import.id, attempt: import.attempt, id: ids)
+                .update_all(status: record_status)
+        end
+      end
+    end
+  end
+end
+
+

data/lib/massive-import.rb

@@ -0,0 +1,180 @@
+require 'active_record'
+require 'sidekiq'
+require 'logger'
+
+require_relative 'massive-import/planner_job'
+require_relative 'massive-import/processor_job'
+require_relative 'massive-import/dashboard_server'
+
+
+module MassiveImport
+  class Configuration
+    attr_accessor :queue_name, :batch_timeout, :planning_interval, :planner_lease
+
+    def initialize
+      unless ActiveRecord::Base.connected?
+        ActiveRecord::Base.establish_connection(
+          adapter:  'mysql2',
+          host:     ENV['host'],
+          username: ENV['username'],
+          password: ENV['password'],
+          database: ENV['database']
+        )
+      end
+      ActiveRecord::Base.logger ||= Logger.new($stdout)
+    end
+
+    def queue_name
+      @queue_name || :default
+    end
+
+    def batch_timeout
+      @batch_timeout || 900
+    end
+
+    def planning_interval
+      @planning_interval || 5
+    end
+
+    def planner_lease
+      @planner_lease || 900
+    end
+  end
+
+# CREATE TABLE `massive_import_imports` (
+#   `id` bigint unsigned NOT NULL AUTO_INCREMENT,
+#   `attempt` tinyint NOT NULL DEFAULT 1,
+#   `status` varchar(50) DEFAULT 'PENDING',
+#   `total_records` bigint unsigned NOT NULL DEFAULT 0,
+#   `batch_records` bigint unsigned NOT NULL DEFAULT 0,
+#   `max_batch_concurrency` smallint unsigned NOT NULL DEFAULT 5,
+#   `current_batch_concurrency` smallint unsigned NOT NULL DEFAULT 0,
+#   `max_attempts` tinyint NOT NULL DEFAULT 3,
+#   `batch_size` smallint NOT NULL DEFAULT 50,
+#   `end_id` bigint unsigned NOT NULL DEFAULT 0,
+#   `processor_class` text DEFAULT NULL,
+#   `planner_locked_until` bigint unsigned DEFAULT NULL,
+#   `planner_token` text DEFAULT NULL,
+#   PRIMARY KEY (`id`)
+# ) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci;
+
+  class Import < ActiveRecord::Base
+    def self.table_name_prefix
+      'massive_import_'
+    end
+  end
+
+# CREATE TABLE `massive_import_batches` (
+#   `id` bigint unsigned NOT NULL AUTO_INCREMENT,
+#   `import_id` bigint unsigned NOT NULL,
+#   `attempt` tinyint NOT NULL DEFAULT 1,
+#   `status` varchar(50) DEFAULT 'PENDING',
+#   `start_id` bigint unsigned NOT NULL DEFAULT 0,
+#   `end_id` bigint unsigned NOT NULL DEFAULT 0,
+#   `started_at` bigint unsigned DEFAULT NULL,
+#   `token` text DEFAULT NULL,
+#   PRIMARY KEY (`id`),
+#   KEY `idx_import_attempt_status` (`import_id`, `attempt`, `status`)
+# ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci;
+
+
+  class Batch < ActiveRecord::Base
+    def self.table_name_prefix
+      'massive_import_'
+    end
+  end
+
+# CREATE TABLE `massive_import_records` (
+#   `id` bigint unsigned NOT NULL AUTO_INCREMENT,
+#   `import_id` bigint unsigned NOT NULL,
+#   `attempt` tinyint NOT NULL DEFAULT 1,
+#   `status` varchar(50) DEFAULT 'PENDING',
+#   `data` json DEFAULT NULL,
+#   PRIMARY KEY (`id`),
+#   KEY `idx_import_attempt_status` (`import_id`, `attempt`, `status`)
+# ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci;
+
+  class Record < ActiveRecord::Base
+    def self.table_name_prefix
+      'massive_import_'
+    end
+  end
+
+  class << self
+    attr_accessor :configuration
+
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    def configure
+      yield(configuration)
+    end
+
+    def reset!
+      @configuration = Configuration.new
+    end
+
+    def stage_records(import, enumerable, **options)
+      import.reload
+      max_attempts = options.fetch(:max_attempts, import.max_attempts)
+      processor_class = options.fetch(:processor_class, import.processor_class)
+      batch_size = options.fetch(:batch_size, import.batch_size)
+      max_concurrency = options.fetch(:max_batch_concurrency, import.max_batch_concurrency)
+
+      updated = Import
+        .where(id: import.id, status: 'PENDING')
+        .update_all(
+          status: 'STAGING',
+          max_attempts: max_attempts,
+          processor_class: processor_class.to_s,
+          batch_size: batch_size,
+          max_batch_concurrency: max_concurrency
+        )
+
+      return unless updated > 0
+
+      import.reload
+      end_id = import.end_id
+      enumerable.each_slice(import.batch_size) do |slice|
+        records = slice.map do |record|
+          {
+            import_id: import.id,
+            attempt: import.attempt,
+            status: 'PENDING',
+            data: record
+          }
+        end
+
+        committed =
+          ActiveRecord::Base.transaction do
+            Record.insert_all(records)
+            end_id = Record
+              .where(import_id: import.id, attempt: import.attempt)
+              .order(id: :desc)
+              .limit(1)
+              .pick(:id)
+            raise ActiveRecord::Rollback unless end_id
+
+            updated = Import
+              .where(id: import.id, status: 'STAGING')
+              .update_all(["total_records = total_records + ?, end_id = ?", records.size, end_id])
+            raise ActiveRecord::Rollback unless updated > 0
+
+            true
+          end
+
+        return unless committed
+      end
+
+      updated = Import
+        .where(id: import.id, status: 'STAGING')
+        .update_all(status: 'RUNNING', end_id: 0)
+      return unless updated > 0
+
+      PlannerJob.set(queue: MassiveImport.configuration.queue_name).perform_async({'import_id' => import.id})
+    end
+  end
+
+  configuration
+end

metadata

@@ -0,0 +1,156 @@
+--- !ruby/object:Gem::Specification
+name: massive-import
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+platform: ruby
+authors:
+- Laughing Orca
+bindir: bin
+cert_chain: []
+date: 2026-08-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '8.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '8.1'
+- !ruby/object:Gem::Dependency
+  name: mysql2
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.5'
+- !ruby/object:Gem::Dependency
+  name: sidekiq
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '8.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '8.1'
+- !ruby/object:Gem::Dependency
+  name: webrick
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.9'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.9'
+- !ruby/object:Gem::Dependency
+  name: rack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+- !ruby/object:Gem::Dependency
+  name: rack-session
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.1'
+- !ruby/object:Gem::Dependency
+  name: rackup
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.3'
+- !ruby/object:Gem::Dependency
+  name: byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+description: execute massive imports!
+email: trulyop100@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- VERSION
+- lib/massive-import.rb
+- lib/massive-import/dashboard_server.rb
+- lib/massive-import/migration.rb
+- lib/massive-import/planner_job.rb
+- lib/massive-import/processor_job.rb
+homepage: https://github.com/laughing-orca/massive-import
+licenses: []
+metadata: {}
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.2
+specification_version: 4
+summary: execute massive imports!
+test_files: []