andyjeffries-rubyrep 1.2.1

data/lib/rubyrep/database_proxy.rb

@@ -0,0 +1,52 @@
+$LOAD_PATH.unshift File.dirname(__FILE__) + '/..'
+
+require 'drb'
+
+require 'rubyrep'
+
+module RR
+  # The proxy to a remote database connection
+  class DatabaseProxy
+    
+    # Ensure that the proxy object always stays on server side and only remote
+    # references are returned to the client.
+    include DRbUndumped 
+    
+    # Default tcp port to listen on
+    DEFAULT_PORT = 9876
+    
+    # A simple Hash to hold Session object
+    # Purpose: preventing them from being garbage collected when they are only referenced through Drb
+    attr_accessor :session_register
+    
+    def initialize
+      self.session_register = {}
+    end
+    
+    # Create a ProxyConnection according to provided configuration Hash.
+    # +config+ is a hash as described by ActiveRecord::Base#establish_connection
+    def create_session(config)
+      session = ProxyConnection.new config
+      self.session_register[session] = session
+      session
+    end
+    
+    # Destroys the given session from the session register
+    def destroy_session(session)
+      session.destroy
+      session_register.delete session
+    end
+    
+    # Returns 'pong'. Used to verify that a working proxy is running.
+    def ping
+      'pong'
+    end
+    
+    # Terminates this proxy
+    def terminate!
+      # AL: The only way I could find to kill the main thread from a sub thread
+      Thread.main.raise SystemExit
+    end
+  end
+end
+

data/lib/rubyrep/direct_table_scan.rb

@@ -0,0 +1,75 @@
+module RR
+
+  # Scans two tables for differences.
+  # Doesn't have any reporting functionality by itself. 
+  # Instead DirectTableScan#run yields all the differences for the caller to do with as it pleases.
+  # Usage:
+  #   1. Create a new DirectTableScan object and hand it all necessary information
+  #   2. Call DirectTableScan#run to do the actual comparison
+  #   3. The block handed to DirectTableScan#run receives all differences
+  class DirectTableScan < TableScan
+    include TableScanHelper
+
+    # The TypeCastingCursor for the left table
+    attr_accessor :left_caster
+    
+    # The TypeCastingCursor for the right table
+    attr_accessor :right_caster
+
+    # Creates a new DirectTableScan instance
+    #   * session: a Session object representing the current database session
+    #   * left_table: name of the table in the left database
+    #   * right_table: name of the table in the right database. If not given, same like left_table
+    def initialize(session, left_table, right_table = nil)
+      super
+    end
+    
+    # Runs the table scan.
+    # Calls the block for every found difference.
+    # Differences are yielded with 2 parameters
+    #   * type: describes the difference, either :left (row only in left table), :right (row only in right table) or :conflict
+    #   * row: For :left or :right cases a hash describing the row; for :conflict an array of left and right row.
+    #          A row is a hash of column_name => value pairs.
+    def run(&blck)
+      left_cursor = right_cursor = nil
+      left_cursor = session.left.select_cursor(
+        :table => left_table,
+        :row_buffer_size => scan_options[:row_buffer_size],
+        :type_cast => true
+      )
+      right_cursor = session.right.select_cursor(
+        :table => right_table,
+        :row_buffer_size => scan_options[:row_buffer_size],
+        :type_cast => true
+      )
+      left_row = right_row = nil
+      update_progress 0 # ensures progress bar is printed even if there are no records
+      while left_row or right_row or left_cursor.next? or right_cursor.next?
+        # if there is no current left row, _try_ to load the next one
+        left_row ||= left_cursor.next_row if left_cursor.next?
+        # if there is no current right row, _try_ to load the next one
+        right_row ||= right_cursor.next_row if right_cursor.next?
+        rank = rank_rows left_row, right_row
+        case rank
+        when -1
+          yield :left, left_row
+          left_row = nil
+          update_progress 1
+        when 1
+          yield :right, right_row
+          right_row = nil
+          update_progress 1
+        when 0
+          update_progress 2
+          if not left_row == right_row
+            yield :conflict, [left_row, right_row]
+          end
+          left_row = right_row = nil
+        end
+        # check for corresponding right rows
+      end
+    ensure
+      [left_cursor, right_cursor].each {|cursor| cursor.clear if cursor}
+    end
+  end
+end

data/lib/rubyrep/generate_runner.rb

@@ -0,0 +1,105 @@
+$LOAD_PATH.unshift File.dirname(__FILE__) + '/../lib'
+
+require 'optparse'
+
+module RR
+  # This class implements the functionality of the 'generate' command.
+  class GenerateRunner
+
+    CONFIG_TEMPLATE = <<EOF
+RR::Initializer::run do |config|
+  config.left = {
+    :adapter  => 'postgresql', # or 'mysql2'
+    :database => 'SCOTT',
+    :username => 'scott',
+    :password => 'tiger',
+    :host     => '172.16.1.1'
+  }
+
+  config.right = {
+    :adapter  => 'postgresql',
+    :database => 'SCOTT',
+    :username => 'scott',
+    :password => 'tiger',
+    :host     => '172.16.1.2'
+  }
+
+  config.include_tables 'dept'
+  config.include_tables /^e/ # regexp matching all tables starting with e
+  # config.include_tables /./ # regexp matching all tables in the database
+end
+EOF
+
+    CommandRunner.register 'generate' => {
+      :command => self,
+      :description => 'Generates a configuration file template'
+    }
+    
+    # Provided options. Possible values:
+    # * +:config_file+: path to config file
+    attr_accessor :options
+
+    # Parses the given command line parameter array.
+    # Returns the status (as per UNIX conventions: 1 if parameters were invalid,
+    # 0 otherwise)
+    def process_options(args)
+      status = 0
+      self.options = {}
+
+      parser = OptionParser.new do |opts|
+        opts.banner = <<EOS
+Usage: #{$0} generate [file_name]
+
+  Generates a configuration file template under name [file_name].
+EOS
+        opts.separator ""
+        opts.separator "  Specific options:"
+
+        opts.on_tail("--help", "Show this message") do
+          $stderr.puts opts
+          self.options = nil
+        end
+      end
+
+      begin
+        unprocessed_args = parser.parse!(args)
+        if options # this will be +nil+ if the --help option is specified
+          raise("Please specify the name of the configuration file") if unprocessed_args.empty?
+          options[:file_name] = unprocessed_args[0]
+        end
+      rescue Exception => e
+        $stderr.puts "Command line parsing failed: #{e}"
+        $stderr.puts parser.help
+        self.options = nil
+        status = 1
+      end
+
+      return status
+    end
+
+    # Generates a configuration file template.
+    def execute
+      if File.exists?(options[:file_name])
+        raise("Cowardly refuse to overwrite existing file '#{options[:file_name]}'")
+      end
+      File.open(options[:file_name], 'w') do |f|
+        f.write CONFIG_TEMPLATE
+      end
+    end
+
+    # Entry points for executing a processing run.
+    # args: the array of command line options that were provided by the user.
+    def self.run(args)
+      runner = new
+
+      status = runner.process_options(args)
+      if runner.options
+        runner.execute
+      end
+      status
+    end
+
+  end
+end
+
+

data/lib/rubyrep/initializer.rb

@@ -0,0 +1,39 @@
+module RR
+
+  # The settings of the current deployment are passed to Rubyrep through the
+  # Initializer::run method.
+  # This method yields a Configuration object for overwriting of the default
+  # settings.
+  # Accordingly a configuration file should look something like this:
+  #
+  #   Rubyrep::Initializer.run do |config|
+  #     config.left = ...
+  #   end
+  class Initializer
+
+    # Sets a new Configuration object
+    # Current configuration values are lost and replaced with the default
+    # settings.
+    def self.reset
+      @@configuration = Configuration.new
+    end
+    reset
+
+    # Returns the current Configuration object
+    def self.configuration
+      @@configuration
+    end
+
+    # Allows direct overwriting of the Configuration
+    def self.configuration=(configuration)
+      @@configuration = configuration
+    end
+
+    # Yields the current Configuration object to enable overwriting of
+    # configuration values.
+    # Refer to the Initializer class documentation for a usage example.
+    def self.run
+      yield configuration
+    end
+  end
+end

data/lib/rubyrep/log_helper.rb

@@ -0,0 +1,30 @@
+module RR
+
+  # Shared functionality for SyncHelper and LogHelper
+  module LogHelper
+
+    # Takes outcome and details and makes them fit (for available space) in the
+    # 'descrition' and 'long_description' columns of the event log.
+    # Parameters:
+    # * outcome: short description
+    # * details: long description
+    # Returns (cut off if necessary)
+    # * outcome
+    # * details (also containig the full outcome if it had to be cut off for short description)
+    def fit_description_columns(outcome, details)
+      outcome = outcome.to_s
+      if outcome.length > ReplicationInitializer::DESCRIPTION_SIZE
+        fitting_outcome = outcome[0...ReplicationInitializer::DESCRIPTION_SIZE]
+        fitting_details = outcome + "\n"
+      else
+        fitting_outcome = outcome
+        fitting_details = ""
+      end
+      fitting_details += details if details
+      fitting_details = fitting_details[0...ReplicationInitializer::LONG_DESCRIPTION_SIZE]
+      fitting_details = nil if fitting_details.empty?
+
+      return fitting_outcome, fitting_details
+    end
+  end
+end

data/lib/rubyrep/logged_change.rb

@@ -0,0 +1,160 @@
+module RR
+  
+  # Describes a single logged record change.
+  # 
+  # Note:
+  # The change loading functionality depends on the current database session
+  # being executed in an open database transaction.
+  # Also at the end of change processing the transaction must be committed.
+  class LoggedChange
+
+    # The current LoggedChangeLoader
+    attr_accessor :loader
+
+    # The current Session
+    def session
+      @session ||= loader.session
+    end
+
+    # The current database (either +:left+ or +:right+)
+    def database
+      @database ||= loader.database
+    end
+
+    # The name of the changed table
+    attr_accessor :table
+
+    # When the first change to the record happened
+    attr_accessor :first_changed_at
+
+    # When the last change to the record happened
+    attr_accessor :last_changed_at
+
+    # Type of the change. Either :+insert+, :+update+ or :+delete+.
+    attr_accessor :type
+
+    # A column_name => value hash identifying the changed record
+    attr_accessor :key
+
+    # Only used for updates: a column_name => value hash of the original primary
+    # key of the updated record
+    attr_accessor :new_key
+
+    # Creates a new LoggedChange instance.
+    # * +loader+: the current LoggedChangeLoader
+    # * +database+: either :+left+ or :+right+
+    def initialize(loader)
+      self.loader = loader
+      self.type = :no_change
+    end
+
+    # A hash describing how the change state morph based on newly found change
+    # records.
+    # * key: String consisting of 2 letters
+    #   * first letter: describes current type change (nothing, insert, update, delete)
+    #   * second letter: the new change type as read of the change log table
+    # * value:
+    #   The resulting change type.
+    # [1]: such cases shouldn't happen. but just in case, choose the most
+    # sensible solution.
+    TYPE_CHANGES = {
+      'NI' => 'I',
+      'NU' => 'U',
+      'ND' => 'D',
+      'II' => 'I', # [1]
+      'IU' => 'I',
+      'ID' => 'N',
+      'UI' => 'U', # [1]
+      'UU' => 'U',
+      'UD' => 'D',
+      'DI' => 'U',
+      'DU' => 'U', # [1]
+      'DD' => 'D', # [1]
+    }
+
+    # A hash translating the short 1-letter types to the according symbols
+    SHORT_TYPES = {
+      'I' => :insert,
+      'U' => :update,
+      'D' => :delete,
+      'N' => :no_change
+    }
+    # A hash translating the symbold types to according 1 letter types
+    LONG_TYPES = SHORT_TYPES.invert
+
+    # Returns the configured key separator
+    def key_sep
+      @key_sep ||= session.configuration.options[:key_sep]
+    end
+
+    # Returns a column_name => value hash based on the provided +raw_key+ string
+    # (which is a string in the format as read directly from the change log table).
+    def key_to_hash(raw_key)
+      result = {}
+      #raw_key.split(key_sep).each_slice(2) {|a| result[a[0]] = a[1]}
+      raw_key.split(key_sep).each_slice(2) {|field_name, value| result[field_name] = value}
+      result
+    end
+
+    # Loads the change as per #table and #key. Works if the LoggedChange instance
+    # is totally new or was already loaded before.
+    def load
+      current_type = LONG_TYPES[type]
+
+      org_key = new_key || key
+      # change to key string as can be found in change log table
+      org_key = session.send(database).primary_key_names(table).map do |key_name|
+        "#{key_name}#{key_sep}#{org_key[key_name]}"
+      end.join(key_sep)
+      current_key = org_key
+
+      while change = loader.load(table, current_key)
+
+        new_type = change['change_type']
+        current_type = TYPE_CHANGES["#{current_type}#{new_type}"]
+
+        self.first_changed_at ||= change['change_time']
+        self.last_changed_at = change['change_time']
+
+        if change['change_type'] == 'U' and change['change_new_key'] != current_key
+          current_key = change['change_new_key']
+        end
+      end
+
+      self.type = SHORT_TYPES[current_type]
+      self.new_key = nil
+      if type == :update
+        self.key ||= key_to_hash(org_key)
+        self.new_key = key_to_hash(current_key)
+      else
+        self.key = key_to_hash(current_key)
+      end
+    end
+
+    # Loads the change with the specified key for the named +table+.
+    # * +table+: name of the table
+    # * +key+: a column_name => value hash for all primary key columns of the table
+    def load_specified(table, key)
+      self.table = table
+      self.key = key
+      load
+    end
+
+    # Loads the oldest available change
+    def load_oldest
+      begin
+        change = loader.oldest_change
+        break unless change
+        self.key = key_to_hash(change['change_key'])
+        self.table = change['change_table']
+        load
+      end until type != :no_change
+    end
+
+    # Prevents session from going into YAML output
+    def to_yaml_properties
+      instance_variables.sort.reject {|var_name| ['@session', '@loader'].include? var_name}
+    end
+
+  end
+end