odba 1.1.8 → 1.2.0

data/lib/odba/cache_entry.rb

@@ -1,18 +1,18 @@
 #!/usr/bin/env ruby
-# encoding: utf-8
+
 # ODBA::CacheEntry -- odba -- 09.01.2012 -- mhatakeyama@ywesee.com
 # ODBA::CacheEntry -- odba -- 29.04.2004 -- hwyss@ywesee.com mwalder@ywesee.com
 
 module ODBA
-	class CacheEntry # :nodoc: all
+  class CacheEntry # :nodoc: all
     @@id_table = {}
     @@finalizer = proc { |object_id|
-      if(odba_id = @@id_table.delete(object_id))
+      if (odba_id = @@id_table.delete(object_id))
         ODBA.cache.invalidate odba_id
       end
     }
-		attr_accessor :last_access
-		attr_reader :accessed_by, :odba_id, :odba_object_id
+    attr_accessor :last_access
+    attr_reader :accessed_by, :odba_id, :odba_object_id
     def initialize(obj)
       @odba_id = obj.odba_id
       update obj
@@ -20,6 +20,7 @@ module ODBA
       @odba_observers = obj.odba_observers
       @cache_entry_mutex = Mutex.new
     end
+
     def update obj
       @last_access = Time.now
       @odba_object = obj
@@ -32,59 +33,68 @@ module ODBA
         ObjectSpace.define_finalizer obj, @@finalizer
       end
     end
+
     def object_id2ref(object_id, odba_id)
       if (obj = ObjectSpace._id2ref(object_id)) \
         && obj.is_a?(Persistable) && !obj.odba_unsaved? \
         && obj.odba_id == odba_id
         obj
       end
-    rescue RangeError, NoMethodError => e
+    rescue RangeError, NoMethodError
       nil
     end
+
     def odba_id2ref(odba_id)
       odba_id && ODBA.cache.include?(odba_id) && ODBA.cache.fetch(odba_id)
     end
-		def odba_add_reference(object)
+
+    def odba_add_reference(object)
       return unless object.respond_to?(:odba_id)
       @cache_entry_mutex.synchronize do
         @accessed_by.store(object.object_id, object.odba_id)
       end
-			object
-		end
-		def odba_cut_connections!
+      object
+    end
+
+    def odba_cut_connections!
       @cache_entry_mutex.synchronize do
         @accessed_by.each { |object_id, odba_id|
-          if((item = odba_id2ref(odba_id) || object_id2ref(object_id, odba_id)) \
-            && item.respond_to?(:odba_cut_connection))
+          if (item = odba_id2ref(odba_id) || object_id2ref(object_id, odba_id)) \
+            && item.respond_to?(:odba_cut_connection)
             item.odba_cut_connection(_odba_object)
           end
         }
       end
-		end
+    end
+
     def odba_notify_observers(*args)
       @odba_observers.each { |obs| obs.odba_update(*args) }
     end
-		def odba_object
-			@last_access  = Time.now
+
+    def odba_object
+      @last_access = Time.now
       @odba_object = _odba_object
       @odba_object || ODBA.cache.fetch(@odba_id)
     end
+
     def _odba_object
       @odba_object || object_id2ref(@odba_object_id, @odba_id)
-		end
-		def odba_old?(retire_horizon = Time.now - ODBA.cache.retire_age)
+    end
+
+    def odba_old?(retire_horizon = Time.now - ODBA.cache.retire_age)
       !_odba_object.odba_unsaved? \
         && (retire_horizon > @last_access)
-		end
-		def odba_retire opts={}
-			# replace with stubs in accessed_by
+    end
+
+    def odba_retire opts = {}
+      # replace with stubs in accessed_by
       instance = _odba_object
       if opts[:force]
         @cache_entry_mutex.synchronize do
           @accessed_by.each do |object_id, odba_id|
             if item = odba_id2ref(odba_id)
               item.odba_stubize instance, opts
-            elsif(item = object_id2ref(object_id, odba_id))
+            elsif (item = object_id2ref(object_id, odba_id))
               if item.is_a?(Persistable) && !item.is_a?(Stub)
                 item.odba_stubize instance, opts
               end
@@ -95,9 +105,9 @@ module ODBA
         @odba_object = nil
       else
         @accessed_by.delete_if { |object_id, odba_id|
-          if(item = odba_id2ref(odba_id))
+          if (item = odba_id2ref(odba_id))
             item.odba_stubize instance
-          elsif(item = object_id2ref(object_id, odba_id))
+          elsif (item = object_id2ref(object_id, odba_id))
             case item
             when Stub
               true
@@ -116,19 +126,20 @@ module ODBA
           @odba_object = nil
         end
       end
-		end
-		def odba_replace!(obj)
+    end
+
+    def odba_replace!(obj)
       oldhash = _odba_object.hash
-			_odba_object.odba_replace!(obj)
-      if(_odba_object.hash != oldhash)
+      _odba_object.odba_replace!(obj)
+      if _odba_object.hash != oldhash
         @cache_entry_mutex.synchronize do
           @accessed_by.each { |object_id, odba_id|
-            if(item = odba_id2ref(odba_id) || object_id2ref(object_id, odba_id))
-              item.rehash if(item.respond_to? :rehash)
+            if (item = odba_id2ref(odba_id) || object_id2ref(object_id, odba_id))
+              item.rehash if item.respond_to? :rehash
             end
           }
         end
       end
-		end
-	end
+    end
+  end
 end

data/lib/odba/connection_pool.rb

@@ -1,63 +1,87 @@
 #!/usr/bin/env ruby
-# encoding: utf-8
+
 # ODBA::ConnectionPool -- odba -- 08.12.2011 -- mhatakeyama@ywesee.com
 # ODBA::ConnectionPool -- odba -- 08.03.2005 -- hwyss@ywesee.com
 
-require 'dbi'
-require 'thread'
+require "dbi"
 
 module ODBA
-	class ConnectionPool
-		POOL_SIZE = 5
-		SETUP_RETRIES = 3
-		#attr_reader :connections
-		attr_reader :connections, :dbi_args
-		# All connections are delegated to DBI. The constructor simply records
-		# the DBI-arguments and reuses them to setup connections when needed.
-		def initialize(*dbi_args)
-			@dbi_args = dbi_args
-      @opts = @dbi_args.last.is_a?(Hash) ? @dbi_args.pop : Hash.new
-			@connections = []
-			@mutex = Mutex.new
-			connect
-		end
-		def next_connection # :nodoc:
-			conn = nil
-			@mutex.synchronize {
-				conn = @connections.shift
-			}
-			yield(conn)
-		ensure
-			@mutex.synchronize {
-				@connections.push(conn)
-			}
-		end
-		def method_missing(method, *args, &block) # :nodoc:
-			tries = SETUP_RETRIES
-			begin
-				next_connection { |conn|
-					conn.send(method, *args, &block)
-				}
-			rescue NoMethodError, DBI::Error => e
+  class ConnectionPool
+    POOL_SIZE = 5
+    SETUP_RETRIES = 3
+    # ydbd-pg maps every PG::Error - including connection level failures -
+    # onto DBI::ProgrammingError, so for that class the message is the only
+    # thing that tells a dead connection apart from a malformed statement.
+    # Without this list a restart of the database server leaves every pooled
+    # connection permanently broken, because the reconnect below never runs.
+    CONNECTION_LOST_MESSAGES = /
+      no\ connection\ to\ the\ server
+      | PQsocket
+      | server\ closed\ the\ connection
+      | connection\ not\ open
+      | terminating\ connection
+      | SSL\ connection\ has\ been\ closed
+      | could\ not\ connect\ to\ server
+    /xi
+    # attr_reader :connections
+    attr_reader :connections, :dbi_args
+    # All connections are delegated to DBI. The constructor simply records
+    # the DBI-arguments and reuses them to setup connections when needed.
+    def initialize(*dbi_args)
+      @dbi_args = dbi_args
+      @opts = @dbi_args.last.is_a?(Hash) ? @dbi_args.pop : {}
+      @connections = []
+      @mutex = Mutex.new
+      connect
+    end
+
+    def next_connection # :nodoc:
+      conn = nil
+      @mutex.synchronize {
+        conn = @connections.shift
+      }
+      yield(conn)
+    ensure
+      @mutex.synchronize {
+        @connections.push(conn)
+      }
+    end
+
+    def method_missing(method, *args, &block) # :nodoc:
+      tries = SETUP_RETRIES
+      begin
+        next_connection { |conn|
+          conn.send(method, *args, &block)
+        }
+      rescue NoMethodError, DBI::Error => e
         warn e
-				if(tries > 0 && (!e.is_a?(DBI::ProgrammingError) \
-           || e.message == 'no connection to the server'))
-					sleep(SETUP_RETRIES - tries)
-					tries -= 1
-					reconnect
-					retry
-				else
-					raise
-				end
-			end
-		end
-		def size 
-			@connections.size
-		end
-    alias :pool_size :size
-		def connect # :nodoc:
-			@mutex.synchronize { _connect }
-		end
+        if tries > 0 && retryable?(e)
+          sleep(SETUP_RETRIES - tries)
+          tries -= 1
+          reconnect
+          retry
+        else
+          raise
+        end
+      end
+    end
+
+    # A statement that failed because the connection is gone is worth
+    # retrying on a fresh one. A statement that failed on its own merits is
+    # not - retrying it would only repeat the same error three times.
+    def retryable?(error) # :nodoc:
+      !error.is_a?(DBI::ProgrammingError) ||
+        CONNECTION_LOST_MESSAGES.match?(error.message.to_s)
+    end
+
+    def size
+      @connections.size
+    end
+    alias_method :pool_size, :size
+    def connect # :nodoc:
+      @mutex.synchronize { _connect }
+    end
+
     def _connect # :nodoc:
       POOL_SIZE.times {
         conn = DBI.connect(*@dbi_args)
@@ -67,24 +91,27 @@ module ODBA
         @connections.push(conn)
       }
     end
-		def disconnect # :nodoc:
-			@mutex.synchronize { _disconnect }
-		end
-		def _disconnect # :nodoc:
-			while(conn = @connections.shift)
-				begin 
-					conn.disconnect
-				rescue DBI::InterfaceError, Exception
-					## we're not interested, since we are disconnecting anyway
+
+    def disconnect # :nodoc:
+      @mutex.synchronize { _disconnect }
+    end
+
+    def _disconnect # :nodoc:
+      while (conn = @connections.shift)
+        begin
+          conn.disconnect
+        rescue DBI::InterfaceError, Exception
+          ## we're not interested, since we are disconnecting anyway
           nil
-				end
-			end
-		end
-		def reconnect # :nodoc:
-			@mutex.synchronize {
-				_disconnect
-				_connect
-			}
-		end
-	end
+        end
+      end
+    end
+
+    def reconnect # :nodoc:
+      @mutex.synchronize {
+        _disconnect
+        _connect
+      }
+    end
+  end
 end

data/lib/odba/drbwrapper.rb

@@ -1,59 +1,65 @@
 #!/usr/bin/env ruby
 # DRbWrapper -- ydim -- 11.01.2006 -- hwyss@ywesee.com
 
-require 'drb'
-require 'odba/persistable'
-require 'odba/stub'
-require 'odba/odba'
-require 'drb/timeridconv'
+require "drb"
+require "odba/persistable"
+require "odba/stub"
+require "odba/odba"
+require "drb/timeridconv"
 
 module ODBA
-  class DRbWrapper 
-    instance_methods.each { |m| 
-      undef_method(m) unless m =~ /^(__)|(respond_to\?|object_id$)/ }
+  class DRbWrapper
+    instance_methods.each { |m|
+      undef_method(m) unless /^(__)|(respond_to\?|object_id$)/.match?(m)
+    }
     include DRb::DRbUndumped
     def initialize(obj)
       @obj = obj
     end
+
     def respond_to?(sym, *args)
       super || @obj.respond_to?(sym, *args)
     end
+
     def method_missing(sym, *args)
-      if(block_given?)
+      if block_given?
         res = @obj.__send__(sym, *args) { |*block_args|
-          yield *block_args.collect { |arg| __wrap(arg) }
+          yield(*block_args.collect { |arg| __wrap(arg) })
         }
         __wrap(res)
       else
         res = @obj.__send__(sym, *args)
-        if(res.is_a?(Array))
+        if res.is_a?(Array)
           res.collect { |item| __wrap(item) }
-        elsif(res.is_a?(Hash))
-          res.inject({}) { |memo, (key, value)|
+        elsif res.is_a?(Hash)
+          res.each_with_object({}) { |(key, value), memo|
             memo.store(__wrap(key), __wrap(value))
-            memo
           }
         else
           __wrap(res)
         end
       end
     end
+
     def __wrap(obj)
-      if(obj.is_a?(ODBA::Persistable))
+      if obj.is_a?(ODBA::Persistable)
         DRbWrapper.new(obj.odba_instance)
       else
         obj
       end
     end
+
     def __wrappee
       @obj
     end
   end
+
   class DRbIdConv < DRb::DRbIdConv
     def initialize(*args)
       super
       @unsaved = {}
     end
+
     def odba_update(key, odba_id, object_id)
       case key
       when :store
@@ -62,9 +68,10 @@ module ODBA
         @unsaved.delete(object_id)
       end
     end
+
     def to_obj(ref)
       test = ref
-      if(test.is_a?(String) || (test = @unsaved[ref]))
+      if test.is_a?(String) || (test = @unsaved[ref])
         DRbWrapper.new(ODBA.cache.fetch(test.to_i))
       else
         super
@@ -72,9 +79,10 @@ module ODBA
     rescue RuntimeError => e
       raise RangeError, e.message
     end
+
     def to_id(obj)
-      if(obj.is_a?(ODBA::Persistable))
-        if(obj.odba_unsaved?)
+      if obj.is_a?(ODBA::Persistable)
+        if obj.odba_unsaved?
           obj.odba_add_observer(self)
           super
         else

data/lib/odba/id_server.rb

@@ -1,26 +1,26 @@
 #!/usr/bin/env ruby
 #-- IdServer -- odba -- 10.11.2004 -- hwyss@ywesee.com
 
-require 'odba/persistable'
-require 'thread'
+require "odba/persistable"
 
 module ODBA
-	class IdServer
-		include Persistable
-		ODBA_SERIALIZABLE = ['@ids']
-		ODBA_EXCLUDE_VARS = ['@mutex']
-		def initialize
-			@ids = {}
-		end
-		def next_id(key, startval=1)
-			@mutex ||= Mutex.new
-			res = nil
-			@mutex.synchronize { 
-				@ids[key] ||= (startval - 1)
-				res = @ids[key] += 1
-			}
-			odba_store
-			res
-		end
-	end
+  class IdServer
+    include Persistable
+    ODBA_SERIALIZABLE = ["@ids"]
+    ODBA_EXCLUDE_VARS = ["@mutex"]
+    def initialize
+      @ids = {}
+    end
+
+    def next_id(key, startval = 1)
+      @mutex ||= Mutex.new
+      res = nil
+      @mutex.synchronize {
+        @ids[key] ||= (startval - 1)
+        res = @ids[key] += 1
+      }
+      odba_store
+      res
+    end
+  end
 end