rubyrep 1.0.7 → 1.0.8

data/History.txt

@@ -1,3 +1,11 @@
+== 1.0.8 2009-10-01
+
+* Feature: replication more robust against connection failures
+* Feature: initial syncs before replication can be disabled with :initial_sync option
+* Bug fix: better detection of failed update and delete replications
+* Bug fix: fix scenario where replication could be logged as successful even when failed
+* Bug fix: make proxied replication work under JRuby
+
 == 1.0.7 2009-07-26
 
 * Bug fix: buffered LoggedChangeLoader#update to avoid timeouts with large replication backlogs.

data/Manifest.txt

@@ -67,6 +67,8 @@ lib/rubyrep/trigger_mode_switcher.rb
 lib/rubyrep/type_casting_cursor.rb
 lib/rubyrep/uninstall_runner.rb
 lib/rubyrep/version.rb
+rubyrep
+rubyrep.bat
 script/destroy
 script/generate
 script/txt2html

data/lib/rubyrep/committers/buffered_committer.rb

@@ -89,6 +89,12 @@ module RR
         end
       end
 
+      # Returns +true+ if a new transaction was started since the last
+      # insert / update / delete.
+      def new_transaction?
+        @change_counter == 0
+      end
+
       # A new committer is created for each table sync.
       #   * session: a Session object representing the current database session
       def initialize(session)

data/lib/rubyrep/committers/committers.rb

@@ -68,6 +68,12 @@ module RR
         self.session = session
         self.connections = {:left => session.left, :right => session.right}
       end
+
+      # Returns +true+ if a new transaction was started since the last
+      # insert / update / delete.
+      def new_transaction?
+        false
+      end
       
       # Inserts the specified record in the specified +database+ (either :left or :right).
       # +table+ is the name of the target table.

data/lib/rubyrep/configuration.rb

@@ -30,6 +30,7 @@ module RR
       :table_ordering => true,
       :scan_progress_printer => :progress_bar,
       :use_ansi => true_if_running_in_a_terminal_and_not_under_windows,
+      :initial_sync => true,
       :adjust_sequences => true,
       :sequence_adjustment_buffer => 0,
       :sequence_increment => 2,
@@ -98,8 +99,13 @@ module RR
     #   used for the initial sync of a table.)
     #   If no +:syncer+ option is specified, than a syncer as named by this
     #   option is used.
+    # * :+initial_sync+:
+    #   If +true+, syncs a table when initializing replication.
+    #   Disable with care!
+    #   (I. e. ensure that the table(s) have indeed same data in both databases
+    #   before starting replication.)
     # * :+adjust_sequences+:
-    #   If true, adjust sequences to avoid number conflicts between left and
+    #   If +true+, adjust sequences to avoid number conflicts between left and
     #   right database during replication.
     # * :+sequence_adjustement_buffer+:
     #   When updating a sequence, this is the additional gap to avoid sequence

data/lib/rubyrep/proxy_connection.rb

@@ -93,6 +93,10 @@ module RR
   # This class represents a remote activerecord database connection.
   # Normally created by DatabaseProxy
   class ProxyConnection
+    # Ensure that the proxy object always stays on server side and only remote
+    # references are returned to the client.
+    include DRbUndumped
+
     extend Forwardable
     
     # The database connection
@@ -105,14 +109,14 @@ module RR
     def_delegators :connection,
       :columns, :quote_column_name,
       :quote_table_name, :execute,
-      :select_one, :select_all, :tables,
+      :select_one, :select_all, :tables, :update, :delete,
       :begin_db_transaction, :rollback_db_transaction, :commit_db_transaction,
       :referenced_tables,
       :create_or_replace_replication_trigger_function,
       :create_replication_trigger, :drop_replication_trigger, :replication_trigger_exists?,
       :sequence_values, :update_sequences, :clear_sequence_setup,
-      :create_table, :drop_table, :add_big_primary_key
-    
+      :drop_table, :add_big_primary_key, :add_column, :remove_column
+
     # Caching the primary keys. This is a hash with
     #   * key: table name
     #   * value: array of primary key names
@@ -155,6 +159,13 @@ module RR
       result
     end
     
+    # Creates a table
+    # Call forwarded to ActiveRecord::ConnectionAdapters::SchemaStatements#create_table
+    # Provides an empty block (to prevent DRB from calling back the client)
+    def create_table(*params)
+      connection.create_table(*params) {}
+    end
+
     # Returns a Hash of currently registerred cursors
     def cursors
       @cursors ||= {}
@@ -361,8 +372,9 @@ module RR
     # * +org_key+:
     #   A hash of column_name => value pairs. If +nil+, use the key specified by
     #   +values+ instead.
+    # Returns the number of modified records.
     def update_record(table, values, org_key = nil)
-      execute table_update_query(table, values, org_key)
+      update table_update_query(table, values, org_key)
     end
 
     # Returns an SQL delete query for the given +table+ and +values+
@@ -379,8 +391,9 @@ module RR
     # Deletes the specified record from the named +table+.
     # +values+ is a hash of column_name => value pairs. (Only the primary key
     # values will be used and must be included in the hash.)
+    # Returns the number of deleted records.
     def delete_record(table, values)
-      execute table_delete_query(table, values)
+      delete table_delete_query(table, values)
     end
   end
 end

data/lib/rubyrep/replication_helper.rb

@@ -19,6 +19,12 @@ module RR
     # 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 Committer#insert_record
     def insert_record(database, table, values)
       committer.insert_record(database, table, values)

data/lib/rubyrep/replication_initializer.rb

@@ -149,19 +149,20 @@ module RR
     # Creates the replication log table.
     def create_event_log
       silence_ddl_notices(:left) do
-        session.left.create_table "#{options[:rep_prefix]}_logged_events", :id => false do |t|
-          t.column :activity, :string
-          t.column :change_table, :string
-          t.column :diff_type, :string
-          t.column :change_key, :string
-          t.column :left_change_type, :string
-          t.column :right_change_type, :string
-          t.column :description, :string, :limit => DESCRIPTION_SIZE
-          t.column :long_description, :string, :limit => LONG_DESCRIPTION_SIZE
-          t.column :event_time, :timestamp
-          t.column :diff_dump, :string, :limit => DIFF_DUMP_SIZE
-        end
-        session.left.add_big_primary_key "#{options[:rep_prefix]}_logged_events", 'id'
+        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
 
@@ -169,14 +170,16 @@ module RR
     # * database: either :+left+ or :+right+
     def create_change_log(database)
       silence_ddl_notices(database) do
-        session.send(database).create_table "#{options[:rep_prefix]}_pending_changes", :id => false do |t|
-          t.column :change_table, :string
-          t.column :change_key, :string
-          t.column :change_new_key, :string
-          t.column :change_type, :string
-          t.column :change_time, :timestamp
-        end
-        session.send(database).add_big_primary_key "#{options[:rep_prefix]}_pending_changes", 'id'
+        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
 
@@ -190,9 +193,12 @@ module RR
     def ensure_activity_markers
       table_name = "#{options[:rep_prefix]}_running_flags"
       [:left, :right].each do |database|
-        unless session.send(database).tables.include? table_name
-          session.send(database).create_table table_name, :id => false do |t|
-            t.column :active, :integer
+        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
@@ -298,7 +304,9 @@ module RR
             unsynced = true
           end
         end
-        unsynced_table_pairs << table_pair if unsynced
+        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]}"

data/lib/rubyrep/replication_run.rb

@@ -35,10 +35,15 @@ module RR
         changes_pending
       end
 
+      # Apparently sometimes above check for changes takes already so long, that
+      # the replication run times out.
+      # Check for this and if timed out, return (silently).
+      return if sweeper.terminated?
+
       loaders = LoggedChangeLoaders.new(session)
 
+      success = false
       begin
-        success = false
         replicator # ensure that replicator is created and has chance to validate settings
 
         loop do
@@ -47,16 +52,26 @@ module RR
             diff = ReplicationDifference.new loaders
             diff.load
             break unless diff.loaded?
-            raise "Replication run timed out" if sweeper.terminated?
+            break if sweeper.terminated?
             replicator.replicate_difference diff if diff.type != :no_diff
           rescue Exception => e
-            helper.log_replication_outcome diff, e.message,
-              e.class.to_s + "\n" + e.backtrace.join("\n")
+            begin
+              helper.log_replication_outcome diff, e.message,
+                e.class.to_s + "\n" + e.backtrace.join("\n")
+            rescue Exception => _
+              # if logging to database itself fails, re-raise the original exception
+              raise e
+            end
           end
         end
-        success = true # considered to be successful if we get till here
+        success = true
       ensure
-        helper.finalize success
+        if sweeper.terminated?
+          helper.finalize false
+          session.disconnect_databases
+        else
+          helper.finalize success
+        end
       end
     end
 

data/lib/rubyrep/replication_runner.rb

@@ -65,12 +65,20 @@ EOS
     # Loads config file and creates session if necessary.
     def session
       unless @session
-        load options[:config_file]
-        @session = Session.new Initializer.configuration
+        unless @config
+          load options[:config_file]
+          @config = Initializer.configuration
+        end
+        @session = Session.new @config
       end
       @session
     end
 
+    # Removes current +Session+.
+    def clear_session
+      @session = nil
+    end
+
     # Wait for the next replication time
     def pause_replication
       @last_run ||= 1.year.ago
@@ -100,6 +108,20 @@ EOS
       initializer.prepare_replication
     end
 
+    # Executes a single replication run
+    def execute_once
+      session.refresh
+      timeout = session.configuration.options[:database_connection_timeout]
+      terminated = TaskSweeper.timeout(timeout) do |sweeper|
+        run = ReplicationRun.new session, sweeper
+        run.run
+      end.terminated?
+      raise "replication run timed out" if terminated
+    rescue Exception => e
+      clear_session
+      raise e
+    end
+
     # Executes an endless loop of replication runs
     def execute
       init_waiter
@@ -107,13 +129,7 @@ EOS
 
       until termination_requested do
         begin
-          session.refresh
-          timeout = session.configuration.options[:database_connection_timeout]
-          terminated = TaskSweeper.timeout(timeout) do |sweeper|
-            run = ReplicationRun.new session, sweeper
-            run.run
-          end.terminated?
-          raise "replication run timed out" if terminated
+          execute_once
         rescue Exception => e
           now = Time.now.iso8601
           $stderr.puts "#{now} Exception caught: #{e}"

data/lib/rubyrep/replicators/two_way_replicator.rb

@@ -227,19 +227,9 @@ module RR
           diff.amend
           replicate_difference diff, remaining_attempts - 1, "source record for insert vanished"
         else
-          begin
-            # note: savepoints have to be used for postgresql (as a failed SQL
-            #       statement will otherwise invalidate the complete transaction.)
-            rep_helper.session.send(target_db).execute "savepoint rr_insert"
-            log_replication_outcome source_db, diff
+          attempt_change('insert', source_db, target_db, diff, remaining_attempts) do
             rep_helper.insert_record target_db, target_table, values
-          rescue Exception => e
-            rep_helper.session.send(target_db).execute "rollback to savepoint rr_insert"
-            row = rep_helper.load_record target_db, target_table, source_key
-            raise unless row # problem is not the existence of the record in the target db
-            diff.amend
-            replicate_difference diff, remaining_attempts - 1,
-              "insert failed with #{e.message}"
+            log_replication_outcome source_db, diff
           end
         end
       end
@@ -263,19 +253,45 @@ module RR
           diff.amend
           replicate_difference diff, remaining_attempts - 1, "source record for update vanished"
         else
-          begin
-            rep_helper.session.send(target_db).execute "savepoint rr_update"
-            log_replication_outcome source_db, diff
-            rep_helper.update_record target_db, target_table, values, target_key
-          rescue Exception => e
-            rep_helper.session.send(target_db).execute "rollback to savepoint rr_update"
-            diff.amend
-            replicate_difference diff, remaining_attempts - 1,
-              "update failed with #{e.message}"
+          attempt_change('update', source_db, target_db, diff, remaining_attempts) do
+            number_updated = rep_helper.update_record target_db, target_table, values, target_key
+            if number_updated == 0
+              diff.amend
+              replicate_difference diff, remaining_attempts - 1, "target record for update vanished"
+            else
+              log_replication_outcome source_db, diff
+            end
           end
         end
       end
 
+      # Helper for execution of insert / update / delete attempts.
+      # Wraps those attempts into savepoints and handles exceptions.
+      #
+      # Note:
+      # Savepoints have to be used for PostgreSQL (as a failed SQL statement
+      # will otherwise invalidate the complete transaction.)
+      #
+      # * +action+: short description of change (e. g.: "update" or "delete")
+      # * +source_db+: either :+left+ or :+right+ - source database of replication
+      # * +target_db+: either :+left+ or :+right+ - target database of replication
+      # * +diff+: the current ReplicationDifference instance
+      # * +remaining_attempts+: the number of remaining replication attempts for this difference
+      def attempt_change(action, source_db, target_db, diff, remaining_attempts)
+        begin
+          rep_helper.session.send(target_db).execute "savepoint rr_#{action}_#{remaining_attempts}"
+          yield
+          unless rep_helper.new_transaction?
+            rep_helper.session.send(target_db).execute "release savepoint rr_#{action}_#{remaining_attempts}"
+          end
+        rescue Exception => e
+          rep_helper.session.send(target_db).execute "rollback to savepoint rr_#{action}_#{remaining_attempts}"
+          diff.amend
+          replicate_difference diff, remaining_attempts - 1,
+            "#{action} failed with #{e.message}"
+        end
+      end
+
       # Attempts to delete the source record from the target database.
       # E. g. if +source_db is :+left+, then the record is deleted in database
       # :+right+.
@@ -287,15 +303,15 @@ module RR
         change = diff.changes[source_db]
         target_db = OTHER_SIDE[source_db]
         target_table = rep_helper.corresponding_table(source_db, change.table)
-        begin
-          rep_helper.session.send(target_db).execute "savepoint rr_delete"
-          log_replication_outcome source_db, diff
-          rep_helper.delete_record target_db, target_table, target_key
-        rescue Exception => e
-          rep_helper.session.send(target_db).execute "rollback to savepoint rr_delete"
-          diff.amend
-          replicate_difference diff, remaining_attempts - 1,
-            "delete failed with #{e.message}"
+
+        attempt_change('delete', source_db, target_db, diff, remaining_attempts) do
+          number_updated = rep_helper.delete_record target_db, target_table, target_key
+          if number_updated == 0
+            diff.amend
+            replicate_difference diff, remaining_attempts - 1, "target record for delete vanished"
+          else
+            log_replication_outcome source_db, diff
+          end
         end
       end
 

data/lib/rubyrep/session.rb

@@ -133,10 +133,17 @@ module RR
       unreachable
     end
 
+    # Disconnects both database connections
+    def disconnect_databases
+      [:left, :right].each do |database|
+        disconnect_database(database)
+      end
+    end
+
     # Disconnnects the specified database
     # * +database+: the target database (either :+left+ or :+right+)
     def disconnect_database(database)
-      proxy, connection = @proxies[database], @connection[database]
+      proxy, connection = @proxies[database], @connections[database]
       @proxies[database] = nil
       @connections[database] = nil
       if proxy
@@ -145,15 +152,19 @@ module RR
     end
 
     # Refreshes both database connections
-    def refresh
-      [:left, :right].each {|database| refresh_database_connection database}
+    # * +options+: A options hash with the following settings
+    #   * :+forced+: if +true+, always establish a new database connection
+    def refresh(options = {})
+      [:left, :right].each {|database| refresh_database_connection database, options}
     end
 
     # Refreshes the specified database connection.
     # (I. e. reestablish if not active anymore.)
     # * +database+: target database (either :+left+ or :+right+)
-    def refresh_database_connection(database)
-      if database_unreachable?(database)
+    # * +options+: A options hash with the following settings
+    #   * :+forced+: if +true+, always establish a new database connection
+    def refresh_database_connection(database, options)
+      if options[:forced] or database_unreachable?(database)
         # step 1: disconnect both database connection (if still possible)
         begin
           Thread.new do

data/lib/rubyrep/uninstall_runner.rb

@@ -72,6 +72,7 @@ EOS
       initializer = ReplicationInitializer.new session
       initializer.restore_unconfigured_tables([])
       initializer.drop_infrastructure
+      puts "Uninstall completed: rubyrep tables and triggers removed!"
     end
 
     # Entry points for executing a processing run.

data/lib/rubyrep/version.rb

@@ -2,7 +2,7 @@ module RR #:nodoc:
   module VERSION #:nodoc:
     MAJOR = 1
     MINOR = 0
-    TINY  = 7
+    TINY  = 8
 
     STRING = [MAJOR, MINOR, TINY].join('.')
   end

data/rubyrep

@@ -0,0 +1,8 @@
+#!/bin/bash
+
+script_dir="`dirname \"$0\"`"
+
+jruby_path="$script_dir"/jruby/bin/jruby
+rubyrep_path="$script_dir"/bin/rubyrep
+
+$jruby_path --server $rubyrep_path $*

data/rubyrep.bat

@@ -0,0 +1,4 @@
+@echo off
+set jruby_path=%~dp0jruby\bin\jruby.bat
+set rubyrep_path=%~dp0bin\rubyrep
+%jruby_path% --server %rubyrep_path% %1 %2 %3 %4 %5 %6 %7 %8 %9

data/sims/performance/performance.rake

@@ -8,16 +8,16 @@ def prepare_schema
   session = RR::Session.new
 
   [:left, :right].each do |database|
+    c = session.send(database)
     [:big_scan, :big_rep, :big_rep_backup].each do |table|
-      session.send(database).drop_table table rescue nil
-      session.send(database).create_table table do |t|
-        t.column :diff_type, :string
-        t.string :text1, :text2, :text3, :text4
-        t.text :text5
-        t.binary :text6
-        t.integer :number1, :number2, :number3
-        t.float :number4
-      end rescue nil
+      c.drop_table table rescue nil
+      c.create_table table
+      c.add_column table, :diff_type, :string
+      (1..4).each {|i| c.add_column table, "text#{i}", :string}
+      c.add_column table, :text5, :text
+      c.add_column table, :text6, :binary
+      (1..3).each {|i| c.add_column table, "number#{i}", :integer}
+      c.add_column table, :number4, :float
     end
   end
 end  

data/spec/buffered_committer_spec.rb

@@ -202,9 +202,12 @@ describe Committers::BufferedCommitter do
     stub_execute session
     committer = Committers::BufferedCommitter.new(session)
 
-    committer.should_not_receive(:commit_db_transactions).twice
-    committer.should_not_receive(:begin_db_transactions).twice
-    4.times {committer.commit}
+    committer.should_receive(:commit_db_transactions).twice
+    committer.should_receive(:begin_db_transactions).twice
+    committer.commit
+    committer.new_transaction?.should be_false
+    3.times {committer.commit}
+    committer.new_transaction?.should be_true
   end
 
   it "insert_record should commit" do

data/spec/committers_spec.rb

@@ -82,6 +82,10 @@ describe Committers::DefaultCommitter do
     @committer.connections \
       .should == {:left => @session.left, :right => @session.right}
   end
+
+  it "new_transaction? should return false" do
+    @committer.new_transaction?.should be_false
+  end
   
   it_should_behave_like "Committer"
 end

data/spec/proxy_connection_spec.rb

@@ -296,6 +296,20 @@ describe ProxyConnection do
     end
   end
 
+  it "update_record should return the number of updated records" do
+    @connection.begin_db_transaction
+    begin
+      @connection.
+        update_record('scanner_records', 'id' => 1, 'name' => 'update_test').
+        should == 1
+      @connection.
+        update_record('scanner_records', 'id' => 0, 'name' => 'update_test').
+        should == 0
+    ensure
+      @connection.rollback_db_transaction
+    end
+  end
+
   it "update_record should handle combined primary keys" do
     @connection.begin_db_transaction
     begin
@@ -377,4 +391,17 @@ describe ProxyConnection do
     end
   end
 
+  it "delete_record should return the number of deleted records" do
+    @connection.begin_db_transaction
+    begin
+      @connection.
+        delete_record('extender_combined_key', 'first_id' => 1, 'second_id' => '1').
+        should == 1
+      @connection.
+        delete_record('extender_combined_key', 'first_id' => 1, 'second_id' => '0').
+        should == 0
+    ensure
+      @connection.rollback_db_transaction
+    end
+  end
 end

data/spec/replication_extender_interface_spec.rb

@@ -345,12 +345,14 @@ describe "ReplicationExtender", :shared => true do
     session = nil
     begin
       session = Session.new
-      session.left.drop_table 'big_key_test' if session.left.tables.include? 'big_key_test'
-      session.left.create_table 'big_key_test'.to_sym, :id => false do |t|
-        t.column :name, :string
+      initializer = ReplicationInitializer.new(session)
+      initializer.silence_ddl_notices(:left) do
+        session.left.drop_table 'big_key_test' if session.left.tables.include? 'big_key_test'
+        session.left.create_table 'big_key_test'.to_sym
+        session.left.add_column 'big_key_test', :name, :string
+        session.left.remove_column 'big_key_test', 'id'
+        session.left.add_big_primary_key 'big_key_test', 'id'
       end
-      session.left.add_big_primary_key 'big_key_test', 'id'
-
       # should auto generate the primary key if not manually specified
       session.left.insert_record 'big_key_test', {'name' => 'bla'}
       session.left.select_one("select id from big_key_test where name = 'bla'")['id'].

data/spec/replication_helper_spec.rb

@@ -22,6 +22,15 @@ describe ReplicationHelper do
     helper.session.should == rep_run.session
   end
 
+  it "new_transaction? should delegate to the committer" do
+    session = Session.new
+    rep_run = ReplicationRun.new(session, TaskSweeper.new(1))
+    helper = ReplicationHelper.new(rep_run)
+    c = helper.instance_eval {@committer}
+    c.should_receive(:new_transaction?).and_return(true)
+    helper.new_transaction?.should be_true
+  end
+
   it "replication_run should return the current ReplicationRun instance" do
     rep_run = ReplicationRun.new(Session.new, TaskSweeper.new(1))
     helper = ReplicationHelper.new(rep_run)

data/spec/replication_initializer_spec.rb

@@ -437,8 +437,14 @@ describe ReplicationInitializer do
 
     config.include_tables 'rr_pending_changes' # added to verify that it is ignored
 
+    # added to verify that a disabled :initial_sync is honored
+    config.add_table_options 'table_with_manual_key', :initial_sync => false
+
     session = Session.new(config)
 
+    # dummy data to verify that 'table_with_manual_key' is indeed not synced
+    session.left.insert_record 'table_with_manual_key', :id => 1, :name => 'bla'
+
     $stdout = StringIO.new
     begin
       initializer = ReplicationInitializer.new(session)
@@ -470,6 +476,9 @@ describe ReplicationInitializer do
       # verify that the 'rr_pending_changes' table was not touched
       initializer.trigger_exists?(:left, 'rr_pending_changes').should be_false
 
+      # verify that :initial_sync => false is honored
+      session.right.select_all("select * from table_with_manual_key").should be_empty
+
       # verify that syncing is done only for unsynced tables
       SyncRunner.should_not_receive(:new)
       initializer.prepare_replication
@@ -477,6 +486,7 @@ describe ReplicationInitializer do
     ensure
       $stdout = org_stdout
       if session
+        session.left.execute "delete from table_with_manual_key"
         session.left.execute "delete from scanner_left_records_only where id = 10"
         session.right.execute "delete from scanner_left_records_only"
         [:left, :right].each do |database|

data/spec/replication_run_spec.rb

@@ -137,6 +137,76 @@ describe ReplicationRun do
     end
   end
 
+  it "run should re-raise original exception if logging to database fails" do
+    session = Session.new
+    session.left.begin_db_transaction
+    session.right.begin_db_transaction
+    begin
+      session.left.execute "delete from rr_pending_changes"
+      session.left.execute "delete from rr_logged_events"
+      session.left.insert_record 'rr_pending_changes', {
+        'change_table' => 'extender_no_record',
+        'change_key' => 'id|1',
+        'change_type' => 'D',
+        'change_time' => Time.now
+      }
+      run = ReplicationRun.new session, TaskSweeper.new(1)
+      run.replicator.stub!(:replicate_difference).and_return {raise Exception, 'dummy message'}
+      run.helper.stub!(:log_replication_outcome).and_return {raise Exception, 'blub'}
+      lambda {run.run}.should raise_error(Exception, 'dummy message')
+    ensure
+      session.left.rollback_db_transaction
+      session.right.rollback_db_transaction
+    end
+  end
+
+  it "run should return silently if timed out before work actually started" do
+    session = Session.new
+    session.left.begin_db_transaction
+    session.right.begin_db_transaction
+    begin
+      session.left.execute "delete from rr_pending_changes"
+      session.left.insert_record 'rr_pending_changes', {
+        'change_table' => 'extender_no_record',
+        'change_key' => 'id|1',
+        'change_type' => 'D',
+        'change_time' => Time.now
+      }
+      sweeper = TaskSweeper.new(1)
+      sweeper.stub!(:terminated?).and_return(true)
+      run = ReplicationRun.new session, sweeper
+      LoggedChangeLoaders.should_not_receive(:new)
+      run.run
+    ensure
+      session.left.rollback_db_transaction
+      session.right.rollback_db_transaction
+    end
+  end
+
+  it "run should rollback if timed out" do
+    session = Session.new
+    session.left.begin_db_transaction
+    session.right.begin_db_transaction
+    begin
+      session.left.execute "delete from rr_pending_changes"
+      session.left.execute "delete from rr_logged_events"
+      session.left.insert_record 'rr_pending_changes', {
+        'change_table' => 'extender_no_record',
+        'change_key' => 'id|1',
+        'change_type' => 'D',
+        'change_time' => Time.now
+      }
+      sweeper = TaskSweeper.new(1)
+      sweeper.should_receive(:terminated?).any_number_of_times.and_return(false, true)
+      run = ReplicationRun.new session, sweeper
+      run.helper.should_receive(:finalize).with(false)
+      run.run
+    ensure
+      session.left.rollback_db_transaction if session.left
+      session.right.rollback_db_transaction if session.right
+    end
+  end
+
   it "run should not catch exceptions raised during replicator initialization" do
     config = deep_copy(standard_config)
     config.options[:logged_replication_events] = [:invalid_option]

data/spec/replication_runner_spec.rb

@@ -4,6 +4,7 @@ include RR
 
 describe ReplicationRunner do
   before(:each) do
+    Initializer.configuration = standard_config
   end
 
   it "should register itself with CommandRunner" do
@@ -168,6 +169,36 @@ describe ReplicationRunner do
     end
   end
 
+  it "execute_once should not clean up if successful" do
+    runner = ReplicationRunner.new
+    session = Session.new
+    runner.instance_variable_set(:@session, session)
+
+    runner.execute_once
+    runner.instance_variable_get(:@session).should == session
+  end
+
+  it "execute_once should clean up after failed replication runs" do
+    runner = ReplicationRunner.new
+    session = Session.new
+    runner.instance_variable_set(:@session, session)
+
+    session.should_receive(:refresh).and_raise('bla')
+    lambda {runner.execute_once}.should raise_error('bla')
+    runner.instance_variable_get(:@session).should be_nil
+  end
+
+  it "execute_once should raise exception if replication run times out" do
+    session = Session.new
+    runner = ReplicationRunner.new
+    runner.stub!(:session).and_return(session)
+    terminated = mock("terminated")
+    terminated.stub!(:terminated?).and_return(true)
+    TaskSweeper.stub!(:timeout).and_return(terminated)
+
+    lambda {runner.execute_once}.should raise_error(/timed out/)
+  end
+
   it "execute should start the replication" do
     config = deep_copy(standard_config)
     config.options[:committer] = :buffered_commit

data/spec/session_spec.rb

@@ -118,6 +118,17 @@ describe Session do   # here database connection caching is _not_ disabled
     session.right.select_one("select 1+1 as x")['x'].to_i.should == 2
   end
 
+  it "disconnect_databases should disconnect both databases" do
+    session = Session.new(standard_config)
+    session.left.connection.should be_active
+    old_right_connection = session.right.connection
+    old_right_connection.should be_active
+    session.disconnect_databases
+    session.left.should be_nil
+    session.right.should be_nil
+    old_right_connection.should_not be_active
+  end
+
   it "refresh should not do anyting if the connection is still active" do
     session = Session.new
     old_connection_id = session.right.connection.object_id
@@ -125,6 +136,13 @@ describe Session do   # here database connection caching is _not_ disabled
     session.right.connection.object_id.should == old_connection_id
   end
 
+  it "refresh should replace active connections if forced is true" do
+    session = Session.new
+    old_connection_id = session.right.connection.object_id
+    session.refresh :forced => true
+    session.right.connection.object_id.should_not == old_connection_id
+  end
+
   it "manual_primary_keys should return the specified manual primary keys" do
     config = deep_copy(standard_config)
     config.included_table_specs.clear

data/spec/spec_helper.rb

@@ -240,9 +240,9 @@ $start_proxy_as_external_process ||= false
 # Starts a proxy under the given host and post
 def start_proxy(host, port)
   if $start_proxy_as_external_process
-    rrproxy_path = File.join(File.dirname(__FILE__), "..", "bin", "rrproxy.rb")
+    bin_path = File.join(File.dirname(__FILE__), "..", "bin", "rubyrep")
     ruby = RUBY_PLATFORM =~ /java/ ? 'jruby' : 'ruby'
-    cmd = "#{ruby} #{rrproxy_path} -h #{host} -p #{port}"
+    cmd = "#{ruby} #{bin_path} proxy -h #{host} -p #{port}"
     Thread.new {system cmd}    
   else
     url = "druby://#{host}:#{port}"

data/spec/two_way_replicator_spec.rb

@@ -514,6 +514,7 @@ describe Replicators::TwoWayReplicator do
       config.options[:replication_conflict_handling] = :left_wins
 
       session = Session.new(config)
+      session.left.execute "delete from rr_logged_events"
 
       session.left.insert_record 'rr_pending_changes', {
         'change_table' => 'scanner_records',
@@ -593,6 +594,50 @@ describe Replicators::TwoWayReplicator do
     end
   end
 
+  it "replicate_difference should handle deletes failing due to the target record vanishing" do
+    begin
+      config = deep_copy(standard_config)
+      config.options[:committer] = :never_commit
+      config.options[:replication_conflict_handling] = :left_wins
+
+      session = Session.new(config)
+
+      session.left.insert_record 'rr_pending_changes', {
+        'change_table' => 'scanner_records',
+        'change_key' => 'id|3',
+        'change_new_key' => nil,
+        'change_type' => 'D',
+        'change_time' => Time.now
+      }
+
+      rep_run = ReplicationRun.new session, TaskSweeper.new(1)
+      helper = ReplicationHelper.new(rep_run)
+      replicator = Replicators::TwoWayReplicator.new(helper)
+
+      diff = ReplicationDifference.new LoggedChangeLoaders.new(session)
+      diff.load
+
+      session.right.insert_record 'rr_pending_changes', {
+        'change_table' => 'scanner_records',
+        'change_key' => 'id|3',
+        'change_new_key' => 'id|4',
+        'change_type' => 'U',
+        'change_time' => Time.now
+      }
+
+      replicator.replicate_difference diff, 2
+      
+      session.right.select_one("select * from scanner_records where id = 4").
+        should be_nil
+    ensure
+      Committers::NeverCommitter.rollback_current_session
+      if session
+        session.left.execute "delete from rr_pending_changes"
+        session.left.execute "delete from rr_logged_events"
+      end
+    end
+  end
+
   it "replicate_difference should handle updates failing due to the source record being deleted after the original diff was loaded" do
     begin
       config = deep_copy(standard_config)
@@ -644,4 +689,53 @@ describe Replicators::TwoWayReplicator do
       end
     end
   end
+
+  it "replicate_difference should handle updates failing due to the target record being deleted after the original diff was loaded" do
+    begin
+      config = deep_copy(standard_config)
+      config.options[:committer] = :never_commit
+      config.options[:replication_conflict_handling] = :left_wins
+
+      session = Session.new(config)
+
+      session.left.insert_record 'extender_no_record', {
+        'id' => '2',
+        'name' => 'bla'
+      }
+      session.left.insert_record 'rr_pending_changes', {
+        'change_table' => 'extender_no_record',
+        'change_key' => 'id|1',
+        'change_new_key' => 'id|2',
+        'change_type' => 'U',
+        'change_time' => Time.now
+      }
+
+      rep_run = ReplicationRun.new session, TaskSweeper.new(1)
+      helper = ReplicationHelper.new(rep_run)
+      replicator = Replicators::TwoWayReplicator.new(helper)
+
+      diff = ReplicationDifference.new LoggedChangeLoaders.new(session)
+      diff.load
+
+      session.right.insert_record 'rr_pending_changes', {
+        'change_table' => 'extender_no_record',
+        'change_key' => 'id|1',
+        'change_type' => 'D',
+        'change_time' => Time.now
+      }
+      replicator.replicate_difference diff, 2
+
+      session.right.select_one("select * from extender_no_record").should == {
+        'id' => '2',
+        'name' => 'bla'
+      }
+    ensure
+      Committers::NeverCommitter.rollback_current_session
+      if session
+        session.left.execute "delete from extender_no_record"
+        session.right.execute "delete from extender_no_record"
+        session.left.execute "delete from rr_pending_changes"
+      end
+    end
+  end
 end

data/spec/uninstall_runner_spec.rb

@@ -65,22 +65,29 @@ describe UninstallRunner do
   end
 
   it "execute should uninstall all rubyrep elements" do
-    config = deep_copy(standard_config)
-    config.options[:rep_prefix] = 'rx'
-    session = Session.new(config)
-    initializer = ReplicationInitializer.new(session)
+    begin
+      org_stdout, $stdout = $stdout, StringIO.new
+      config = deep_copy(standard_config)
+      config.options[:rep_prefix] = 'rx'
+      session = Session.new(config)
+      initializer = ReplicationInitializer.new(session)
 
-    initializer.ensure_infrastructure
-    initializer.create_trigger :left, 'scanner_records'
+      initializer.ensure_infrastructure
+      initializer.create_trigger :left, 'scanner_records'
 
-    runner = UninstallRunner.new
-    runner.stub!(:session).and_return(session)
+      runner = UninstallRunner.new
+      runner.stub!(:session).and_return(session)
+
+      runner.execute
 
-    runner.execute
+      initializer.trigger_exists?(:left, 'scanner_records').should be_false
+      initializer.change_log_exists?(:left).should be_false
+      session.right.tables.include?('rx_running_flags').should be_false
+      initializer.event_log_exists?.should be_false
 
-    initializer.trigger_exists?(:left, 'scanner_records').should be_false
-    initializer.change_log_exists?(:left).should be_false
-    session.right.tables.include?('rx_running_flags').should be_false
-    initializer.event_log_exists?.should be_false
+      $stdout.string =~ /uninstall completed/i
+    ensure
+      $stdout = org_stdout
+    end
   end
 end

data/tasks/java.rake

@@ -1,23 +1,5 @@
 namespace :deploy do
 
-  BASH_FILE_CONTENT = <<'EOS'
-#!/bin/bash
-
-script_dir="`dirname \"$0\"`"
-
-jruby_path="$script_dir"/jruby/bin/jruby
-rubyrep_path="$script_dir"/bin/rubyrep
-
-$jruby_path --server $rubyrep_path $*
-EOS
-
-  BAT_FILE_CONTENT = <<'EOS'.gsub(/^(.*)$/,"\\1\r")
-@echo off
-set jruby_path=%~dp0jruby\bin\jruby.bat
-set rubyrep_path=%~dp0bin\rubyrep
-%jruby_path% --server %rubyrep_path% %1 %2 %3 %4 %5 %6 %7 %8 %9
-EOS
-
   desc "Create the java installation package"
   task :java do
     pkg_name = "rubyrep-#{RR::VERSION::STRING}"
@@ -28,8 +10,6 @@ EOS
     system "mkdir -p /tmp/#{pkg_name}/jruby"
     system "cp -r #{JRUBY_HOME}/* /tmp/#{pkg_name}/jruby/"
     system "cd /tmp/#{pkg_name}/jruby; rm -rf samples share/ri lib/ruby/gems/1.8/doc"
-    File.open("/tmp/#{pkg_name}/rubyrep.bat", 'w') {|f| f.write(BAT_FILE_CONTENT)}
-    File.open("/tmp/#{pkg_name}/rubyrep", 'w') {|f| f.write(BASH_FILE_CONTENT)}
     system "chmod a+x /tmp/#{pkg_name}/rubyrep"
     system "cd /tmp; rm -f #{pkg_name}.zip; zip -r #{pkg_name}.zip #{pkg_name} >/dev/null"
     system "mkdir -p pkg"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: rubyrep
 version: !ruby/object:Gem::Version 
-  version: 1.0.7
+  version: 1.0.8
 platform: ruby
 authors: 
 - Arndt Lehmann
@@ -30,7 +30,7 @@ cert_chain:
   NwT26VZnE2nr8g==
   -----END CERTIFICATE-----
 
-date: 2009-07-26 00:00:00 +09:00
+date: 2009-10-01 00:00:00 +09:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -144,6 +144,8 @@ files:
 - lib/rubyrep/type_casting_cursor.rb
 - lib/rubyrep/uninstall_runner.rb
 - lib/rubyrep/version.rb
+- rubyrep
+- rubyrep.bat
 - script/destroy
 - script/generate
 - script/txt2html