combinaut_stagehand 1.2.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: b792d867277a6bc5d64f17e50d808241ddac020d6ad02684c00f1caec51e5f9e
+  data.tar.gz: 6affa9483ef3c301aadc83220c606223b3372588c012b2187af388ff1bbbcf57
+SHA512:
+  metadata.gz: d68610dfb55385f62ea8d3c202ef6e844db4cddef16129e1b57759d724041fdf6e450f5df8c390ec4d512affb7b78684004af87c7263d8a535aa56dc1b9c3490
+  data.tar.gz: 55d867ef57194d15c22ca576b798e9727b4204826efd83f2d0a6d92901252f8bb7ddee44e1ac068b8a1420972424667801383b809236b06579cf2c5188e7a447

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2016 Nicholas Jakobsen
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,20 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+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/combinaut_stagehand.rb

@@ -0,0 +1,2 @@
+# Wrapper because Rubygems.org already had a 'stagehand' gem. This avoids needing a :require option in Bundler.
+require "stagehand"

data/lib/stagehand/active_record_extensions.rb

@@ -0,0 +1,110 @@
+require 'thread'
+
+ActiveRecord::Base.class_eval do
+  # SYNC CALLBACKS
+  ([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)
+    super
+
+    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',
+        :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) unless defined?(@has_stagehand)
+    return @has_stagehand
+  end
+
+  # MULTITHREADED CONNECTION HANDLING
+
+  class_attribute :stagehand_threadsafe_connections
+  self.stagehand_threadsafe_connections = true
+
+  # 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))
+    return super unless stagehand_threadsafe_connections
+
+    StagehandConnectionMap.set(self, nil)
+    super
+  end
+
+  def self.connection_specification_name=(connection_name)
+    return super unless stagehand_threadsafe_connections
+
+    # 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)
+  end
+
+  def self.connection_specification_name
+    return super unless stagehand_threadsafe_connections
+
+    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)
+      current_map[klass.name] = connection_name
+    end
+
+    def self.get(klass)
+      current_map[klass.name]
+    end
+
+    def self.current_map
+      map = Thread.current.thread_variable_get('StagehandConnectionMap')
+      map = Thread.current.thread_variable_set('StagehandConnectionMap', Concurrent::Hash.new) unless map
+      return map
+    end
+  end
+end
+
+module StagehandAssociationReflection
+  # SOURCE: https://github.com/rails/rails/blob/a4581b53aae93a8dd3205abae0630398cbce9204/activerecord/lib/active_record/reflection.rb#L429
+  def initialize(*)
+    super
+    @association_scope_cache = StagehandAssociationScopeCache.new
+  end
+
+  # Ensure the association query statements are cached separately for the staging and production connections or else
+  # queries for Staging Models may cache the database name for the wrong connection.
+  class StagehandAssociationScopeCache < Delegator
+    def initialize
+      @staging_cache = Concurrent::Map.new
+      @production_cache = Concurrent::Map.new
+    end
+
+    def __getobj__
+      Stagehand::Database.connected_to_production? ? @production_cache : @staging_cache
+    end
+  end
+end
+
+ActiveRecord::Reflection::AssociationReflection.prepend(StagehandAssociationReflection)

data/lib/stagehand/auditor/checklist_visualizer.rb

@@ -0,0 +1,90 @@
+require 'graphviz'
+
+module Stagehand
+  module Auditor
+    class ChecklistVisualizer
+      def initialize(checklist, show_all_commits: false)
+        entries = checklist.affected_entries.select(&:commit_id)
+
+        @graph = GraphViz.new( :G, :type => :graph )
+        @commits = Hash.new {|hash, commit_id| hash[commit_id] = Stagehand::Staging::CommitEntry.find(commit_id) }
+        nodes = Hash.new
+        edges = []
+
+        # Detect edges
+        entries.group_by(&:key).each_value do |entries|
+          entries.combination(2).each do |entry_a, entry_b|
+            current_edge = [entry_a, entry_b]
+            next if edges.detect {|edge| edge.sort == current_edge.sort }
+            next if same_node?(entry_a, entry_b)
+            next if same_subject?(entry_a, entry_b)
+            edges << current_edge
+          end
+        end
+
+        # Create Subgraph nodes for commits with connections to other subjects
+        entries = edges.flatten.uniq unless show_all_commits
+        entries.group_by {|entry| commit_subject(entry) || entry.commit_id }.each do |group, entries|
+          subject = commit_subject(entries.first)
+          subgraph = create_subgraph(subject, @graph, id: group)
+          entries.each do |entry|
+            nodes[entry] = create_node(entry, subgraph)
+          end
+        end
+
+        # Create deduplicate edge data in case multiple entries for the same record were part of a single commit
+        edges = edges.map do |entry_a, entry_b|
+          [[nodes[entry_a], nodes[entry_b]], label: edge_label(entry_a, entry_b)]
+        end
+
+        # Create edges
+        edges.uniq.each do |(node_a, node_b), options|
+          create_edge(node_a, node_b, options)
+        end
+      end
+
+      def output(file_name, format: File.extname(file_name)[1..-1])
+        @graph.output(format => file_name)
+        File.open(file_name)
+      end
+
+      private
+
+      def create_subgraph(subject, graph, id: subject)
+        graph.add_graph("cluster_#{id}", :label => subject, :style => :filled, :color => :lightgrey)
+      end
+
+      def create_edge(node_a, node_b, options = {})
+        @graph.add_edges(node_a, node_b, options.reverse_merge(:color => :red, :fontcolor => :red))
+      end
+
+      def create_node(entry, graph)
+        graph.add_nodes(node_name(entry), :shape => :rect, :style => :filled, :fillcolor => :white)
+      end
+
+      def edge_label(entry_a, entry_b)
+        pretty_key(entry_a)
+      end
+
+      def same_node?(entry_a, entry_b)
+        node_name(entry_a) == node_name(entry_b)
+      end
+
+      def same_subject?(entry_a, entry_b)
+        commit_subject(entry_a) == commit_subject(entry_b) && commit_subject(entry_a)
+      end
+
+      def commit_subject(entry)
+        pretty_key(@commits[entry.commit_id])
+      end
+
+      def node_name(entry)
+        "Commit #{entry.commit_id}"
+      end
+
+      def pretty_key(entry)
+        "#{entry.table_name.classify} #{entry.record_id}" if entry.record_id && entry.table_name
+      end
+    end
+  end
+end

data/lib/stagehand/auditor.rb

@@ -0,0 +1,90 @@
+require 'stagehand/auditor/checklist_visualizer'
+
+module Stagehand
+  module Auditor
+    extend self
+
+    def incomplete_commits
+      incomplete = []
+
+      incomplete_commit_ids.each do |commit_id|
+        incomplete << [commit_id, Staging::CommitEntry.where(:commit_id => commit_id)]
+      end
+
+      return incomplete.to_h
+    end
+
+    def mismatched_records(options = {})
+      output = {}
+
+      tables = options[:tables] || Database.staging_connection.tables.select {|table_name| Schema::has_stagehand?(table_name) }
+      Array(tables).each do |table_name|
+        print "\nChecking #{table_name} "
+        mismatched = Hash.new {|k,v| k[v] = {} }
+        limit = 1000
+
+        min_id = [
+          Database.staging_connection.select_value("SELECT MIN(id) FROM #{table_name}").to_i,
+          Database.production_connection.select_value("SELECT MIN(id) FROM #{table_name}").to_i
+        ].min
+
+        index = min_id / limit
+
+        max_id = [
+          Database.staging_connection.select_value("SELECT MAX(id) FROM #{table_name}").to_i,
+          Database.production_connection.select_value("SELECT MAX(id) FROM #{table_name}").to_i
+        ].max
+
+        loop do
+          production_records = Database.production_connection.select_all("SELECT * FROM #{table_name} WHERE id BETWEEN #{limit * index} AND #{limit * (index + 1)}")
+          staging_records = Database.staging_connection.select_all("SELECT * FROM #{table_name} WHERE id BETWEEN #{limit * index} AND #{limit * (index + 1)}")
+          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 if index * limit > max_id
+        end
+
+        if mismatched.present?
+          print " #{mismatched.count} mismatched"
+          output[table_name] = mismatched
+        end
+      end
+
+      return output
+    end
+
+    def visualize(subject, output_file_name, options = {})
+      visualize_checklist(Staging::Checklist.new(subject), output_file_name, options)
+    end
+
+    def visualize_checklist(checklist, output_file_name, options = {})
+      ChecklistVisualizer.new(checklist, options).output(output_file_name)
+    end
+
+    private
+
+    # Commit that is missing a start or end operation
+    def incomplete_commit_ids
+      Staging::CommitEntry.control_operations.group(:commit_id).having("count(*) != 2").pluck("MIN(commit_id)")
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+module Stagehand
+  extend self
+
+  def configuration
+    yield Configuration if block_given?
+    Configuration
+  end
+
+  module Configuration
+    extend self
+
+    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
+      Rails.env.to_sym
+    end
+
+    def production_connection_name
+      Rails.configuration.x.stagehand.production_connection_name || Rails.env.to_sym
+    end
+
+    def ghost_mode?
+      !!Rails.configuration.x.stagehand.ghost_mode
+    end
+
+    # Allow unsynchronized writes directly to the production database? A warning will be logged if set to true.
+    def allow_unsynced_production_writes?
+      !!Rails.configuration.x.stagehand.allow_unsynced_production_writes
+    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
+
+    # Columns not to copy to the production database
+    # e.g. table_name => [column, column, ...]
+    def self.ignored_columns=(hash)
+      super HashWithIndifferentAccess.new(hash)
+    end
+  end
+end

data/lib/stagehand/connection_adapter_extensions.rb

@@ -0,0 +1,75 @@
+module Stagehand
+  module Connection
+    def self.with_production_writes(&block)
+      state = allow_unsynced_production_writes?
+      allow_unsynced_production_writes!(true)
+      return block.call
+    ensure
+      allow_unsynced_production_writes!(state)
+    end
+
+    def self.allow_unsynced_production_writes!(state = true)
+      Thread.current.thread_variable_set(:stagehand_allow_unsynced_production_writes, state)
+    end
+
+    def self.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(sql, *)
+        handle_readonly_writes!(sql)
+        super
+      end
+
+      def exec_update(sql, *)
+        handle_readonly_writes!(sql)
+        super
+      end
+
+      def exec_delete(sql, *)
+        handle_readonly_writes!(sql)
+        super
+      end
+
+      private
+
+      def write_access?
+        Configuration.single_connection? || @config[:database] == Database.staging_database_name || Connection.allow_unsynced_production_writes?
+      end
+
+      def handle_readonly_writes!(sql)
+        if write_access?
+          return
+        elsif Configuration.allow_unsynced_production_writes?
+          Rails.logger.warn "Writing directly to #{@config[:database]} database using readonly connection"
+        else
+          raise(UnsyncedProductionWrite, "Attempted to write directly to #{@config[:database]} database using readonly connection: #{sql}")
+        end
+      end
+    end
+  end
+
+
+  # EXCEPTIONS
+
+  class UnsyncedProductionWrite < StandardError; end
+end
+
+ActiveRecord::Base.connection.class.prepend(Stagehand::Connection::AdapterExtensions)

data/lib/stagehand/controller_extensions.rb

@@ -0,0 +1,35 @@
+module Stagehand
+  module ControllerExtensions
+    extend ActiveSupport::Concern
+
+    class_methods do
+      def use_staging_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_around_action :use_staging_database, raise: false, **options
+        prepend_around_action :use_production_database, options
+      end
+    end
+
+    private
+
+    def use_staging_database(&block)
+      use_database(Configuration.staging_connection_name, &block)
+    end
+
+    def use_production_database(&block)
+      use_database(Configuration.production_connection_name, &block)
+    end
+
+    def use_database(connection_name, &block)
+      if Configuration.ghost_mode?
+        block.call
+      else
+        Database.with_connection(connection_name, &block)
+      end
+    end
+  end
+end