culturecode_stagehand 0.1.4 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 72f51c6303b63f139ef0af10cd15021907df8a1d
-  data.tar.gz: 104d5725ec17b18f858ee42d02cdb08be33406fd
+  metadata.gz: 80028dbb24f83c131a67022d24ab3c84dc64edb7
+  data.tar.gz: c307e846e18fafc50f6987e9208b2dd6601d753c
 SHA512:
-  metadata.gz: ce29783f1db29d1fbe6575d35a9335cca2ae38eb3cefa5f87f1403bb01faa7afbe9660a9d8823e687bd4e77b6035409118756a51e55d9399daa9f2e82c53e911
-  data.tar.gz: b23952031a353d566de6c590d55ca5be648e3b0cd868b77b204139326c43def85065cbb8467616461321257b00dca01fa0a4af28a2f533d2febbb728958df2bc
+  metadata.gz: 8e1f6ceba25e85f6dd598b2b6ce52ca9c36e09af45ed327a7ef56a5799c8a57b2e9d76f2d8aa7d52c32783de0008c78adfc8900847127a15bea19cb6c6d76c32
+  data.tar.gz: d1c21179ad1014dd99208ca1936ab57306aaa76a6ecb070d3fb4306dd606649afc632f5005972388e767ebfddd5586820a917000f79690507361145dbf66c562

data/lib/stagehand/cache.rb

@@ -0,0 +1,12 @@
+module Stagehand
+  module Cache
+    def cache(key, &block)
+      @cache ||= {}
+      if @cache.key?(key)
+        @cache[key]
+      else
+        @cache[key] = block.call
+      end
+    end
+  end
+end

data/lib/stagehand/configuration.rb

@@ -19,6 +19,12 @@ module Stagehand
     def ghost_mode?
       !!Rails.configuration.x.stagehand.ghost_mode
     end
+
+    # Returns true if the production and staging connections are the same.
+    # Use case: Front-end devs may not have a second database set up as they are only concerned with the front end
+    def single_connection?
+      staging_connection_name == production_connection_name
+    end
   end
 
   # EXCEPTIONS

data/lib/stagehand/{helpers.rb → database.rb}

@@ -1,30 +1,24 @@
 module Stagehand
-  module Key
+  module Database
     extend self
 
-    def generate(staging_record, options = {})
-      case staging_record
-      when Staging::CommitEntry
-        id = staging_record.record_id || staging_record.id
-        table_name = staging_record.table_name || staging_record.class.table_name
-      when ActiveRecord::Base
-        id = staging_record.id
-        table_name = staging_record.class.table_name
-      else
-        id = staging_record
-        table_name = options[:table_name]
-      end
+    @@connection_name_stack = [Rails.env.to_sym]
 
-      raise 'Invalid input' unless table_name && id
+    def connected_to_production?
+      current_connection_name == Configuration.production_connection_name
+    end
 
-      return [table_name, id]
+    def connected_to_staging?
+      current_connection_name == Configuration.staging_connection_name
     end
-  end
 
-  module Database
-    extend self
+    def staging_connection
+      StagingProbe.connection
+    end
 
-    @@connection_name_stack = [Rails.env.to_sym]
+    def production_connection
+      ProductionProbe.connection
+    end
 
     def with_connection(connection_name)
       different = !Configuration.ghost_mode? && current_connection_name != connection_name.to_sym
@@ -53,5 +47,28 @@ module Stagehand
     def current_connection_name
       @@connection_name_stack.last
     end
+
+
+    # CLASSES
+
+    class StagingProbe < ActiveRecord::Base
+      self.abstract_class = true
+
+      def self.init_connection
+        establish_connection(Configuration.staging_connection_name)
+      end
+
+      init_connection
+    end
+
+    class ProductionProbe < ActiveRecord::Base
+      self.abstract_class = true
+
+      def self.init_connection
+        establish_connection(Configuration.production_connection_name)
+      end
+
+      init_connection
+    end
   end
 end

data/lib/stagehand/engine.rb

@@ -9,11 +9,13 @@ module Stagehand
     # These require the rails application to be intialized because configuration variables are used
     initializer "stagehand.load_modules" do
       require "stagehand/configuration"
+      require "stagehand/cache"
+      require "stagehand/key"
+      require "stagehand/database"
       require "stagehand/controller_extensions"
       require "stagehand/staging"
       require "stagehand/schema"
       require "stagehand/production"
-      require "stagehand/helpers"
     end
   end
 end

data/lib/stagehand/key.rb

@@ -0,0 +1,23 @@
+module Stagehand
+  module Key
+    extend self
+
+    def generate(staging_record, options = {})
+      case staging_record
+      when Staging::CommitEntry
+        id = staging_record.record_id || staging_record.id
+        table_name = staging_record.table_name || staging_record.class.table_name
+      when ActiveRecord::Base
+        id = staging_record.id
+        table_name = staging_record.class.table_name
+      else
+        id = staging_record
+        table_name = options[:table_name]
+      end
+
+      raise 'Invalid input' unless table_name && id
+
+      return [table_name, id]
+    end
+  end
+end

data/lib/stagehand/production.rb

@@ -56,7 +56,6 @@ module Stagehand
 
     def prepare_to_modify(table_name)
       raise "Can't prepare to modify production records without knowning the table_name" unless table_name.present?
-      Record.establish_connection(Configuration.production_connection_name) and @connection_established = true unless @connection_established
       Record.table_name = table_name
     end
 
@@ -71,7 +70,7 @@ module Stagehand
 
     # CLASSES
 
-    class Record < ActiveRecord::Base
+    class Record < Stagehand::Database::ProductionProbe
       self.record_timestamps = false
     end
   end

data/lib/stagehand/schema/statements.rb

@@ -5,9 +5,11 @@ module Stagehand
       def create_table(table_name, options = {})
         super
 
-        unless options.symbolize_keys[:stagehand] == false || UNTRACKED_TABLES.include?(table_name)
-          Schema.add_stagehand! :only => table_name
-        end
+        return if options.symbolize_keys[:stagehand] == false
+        return if UNTRACKED_TABLES.include?(table_name)
+        return if Database.connected_to_production?
+
+        Schema.add_stagehand! :only => table_name
       end
     end
   end

data/lib/stagehand/schema.rb

@@ -2,9 +2,11 @@ require "stagehand/schema/statements"
 
 module Stagehand
   module Schema
+    extend self
+
     UNTRACKED_TABLES = ['schema_migrations', Stagehand::Staging::CommitEntry.table_name]
 
-    def self.init_stagehand!(options = {})
+    def init_stagehand!(options = {})
       ActiveRecord::Schema.define do
         create_table :stagehand_commit_entries do |t|
           t.integer :record_id
@@ -28,44 +30,49 @@ module Stagehand
       add_stagehand!(options)
     end
 
-    def self.add_stagehand!(options = {})
+    def add_stagehand!(options = {})
       ActiveRecord::Schema.define do
-
         table_names = ActiveRecord::Base.connection.tables
         table_names -= UNTRACKED_TABLES
         table_names -= Array(options[:except]).collect(&:to_s)
         table_names &= Array(options[:only]).collect(&:to_s) if options[:only].present?
 
         table_names.each do |table_name|
-          Stagehand::Schema.drop_trigger(table_name, 'insert')
-          Stagehand::Schema.drop_trigger(table_name, 'update')
-          Stagehand::Schema.drop_trigger(table_name, 'delete')
-
-          Stagehand::Schema.create_trigger(table_name, 'insert', 'NEW')
-          Stagehand::Schema.create_trigger(table_name, 'update', 'NEW')
-          Stagehand::Schema.create_trigger(table_name, 'delete', 'OLD')
+          Stagehand::Schema.send :create_trigger, table_name, 'insert', 'NEW'
+          Stagehand::Schema.send :create_trigger, table_name, 'update', 'NEW'
+          Stagehand::Schema.send :create_trigger, table_name, 'delete', 'OLD'
         end
       end
     end
 
-    def self.remove_stagehand!(options = {})
+    def remove_stagehand!(options = {})
       ActiveRecord::Schema.define do
         table_names = ActiveRecord::Base.connection.tables
         table_names &= Array(options[:only]).collect(&:to_s) if options[:only].present?
 
         table_names.each do |table_name|
-          Stagehand::Schema.drop_trigger(table_name, 'insert')
-          Stagehand::Schema.drop_trigger(table_name, 'update')
-          Stagehand::Schema.drop_trigger(table_name, 'delete')
+          Stagehand::Schema.send :drop_trigger, table_name, 'insert'
+          Stagehand::Schema.send :drop_trigger, table_name, 'update'
+          Stagehand::Schema.send :drop_trigger, table_name, 'delete'
         end
 
         drop_table :stagehand_commit_entries unless options[:only].present?
       end
     end
 
+    def has_stagehand?(table_name = nil)
+      if table_name
+        trigger_exists?(table_name, 'insert')
+      else
+        ActiveRecord::Base.Connection.table_exists?(Stagehand::Staging::CommitEntry.table_name)
+      end
+    end
+
     private
 
-    def self.create_trigger(table_name, trigger_action, record)
+    def create_trigger(table_name, trigger_action, record)
+      return if trigger_exists?(table_name, trigger_action)
+
       ActiveRecord::Base.connection.execute("
         CREATE TRIGGER #{trigger_name(table_name, trigger_action)} AFTER #{trigger_action.upcase} ON #{table_name}
         FOR EACH ROW
@@ -76,12 +83,16 @@ module Stagehand
       ")
     end
 
-    def self.drop_trigger(table_name, trigger_action)
+    def drop_trigger(table_name, trigger_action)
       ActiveRecord::Base.connection.execute("DROP TRIGGER IF EXISTS #{trigger_name(table_name, trigger_action)};")
     end
 
-    def self.trigger_name(table_name, trigger_action)
-      "stagehand_#{trigger_action}_trigger_#{table_name}"
+    def trigger_exists?(table_name, trigger_action)
+      ActiveRecord::Base.connection.select_one("SHOW TRIGGERS where `trigger` = '#{trigger_name(table_name, trigger_action)}'").present?
+    end
+
+    def trigger_name(table_name, trigger_action)
+      "stagehand_#{trigger_action}_trigger_#{table_name}".downcase
     end
   end
 end

data/lib/stagehand/staging/auditor.rb

@@ -0,0 +1,64 @@
+module Stagehand
+  module Staging
+    module Auditor
+      extend self
+
+      def incomplete_commits
+        incomplete = []
+
+        incomplete_start_operations.each do |start_operation|
+          entries = records_until_match(start_operation, :asc, :operation => CommitEntry::START_OPERATION).to_a
+          incomplete << [start_operation.id, entries]
+        end
+
+        incomplete_end_operations.each do |end_operation|
+          entries = records_through_match(end_operation, :desc, :operation => CommitEntry::START_OPERATION).to_a
+          incomplete << [entries.last.id, entries]
+        end
+
+        return incomplete.to_h
+      end
+
+      private
+
+      # Incomplete End Operation that are not the last entry in their session
+      def incomplete_end_operations
+        last_entry_per_session = CommitEntry.group(:session).select('MAX(id) AS id')
+        return CommitEntry.uncontained.end_operations.where.not(:id => last_entry_per_session)
+      end
+
+      # Incomplete Start on the same session as a subsequent start operation
+      def incomplete_start_operations
+        last_start_entry_per_session = CommitEntry.start_operations.group(:session).select('MAX(id) AS id')
+        return CommitEntry.uncontained.start_operations.where.not(:id => last_start_entry_per_session)
+      end
+
+      def records_until_match(start_entry, direction, match_attributes)
+        records_through_match(start_entry, direction, match_attributes)[0..-2]
+      end
+
+      def records_through_match(start_entry, direction, match_attributes)
+        last_entry = next_match(start_entry, direction, match_attributes)
+        return records_from(start_entry, direction).where.not("id #{exclusive_comparator(direction)} ?", last_entry)
+      end
+
+      def next_match(start_entry, direction, match_attributes)
+        records_from(start_entry, direction).where.not(:id => start_entry.id).where(match_attributes).first
+      end
+
+      def records_from(start_entry, direction)
+        scope = CommitEntry.where(:session => start_entry.session).where("id #{comparator(direction)} ?", start_entry.id)
+        scope = scope.reverse_order if direction == :desc
+        return scope
+      end
+
+      def comparator(direction)
+        exclusive_comparator(direction) + '='
+      end
+
+      def exclusive_comparator(direction)
+        direction == :asc ? '>' : '<'
+      end
+    end
+  end
+end

data/lib/stagehand/staging/checklist.rb

@@ -1,6 +1,9 @@
 module Stagehand
   module Staging
     class Checklist
+      extend Cache
+      include Cache
+
       def self.related_commits(commit)
         Commit.find(related_commit_ids(commit))
       end
@@ -34,10 +37,67 @@ module Stagehand
         return related_entries
       end
 
+      def self.associated_records(entries)
+        records = preload_records(compact_entries(entries)).select(&:record).flat_map do |entry|
+          associated_associations(entry.record_class).flat_map do |association|
+            entry.record.send(association)
+          end
+        end
+
+        records.uniq!
+        records.compact!
+        records.select! {|record| stagehand_class?(record.class) }
+
+        return records
+      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)
+        compact_entries = group_entries(entries)
+        compact_entries = compact_entries[:delete] + compact_entries[:insert] + compact_entries[:update]
+        compact_entries.uniq!(&:key)
+
+        return compact_entries
+      end
+
+      # Groups entries by their operation
+      def self.group_entries(entries)
+        group_entries = Hash.new {|h,k| h[k] = [] }
+        group_entries.merge! entries.group_by(&:operation).symbolize_keys!
+
+        return group_entries
+      end
+
+      def self.preload_records(entries)
+        entries.group_by(&:table_name).each do |table_name, group_entries|
+          klass = CommitEntry.infer_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
+          group_entries.each do |entry|
+            entry.record = records_by_id[entry.record_id]
+          end
+        end
+
+        return entries
+      end
+
+      private
+
+      def self.associated_associations(klass)
+        cache("#{klass.name}_associated_associations") { klass.reflect_on_all_associations(:belongs_to).collect(&:name) }
+      end
+
+      def self.stagehand_class?(klass)
+        cache("#{klass.name}_stagehand_class?") { Schema.has_stagehand?(klass.table_name) }
+      end
+
+      public
+
       def initialize(subject, &confirmation_filter)
         @subject = subject
         @confirmation_filter = confirmation_filter
-        @cache = {}
         affected_entries # Init the affected_entries changes can be rolled back without affecting the checklist
       end
 
@@ -64,7 +124,7 @@ module Stagehand
       end
 
       def syncing_entries
-        cache(:syncing_entries) { compact_entries(affected_entries) }
+        cache(:syncing_entries) { self.class.compact_entries(affected_entries) }
       end
 
       def affected_records
@@ -72,7 +132,13 @@ module Stagehand
       end
 
       def affected_entries
-        cache(:affected_entries) { self.class.related_entries(@subject) }
+        cache(:affected_entries) do
+          related = self.class.related_entries(@subject)
+          associated = self.class.associated_records(related)
+          associated_related = self.class.related_entries(associated)
+
+          related + associated_related
+        end
       end
 
       private
@@ -89,59 +155,15 @@ module Stagehand
           # Don't need to confirm entries that were not part of a commit
           entries = entries.select(&:commit_id)
 
-          entries = compact_entries(entries)
-          entries = preload_records(entries)
+          entries = self.class.compact_entries(entries)
           entries = filter_entries(entries)
-          entries = group_entries(entries)
+          entries = self.class.group_entries(entries)
         end
       end
 
       def filter_entries(entries)
         @confirmation_filter ? entries.select {|entry| @confirmation_filter.call(entry.record) } : entries
       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 compact_entries(entries)
-        compact_entries = group_entries(entries)
-        compact_entries = compact_entries[:delete] + compact_entries[:insert] + compact_entries[:update]
-        compact_entries.uniq!(&:key)
-
-        return compact_entries
-      end
-
-      # Groups entries by their operation
-      def group_entries(entries)
-        group_entries = Hash.new {|h,k| h[k] = [] }
-        group_entries.merge! entries.group_by(&:operation).symbolize_keys!
-
-        return group_entries
-      end
-
-      def preload_records(entries)
-        entries.group_by(&:table_name).each do |table_name, group_entries|
-          klass = CommitEntry.infer_class(table_name)
-          records = klass.where(:id => group_entries.collect(&:record_id))
-          records_by_id = records.collect {|r| [r.id, r] }.to_h
-          group_entries.each do |entry|
-            entry.record = records_by_id[entry.record_id]
-          end
-        end
-
-        return entries
-      end
-
-      def cache(key, &block)
-        if @cache.key?(key)
-          @cache[key]
-        else
-          @cache[key] = block.call
-        end
-      end
-
-      def clear_cache
-        @cache.clear
-      end
     end
   end
 end

data/lib/stagehand/staging/synchronizer.rb

@@ -40,6 +40,10 @@ module Stagehand
       end
 
       def sync_entries(entries)
+        return 0 if Configuration.single_connection? # Avoid deadlocking if the databases are the same
+
+        raise SchemaMismatch unless schemas_match?
+
         ActiveRecord::Base.transaction do
           entries.each do |entry|
             Rails.logger.info "Synchronizing #{entry.table_name} #{entry.record_id}"
@@ -62,10 +66,18 @@ module Stagehand
             CommitEntry.select('MAX(id) AS id').content_operations.not_in_progress.group('record_id, table_name').having('count(commit_id) = 0'))
         end
       end
+
+      def schemas_match?
+        versions_scope = ActiveRecord::SchemaMigration.order(:version)
+        staging_versions = Stagehand::Database.staging_connection.select_values(versions_scope)
+        production_versions = Stagehand::Database.production_connection.select_values(versions_scope)
+        return staging_versions == production_versions
+      end
     end
   end
 
   # EXCEPTIONS
 
   class SyncBlockRequired < StandardError; end
+  class SchemaMismatch < StandardError; end
 end

data/lib/stagehand/staging.rb

@@ -4,6 +4,7 @@ require 'stagehand/staging/checklist'
 require 'stagehand/staging/controller'
 require 'stagehand/staging/model'
 require 'stagehand/staging/synchronizer'
+require 'stagehand/staging/auditor'
 
 module Stagehand
   module Staging

data/lib/stagehand/version.rb

@@ -1,3 +1,3 @@
 module Stagehand
-  VERSION = "0.1.4"
+  VERSION = "0.2.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: culturecode_stagehand
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.2.0
 platform: ruby
 authors:
 - Nicholas Jakobsen
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-04-01 00:00:00.000000000 Z
+date: 2016-04-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -67,15 +67,18 @@ files:
 - Rakefile
 - lib/culturecode_stagehand.rb
 - lib/stagehand.rb
+- lib/stagehand/cache.rb
 - lib/stagehand/configuration.rb
 - lib/stagehand/controller_extensions.rb
+- lib/stagehand/database.rb
 - lib/stagehand/engine.rb
-- lib/stagehand/helpers.rb
+- lib/stagehand/key.rb
 - lib/stagehand/production.rb
 - lib/stagehand/production/controller.rb
 - lib/stagehand/schema.rb
 - lib/stagehand/schema/statements.rb
 - lib/stagehand/staging.rb
+- lib/stagehand/staging/auditor.rb
 - lib/stagehand/staging/checklist.rb
 - lib/stagehand/staging/commit.rb
 - lib/stagehand/staging/commit_entry.rb