rails_async_migrations 1.0.0

data/lib/rails_async_migrations/migration/check_queue.rb

@@ -0,0 +1,72 @@
+# we check the state of the queue and launch run worker if needed
+module RailsAsyncMigrations
+  module Migration
+    class CheckQueue
+      def initialize
+      end
+
+      def perform
+        Tracer.new.verbose 'Check queue has been triggered'
+
+        return if has_failures?
+        return if has_on_going?
+        return if no_migration?
+
+        pending!
+        fire_migration
+      end
+
+      private
+
+      def fire_migration
+        Tracer.new.verbose "Migration `#{current_migration.id}` will now be processed"
+        Workers.new(:fire_migration).perform(current_migration.id)
+      end
+
+      def pending!
+        current_migration.update state: 'pending'
+      end
+
+      def current_migration
+        created_migration
+      end
+
+      def processing_migration
+        @processing_migration ||= AsyncSchemaMigration.processing.first
+      end
+
+      def pending_migration
+        @pending_migration ||= AsyncSchemaMigration.pending.first
+      end
+
+      def created_migration
+        @created_migration ||= AsyncSchemaMigration.created.first
+      end
+
+      def no_migration?
+        unless current_migration
+          Tracer.new.verbose 'No available migration in queue, cancelling check'
+          true
+        end
+      end
+
+      def has_on_going?
+        if pending_migration || processing_migration
+          Tracer.new.verbose 'Another migration under progress, cancelling check'
+          true
+        end
+      end
+
+      def has_failures?
+        if failed_migration
+          Tracer.new.verbose 'Failing migration blocking the queue, cancelling check'
+          true
+        end
+      end
+
+      def failed_migration
+        @failed_migration ||= AsyncSchemaMigration.failed.first
+      end
+    end
+  end
+end

data/lib/rails_async_migrations/migration/fire_migration.rb

@@ -0,0 +1,56 @@
+# we check the state of the queue and launch run worker if needed
+module RailsAsyncMigrations
+  module Migration
+    class FireMigration
+      attr_reader :migration
+
+      def initialize(migration_id)
+        @migration = AsyncSchemaMigration.find(migration_id)
+      end
+
+      def perform
+        return if done?
+
+        process!
+        run_migration
+        done!
+
+        check_queue
+      end
+
+      private
+
+      def check_queue
+        Workers.new(:check_queue).perform
+      end
+
+      def run_migration
+        Migration::Run.new(migration.direction, migration.version).perform
+      rescue Exception => exception
+        failed_with! exception
+        raise
+      end
+
+      def done?
+        if migration.state == 'done'
+          Tracer.new.verbose "Migration #{migration.id} is already `done`, cancelling fire"
+          return
+        end
+      end
+
+      def process!
+        migration.update! state: 'processing'
+      end
+
+      def done!
+        migration.update! state: 'done'
+        Tracer.new.verbose "Migration #{migration.id} was correctly processed"
+      end
+
+      def failed_with!(error)
+        migration.update! state: 'failed'
+        Tracer.new.verbose "Migration #{migration.id} failed with exception `#{error}`"
+      end
+    end
+  end
+end

data/lib/rails_async_migrations/migration/lock.rb

@@ -0,0 +1,84 @@
+# locks any class methods depending on a configuration list
+# this allow us to ignore migration without making
+# a parallel pipeline system
+module RailsAsyncMigrations
+  module Migration
+    class Lock
+      attr_reader :resource_class, :method_name
+
+      def initialize(resource_class, method_name)
+        @resource_class = resource_class
+        @method_name = method_name
+      end
+
+      def perform
+        return false unless locked_method?
+        return false if unlocked?
+
+        preserve_method_logics
+
+        suspend_lock do
+          overwrite_method
+        end
+      end
+
+      def suspend_lock(&block)
+        unlock
+        yield if block_given?
+        lock
+      end
+
+      private
+
+      def unlocked?
+        locked == false
+      end
+
+      def clone_method_name
+        "async_#{method_name}"
+      end
+
+      def preserve_method_logics
+        resource_class.define_method(clone_method_name, &captured_method)
+      end
+
+      def captured_method
+        resource_class.new.method(method_name).clone
+      end
+
+      def overwrite_method
+        resource_class.define_method(method_name, &overwrite_closure)
+      end
+
+      def overwrite_closure
+        proc do
+          Overwrite.new(self, __method__).perform
+        end
+      end
+
+      def lockable?
+        unlocked? && locked_method?
+      end
+
+      def locked_method?
+        RailsAsyncMigrations.config.locked_methods.include? method_name
+      end
+
+      def lock
+        self.locked = true
+      end
+
+      def unlock
+        self.locked = false
+      end
+
+      def locked=(value)
+        resource_class.instance_variable_set(:@locked, value)
+      end
+
+      def locked
+        resource_class.instance_variable_get(:@locked)
+      end
+    end
+  end
+end

data/lib/rails_async_migrations/migration/method_added.rb

@@ -0,0 +1,24 @@
+# any method added within the synchronous migration
+# with asynchronous directive will trigger this class
+module RailsAsyncMigrations
+  module Migration
+    class MethodAdded
+      attr_reader :resource_class, :method_name
+
+      def initialize(resource_class, method_name)
+        @resource_class = resource_class
+        @method_name = method_name
+      end
+
+      def perform
+        lock_and_overwrite
+      end
+
+      private
+
+      def lock_and_overwrite
+        Lock.new(resource_class, method_name).perform
+      end
+    end
+  end
+end

data/lib/rails_async_migrations/migration/overwrite.rb

@@ -0,0 +1,28 @@
+module RailsAsyncMigrations
+  module Migration
+    class Overwrite
+      attr_reader :instance, :method_name
+
+      def initialize(instance, method_name)
+        @instance = instance
+        @method_name = method_name
+      end
+
+      def perform
+        dispatch_trace
+        trigger_callback
+      end
+
+      private
+
+      def dispatch_trace
+        Tracer.new.verbose "#{instance.class}\##{method_name} was called in a locked state"
+      end
+
+      def trigger_callback
+        instance.send(:trigger_callback, method_name)
+      rescue NoMethodError
+      end
+    end
+  end
+end

data/lib/rails_async_migrations/migration/run.rb

@@ -0,0 +1,73 @@
+# to run actual migration we need to require the migration files
+module RailsAsyncMigrations
+  module Migration
+    class Run
+      attr_reader :direction, :version, :migration
+
+      def initialize(direction, version)
+        @direction = direction
+        @version = version
+        @migration = migration_from version
+
+        ensure_data_consistency
+        require "#{Rails.root}/#{migration.filename}" if defined? Rails
+      end
+
+      def perform
+        unlock_migration_methods
+        delete_migration_state
+        run_migration
+        delete_migration_state
+        lock_migration_methods
+      end
+
+      private
+
+      def migration_from(version)
+        Connection::ActiveRecord.new(direction).migration_from version
+      end
+
+      def run_migration
+        migrator_instance.migrate
+      end
+
+      def migrator_instance
+        @migrator_instance ||= ::ActiveRecord::Migrator.new(direction.to_sym, [migration])
+      end
+
+      def schema_migration
+        @schema_migration ||= ActiveRecord::SchemaMigration.find_by(version: version)
+      end
+
+      def delete_migration_state
+        schema_migration&.delete
+      end
+
+      def class_name
+        migration.name.constantize
+      end
+
+      def locked_methods
+        RailsAsyncMigrations.config.locked_methods
+      end
+
+      def unlock_migration_methods
+        locked_methods.each do |method_name|
+          Migration::Unlock.new(class_name, method_name).perform
+        end
+      end
+
+      def lock_migration_methods
+        locked_methods.each do |method_name|
+          Migration::Lock.new(class_name, method_name).perform
+        end
+      end
+
+      def ensure_data_consistency
+        unless migration
+          raise RailsAsyncMigrations::Error, "No migration from version `#{version}`"
+        end
+      end
+    end
+  end
+end

data/lib/rails_async_migrations/migration/unlock.rb

@@ -0,0 +1,42 @@
+module RailsAsyncMigrations
+  module Migration
+    class Unlock
+      attr_reader :resource_class, :method_name
+
+      def initialize(resource_class, method_name)
+        @resource_class = resource_class
+        @method_name = method_name
+      end
+
+      def perform
+        restore_original_method
+      end
+
+      private
+
+      def restore_original_method
+        if valid?
+          Lock.new(resource_class, method_name).suspend_lock do
+            resource_class.define_method(method_name, &method_clone)
+          end
+        end
+      end
+
+      def valid?
+        temporary_instance.respond_to? clone_method_name
+      end
+
+      def clone_method_name
+        "async_#{method_name}"
+      end
+
+      def method_clone
+        temporary_instance.method(clone_method_name).clone
+      end
+
+      def temporary_instance
+        @temporary_instance ||= resource_class.new
+      end
+    end
+  end
+end

data/lib/rails_async_migrations/migration.rb

@@ -0,0 +1,23 @@
+require 'rails_async_migrations/migration/check_queue'
+require 'rails_async_migrations/migration/fire_migration'
+require 'rails_async_migrations/migration/lock'
+require 'rails_async_migrations/migration/method_added'
+require 'rails_async_migrations/migration/overwrite'
+require 'rails_async_migrations/migration/run'
+require 'rails_async_migrations/migration/unlock'
+
+# when included this class is the gateway
+# to the method locking system
+module RailsAsyncMigrations
+  module Migration
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+      def method_added(name)
+        MethodAdded.new(self, name).perform
+      end
+    end
+  end
+end

data/lib/rails_async_migrations/models/async_schema_migration.rb

@@ -0,0 +1,18 @@
+class AsyncSchemaMigration < ActiveRecord::Base
+  validates :version, presence: true
+  validates :state, inclusion: { in: %w[created pending processing done failed] }
+  validates :direction, inclusion: { in: %w[up down] }
+
+  after_save :trace
+
+  scope :created, -> { where(state: 'created').by_version }
+  scope :pending, -> { where(state: 'pending').by_version }
+  scope :processing, -> { where(state: 'processing').by_version }
+  scope :done, -> { where(state: 'done').by_version }
+  scope :failed, -> { where(state: 'failed').by_version }
+  scope :by_version, -> { order(version: :asc) }
+
+  def trace
+    RailsAsyncMigrations::Tracer.new.verbose "Asynchronous migration `#{id}` is now `#{state}`"
+  end
+end

data/lib/rails_async_migrations/mutators/base.rb

@@ -0,0 +1,9 @@
+module RailsAsyncMigrations
+  module Mutators
+    class Base
+      def migration_class
+        instance.class
+      end
+    end
+  end
+end

data/lib/rails_async_migrations/mutators/trigger_callback.rb

@@ -0,0 +1,57 @@
+module RailsAsyncMigrations
+  module Mutators
+    class TriggerCallback < Base
+      attr_reader :instance, :method_name
+
+      def initialize(instance, method_name)
+        @instance = instance
+        @method_name = method_name
+      end
+
+      # this method can be called multiple times (we should see what manages this actually)
+      # if you use up down and change it'll be called 3 times for example
+      def perform
+        unless active_record.allowed_direction?
+          Tracer.new.verbose "Direction `#{direction}` not allowed."
+          return
+        end
+
+        enqueue_asynchronous unless already_enqueued?
+        check_queue
+      end
+
+      private
+
+      def enqueue_asynchronous
+        AsyncSchemaMigration.create!(
+          version: active_record.current_version,
+          direction: active_record.current_direction,
+          state: 'created'
+        )
+      end
+
+      def already_enqueued?
+        AsyncSchemaMigration.find_by(
+          version: active_record.current_version,
+          direction: active_record.current_direction
+        )
+      end
+
+      def check_queue
+        Workers.new(:check_queue).perform
+      end
+
+      def active_record
+        @active_record ||= Connection::ActiveRecord.new(direction)
+      end
+
+      def direction
+        if instance.reverting?
+          :down
+        else
+          :up
+        end
+      end
+    end
+  end
+end

data/lib/rails_async_migrations/mutators/turn_async.rb

@@ -0,0 +1,22 @@
+module RailsAsyncMigrations
+  module Mutators
+    class TurnAsync < Base
+      attr_reader :instance
+
+      def initialize(instance)
+        @instance = instance
+      end
+
+      def perform
+        Tracer.new.verbose '`turn_async` has been triggered'
+        alter_migration
+      end
+
+      private
+
+      def alter_migration
+        migration_class.include RailsAsyncMigrations::Migration
+      end
+    end
+  end
+end

data/lib/rails_async_migrations/mutators.rb

@@ -0,0 +1,24 @@
+require 'rails_async_migrations/mutators/base'
+require 'rails_async_migrations/mutators/turn_async'
+require 'rails_async_migrations/mutators/trigger_callback'
+
+# this is the entry point of the gem as it adds methods to the current migration class
+# the `self` represents the class being ran so we have to be careful as not to conflict
+# with the original ActiveRecord names
+module RailsAsyncMigrations
+  module Mutators
+    private
+
+    def turn_async
+      TurnAsync.new(self).perform
+    end
+
+    # # the following methods are internal mechanics
+    # # do not overwrite those methods if you don't know
+    # # exactly what you're doing
+
+    def trigger_callback(method)
+      TriggerCallback.new(self, method).perform
+    end
+  end
+end

data/lib/rails_async_migrations/railtie.rb

@@ -0,0 +1,7 @@
+module RailsAsyncMigrations
+  class Railtie < ::Rails::Railtie
+    rake_tasks do
+      load 'tasks/rails_async_migrations.rake'
+    end
+  end
+end

data/lib/rails_async_migrations/tracer.rb

@@ -0,0 +1,23 @@
+# log things and dispatch them wherever
+# depending on the context mode
+module RailsAsyncMigrations
+  class Tracer
+    def initialize
+    end
+
+    def verbose(text)
+      return unless verbose?
+      puts text
+    end
+
+    private
+
+    def verbose?
+      mode == :verbose
+    end
+
+    def mode
+      RailsAsyncMigrations.config.mode
+    end
+  end
+end

data/lib/rails_async_migrations/version.rb

@@ -0,0 +1,3 @@
+module RailsAsyncMigrations
+  VERSION = "1.0.0"
+end

data/lib/rails_async_migrations/workers/sidekiq/check_queue_worker.rb

@@ -0,0 +1,16 @@
+# we check the state of the queue and launch run worker if needed
+module RailsAsyncMigrations
+  class Workers
+    module Sidekiq
+      class CheckQueueWorker
+        include ::Sidekiq::Worker
+
+        sidekiq_options queue: :default
+
+        def perform
+          Migration::CheckQueue.new.perform
+        end
+      end
+    end
+  end
+end

data/lib/rails_async_migrations/workers/sidekiq/fire_migration_worker.rb

@@ -0,0 +1,18 @@
+# we check the state of the queue and launch run worker if needed
+module RailsAsyncMigrations
+  class Workers
+    module Sidekiq
+      class FireMigrationWorker
+        include ::Sidekiq::Worker
+
+        sidekiq_options queue: :default
+
+        def perform(migration_id)
+          Migration::FireMigration.new(
+            migration_id
+          ).perform
+        end
+      end
+    end
+  end
+end

data/lib/rails_async_migrations/workers.rb

@@ -0,0 +1,58 @@
+# we check the state of the queue and launch run worker if needed
+module RailsAsyncMigrations
+  class Workers
+    ALLOWED = [:check_queue, :fire_migration].freeze
+    attr_reader :called_worker
+
+    def initialize(called_worker)
+      @called_worker = called_worker # :check_queue, :fire_migration
+      ensure_worker_presence
+    end
+
+    def perform(args = nil)
+      return unless ALLOWED.include? called_worker
+      self.send called_worker, *args
+    end
+
+    private
+
+    def check_queue(*args)
+      case workers_type
+      when :sidekiq
+        Workers::Sidekiq::CheckQueueWorker.perform_async(*args)
+      when :delayed_job
+        ::Delayed::Job.enqueue Migration::CheckQueue.new
+      end
+    end
+
+    def fire_migration(*args)
+      case workers_type
+      when :sidekiq
+        Workers::Sidekiq::FireMigrationWorker.perform_async(*args)
+      when :delayed_job
+        ::Delayed::Job.enqueue Migration::FireMigration.new(*args)
+      end
+    end
+
+    def workers_type
+      RailsAsyncMigrations.config.workers
+    end
+
+    def ensure_worker_presence
+      case workers_type
+      when :sidekiq
+        require 'sidekiq'
+        require 'rails_async_migrations/workers/sidekiq/check_queue_worker'
+        require 'rails_async_migrations/workers/sidekiq/fire_migration_worker'
+
+        unless defined? ::Sidekiq::Worker
+          raise Error, 'Please install Sidekiq before to set it as worker adapter'
+        end
+      when :delayed_job
+        unless defined? ::Delayed::Job
+          raise Error, 'Please install Delayed::Job before to set it as worker adapter'
+        end
+      end
+    end
+  end
+end