culturecode_stagehand 0.3.0 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: db833ca765b28d4f8c2ee6700ffdd3e450dff705
-  data.tar.gz: ed31a76fa1c17d8edacdc595a2d7353c0c0720b2
+  metadata.gz: 88258f8ab5b38d62a941024ddeef50d3e66ac13b
+  data.tar.gz: 9f1571c1823366b2a5b576d9e213a7585713e883
 SHA512:
-  metadata.gz: 2cf9ce58d98f5c1b962036280f0ccb9f0da9ac3bb881c7f08f2689f944cb7b5e255062fb018b79b630f392258b39007316b636c90972aef4cc68cffb5e79946a
-  data.tar.gz: b0dea71a1f093f7f78fc836bc427a20a3e7b777fbfd5d6456909be62ea1b2be1c078d695ef0abbc8831cc63b7d64081ce8a1cb2901fd60ca2b94f69e8898a830
+  metadata.gz: a8020df0d22695e6fe842996690431bff25595e5dc3c76f46cb3ff7054dc8e56fad5dab0dc93007d6cc81d84b9875e922f2d70f0b98a37f28a479e50b63e1c55
+  data.tar.gz: 391d375fd5dcc015f8ad867cc7495c476e2e1d652beddd18584ca2a4df262baf5aa0938f6ebb323357fd823055b73f8b32c8200b1dffb72829503e91bc32c176

data/lib/stagehand/auditor.rb

@@ -0,0 +1,108 @@
+module Stagehand
+  module Auditor
+    extend self
+
+    def incomplete_commits
+      incomplete = []
+
+      incomplete_start_operations.each do |start_operation|
+        entries = records_until_match(start_operation, :asc, :operation => Staging::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 => Staging::CommitEntry::START_OPERATION).to_a
+        incomplete << [entries.last.id, entries]
+      end
+
+      return incomplete.to_h
+    end
+
+    def mismatched_records
+      output = {}
+
+      tables = Database.staging_connection.tables.select {|table_name| Schema::has_stagehand?(table_name) }
+      tables.each do |table_name|
+        print "\nChecking #{table_name} "
+        mismatched = {}
+        limit = 1000
+        index = 0
+
+        loop do
+          production_records = Database.production_connection.select_all("SELECT * FROM #{table_name} LIMIT #{limit} OFFSET #{limit * index}")
+          staging_records = Database.staging_connection.select_all("SELECT * FROM #{table_name} LIMIT #{limit} OFFSET #{limit * index}")
+          id_column = production_records.columns.index('id')
+
+          production_differences = production_records.rows - staging_records.rows
+          staging_differences = staging_records.rows - production_records.rows
+
+          production_differences.each do |row|
+            id = row[id_column]
+            mismatched[id] = {:production => row}
+          end
+          staging_differences.each do |row|
+            id = row[id_column]
+            mismatched[id] ||= {:staging => row}
+          end
+
+          if production_differences.present? || staging_differences.present?
+            print '!'
+          else
+            print '.'
+          end
+
+          index += 1
+          break unless staging_records.present? || production_records.present?
+        end
+
+        if mismatched.present?
+          print " #{mismatched.count} mismatched"
+          output[table_name] = mismatched
+        end
+      end
+
+      return output
+    end
+
+    private
+
+    # Incomplete End Operation that are not the last entry in their session
+    def incomplete_end_operations
+      last_entry_per_session = Staging::CommitEntry.group(:session).select('MAX(id) AS id')
+      return Staging::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 = Staging::CommitEntry.start_operations.group(:session).select('MAX(id) AS id')
+      return Staging::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 = Staging::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

data/lib/stagehand/engine.rb

@@ -14,8 +14,9 @@ module Stagehand
       require "stagehand/database"
       require "stagehand/controller_extensions"
       require "stagehand/staging"
-      require "stagehand/schema"
       require "stagehand/production"
+      require "stagehand/schema"
+      require 'stagehand/auditor'
     end
   end
 end

data/lib/stagehand/production.rb

@@ -5,22 +5,22 @@ module Stagehand
     extend self
 
     # Outputs a symbol representing the status of the staging record as it exists in the production database
-    def status(staging_record)
-      if !exists?(staging_record)
+    def status(staging_record, table_name = nil)
+      if !exists?(staging_record, table_name)
         :new
-      elsif modified?(staging_record)
+      elsif modified?(staging_record, table_name)
         :modified
       else
         :not_modified
       end
     end
 
-    def save(staging_record)
-      attributes = staging_record_attributes(staging_record)
+    def save(staging_record, table_name = nil)
+      attributes = staging_record_attributes(staging_record, table_name)
 
       return unless attributes.present?
 
-      is_new = lookup(staging_record).update_all(attributes).zero?
+      is_new = lookup(staging_record, table_name).update_all(attributes).zero?
 
       # Ensure we always return a record, even when updating instead of creating
       Record.new.tap do |record|
@@ -40,8 +40,8 @@ module Stagehand
     # Returns true if the staging record's attributes are different from the production record's attributes
     # Returns true if the staging_record does not exist on production
     # Returns false if the staging record is identical to the production record
-    def modified?(staging_record)
-      production_record_attributes(staging_record) != staging_record_attributes(staging_record)
+    def modified?(staging_record, table_name = nil)
+      production_record_attributes(staging_record, table_name) != staging_record_attributes(staging_record, table_name)
     end
 
     # Returns a scope that limits results any occurrences of the specified record.
@@ -59,8 +59,8 @@ module Stagehand
       Record.table_name = table_name
     end
 
-    def production_record_attributes(staging_record)
-      Record.connection.select_one(lookup(staging_record))
+    def production_record_attributes(staging_record, table_name = nil)
+      Record.connection.select_one(lookup(staging_record, table_name))
     end
 
     def staging_record_attributes(staging_record, table_name = nil)

data/lib/stagehand/staging/commit_entry.rb

@@ -33,8 +33,15 @@ module Stagehand
         keys = Array.wrap(object).collect {|entry| Stagehand::Key.generate(entry) }.compact
         sql = []
         interpolates = []
+        groups = keys.group_by(&:first)
 
-        keys.group_by(&:first).each do |table_name, keys|
+        # If passed control operation commit entries, ensure they are returned since their keys match the CommitEntry's primary key
+        if commit_entry_group = groups.delete(CommitEntry.table_name)
+          sql << 'id IN (?)'
+          interpolates << commit_entry_group.collect(&:last)
+        end
+
+        groups.each do |table_name, keys|
           sql << "(table_name = ? AND record_id IN (?))"
           interpolates << table_name
           interpolates << keys.collect(&:last)

data/lib/stagehand/staging/synchronizer.rb

@@ -18,13 +18,27 @@ module Stagehand
         scope = autosyncable_entries.limit(1000)
 
         loop do
-          puts "Synced #{sync_entries(scope.reload)} entries"
+          Rails.logger.info "Synced #{sync_entries(scope.reload)} entries"
           sleep(delay) if delay
         end
       end
 
-      def sync
-        sync_entries(autosyncable_entries.limit(1000))
+      def sync(limit = nil)
+        sync_entries(autosyncable_entries.limit(limit))
+      end
+
+      def sync_all
+        loop do
+          entries = CommitEntry.order(:id => :desc).limit(1000).to_a
+          break unless entries.present?
+
+          latest_entries = entries.uniq(&:key)
+          sync_entries(latest_entries)
+          Rails.logger.info "Synced #{latest_entries.count} entries"
+
+          deleted_count = CommitEntry.matching(latest_entries).delete_all
+          Rails.logger.info "Removed #{deleted_count - latest_entries.count} stale entries"
+        end
       end
 
       # Copies all the affected records from the staging database to the production database
@@ -46,7 +60,7 @@ module Stagehand
 
         ActiveRecord::Base.transaction do
           entries.each do |entry|
-            Rails.logger.info "Synchronizing #{entry.table_name} #{entry.record_id}"
+            Rails.logger.info "Synchronizing #{entry.table_name} #{entry.record_id}" if entry.content_operation?
             if entry.delete_operation?
               Stagehand::Production.delete(entry)
             elsif entry.save_operation?

data/lib/stagehand/staging.rb

@@ -4,7 +4,6 @@ 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.3.0"
+  VERSION = "0.3.1"
 end

data/lib/tasks/stagehand_tasks.rake

@@ -4,6 +4,16 @@ namespace :stagehand do
     Stagehand::Staging::Synchronizer.auto_sync(args[:delay] ||= 5.seconds)
   end
 
+  desc "Syncs records that don't need confirmation to production"
+  task :sync, [:limit] => :environment do |t, args|
+    Stagehand::Staging::Synchronizer.sync(args[:limit])
+  end
+
+  desc "Syncs all records to production, including those that require confirmation"
+  task :sync_all, :environment do
+    Stagehand::Staging::Synchronizer.sync_all
+  end
+
   desc "Migrate both databases used by stagehand"
   task :migrate => :environment do
     [Rails.configuration.x.stagehand.staging_connection_name,

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: culturecode_stagehand
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.3.1
 platform: ruby
 authors:
 - Nicholas Jakobsen
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-04-14 00:00:00.000000000 Z
+date: 2016-04-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -67,6 +67,7 @@ files:
 - Rakefile
 - lib/culturecode_stagehand.rb
 - lib/stagehand.rb
+- lib/stagehand/auditor.rb
 - lib/stagehand/cache.rb
 - lib/stagehand/configuration.rb
 - lib/stagehand/controller_extensions.rb
@@ -78,7 +79,6 @@ files:
 - 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

data/lib/stagehand/staging/auditor.rb

@@ -1,64 +0,0 @@
-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