culturecode_stagehand 0.15.1 → 1.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5fdc23b385dbb657b54cb029e4714657b4aa3e69
-  data.tar.gz: bdbd449b63397e6a68e223616d1ee6f7ce737c58
+  metadata.gz: 778925f3540847fcf089ab3ffb65d6993362c59e
+  data.tar.gz: 770602a0719fef798f82744b00e9c60dc33f6c24
 SHA512:
-  metadata.gz: 87fb81e17c7fb2837b9217bc7cda6758b1694667f1b5b0a97da5b75bb0c512fe2a695d2ee44768d8e3ceb275d07f222453d7eb79ad69dd98426156df021f4cbe
-  data.tar.gz: ab28c8a9ab9cc625c30a573c17c2e4043d9498aef2f9cf90e01bcba2ed9d68d91c0d1708d59f2df27905cf6644617e1e99a6bd41d626d1ff7902f32209db7662
+  metadata.gz: fd85561ed53df15f0180ef0a42eaa17f01e6c904e6208aec47b87b9ba3fdd661285c1bb88e8d6d16916df38247ff399d9d8e371b34761526bd877ce724d65b22
+  data.tar.gz: 1e0a9fe56efcf5fe0a65183cbc3d798c629c814d6be31bf3aa4fa637821fbe4e8d9c037c1fa302372da03910f61d8066afd1dce047e218b1be059ced4afc7486

data/Rakefile

@@ -4,9 +4,17 @@ rescue LoadError
   puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
 end
 
-APP_RAKEFILE = File.expand_path("../spec/dummy/Rakefile", __FILE__)
+APP_RAKEFILE = File.expand_path("../spec/internal/Rakefile", __FILE__)
 load 'rails/tasks/engine.rake'
 
 load 'rails/tasks/statistics.rake'
 
 Bundler::GemHelper.install_tasks
+
+
+# Add Rspec tasks
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/lib/stagehand.rb

@@ -1,4 +1,5 @@
-require "stagehand/engine"
+require 'rails/all'
+require 'stagehand/engine'
 
 module Stagehand
 end

data/lib/stagehand/active_record_extensions.rb

@@ -1,6 +1,10 @@
+require 'thread'
+
 ActiveRecord::Base.class_eval do
   # SYNC CALLBACKS
-  define_model_callbacks :sync, :sync_as_subject, :sync_as_affected
+  ([self] + ActiveSupport::DescendantsTracker.descendants(self)).each do |klass|
+    klass.define_model_callbacks :sync, :sync_as_subject, :sync_as_affected
+  end
 
   # SYNC STATUS
   def self.inherited(subclass)
@@ -9,18 +13,70 @@ ActiveRecord::Base.class_eval do
     subclass.class_eval do
       has_one :stagehand_unsynced_indicator,
         lambda { where(:stagehand_commit_entries => {:table_name => subclass.table_name}).readonly },
-        :class_name => Stagehand::Staging::CommitEntry,
+        :class_name => 'Stagehand::Staging::CommitEntry',
+        :foreign_key => :record_id
+
+      has_one :stagehand_unsynced_commit_indicator,
+        lambda { where(:stagehand_commit_entries => {:table_name => subclass.table_name}).where.not(commit_id: nil).readonly },
+        :class_name => 'Stagehand::Staging::CommitEntry',
         :foreign_key => :record_id
 
       def synced?
         stagehand_unsynced_indicator.blank?
       end
+
+      def synced_all_commits?
+        stagehand_unsynced_commit_indicator.blank?
+      end
     end
   end
 
   # SCHEMA
   delegate :has_stagehand?, to: :class
   def self.has_stagehand?
-    @has_stagehand ||= Stagehand::Schema.has_stagehand?(table_name)
+    @has_stagehand = Stagehand::Schema.has_stagehand?(table_name) unless defined?(@has_stagehand)
+    return @has_stagehand
+  end
+
+  # MULTITHREADED CONNECTION HANDLING
+
+  # The original implementation of remove_connection uses @connection_specification_name, which is shared across Threads.
+  # We need to pass in the connection that model in the current thread is using if we call remove_connection.
+  def self.remove_connection(name = StagehandConnectionMap.get(self))
+    StagehandConnectionMap.set(self, nil)
+    super
+  end
+
+  def self.connection_specification_name=(connection_name)
+    # ActiveRecord sets the connection pool to 'primary' by default, so we want to reuse that connection for staging
+    # in order to avoid using a different connection pool after our first swap back to the staging connection.
+    connection_name == 'primary' if connection_name == Stagehand::Configuration.staging_connection_name
+
+    StagehandConnectionMap.set(self, connection_name)
+
+    # We want to keep track of the @connection_specification_name as a fallback shared across threads in case we
+    # haven't set the connection on more than one thread.
+    super
+  end
+
+  def self.connection_specification_name
+    StagehandConnectionMap.get(self) || super
+  end
+
+  # Keep track of the current connection name per-model, per-thread so multithreaded webservers don't overwrite it
+  module StagehandConnectionMap
+    def self.set(klass, connection_name)
+      currentMap[klass.name] = connection_name
+    end
+
+    def self.get(klass)
+      currentMap[klass.name]
+    end
+
+    def self.currentMap
+      map = Thread.current.thread_variable_get('StagehandConnectionMap')
+      map = Thread.current.thread_variable_set('StagehandConnectionMap', {}) unless map
+      return map
+    end
   end
 end

data/lib/stagehand/connection_adapter_extensions.rb

@@ -1,11 +1,7 @@
 module Stagehand
   module Connection
     def self.with_production_writes(model, &block)
-      state = model.connection.readonly?
-      model.connection.readonly!(false)
-      return block.call
-    ensure
-      model.connection.readonly!(state)
+      model.connection.allow_writes(&block)
     end
 
     module AdapterExtensions
@@ -31,7 +27,7 @@ module Stagehand
 
       def allow_writes(&block)
         state = readonly?
-        readonly!(true)
+        readonly!(false)
         return block.call
       ensure
         readonly!(state)
@@ -48,7 +44,7 @@ module Stagehand
       private
 
       def update_readonly_state
-        readonly! unless Configuration.single_connection? || @config[:database] != Database.production_database_name
+        readonly! unless Configuration.single_connection? || @config[:database] == Database.staging_database_name
       end
 
       def clear_readonly_state
@@ -59,9 +55,9 @@ module Stagehand
         if !readonly?
           return
         elsif Configuration.allow_unsynced_production_writes?
-          Rails.logger.warn "Writing directly to production database"
+          Rails.logger.warn "Writing directly to #{@config[:database]} database using readonly connection"
         else
-          raise(UnsyncedProductionWrite, "Attempted to write directly to production database")
+          raise(UnsyncedProductionWrite, "Attempted to write directly to #{@config[:database]} database using readonly connection")
         end
       end
     end

data/lib/stagehand/controller_extensions.rb

@@ -4,12 +4,12 @@ module Stagehand
 
     class_methods do
       def use_staging_database(options = {})
-        skip_action_callback :use_production_database, options
+        skip_around_action :use_production_database, raise: false, **options
         prepend_around_action :use_staging_database, options
       end
 
       def use_production_database(options = {})
-        skip_action_callback :use_staging_database, options
+        skip_around_action :use_staging_database, raise: false, **options
         prepend_around_action :use_production_database, options
       end
     end

data/lib/stagehand/database.rb

@@ -1,9 +1,9 @@
+require 'thread'
+
 module Stagehand
   module Database
     extend self
 
-    @@connection_name_stack = [Rails.env.to_sym]
-
     def each(&block)
       with_production_connection(&block) unless Configuration.single_connection?
       with_staging_connection(&block)
@@ -49,24 +49,16 @@ module Stagehand
       with_connection(Configuration.production_connection_name, &block)
     end
 
-    def with_connection(connection_name)
-      different = current_connection_name != connection_name.to_sym
-
-      if different
-        @@connection_name_stack.push(connection_name.to_sym)
-        Rails.logger.debug "Connecting to #{current_connection_name}"
-        connect_to(current_connection_name)
+    def with_connection(connection_name, &block)
+      if current_connection_name != connection_name.to_sym
+        Rails.logger.debug "Connecting to #{connection_name}"
+        output = swap_connection(connection_name, &block)
+        Rails.logger.debug "Restoring connection to #{current_connection_name}"
       else
         Rails.logger.debug "Already connected to #{connection_name}"
+        output = yield connection_name
       end
-
-      yield connection_name
-    ensure
-      if different
-        @@connection_name_stack.pop
-        Rails.logger.debug "Restoring connection to #{current_connection_name}"
-        connect_to(current_connection_name)
-      end
+      return output
     end
 
     def transaction
@@ -84,12 +76,27 @@ module Stagehand
 
     private
 
-    def connect_to(connection_name)
-      ActiveRecord::Base.establish_connection(connection_name)
+    def swap_connection(connection_name)
+      raise ConnectionSwapDuringTransaction unless safe_to_swap_connection?
+      
+      cache = ActiveRecord::Base.connection_pool.query_cache_enabled
+      ConnectionStack.push(connection_name.to_sym)
+      ActiveRecord::Base.connection_specification_name = current_connection_name
+      ActiveRecord::Base.connection_pool.enable_query_cache! if cache
+
+      yield connection_name
+    ensure
+      ConnectionStack.pop
+      ActiveRecord::Base.connection_specification_name = current_connection_name
+      ActiveRecord::Base.connection_pool.enable_query_cache! if cache
+    end
+
+    def safe_to_swap_connection?
+      ActiveRecord::Base.connection.open_transactions == 0
     end
 
     def current_connection_name
-      @@connection_name_stack.last
+      ConnectionStack.last
     end
 
     def database_name(connection_name)
@@ -102,24 +109,65 @@ module Stagehand
 
     # CLASSES
 
-    class StagingProbe < ActiveRecord::Base
+    class Probe < ActiveRecord::Base
+      self.abstract_class = true
+
+      # We fake the class name so we can create a connection pool with the desired connection name instead of the name of the class
+      def self.init_connection(connection_name)
+        @probe_name = connection_name
+        establish_connection(connection_name)
+      ensure
+        @probe_name = nil
+      end
+
+      def self.name
+        @probe_name || super
+      end
+    end
+
+    class StagingProbe < Probe
       self.abstract_class = true
 
       def self.init_connection
-        establish_connection(Configuration.staging_connection_name)
+        super(Configuration.staging_connection_name)
       end
 
       init_connection
     end
 
-    class ProductionProbe < ActiveRecord::Base
+    class ProductionProbe < Probe
       self.abstract_class = true
 
       def self.init_connection
-        establish_connection(Configuration.production_connection_name)
+        super(Configuration.production_connection_name)
       end
 
-      init_connection
+      init_connection unless Configuration.single_connection?
+    end
+
+    # Threadsafe tracking of the connection stack
+    module ConnectionStack
+      @@connection_name_stack = Hash.new { |h,k| h[k] = [ Rails.env.to_sym ] }
+
+      def self.push(connection_name)
+        current_stack.push connection_name
+      end
+
+      def self.pop
+        current_stack.pop
+      end
+
+      def self.last
+        current_stack.last
+      end
+
+      def self.current_stack
+        @@connection_name_stack[Thread.current.object_id]
+      end
     end
   end
+
+  # EXCEPTIONS
+
+  class ConnectionSwapDuringTransaction < StandardError; end
 end

data/lib/stagehand/engine.rb

@@ -1,4 +1,4 @@
-require "stagehand/configuration"
+require 'stagehand/configuration'
 
 module Stagehand
   class Engine < ::Rails::Engine
@@ -8,17 +8,18 @@ module Stagehand
       g.test_framework :rspec
     end
 
-    # These require the rails application to be intialized because configuration variables are used
-    initializer "stagehand.load_modules" do
-      require "stagehand/cache"
-      require "stagehand/key"
-      require "stagehand/database"
-      require "stagehand/connection_adapter_extensions"
-      require "stagehand/controller_extensions"
-      require "stagehand/active_record_extensions"
-      require "stagehand/staging"
-      require "stagehand/production"
-      require "stagehand/schema"
+    # These require the rails application to be initialized because configuration variables are used
+    initializer 'stagehand.load_modules' do
+      require 'stagehand/cache'
+      require 'stagehand/key'
+      require 'stagehand/database'
+      require 'stagehand/connection_adapter_extensions'
+      require 'stagehand/controller_extensions'
+      require 'stagehand/active_record_extensions'
+      require 'stagehand/schema_extensions'
+      require 'stagehand/staging'
+      require 'stagehand/production'
+      require 'stagehand/schema'
       require 'stagehand/auditor'
     end
   end

data/lib/stagehand/schema.rb

@@ -4,7 +4,7 @@ module Stagehand
   module Schema
     extend self
 
-    UNTRACKED_TABLES = ['schema_migrations', Stagehand::Staging::CommitEntry.table_name]
+    UNTRACKED_TABLES = ['ar_internal_metadata', 'schema_migrations', Stagehand::Staging::CommitEntry.table_name]
 
     def init_stagehand!(options = {})
       ActiveRecord::Schema.define do

data/lib/stagehand/schema_extensions.rb

@@ -0,0 +1,10 @@
+module Stagehand
+  module SchemaExtensions
+    def define(*)
+      # Allow production writes during Schema.define to allow Rails to write to ar_internal_metadata table
+      Stagehand::Connection.with_production_writes(ActiveRecord::Base) { super }
+    end
+  end
+end
+
+ActiveRecord::Schema.prepend(Stagehand::SchemaExtensions)

data/lib/stagehand/staging/checklist.rb

@@ -55,10 +55,10 @@ module Stagehand
       end
 
       # Returns a list of entries that only includes a single entry for each record.
-      # The type of entry chosen prioritizes creates over updates, and deletes over creates.
-      def self.compact_entries(entries)
+      # The entries are prioritized by the list of operations as given by `:priority`.
+      def self.compact_entries(entries, priority: [:delete, :update, :insert])
         compact_entries = group_entries(entries)
-        compact_entries = compact_entries[:delete] + compact_entries[:insert] + compact_entries[:update]
+        compact_entries = compact_entries.values_at(*priority).flatten
         compact_entries.uniq!(&:key)
 
         return compact_entries
@@ -74,7 +74,7 @@ module Stagehand
 
       def self.preload_records(entries)
         entries.group_by(&:table_name).each do |table_name, group_entries|
-          klass = CommitEntry.infer_class(table_name)
+          klass = CommitEntry.infer_base_class(table_name)
           records = klass.where(:id => group_entries.collect(&:record_id))
           records = records.includes(associated_associations(klass))
           records_by_id = records.collect {|r| [r.id, r] }.to_h
@@ -129,7 +129,7 @@ module Stagehand
       end
 
       def syncing_entries
-        cache(:syncing_entries) { self.class.compact_entries(affected_entries) }
+        cache(:syncing_entries) { self.class.compact_entries(affected_entries, priority: Synchronizer::ENTRY_SYNC_ORDER) }
       end
 
       def affected_records
@@ -138,11 +138,13 @@ module Stagehand
 
       def affected_entries
         cache(:affected_entries) do
-          related = self.class.related_entries(@subject, @relation_filter)
+          from_subject = subject_entries
+          from_subject |= CommitEntry.where(commit_id: subject_entries.select(:commit_id))
+          related = self.class.related_entries(from_subject, @relation_filter)
           associated = self.class.associated_records(related, @association_filter)
           associated_related = self.class.related_entries(associated, @relation_filter)
 
-          (related + associated_related).uniq
+          (from_subject + related + associated_related).uniq
         end
       end
 
@@ -172,7 +174,7 @@ module Stagehand
           end.collect(&:id)
           entries.reject! {|entry| staging_record_start_operation_ids.include?(entry.commit_id) }
 
-          entries = self.class.compact_entries(entries)
+          entries = self.class.compact_entries(entries, priority: [:delete, :insert, :update])
           entries = filter_entries(entries)
           entries = self.class.group_entries(entries)
         end

data/lib/stagehand/staging/commit_entry.rb

@@ -60,16 +60,10 @@ module Stagehand
         return keys.present? ? where(sql.join(' OR '), *interpolates) : none
       end
 
-      def self.infer_class(table_name, record_id = nil)
+      def self.infer_base_class(table_name)
         classes = ActiveRecord::Base.descendants.select {|klass| klass.table_name == table_name }
         classes.delete(Stagehand::Production::Record)
-        root_class = classes.first || table_name.classify.constantize # Try loading the class if it isn't loaded yet
-
-        if record_id && record = root_class.find_by_id(record_id)
-          klass = record.class
-        end
-
-        return klass || root_class
+        return classes.first || table_name.classify.constantize.base_class # Try loading the class if it isn't loaded yet
       rescue NameError
         raise(IndeterminateRecordClass, "Can't determine class from table name: #{table_name}")
       end
@@ -122,22 +116,37 @@ module Stagehand
       end
 
       def record_class
-        @record_class ||= self.class.infer_class(table_name, record_id)
+        @record_class ||= infer_class
       rescue IndeterminateRecordClass
         @record_class ||= self.class.build_missing_model(table_name)
       end
 
+      def production_record
+        @production_record = Stagehand::Production.find(record_id, table_name) unless defined?(@production_record)
+        return @production_record
+      end
+
       private
 
+      def infer_class
+        klass = self.class.infer_base_class(table_name)
+        klass = infer_sti_class(klass) || infer_production_sti_class(klass) || klass if record_id
+        return klass
+      end
+
+      def infer_sti_class(root_class)
+        root_class.find_by_id(record_id)&.class
+      end
+
+      def infer_production_sti_class(root_class)
+        production_record[root_class.inheritance_column]&.constantize if production_record
+      end
+
       def build_deleted_record
-        production_record = Stagehand::Production.find(record_id, table_name)
         return unless production_record
-
-        deleted_record = record_class.new(production_record.attributes)
+        deleted_record = production_record.becomes(record_class)
         deleted_record.readonly!
-        deleted_record.instance_variable_set(:@new_record, false)
-        deleted_record.instance_variable_set(:@destroyed, true)
-
+        deleted_record.singleton_class.include(DeletedRecord)
         return deleted_record
       end
 
@@ -149,11 +158,13 @@ module Stagehand
     end
   end
 
-  # DUMMY CLASSES
+  # UTILITY MODULES
 
-  module DummyClass; end
+  module DummyClass; end # A namespace for dummy classes of records with an IndeterminateRecordClass
+  module DeletedRecord; end # Serves as a way of tagging an instance to see if it is_a?(Stagehand::DeletedRecord)
 
   # EXCEPTIONS
+
   class IndeterminateRecordClass < StandardError; end
   class MissingTable < StandardError; end
 end

data/lib/stagehand/staging/synchronizer.rb

@@ -6,6 +6,8 @@ module Stagehand
 
       BATCH_SIZE = 1000
       SESSION_BATCH_SIZE = 30
+      ENTRY_SYNC_ORDER = [:delete, :update, :insert].freeze
+      ENTRY_SYNC_ORDER_SQL = ActiveRecord::Base.send(:sanitize_sql_for_order, ['FIELD(operation, ?), id DESC', ENTRY_SYNC_ORDER]).freeze
 
       # Immediately attempt to sync the changes from the block if possible
       # The block is wrapped in a transaction to prevent changes to records while being synced
@@ -50,7 +52,7 @@ module Stagehand
 
       def sync_all
         loop do
-          entries = CommitEntry.order(:id => :desc).limit(BATCH_SIZE).to_a
+          entries = CommitEntry.order(ENTRY_SYNC_ORDER_SQL).limit(BATCH_SIZE).to_a
           break unless entries.present?
 
           latest_entries = entries.uniq(&:key)
@@ -87,7 +89,8 @@ module Stagehand
       # Returns commit entries in ID descending order
       def iterate_autosyncable_entries(&block)
         current = CommitEntry.maximum(:id).to_i
-        while entries = autosyncable_entries("id <= #{current}").limit(BATCH_SIZE).order(:id => :desc).to_a.presence do
+
+        while entries = autosyncable_entries("id <= #{current}").limit(BATCH_SIZE).order(ENTRY_SYNC_ORDER_SQL).to_a.presence do
           with_confirmed_autosyncability(entries.uniq(&:key), &block)
           current = entries.last.try(:id).to_i - 1
         end

data/lib/stagehand/version.rb

@@ -1,3 +1,3 @@
 module Stagehand
-  VERSION = "0.15.1"
+  VERSION = "1.0.3"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: culturecode_stagehand
 version: !ruby/object:Gem::Version
-  version: 0.15.1
+  version: 1.0.3
 platform: ruby
 authors:
 - Nicholas Jakobsen
@@ -9,22 +9,28 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-11-23 00:00:00.000000000 Z
+date: 2019-01-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '4.2'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '5.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '4.2'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '5.2'
 - !ruby/object:Gem::Dependency
   name: mysql2
   requirement: !ruby/object:Gem::Requirement
@@ -53,20 +59,62 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: mysql2
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.4.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.4.0
+- !ruby/object:Gem::Dependency
+  name: combustion
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.0
 - !ruby/object:Gem::Dependency
   name: rspec-rails
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '3.7'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '3.7'
+- !ruby/object:Gem::Dependency
+  name: database_cleaner
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Simplify the management of a sandbox database that can sync content to
   a production database. Content changes can be bundled to allow partial syncs of
   the database.
@@ -95,6 +143,7 @@ files:
 - lib/stagehand/production/controller.rb
 - lib/stagehand/schema.rb
 - lib/stagehand/schema/statements.rb
+- lib/stagehand/schema_extensions.rb
 - lib/stagehand/staging.rb
 - lib/stagehand/staging/checklist.rb
 - lib/stagehand/staging/commit.rb
@@ -124,7 +173,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.12
+rubygems_version: 2.6.14
 signing_key: 
 specification_version: 4
 summary: Simplify the management of a sandbox database that can sync content to a