andyjeffries-rubyrep 1.2.1

data/lib/rubyrep/replication_extenders/postgresql_replication.rb

@@ -0,0 +1,236 @@
+module RR
+  module ReplicationExtenders
+
+    # Provides PostgreSQL specific functionality for database replication
+    module PostgreSQLReplication
+      RR::ReplicationExtenders.register :postgresql => self
+
+      # Returns the key clause that is used in the trigger function.
+      # * +trigger_var+: should be either 'NEW' or 'OLD'
+      # * +params+: the parameter hash as described in #create_rep_trigger
+      def key_clause(trigger_var, params)
+        params[:keys].
+          map { |key| "'#{key}#{params[:key_sep]}' || #{trigger_var}.#{quote_column_name(key)}"}.
+          join(" || '#{params[:key_sep]}' || ")
+      end
+      private :key_clause
+
+      # Returns the schema prefix (including dot) that will be used by the
+      # triggers to write into the rubyrep infrastructure tables.
+      # To avoid setting the wrong prefix, it will only return a schema prefix
+      # if the current search path
+      # * consists of only a single schema
+      # * does not consists of a variable search path
+      #   (i. e. the default "$user")
+      def schema_prefix
+        unless @schema_prefix
+          search_path = select_one("show search_path")['search_path']
+          if search_path =~ /[,$]/
+            @schema_prefix = ""
+          else
+            @schema_prefix = %("#{search_path}".)
+          end
+        end
+        @schema_prefix
+      end
+
+      # Creates or replaces the replication trigger function.
+      # See #create_replication_trigger for a descriptions of the +params+ hash.
+      def create_or_replace_replication_trigger_function(params)
+        # first check, if PL/SQL is already activated and if not, do so.
+        if select_all("select lanname from pg_language where lanname = 'plpgsql'").empty?
+          execute "CREATE LANGUAGE plpgsql"
+        end
+
+        activity_check = ""
+        if params[:exclude_rr_activity] then
+          activity_check = <<-end_sql
+            PERFORM ACTIVE FROM #{schema_prefix}#{params[:activity_table]};
+            IF FOUND THEN
+              RETURN NULL;
+            END IF;
+          end_sql
+        end
+
+        version_string = select_value("select version();")
+        version = version_string.gsub(/^\s*postgresql\s*([0-9.]+).*$/i, '\1')
+        if version >= '8.4'
+          modification_check = <<-end_sql
+            IF NEW IS NOT DISTINCT FROM OLD THEN
+              RETURN NULL;
+            END IF;
+          end_sql
+        else
+          modification_check = ""
+        end
+
+        # now create the trigger
+        execute(<<-end_sql)
+          CREATE OR REPLACE FUNCTION "#{params[:trigger_name]}"() RETURNS TRIGGER AS $change_trigger$
+            BEGIN
+              #{activity_check}
+              IF (TG_OP = 'DELETE') THEN
+                INSERT INTO #{schema_prefix}#{params[:log_table]}(change_table, change_key, change_type, change_time)
+                  SELECT '#{params[:table]}', #{key_clause('OLD', params)}, 'D', now();
+              ELSIF (TG_OP = 'UPDATE') THEN
+                #{modification_check}
+                INSERT INTO  #{schema_prefix}#{params[:log_table]}(change_table, change_key, change_new_key, change_type, change_time)
+                  SELECT '#{params[:table]}', #{key_clause('OLD', params)}, #{key_clause('NEW', params)}, 'U', now();
+              ELSIF (TG_OP = 'INSERT') THEN
+                INSERT INTO  #{schema_prefix}#{params[:log_table]}(change_table, change_key, change_type, change_time)
+                  SELECT '#{params[:table]}', #{key_clause('NEW', params)}, 'I', now();
+              END IF;
+              RETURN NULL; -- result is ignored since this is an AFTER trigger
+            END;
+          $change_trigger$ LANGUAGE plpgsql;
+        end_sql
+
+      end
+
+      # Creates a trigger to log all changes for the given table.
+      # +params+ is a hash with all necessary information:
+      # * :+trigger_name+: name of the trigger
+      # * :+table+: name of the table that should be monitored
+      # * :+keys+: array of names of the key columns of the monitored table
+      # * :+log_table+: name of the table receiving all change notifications
+      # * :+activity_table+: name of the table receiving the rubyrep activity information
+      # * :+key_sep+: column seperator to be used in the key column of the log table
+      # * :+exclude_rr_activity+:
+      #   if true, the trigger will check and filter out changes initiated by RubyRep
+      def create_replication_trigger(params)
+        create_or_replace_replication_trigger_function params
+
+        execute(<<-end_sql)
+          CREATE TRIGGER "#{params[:trigger_name]}"
+          AFTER INSERT OR UPDATE OR DELETE ON "#{params[:table]}"
+              FOR EACH ROW EXECUTE PROCEDURE #{schema_prefix}"#{params[:trigger_name]}"();
+        end_sql
+      end
+
+      # Removes a trigger and related trigger procedure.
+      # * +trigger_name+: name of the trigger
+      # * +table_name+: name of the table for which the trigger exists
+      def drop_replication_trigger(trigger_name, table_name)
+        execute "DROP TRIGGER \"#{trigger_name}\" ON \"#{table_name}\";"
+        execute "DROP FUNCTION \"#{trigger_name}\"();"
+      end
+
+      # Returns +true+ if the named trigger exists for the named table.
+      # * +trigger_name+: name of the trigger
+      # * +table_name+: name of the table
+      def replication_trigger_exists?(trigger_name, table_name)
+        !select_all(<<-end_sql).empty?
+          select 1 from information_schema.triggers
+          where event_object_schema in (#{schemas})
+          and trigger_name = '#{trigger_name}'
+          and event_object_table = '#{table_name}'
+        end_sql
+      end
+
+      # Returns all unadjusted sequences of the given table.
+      # Parameters:
+      # * +rep_prefix+: not used (necessary) for the Postgres
+      # * +table_name+: name of the table
+      # Return value: a hash with
+      # * key: sequence name
+      # * value: a hash with
+      #   * :+increment+: current sequence increment
+      #   * :+value+: current value
+      def sequence_values(rep_prefix, table_name)
+        result = {}
+        sequence_names = select_all(<<-end_sql).map { |row| row['relname'] }
+          select s.relname
+          from pg_class as t
+          join pg_depend as r on t.oid = r.refobjid
+          join pg_class as s on r.objid = s.oid
+          and s.relkind = 'S'
+          and t.relname = '#{table_name}' AND t.relnamespace IN
+            (SELECT oid FROM pg_namespace WHERE nspname in (#{schemas}))
+        end_sql
+        sequence_names.each do |sequence_name|
+          row = select_one("select last_value, increment_by from \"#{sequence_name}\"")
+          result[sequence_name] = {
+            :increment => row['increment_by'].to_i,
+            :value => row['last_value'].to_i
+          }
+        end
+        result
+      end
+
+      # Ensures that the sequences of the named table (normally the primary key
+      # column) are generated with the correct increment and offset.
+      # * +rep_prefix+: not used (necessary) for the Postgres
+      # * +table_name+: name of the table (not used for Postgres)
+      # * +increment+: increment of the sequence
+      # * +offset+: offset
+      # * +left_sequence_values+:
+      #    hash as returned by #sequence_values for the left database
+      # * +right_sequence_values+:
+      #    hash as returned by #sequence_values for the right database
+      # * +adjustment_buffer+:
+      #    the "gap" that is created during sequence update to avoid concurrency problems
+      # E. g. an increment of 2 and offset of 1 will lead to generation of odd
+      # numbers.
+      def update_sequences(
+          rep_prefix, table_name, increment, offset,
+          left_sequence_values, right_sequence_values, adjustment_buffer)
+        left_sequence_values.each do |sequence_name, left_current_value|
+          row = select_one("select last_value, increment_by from \"#{sequence_name}\"")
+          current_increment = row['increment_by'].to_i
+          current_value = row['last_value'].to_i
+          unless current_increment == increment and current_value % increment == offset
+            max_current_value =
+              [left_current_value[:value], right_sequence_values[sequence_name][:value]].max +
+              adjustment_buffer
+            new_start = max_current_value - (max_current_value % increment) + increment + offset
+            execute(<<-end_sql)
+            alter sequence "#{sequence_name}" increment by #{increment} restart with #{new_start}
+            end_sql
+          end
+        end
+      end
+
+      # Restores the original sequence settings.
+      # (Actually it sets the sequence increment to 1. If before, it had a
+      # different value, then the restoration will not be correct.)
+      # * +rep_prefix+: not used (necessary) for the Postgres
+      # * +table_name+: name of the table
+      def clear_sequence_setup(rep_prefix, table_name)
+        sequence_names = select_all(<<-end_sql).map { |row| row['relname'] }
+          select s.relname
+          from pg_class as t
+          join pg_depend as r on t.oid = r.refobjid
+          join pg_class as s on r.objid = s.oid
+          and s.relkind = 'S'
+          and t.relname = '#{table_name}' and t.relnamespace IN
+            (SELECT oid FROM pg_namespace WHERE nspname in (#{schemas}))
+        end_sql
+        sequence_names.each do |sequence_name|
+          execute(<<-end_sql)
+              alter sequence "#{sequence_name}" increment by 1
+          end_sql
+        end
+      end
+
+      # Adds a big (8 byte value), auto-incrementing primary key column to the
+      # specified table.
+      # * table_name: name of the target table
+      # * key_name: name of the primary key column
+      def add_big_primary_key(table_name, key_name)
+        old_message_level = select_one("show client_min_messages")['client_min_messages']
+        execute "set client_min_messages = warning"
+        execute(<<-end_sql)
+          alter table "#{table_name}" add column #{key_name} bigserial
+        end_sql
+
+        execute(<<-end_sql)
+          alter table "#{table_name}" add constraint #{table_name}_#{key_name}_pkey primary key (#{key_name})
+        end_sql
+        
+      ensure
+        execute "set client_min_messages = #{old_message_level}"
+      end
+    end
+  end
+end
+

data/lib/rubyrep/replication_extenders/replication_extenders.rb

@@ -0,0 +1,26 @@
+module RR
+
+  # Replication extenders are modules that provide database specific functionality
+  # required for replication. They are mixed into ActiveRecord database connections.
+  # This module itself only provides functionality to register and retrieve
+  # such extenders.
+  module ReplicationExtenders
+    # Returns a Hash of currently registered replication extenders.
+    # (Empty Hash if no replication extenders were defined.)
+    def self.extenders
+      @extenders ||= {}
+      @extenders
+    end
+
+    # Registers one or multiple replication extender.
+    # extender is a Hash with
+    #   key::   The adapter symbol as used by ActiveRecord::Connection Adapters, e. g. :postgresql
+    #   value:: Name of the module implementing the replication extender
+    def self.register(extender)
+      @extenders ||= {}
+      @extenders.merge! extender
+    end
+  end
+end
+
+

data/lib/rubyrep/replication_helper.rb

@@ -0,0 +1,142 @@
+module RR
+
+  # Provides helper functionality for replicators.
+  # The methods exposed by this class are intended to provide a stable interface
+  # for third party replicators.
+  class ReplicationHelper
+
+    include LogHelper
+
+    # The current +ReplicationRun+ instance
+    attr_accessor :replication_run
+
+    # The active +Session+
+    def session; replication_run.session; end
+
+    # Current options
+    def options; @options ||= session.configuration.options; end
+
+    # Returns the options for the specified table name.
+    # * +table+: name of the table (left database version)
+    def options_for_table(table)
+      @options_for_table ||= {}
+      unless @options_for_table.include? table
+        @options_for_table[table] = session.configuration.options_for_table(table)
+      end
+      @options_for_table[table]
+    end
+
+    # Delegates to Session#corresponding_table
+    def corresponding_table(db_arm, table); session.corresponding_table(db_arm, table); end
+
+    # Returns +true+ if a new transaction was started since the last
+    # insert / update / delete.
+    def new_transaction?
+      committer.new_transaction?
+    end
+
+    # Delegates to Committers::BufferedCommitter#insert_record
+    def insert_record(database, table, values)
+      committer.insert_record(database, table, values)
+    end
+
+    # Delegates to Committers::BufferedCommitter#update_record
+    def update_record(database, table, values, old_key = nil)
+      committer.update_record(database, table, values, old_key)
+    end
+
+    # Delegates to Committers::BufferedCommitter#delete_record
+    def delete_record(database, table, values)
+      committer.delete_record(database, table, values)
+    end
+
+    # Loads the specified record. Returns an according column_name => value hash.
+    # Parameters:
+    # * +database+: either :+left+ or :+right+
+    # * +table+: name of the table
+    # * +key+: A column_name => value hash for all primary key columns.
+    def load_record(database, table, key)
+      cursor = session.send(database).select_cursor(
+        :table => table,
+        :row_keys => [key],
+        :type_cast => true
+      )
+      row = nil
+      row = cursor.next_row if cursor.next?
+      cursor.clear
+      row
+    end
+
+    # The current Committer
+    attr_reader :committer
+    private :committer
+
+    # Asks the committer (if it exists) to finalize any open transactions
+    # +success+ should be true if there were no problems, false otherwise.
+    def finalize(success = true)
+      committer.finalize(success)
+    end
+
+    # Converts the row values into their proper types as per table definition.
+    # * +table+: name of the table after whose columns is type-casted.
+    # * +row+: A column_name => value hash of the row
+    # Returns a copy of the column_name => value hash (with type-casted values).
+    def type_cast(table, row)
+      @table_columns ||= {}
+      unless @table_columns.include?(table)
+        column_array = session.left.columns(table)
+        column_hash = {}
+        column_array.each {|column| column_hash[column.name] = column}
+        @table_columns[table] = column_hash
+      end
+      columns = @table_columns[table]
+      type_casted_row = {}
+      row.each_pair do |column_name, value|
+        type_casted_row[column_name] = columns[column_name].type_cast(value)
+      end
+      type_casted_row
+    end
+
+    # Logs the outcome of a replication into the replication log table.
+    # * +diff+: the replicated ReplicationDifference
+    # * +outcome+: string summarizing the outcome of the replication
+    # * +details+: string with further details regarding the replication
+    def log_replication_outcome(diff, outcome, details = nil)
+      table = diff.changes[:left].table
+      key = diff.changes[:left].key
+      if key.size == 1
+        key = key.values[0]
+      else
+        key_parts = session.left.primary_key_names(table).map do |column_name|
+          %Q("#{column_name}"=>#{key[column_name].to_s.inspect})
+        end
+        key = key_parts.join(', ')
+      end
+      rep_outcome, rep_details = fit_description_columns(outcome, details)
+      diff_dump = diff.to_yaml[0...ReplicationInitializer::DIFF_DUMP_SIZE]
+      
+      session.left.insert_record "#{options[:rep_prefix]}_logged_events", {
+        :activity => 'replication',
+        :change_table => table,
+        :diff_type => diff.type.to_s,
+        :change_key => key,
+        :left_change_type => (diff.changes[:left] ? diff.changes[:left].type.to_s : nil),
+        :right_change_type => (diff.changes[:right] ? diff.changes[:right].type.to_s : nil),
+        :description => rep_outcome,
+        :long_description => rep_details,
+        :event_time => Time.now,
+        :diff_dump => diff_dump
+      }
+    end
+    
+    # Creates a new SyncHelper for the given +TableSync+ instance.
+    def initialize(replication_run)
+      self.replication_run = replication_run
+
+      # Creates the committer. Important as it gives the committer the
+      # opportunity to start transactions
+      committer_class = Committers::committers[options[:committer]]
+      @committer = committer_class.new(session)
+    end
+  end
+end

data/lib/rubyrep/replication_initializer.rb

@@ -0,0 +1,327 @@
+$LOAD_PATH.unshift File.dirname(__FILE__) + '/..'
+
+require 'rubyrep'
+
+module RR
+
+  # Ensures all preconditions are met to start with replication
+  class ReplicationInitializer
+
+    # The active Session
+    attr_accessor :session
+
+    # Creates a new RepInititializer for the given Session
+    def initialize(session)
+      self.session = session
+    end
+
+    # Returns the options for the given table.
+    # If table is +nil+, returns general options.
+    def options(table = nil)
+      if table
+        session.configuration.options_for_table table
+      else
+        session.configuration.options
+      end
+    end
+
+    # Creates a trigger logging all table changes
+    # * database: either :+left+ or :+right+
+    # * table: name of the table
+    def create_trigger(database, table)
+      options = self.options(table)
+
+      params = {
+        :trigger_name => "#{options[:rep_prefix]}_#{table}",
+        :table => table,
+        :keys => session.send(database).primary_key_names(table),
+        :log_table => "#{options[:rep_prefix]}_pending_changes",
+        :activity_table => "#{options[:rep_prefix]}_running_flags",
+        :key_sep => options[:key_sep],
+        :exclude_rr_activity => false,
+      }
+
+      session.send(database).create_replication_trigger params
+    end
+
+    # Returns +true+ if the replication trigger for the given table exists.
+    # * database: either :+left+ or :+right+
+    # * table: name of the table
+    def trigger_exists?(database, table)
+      trigger_name = "#{options(table)[:rep_prefix]}_#{table}"
+      session.send(database).replication_trigger_exists? trigger_name, table
+    end
+
+    # Drops the replication trigger of the named table.
+    # * database: either :+left+ or :+right+
+    # * table: name of the table
+    def drop_trigger(database, table)
+      trigger_name = "#{options(table)[:rep_prefix]}_#{table}"
+      session.send(database).drop_replication_trigger trigger_name, table
+    end
+
+    # Ensures that the sequences of the named table (normally the primary key
+    # column) are generated with the correct increment and offset in both
+    # left and right database.
+    # The sequence is always updated in both databases.
+    # * +table_pair+: a hash of names of corresponding :left and :right tables
+    # * +increment+: increment of the sequence
+    # * +left_offset+: offset of table in left database
+    # * +right_offset+: offset of table in right database
+    # E. g. an increment of 2 and offset of 1 will lead to generation of odd
+    # numbers.
+    def ensure_sequence_setup(table_pair, increment, left_offset, right_offset)
+      table_options = options(table_pair[:left])
+      if table_options[:adjust_sequences]
+        rep_prefix = table_options[:rep_prefix]
+        left_sequence_values = session.left.sequence_values rep_prefix, table_pair[:left]
+        right_sequence_values = session.right.sequence_values rep_prefix, table_pair[:right]
+        [:left, :right].each do |database|
+          offset = database == :left ? left_offset : right_offset
+          session.send(database).update_sequences \
+            rep_prefix, table_pair[database], increment, offset,
+            left_sequence_values, right_sequence_values, table_options[:sequence_adjustment_buffer]
+        end
+      end
+    end
+
+    # Restores the original sequence settings for the named table.
+    # (Actually it sets the sequence increment to 1. If before, it had a
+    # different value, then the restoration will not be correct.)
+    # * database: either :+left+ or :+right+
+    # * +table_name+: name of the table
+    def clear_sequence_setup(database, table)
+      table_options = options(table)
+      if table_options[:adjust_sequences]
+        session.send(database).clear_sequence_setup(
+          table_options[:rep_prefix], table
+        )
+      end
+    end
+
+    # Returns +true+ if the change log exists in the specified database.
+    # * database: either :+left+ or :+right+
+    def change_log_exists?(database)
+      session.send(database).tables.include? "#{options[:rep_prefix]}_pending_changes"
+    end
+
+    # Returns +true+ if the replication log exists.
+    def event_log_exists?
+      session.left.tables.include? "#{options[:rep_prefix]}_logged_events"
+    end
+
+    # Drops the change log table in the specified database
+    # * database: either :+left+ or :+right+
+    def drop_change_log(database)
+      session.send(database).drop_table "#{options[:rep_prefix]}_pending_changes"
+    end
+
+    # Drops the replication log table.
+    def drop_event_log
+      session.left.drop_table "#{options[:rep_prefix]}_logged_events"
+    end
+
+    # Size of the replication log column diff_dump
+    DIFF_DUMP_SIZE = 2000
+
+    # Size fo the event log column 'description'
+    DESCRIPTION_SIZE = 255
+
+    # Size of the event log column 'long_description'
+    LONG_DESCRIPTION_SIZE = 1000
+
+    # Ensures that create_table and related statements don't print notices to
+    # stdout. Then restored original message setting.
+    # * +database+: either :+left+ or :+right+
+    def silence_ddl_notices(database)
+      if session.configuration.send(database)[:adapter] =~ /postgres/
+        old_message_level = session.send(database).
+          select_one("show client_min_messages")['client_min_messages']
+        session.send(database).execute "set client_min_messages = warning"
+      end
+      yield
+    ensure
+      if session.configuration.send(database)[:adapter] =~ /postgres/
+        session.send(database).execute "set client_min_messages = #{old_message_level}"
+      end
+    end
+
+    # Creates the replication log table.
+    def create_event_log
+      silence_ddl_notices(:left) do
+        table_name = "#{options[:rep_prefix]}_logged_events"
+        session.left.create_table "#{options[:rep_prefix]}_logged_events"
+        session.left.add_column table_name, :activity, :string
+        session.left.add_column table_name, :change_table, :string
+        session.left.add_column table_name, :diff_type, :string
+        session.left.add_column table_name, :change_key, :string
+        session.left.add_column table_name, :left_change_type, :string
+        session.left.add_column table_name, :right_change_type, :string
+        session.left.add_column table_name, :description, :string, :limit => DESCRIPTION_SIZE
+        session.left.add_column table_name, :long_description, :string, :limit => LONG_DESCRIPTION_SIZE
+        session.left.add_column table_name, :event_time, :timestamp
+        session.left.add_column table_name, :diff_dump, :string, :limit => DIFF_DUMP_SIZE
+        session.left.remove_column table_name, 'id'
+        session.left.add_big_primary_key table_name, 'id'
+      end
+    end
+
+    # Creates the change log table in the specified database
+    # * database: either :+left+ or :+right+
+    def create_change_log(database)
+      silence_ddl_notices(database) do
+        connection = session.send(database)
+        table_name = "#{options[:rep_prefix]}_pending_changes"
+        connection.create_table table_name
+        connection.add_column table_name, :change_table, :string
+        connection.add_column table_name, :change_key, :string
+        connection.add_column table_name, :change_new_key, :string
+        connection.add_column table_name, :change_type, :string
+        connection.add_column table_name, :change_time, :timestamp
+        connection.remove_column table_name, 'id'
+        connection.add_big_primary_key table_name, 'id'
+      end
+    end
+
+    # Adds to the current session's configuration an exclusion of rubyrep tables.
+    def exclude_rubyrep_tables
+      session.configuration.exclude_rubyrep_tables
+    end
+
+    # Checks in both databases, if the activity marker tables exist and if not,
+    # creates them.
+    def ensure_activity_markers
+      table_name = "#{options[:rep_prefix]}_running_flags"
+      [:left, :right].each do |database|
+        connection = session.send(database)
+        unless connection.tables.include? table_name
+          silence_ddl_notices(database) do
+            connection.create_table table_name
+            connection.add_column table_name, :active, :integer
+            connection.remove_column table_name, 'id'
+          end
+        end
+      end
+    end
+
+    # Checks if the event log table already exists and creates it if necessary
+    def ensure_event_log
+      create_event_log unless event_log_exists?
+    end
+
+    # Checks in both databases, if the change log tables exists and creates them
+    # if necessary
+    def ensure_change_logs
+      [:left, :right].each do |database|
+        create_change_log(database) unless change_log_exists?(database)
+      end
+    end
+
+    # Checks in both databases, if the infrastructure tables (change log, event
+    # log) exist and creates them if necessary.
+    def ensure_infrastructure
+      ensure_activity_markers
+      ensure_change_logs
+      ensure_event_log
+    end
+
+    # Checks in both databases, if the change_log tables exist. If yes, drops them.
+    def drop_change_logs
+      [:left, :right].each do |database|
+        drop_change_log(database) if change_log_exists?(database)
+      end
+    end
+
+    # Checks in both databases, if the activity_marker tables exist. If yes, drops them.
+    def drop_activity_markers
+      table_name = "#{options[:rep_prefix]}_running_flags"
+      [:left, :right].each do |database|
+        if session.send(database).tables.include? table_name
+          session.send(database).drop_table table_name
+        end
+      end
+    end
+
+    # Removes all rubyrep infrastructure tables from both databases.
+    def drop_infrastructure
+      drop_event_log if event_log_exists?
+      drop_change_logs
+      drop_activity_markers
+    end
+
+    # Checks for tables that have triggers but are not in the list of configured
+    # tables. Removes triggers and restores sequences of those tables.
+    # * +configured_table_pairs+:
+    #   An array of table pairs (e. g. [{:left => 'xy', :right => 'xy2'}]).
+    def restore_unconfigured_tables(configured_table_pairs = session.configured_table_pairs)
+      [:left, :right].each do |database|
+        configured_tables = configured_table_pairs.map {|table_pair| table_pair[database]}
+        unconfigured_tables = session.send(database).tables - configured_tables
+        unconfigured_tables.each do |table|
+          if trigger_exists?(database, table)
+            drop_trigger(database, table)
+            session.send(database).execute(
+              "delete from #{options[:rep_prefix]}_pending_changes where change_table = '#{table}'")
+          end
+          clear_sequence_setup(database, table)
+        end
+      end
+    end
+
+    # Calls the potentially provided :+after_init+ handler after infrastructure
+    # tables are created.
+    def call_after_infrastructure_setup_handler
+      handler = session.configuration.options[:after_infrastructure_setup]
+      handler.call(session) if handler
+    end
+
+    # Prepares the database / tables for replication.
+    def prepare_replication
+      exclude_rubyrep_tables
+
+      puts "Verifying RubyRep tables"
+      ensure_infrastructure
+
+      call_after_infrastructure_setup_handler
+
+      puts "Checking for and removing rubyrep triggers from unconfigured tables"
+      restore_unconfigured_tables
+
+      puts "Verifying rubyrep triggers of configured tables"
+      unsynced_table_pairs = []
+      table_pairs = session.sort_table_pairs(session.configured_table_pairs)
+      table_pairs.each do |table_pair|
+        table_options = options(table_pair[:left])
+        ensure_sequence_setup table_pair,
+          table_options[:sequence_increment],
+          table_options[:left_sequence_offset],
+          table_options[:right_sequence_offset]
+
+        unsynced = false
+        [:left, :right].each do |database|
+          unless trigger_exists? database, table_pair[database]
+            create_trigger database, table_pair[database]
+            unsynced = true
+          end
+        end
+        if unsynced and table_options[:initial_sync]
+          unsynced_table_pairs << table_pair
+        end
+      end
+      unsynced_table_specs = unsynced_table_pairs.map do |table_pair|
+        "#{table_pair[:left]}, #{table_pair[:right]}"
+      end
+
+      unless unsynced_table_specs.empty?
+        puts "Executing initial table syncs"
+        runner = SyncRunner.new
+        runner.session = session
+        runner.options = {:table_specs => unsynced_table_specs}
+        runner.execute
+      end
+
+      puts "Starting replication"
+    end
+  end
+
+end