culturecode_stagehand 1.1.5 → 1.1.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b9684506c931ca15ad9c467e5d96fb359ede46c3d41624331b72b7efe0b7b850
-  data.tar.gz: 43f4509740eb53ace3293ad6bdbd718562e165adf282e1ca2114c5daebd5ee15
+  metadata.gz: a254ae2d2cba86110f9584be58f6975ca777958bec8c1bc6e71f18195080d43e
+  data.tar.gz: 1a4a94337e918823c620bda226fba92789a9e47b9067a6daf6fff5676e33648b
 SHA512:
-  metadata.gz: 5cca6f14c6f8c9194d400a5c21bb49f90758e2160a9ebac99b72621f8b64410f91429a5b6f3ba62db4faf92d7d50caf1caee66a4d5631ccf4ac196206677130c
-  data.tar.gz: 28f4439a34ed046edff565df691fd4d1fada3e227a52a9fc3d60fec9b245db8d0a0c4e50629ab86febc7e5d0171c270b7257ee4121b0b5517296f6fb152b4eb6
+  metadata.gz: 1c2a0b58055a9033a86a4f7fce1a3b83f92140e3390f39aa8b745dc8d9b3e0bcc01e2c8724c810c85d67080ff6c2810a61f711735716269143098b04a2c38523
+  data.tar.gz: 1355afb448d1f0c5549bb814ef1c9a34f36983ce3c78a81f7bf3edc93f0501bc1349718a5a076548682b604193ac3a991093c2cab24b8f8937f980afa4091b0a

data/lib/stagehand/active_record_extensions.rb

@@ -71,16 +71,16 @@ ActiveRecord::Base.class_eval do
   # 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
+      current_map[klass.name] = connection_name
     end
 
     def self.get(klass)
-      currentMap[klass.name]
+      current_map[klass.name]
     end
 
-    def self.currentMap
+    def self.current_map
       map = Thread.current.thread_variable_get('StagehandConnectionMap')
-      map = Thread.current.thread_variable_set('StagehandConnectionMap', {}) unless map
+      map = Thread.current.thread_variable_set('StagehandConnectionMap', Concurrent::Hash.new) unless map
       return map
     end
   end

data/lib/stagehand/configuration.rb

@@ -9,7 +9,8 @@ module Stagehand
   module Configuration
     extend self
 
-    mattr_accessor :checklist_confirmation_filter, :checklist_association_filter, :checklist_relation_filter, :ignored_columns
+    mattr_accessor :checklist_confirmation_filter, :checklist_association_filter, :checklist_relation_filter, :staging_model_tables, :ignored_columns
+    self.staging_model_tables = Set.new
     self.ignored_columns = HashWithIndifferentAccess.new
 
     def staging_connection_name

data/lib/stagehand/connection_adapter_extensions.rb

@@ -9,14 +9,30 @@ module Stagehand
     end
 
     def self.allow_unsynced_production_writes!(state = true)
-      Thread.current[:stagehand_allow_unsynced_production_writes] = state
+      Thread.current.thread_variable_set(:stagehand_allow_unsynced_production_writes, state)
     end
 
     def self.allow_unsynced_production_writes?
-      !!Thread.current[:stagehand_allow_unsynced_production_writes]
+      !!Thread.current.thread_variable_get(:stagehand_allow_unsynced_production_writes)
     end
 
     module AdapterExtensions
+      def quote_table_name(table_name)
+        if prefix_table_name_with_database?(table_name)
+          super("#{Stagehand::Database.staging_database_name}.#{table_name}")
+        else
+          super
+        end
+      end
+
+      def prefix_table_name_with_database?(table_name)
+        return false if Configuration.single_connection?
+        return false unless Database.connected_to_production?
+        return false if Connection.allow_unsynced_production_writes?
+        return false unless Configuration.staging_model_tables.include?(table_name)
+        true
+      end
+
       def exec_insert(*)
         handle_readonly_writes!
         super

data/lib/stagehand/database.rb

@@ -5,6 +5,31 @@ module Stagehand
   module Database
     extend self
 
+    def transaction
+      raise InvalidConnectionError, "Calling Stagehand::Database.transaction is not valid unless connected to staging" unless connected_to_staging?
+
+      success = false
+      attempts = 0
+      output = nil
+      ActiveRecord::Base.transaction do
+        Production::Record.transaction do
+          attempts += 1
+
+          raise NoRetryError, "Retrying is not allowed in Stagehand::Database.transaction" if attempts > 1
+
+          output = yield
+
+          success = true
+        end
+
+        raise ActiveRecord::Rollback unless success
+      end
+
+      return output
+    ensure
+      Rails.logger.warn "Stagehand::Database transaction was rolled back" unless success
+    end
+
     def each(&block)
       with_production_connection(&block) unless Configuration.single_connection?
       with_staging_connection(&block)
@@ -62,30 +87,17 @@ module Stagehand
       return output
     end
 
-    def transaction
-      success = false
-      output = nil
-      ActiveRecord::Base.transaction do
-        Production::Record.transaction do
-          output = yield
-          success = true
-        end
-        raise ActiveRecord::Rollback unless success
-      end
-      return output
-    end
-
     private
 
     def swap_connection(connection_name)
+      pushed = ConnectionStack.push(connection_name.to_sym)
       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
+      ConnectionStack.pop if pushed
       ActiveRecord::Base.connection_specification_name = current_connection_name
       ActiveRecord::Base.connection_pool.enable_query_cache! if cache
     end
@@ -128,6 +140,14 @@ module Stagehand
         super(Configuration.staging_connection_name)
       end
 
+      def self.connection
+        if Stagehand::Database.connected_to_staging?
+          ActiveRecord::Base.connection # Reuse existing connection so we stay within the current transaction
+        else
+          super
+        end
+      end
+
       init_connection
     end
 
@@ -143,8 +163,6 @@ module Stagehand
 
     # 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
@@ -158,8 +176,18 @@ module Stagehand
       end
 
       def self.current_stack
-        @@connection_name_stack[Thread.current.object_id]
+        if stack = Thread.current.thread_variable_get('sparkle_connection_name_stack')
+          stack
+        else
+          stack = Concurrent::Array.new
+          stack << Rails.env.to_sym
+          Thread.current.thread_variable_set('sparkle_connection_name_stack', stack)
+          stack
+        end
       end
     end
+
+    class InvalidConnectionError < StandardError; end
+    class NoRetryError < StandardError; end
   end
 end

data/lib/stagehand/production.rb

@@ -24,16 +24,19 @@ module Stagehand
     end
 
     def write(staging_record, attributes, table_name = nil)
-      Connection.with_production_writes do
-        is_new = matching(staging_record, table_name).update_all(attributes).zero?
+      table_name, id = Stagehand::Key.generate(staging_record, :table_name => table_name)
 
-        # Ensure we always return a record, even when updating instead of creating
-        Record.new.tap do |record|
-          record.assign_attributes(attributes)
-          record.id = Stagehand::Key.generate(staging_record, :table_name => table_name).last unless record.id
-          record.save if is_new
+      production_record = Connection.with_production_writes do
+        prepare_to_modify(table_name)
+
+        if update(table_name, id, attributes).nonzero?
+          Record.find(id)
+        else
+          Record.find(insert(table_name, attributes))
         end
       end
+
+      return production_record
     end
 
     def delete(staging_record, table_name = nil)
@@ -67,25 +70,58 @@ module Stagehand
 
     private
 
-    def prepare_to_modify(table_name)
-      raise "Can't prepare to modify production records without knowning the table_name" unless table_name.present?
-      Record.table_name = table_name
-    end
-
     def production_record_attributes(staging_record, table_name = nil)
       Record.connection.select_one(matching(staging_record, table_name))
     end
 
     def staging_record_attributes(staging_record, table_name = nil)
       table_name, id = Stagehand::Key.generate(staging_record, :table_name => table_name)
-      hash = Stagehand::Staging::CommitEntry.connection.select_one("SELECT * FROM #{table_name} WHERE id = #{id}")
-      hash&.except(*ignored_columns(table_name))
+      hash = select(table_name, id)
+      hash.except(*ignored_columns(table_name)) if hash
     end
 
     def ignored_columns(table_name)
       Array.wrap(Configuration.ignored_columns[table_name]).map(&:to_s)
     end
 
+    def select(table_name, id)
+      table = Arel::Table.new(table_name)
+      statement = Arel::SelectManager.new
+      statement.from table
+      statement.project Arel.star
+      statement.where table[:id].eq(id)
+
+      Stagehand::Database::StagingProbe.connection.select_one(statement)
+    end
+
+    def update(table_name, id, attributes)
+      table = Arel::Table.new(table_name)
+      statement = Arel::UpdateManager.new
+      statement.table table
+      statement.set attributes.map {|attribute, value| [table[attribute], value] }
+      statement.where table[:id].eq(id)
+
+      Record.connection.update(statement)
+    end
+
+    def insert(table_name, attributes)
+      table = Arel::Table.new(table_name)
+      statement = Arel::InsertManager.new
+      statement.into table
+      statement.insert attributes.map {|attribute, value| [table[attribute], value] }
+
+      Record.connection.insert(statement)
+    end
+
+    def prepare_to_modify(table_name)
+      raise "Can't prepare to modify production records without knowning the table_name" unless table_name.present?
+
+      return if Record.table_name == table_name
+
+      Record.table_name = table_name
+      Record.reset_column_information
+    end
+
     # CLASSES
 
     class Record < Stagehand::Database::ProductionProbe

data/lib/stagehand/schema.rb

@@ -28,6 +28,8 @@ module Stagehand
     end
 
     def add_stagehand!(options = {})
+      return if Database.connected_to_production? && !Stagehand::Configuration.single_connection?
+
       ActiveRecord::Schema.define do
         Stagehand::Schema.send :each_table, options do |table_name|
           Stagehand::Schema.send :create_operation_trigger, table_name, 'insert', 'NEW'
@@ -40,6 +42,7 @@ module Stagehand
     def remove_stagehand!(options = {})
       ActiveRecord::Schema.define do
         Stagehand::Schema.send :each_table, options do |table_name|
+          next unless Stagehand::Schema.send :has_stagehand_triggers?, table_name
           Stagehand::Schema.send :drop_trigger, table_name, 'insert'
           Stagehand::Schema.send :drop_trigger, table_name, 'update'
           Stagehand::Schema.send :drop_trigger, table_name, 'delete'
@@ -53,9 +56,9 @@ module Stagehand
       if UNTRACKED_TABLES.include?(table_name.to_s)
         return false
       elsif table_name
-        trigger_exists?(table_name, 'insert')
+        has_stagehand_triggers?(table_name)
       else
-        ActiveRecord::Base.Connection.table_exists?(Stagehand::Staging::CommitEntry.table_name)
+        ActiveRecord::Base.connection.table_exists?(Stagehand::Staging::CommitEntry.table_name)
       end
     end
 
@@ -106,8 +109,21 @@ module Stagehand
       ActiveRecord::Base.connection.select_one("SHOW TRIGGERS where `trigger` = '#{trigger_name(table_name, trigger_event)}'").present?
     end
 
+    def has_stagehand_triggers?(table_name)
+      get_triggers(table_name).present?
+    end
+
     def trigger_name(table_name, trigger_event)
       "stagehand_#{trigger_event}_trigger_#{table_name}".downcase
     end
+
+    def get_triggers(table_name = nil)
+      statement = <<~SQL
+        SHOW TRIGGERS WHERE `Trigger` LIKE 'stagehand_%'
+      SQL
+      statement << " AND `Table` LIKE #{ActiveRecord::Base.connection.quote(table_name)}" if table_name.present?
+
+      return ActiveRecord::Base.connection.select_all(statement)
+    end
   end
 end

data/lib/stagehand/staging/checklist.rb

@@ -33,7 +33,7 @@ module Stagehand
         end
 
         # Also include uncontained commit entries that matched
-        related_entries.concat(CommitEntry.uncontained.matching(entries + related_entries))
+        related_entries.concat(CommitEntry.uncontained.not_in_progress.matching(entries + related_entries))
         related_entries.uniq!
 
         return related_entries

data/lib/stagehand/staging/commit_entry.rb

@@ -61,8 +61,9 @@ module Stagehand
       end
 
       def self.infer_base_class(table_name)
-        classes = ActiveRecord::Base.descendants.select {|klass| klass.table_name == table_name }
-        classes.delete(Stagehand::Production::Record)
+        classes = ActiveRecord::Base.descendants
+        classes.select! {|klass| klass.table_name == table_name }
+        classes.reject! {|klass| klass < Stagehand::Database::Probe }
         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}")

data/lib/stagehand/staging/model.rb

@@ -3,12 +3,22 @@ module Stagehand
     module Model
       extend ActiveSupport::Concern
 
+      included do
+        Stagehand::Configuration.staging_model_tables << table_name
+      end
+
       class_methods do
+        def quoted_table_name
+          if connection.prefix_table_name_with_database?(table_name)
+            @prefixed_quoted_table_name ||= connection.quote_table_name(table_name)
+          else
+            super
+          end
+        end
+
         def connection
           if Configuration.ghost_mode?
             super
-          elsif Stagehand::Database.connected_to_staging?
-            ActiveRecord::Base.connection
           else
             Stagehand::Database::StagingProbe.connection
           end

data/lib/stagehand/staging/synchronizer.rb

@@ -133,7 +133,7 @@ module Stagehand
         raise SchemaMismatch unless schemas_match?
 
         run_sync_callbacks(entry, callbacks) do
-          Rails.logger.info "Synchronizing #{entry.table_name} #{entry.record_id}" if entry.content_operation?
+          Rails.logger.info "Synchronizing #{entry.table_name} #{entry.record_id} (#{entry.operation})" if entry.content_operation?
           if Configuration.single_connection?
             next # Avoid deadlocking if the databases are the same
           elsif entry.delete_operation?

data/lib/stagehand/version.rb

@@ -1,3 +1,3 @@
 module Stagehand
-  VERSION = "1.1.5"
+  VERSION = "1.1.10"
 end

data/lib/tasks/stagehand_tasks.rake

@@ -34,6 +34,8 @@ namespace :stagehand do
   end
 
   rake_both_databases('db:migrate')
+  rake_both_databases('db:migrate:up')
+  rake_both_databases('db:migrate:down')
   rake_both_databases('db:rollback')
   rake_both_databases('db:test:load_structure')
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: culturecode_stagehand
 version: !ruby/object:Gem::Version
-  version: 1.1.5
+  version: 1.1.10
 platform: ruby
 authors:
 - Nicholas Jakobsen
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-06-29 00:00:00.000000000 Z
+date: 2021-11-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -166,8 +166,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.9
+rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
 summary: Simplify the management of a sandbox database that can sync content to a