online_migrations 0.10.0 → 0.11.0

data/lib/online_migrations/background_migrations/migration.rb

@@ -2,7 +2,7 @@
 
 module OnlineMigrations
   module BackgroundMigrations
-    class Migration < ActiveRecord::Base
+    class Migration < ApplicationRecord
       STATUSES = [
         :enqueued,    # The migration has been enqueued by the user.
         :running,     # The migration is being performed by a migration executor.
@@ -15,25 +15,29 @@ module OnlineMigrations
       self.table_name = :background_migrations
 
       scope :queue_order, -> { order(created_at: :asc) }
+      scope :runnable, -> { where(composite: false) }
       scope :active, -> { where(status: [statuses[:enqueued], statuses[:running]]) }
+      scope :except_succeeded, -> { where.not(status: :succeeded) }
       scope :for_migration_name, ->(migration_name) { where(migration_name: normalize_migration_name(migration_name)) }
       scope :for_configuration, ->(migration_name, arguments) do
         for_migration_name(migration_name).where("arguments = ?", arguments.to_json)
       end
 
-      enum status: STATUSES.map { |status| [status, status.to_s] }.to_h
+      enum status: STATUSES.index_with(&:to_s)
 
+      belongs_to :parent, class_name: name, optional: true
+      has_many :children, class_name: name, foreign_key: :parent_id
       has_many :migration_jobs
 
       validates :migration_name, :batch_column_name, presence: true
 
-      validates :min_value, :max_value, :batch_size, :sub_batch_size,
-                  presence: true, numericality: { greater_than: 0 }
+      validates :batch_size, :sub_batch_size, presence: true, numericality: { greater_than: 0 }
+      validates :min_value, :max_value, presence: true, numericality: { greater_than: 0, unless: :composite? }
 
       validates :batch_pause, :sub_batch_pause_ms, presence: true,
                   numericality: { greater_than_or_equal_to: 0 }
-      validates :rows_count, numericality: { greater_than_or_equal_to: 0 }, allow_nil: true
-      validates :arguments, uniqueness: { scope: :migration_name }
+      validates :rows_count, numericality: { greater_than_or_equal_to: 0 }, allow_nil: true, unless: :composite?
+      validates :arguments, uniqueness: { scope: [:migration_name, :shard] }
 
       validate :validate_batch_column_values
       validate :validate_batch_sizes
@@ -43,6 +47,8 @@ module OnlineMigrations
       validates_with MigrationStatusValidator, on: :update
 
       before_validation :set_defaults
+      before_create :create_child_migrations, if: :composite?
+      before_update :copy_attributes_to_children, if: :composite?
 
       # @private
       def self.normalize_migration_name(migration_name)
@@ -58,28 +64,53 @@ module OnlineMigrations
         succeeded? || failed?
       end
 
+      # Overwrite enum's generated method to correctly work for composite migrations.
+      def paused!
+        return super if !composite?
+
+        transaction do
+          super
+          children.each { |child| child.paused! if child.enqueued? || child.running? }
+        end
+      end
+
+      # Overwrite enum's generated method to correctly work for composite migrations.
+      def running!
+        return super if !composite?
+
+        transaction do
+          super
+          children.each { |child| child.running! if child.paused? }
+        end
+      end
+
       def last_job
-        migration_jobs.order(max_value: :desc).first
+        migration_jobs.order(:max_value).last
       end
 
       def last_completed_job
-        migration_jobs.completed.order(finished_at: :desc).first
+        migration_jobs.completed.order(:finished_at).last
       end
 
       # Returns the progress of the background migration.
       #
       # @return [Float, nil]
-      #   - when background migration is configured to not to track progress, returns `nil`
-      #   - otherwise returns value in range of 0.0 and 1.0
+      #   - when background migration is configured to not track progress, returns `nil`
+      #   - otherwise returns value in range from 0.0 to 100.0
       #
       def progress
         if succeeded?
-          1.0
+          100.0
+        elsif composite?
+          progresses = children.map(&:progress).compact
+          if progresses.any?
+            (progresses.sum / progresses.size).round(2)
+          end
         elsif rows_count
           jobs_rows_count = migration_jobs.succeeded.sum(:batch_size)
           # The last migration job may need to process the amount of rows
           # less than the batch size, so we can get a value > 1.0.
-          [jobs_rows_count.to_f / rows_count, 1.0].min
+          ([jobs_rows_count.to_f / rows_count, 1.0].min * 100).round(2)
         end
       end
 
@@ -95,13 +126,19 @@ module OnlineMigrations
         migration_object.relation
       end
 
+      def migration_model
+        migration_relation.model
+      end
+
       # Returns whether the interval between previous step run has passed.
       # @return [Boolean]
       #
       def interval_elapsed?
-        if migration_jobs.running.exists?
+        last_active_job = migration_jobs.active.order(:updated_at).last
+
+        if last_active_job && !last_active_job.stuck?
           false
-        elsif (job = last_completed_job)
+        elsif batch_pause > 0 && (job = last_completed_job)
           job.finished_at + batch_pause <= Time.current
         else
           true
@@ -123,6 +160,14 @@ module OnlineMigrations
         end
       end
 
+      # @private
+      def on_shard(&block)
+        abstract_class = find_abstract_class(migration_model)
+
+        shard = (self.shard || abstract_class.default_shard).to_sym
+        abstract_class.connected_to(shard: shard, role: :writing, &block)
+      end
+
       # @private
       def reset_failed_jobs_attempts
         iterator = BatchIterator.new(migration_jobs.failed.attempts_exceeded)
@@ -138,16 +183,10 @@ module OnlineMigrations
 
         # rubocop:disable Lint/UnreachableLoop
         iterator.each_batch(of: batch_size, column: batch_column_name, start: next_min_value) do |relation|
-          if Utils.ar_version <= 4.2
-            # Active Record <= 4.2 does not support pluck with Arel nodes
-            quoted_column = self.class.connection.quote_column_name(batch_column_name)
-            batch_range = relation.pluck("MIN(#{quoted_column}), MAX(#{quoted_column})").first
-          else
-            min = relation.arel_table[batch_column_name].minimum
-            max = relation.arel_table[batch_column_name].maximum
+          min = relation.arel_table[batch_column_name].minimum
+          max = relation.arel_table[batch_column_name].maximum
+          batch_range = relation.pick(min, max)
 
-            batch_range = relation.pluck(min, max).first
-          end
           break
         end
         # rubocop:enable Lint/UnreachableLoop
@@ -162,6 +201,10 @@ module OnlineMigrations
         [min_value, max_value]
       end
 
+      protected
+        attr_accessor :child
+        alias child? child
+
       private
         def validate_batch_column_values
           if max_value.to_i < min_value.to_i
@@ -176,7 +219,13 @@ module OnlineMigrations
         end
 
         def validate_jobs_status
-          if succeeded? && migration_jobs.except_succeeded.exists?
+          if composite?
+            if succeeded? && children.except_succeeded.exists?
+              errors.add(:base, "all child migrations must be succeeded")
+            elsif failed? && !children.failed.exists?
+              errors.add(:base, "at least one child migration must be failed")
+            end
+          elsif succeeded? && migration_jobs.except_succeeded.exists?
             errors.add(:base, "all migration jobs must be succeeded")
           elsif failed? && !migration_jobs.failed.exists?
             errors.add(:base, "at least one migration job must be failed")
@@ -185,12 +234,30 @@ module OnlineMigrations
 
         def set_defaults
           if migration_relation.is_a?(ActiveRecord::Relation)
-            self.batch_column_name  ||= migration_relation.primary_key
-            self.min_value          ||= migration_relation.minimum(batch_column_name)
-            self.max_value          ||= migration_relation.maximum(batch_column_name)
-
-            count = migration_object.count
-            self.rows_count = count if count != :no_count
+            if !child?
+              shards = Utils.shard_names(migration_model)
+              self.composite = shards.size > 1
+            end
+
+            self.batch_column_name ||= migration_relation.primary_key
+
+            if composite?
+              self.min_value = self.max_value = self.rows_count = -1 # not relevant
+            else
+              on_shard do
+                self.min_value ||= migration_relation.minimum(batch_column_name)
+                self.max_value ||= migration_relation.maximum(batch_column_name)
+
+                # This can be the case when run in development on empty tables
+                if min_value.nil?
+                  # integer IDs minimum value is 1
+                  self.min_value = self.max_value = 1
+                end
+
+                count = migration_object.count
+                self.rows_count = count if count != :no_count
+              end
+            end
           end
 
           config = ::OnlineMigrations.config.background_migrations
@@ -199,12 +266,27 @@ module OnlineMigrations
           self.batch_pause          ||= config.batch_pause
           self.sub_batch_pause_ms   ||= config.sub_batch_pause_ms
           self.batch_max_attempts   ||= config.batch_max_attempts
+        end
+
+        def create_child_migrations
+          shards = Utils.shard_names(migration_model)
 
-          # This can be the case when run in development on empty tables
-          if min_value.nil?
-            # integer IDs minimum value is 1
-            self.min_value = self.max_value = 1
+          children = shards.map do |shard|
+            child = Migration.new(migration_name: migration_name, arguments: arguments, shard: shard)
+            child.child = true
+            child
           end
+
+          self.children = children
+        end
+
+        def copy_attributes_to_children
+          attributes = [:batch_size, :sub_batch_size, :batch_pause, :sub_batch_pause_ms, :batch_max_attempts]
+          updates = {}
+          attributes.each do |attribute|
+            updates[attribute] = read_attribute(attribute) if attribute_changed?(attribute)
+          end
+          children.update_all(updates) if updates.any?
         end
 
         def next_min_value
@@ -214,6 +296,13 @@ module OnlineMigrations
             min_value
           end
         end
+
+        def find_abstract_class(model)
+          model.ancestors.find do |parent|
+            parent == ActiveRecord::Base ||
+              (parent.is_a?(Class) && parent.abstract_class?)
+          end
+        end
     end
   end
 end

data/lib/online_migrations/background_migrations/migration_helpers.rb

@@ -223,10 +223,6 @@ module OnlineMigrations
       #     For smaller tables it is probably better and easier to directly find and delete orpahed records.
       #
       def delete_orphaned_records_in_background(model_name, *associations, **options)
-        if Utils.ar_version <= 4.2
-          raise "#{__method__} does not support Active Record <= 4.2 yet"
-        end
-
         model_name = model_name.name if model_name.is_a?(Class)
 
         enqueue_background_migration(

data/lib/online_migrations/background_migrations/migration_job.rb

@@ -2,7 +2,7 @@
 
 module OnlineMigrations
   module BackgroundMigrations
-    class MigrationJob < ActiveRecord::Base
+    class MigrationJob < ApplicationRecord
       STATUSES = [
         :enqueued,
         :running,
@@ -12,12 +12,11 @@ module OnlineMigrations
 
       self.table_name = :background_migration_jobs
 
-      # For Active Record <= 4.2 needs to fully specify enum values
-      scope :active, -> { where(status: [statuses[:enqueued], statuses[:running]]) }
-      scope :completed, -> { where(status: [statuses[:failed], statuses[:succeeded]]) }
+      scope :active, -> { where(status: [:enqueued, :running]) }
+      scope :completed, -> { where(status: [:failed, :succeeded]) }
       scope :stuck, -> do
-        timeout = ::OnlineMigrations.config.background_migrations.stuck_jobs_timeout
-        active.where("updated_at <= ?", timeout.ago)
+        timeout = OnlineMigrations.config.background_migrations.stuck_jobs_timeout
+        active.where("updated_at <= ?", timeout.seconds.ago)
       end
 
       scope :retriable, -> do
@@ -26,7 +25,7 @@ module OnlineMigrations
         stuck_sql             = connection.unprepared_statement { stuck.to_sql }
         failed_retriable_sql  = connection.unprepared_statement { failed_retriable.to_sql }
 
-        from(Arel.sql(<<-SQL.strip_heredoc))
+        from(Arel.sql(<<~SQL))
           (
             (#{failed_retriable_sql})
             UNION
@@ -35,19 +34,16 @@ module OnlineMigrations
         SQL
       end
 
-      scope :except_succeeded, -> { where("status != ?", statuses[:succeeded]) }
+      scope :except_succeeded, -> { where.not(status: :succeeded) }
       scope :attempts_exceeded, -> { where("attempts >= max_attempts") }
 
-      enum status: STATUSES.map { |status| [status, status.to_s] }.to_h
+      enum status: STATUSES.index_with(&:to_s)
 
       delegate :migration_class, :migration_object, :migration_relation, :batch_column_name,
         :arguments, :batch_pause, to: :migration
 
       belongs_to :migration
 
-      # For Active Record 5.0+ this is validated by default from belongs_to
-      validates :migration, presence: true
-
       validates :min_value, :max_value, presence: true, numericality: { greater_than: 0 }
       validate :values_in_migration_range, if: :min_value?
       validate :validate_values_order, if: :min_value?
@@ -56,6 +52,13 @@ module OnlineMigrations
 
       before_create :copy_settings_from_migration
 
+      # Whether the job is considered stuck (is running for some configured time).
+      #
+      def stuck?
+        timeout = OnlineMigrations.config.background_migrations.stuck_jobs_timeout
+        running? && updated_at <= timeout.seconds.ago
+      end
+
       # Mark this job as ready to be processed again.
       #
       # This is used when retrying failed jobs.

data/lib/online_migrations/background_migrations/migration_job_runner.rb

@@ -6,7 +6,7 @@ module OnlineMigrations
     class MigrationJobRunner
       attr_reader :migration_job
 
-      delegate :attempts, :migration_relation, :migration_object, :sub_batch_size,
+      delegate :migration, :attempts, :migration_relation, :migration_object, :sub_batch_size,
         :batch_column_name, :min_value, :max_value, :pause_ms, to: :migration_job
 
       def initialize(migration_job)
@@ -30,7 +30,7 @@ module OnlineMigrations
         )
 
         ActiveSupport::Notifications.instrument("process_batch.background_migrations", job_payload) do
-          run_batch
+          migration.on_shard { run_batch }
         end
 
         migration_job.update!(status: :succeeded, finished_at: Time.current)

data/lib/online_migrations/background_migrations/migration_runner.rb

@@ -12,8 +12,13 @@ module OnlineMigrations
 
       # Runs one background migration job.
       def run_migration_job
-        migration.running! if migration.enqueued?
-        migration_payload = { background_migration: migration }
+        raise "Should not be called on a composite (with sharding) migration" if migration.composite?
+
+        if migration.enqueued?
+          migration.running!
+          migration.parent.running! if migration.parent && migration.parent.enqueued?
+        end
+        migration_payload = notifications_payload(migration)
 
         if !migration.migration_jobs.exists?
           ActiveSupport::Notifications.instrument("started.background_migrations", migration_payload)
@@ -37,6 +42,8 @@ module OnlineMigrations
           end
 
           ActiveSupport::Notifications.instrument("completed.background_migrations", migration_payload)
+
+          complete_parent_if_needed(migration) if migration.parent.present?
         end
 
         next_migration_job
@@ -52,8 +59,15 @@ module OnlineMigrations
 
         migration.running!
 
-        while migration.running?
-          run_migration_job
+        if migration.composite?
+          migration.children.each do |child_migration|
+            runner = self.class.new(child_migration)
+            runner.run_all_migration_jobs
+          end
+        else
+          while migration.running?
+            run_migration_job
+          end
         end
       end
 
@@ -64,13 +78,20 @@ module OnlineMigrations
       def finish
         return if migration.completed?
 
-        # Mark is as finishing to avoid being picked up
-        # by the background migrations scheduler.
-        migration.finishing!
-        migration.reset_failed_jobs_attempts
-
-        while migration.finishing?
-          run_migration_job
+        if migration.composite?
+          migration.children.each do |child_migration|
+            runner = self.class.new(child_migration)
+            runner.finish
+          end
+        else
+          # Mark is as finishing to avoid being picked up
+          # by the background migrations scheduler.
+          migration.finishing!
+          migration.reset_failed_jobs_attempts
+
+          while migration.finishing?
+            run_migration_job
+          end
         end
       end
 
@@ -95,6 +116,30 @@ module OnlineMigrations
             max_value: max_value
           )
         end
+
+        def complete_parent_if_needed(migration)
+          parent = migration.parent
+          completed = false
+
+          parent.with_lock do
+            children = parent.children.select(:status)
+            if children.all?(&:succeeded?)
+              parent.succeeded!
+              completed = true
+            elsif children.any?(&:failed?)
+              parent.failed!
+              completed = true
+            end
+          end
+
+          if completed
+            ActiveSupport::Notifications.instrument("completed.background_migrations", notifications_payload(migration))
+          end
+        end
+
+        def notifications_payload(migration)
+          { background_migration: migration }
+        end
     end
   end
 end

data/lib/online_migrations/background_migrations/reset_counters.rb

@@ -26,7 +26,7 @@ module OnlineMigrations
           counter_name = reflection.counter_cache_column
 
           quoted_association_table = connection.quote_table_name(has_many_association.table_name)
-          count_subquery = <<-SQL.strip_heredoc
+          count_subquery = <<~SQL
             SELECT COUNT(*)
             FROM #{quoted_association_table}
             WHERE #{quoted_association_table}.#{connection.quote_column_name(foreign_key)} =
@@ -41,8 +41,7 @@ module OnlineMigrations
           names = Array.wrap(names)
           options = names.extract_options!
           touch_updates = touch_attributes_with_time(*names, **options)
-          # In Active Record 4.2 sanitize_sql_for_assignment is protected
-          updates << model.send(:sanitize_sql_for_assignment, touch_updates)
+          updates << model.sanitize_sql_for_assignment(touch_updates)
         end
 
         relation.update_all(updates.join(", "))
@@ -64,11 +63,6 @@ module OnlineMigrations
 
             has_many_association = has_many.find do |association|
               counter_cache_column = association.counter_cache_column
-
-              # Active Record <= 4.2 is able to return only explicitly provided `counter_cache` column.
-              if !counter_cache_column && Utils.ar_version <= 4.2
-                counter_cache_column = "#{association.name}_count"
-              end
               counter_cache_column && counter_cache_column.to_sym == counter_association.to_sym
             end
 
@@ -86,7 +80,7 @@ module OnlineMigrations
         def touch_attributes_with_time(*names, time: nil)
           attribute_names = timestamp_attributes_for_update & model.column_names
           attribute_names |= names.map(&:to_s)
-          attribute_names.map { |attribute_name| [attribute_name, time || Time.current] }.to_h
+          attribute_names.index_with(time || Time.current)
         end
 
         def timestamp_attributes_for_update

data/lib/online_migrations/background_migrations/scheduler.rb

@@ -4,15 +4,14 @@ module OnlineMigrations
   module BackgroundMigrations
     # Class responsible for scheduling background migrations.
     # It selects runnable background migrations and runs them one step (one batch) at a time.
-    # A migration is considered runnable if it is not completed and time the interval between
+    # A migration is considered runnable if it is not completed and the time interval between
     #   successive runs has passed.
-    # Scheduler ensures (via advisory locks) that at most one background migration at a time is running per database.
     #
-    # Scheduler should be run via some kind of periodical means, for example, cron.
+    # Scheduler should be configured to run periodically, for example, via cron.
     # @example Run via whenever
     #   # add this to schedule.rb
     #   every 1.minute do
-    #     runner "OnlineMigrations::BackgroundMigrations::Scheduler.run"
+    #     runner "OnlineMigrations.run_background_migrations"
     #   end
     #
     class Scheduler
@@ -22,24 +21,15 @@ module OnlineMigrations
 
       # Runs Scheduler
       def run
-        active_migrations = Migration.active.queue_order
+        active_migrations = Migration.runnable.active.queue_order
         runnable_migrations = active_migrations.select(&:interval_elapsed?)
 
         runnable_migrations.each do |migration|
-          connection = migration.migration_relation.connection
-
-          with_exclusive_lock(connection) do
-            run_migration_job(migration)
-          end
+          run_migration_job(migration)
         end
       end
 
       private
-        def with_exclusive_lock(connection, &block)
-          lock = AdvisoryLock.new(name: "online_migrations_scheduler", connection: connection)
-          lock.with_lock(&block)
-        end
-
         def run_migration_job(migration)
           runner = MigrationRunner.new(migration)
           runner.run_migration_job