ar_connection_pool 1.0.0

data/init.rb

@@ -0,0 +1 @@
+# require 'ar_connection_pool'

data/lib/ar_connection_pool.rb

@@ -0,0 +1,305 @@
+require 'benchmark'
+require 'date'
+require 'bigdecimal'
+require 'bigdecimal/util'
+
+require 'active_record/connection_adapters/abstract/schema_definitions'
+require 'active_record/connection_adapters/abstract/schema_statements'
+require 'active_record/connection_adapters/abstract/database_statements'
+require 'active_record/connection_adapters/abstract/quoting'
+require 'active_record/connection_adapters/abstract/connection_specification'
+
+module ActiveRecord
+  module ConnectionAdapters # :nodoc:
+    # All the concrete database adapters follow the interface laid down in this class.
+    # You can use this interface directly by borrowing the database connection from the Base with
+    # Base.connection.
+    #
+    # Most of the methods in the adapter are useful during migrations.  Most
+    # notably, SchemaStatements#create_table, SchemaStatements#drop_table,
+    # SchemaStatements#add_index, SchemaStatements#remove_index,
+    # SchemaStatements#add_column, SchemaStatements#change_column and
+    # SchemaStatements#remove_column are very useful.
+    class ArConnectionPoolAdapter < AbstractAdapter
+      include Quoting, DatabaseStatements, SchemaStatements
+      @@row_even = true
+      
+      def initialize(connection, logger = nil) #:nodoc:
+        @connection, @logger = connection, logger
+        @runtime = 0
+        @last_verification = 0
+      end
+
+      # Returns the human-readable name of the adapter.  Use mixed case - one
+      # can always use downcase if needed.
+      def adapter_name
+        'ArConnectionPool'
+      end
+
+      # Does this adapter support migrations?  Backend specific, as the
+      # abstract adapter always returns +false+.
+      def supports_migrations?
+        false
+      end
+      
+      # Does this adapter support using DISTINCT within COUNT?  This is +true+
+      # for all adapters except sqlite.
+      def supports_count_distinct?
+        true
+      end
+
+      # Should primary key values be selected from their corresponding
+      # sequence before the insert statement?  If true, next_sequence_value
+      # is called before each insert to set the record's primary key.
+      # This is false for all adapters but Firebird.
+      def prefetch_primary_key?(table_name = nil)
+        false
+      end
+
+      def reset_runtime #:nodoc:
+        rt, @runtime = @runtime, 0
+        rt
+      end
+
+
+      # CONNECTION MANAGEMENT ====================================
+
+      # Is this connection active and ready to perform queries?
+      def active?
+        @active != false
+      end
+
+      # Close this connection and open a new one in its place.
+      def reconnect!
+        @active = true
+      end
+
+      # Close this connection
+      def disconnect!
+        @active = false
+      end
+
+      # Returns true if its safe to reload the connection between requests for development mode.
+      # This is not the case for Ruby/MySQL and it's not necessary for any adapters except SQLite.
+      def requires_reloading?
+        false
+      end
+
+      # Lazily verify this connection, calling +active?+ only if it hasn't
+      # been called for +timeout+ seconds.       
+      def verify!(timeout)
+        now = Time.now.to_i
+        if (now - @last_verification) > timeout
+          reconnect! unless active?
+          @last_verification = now
+        end
+      end
+      
+      # Provides access to the underlying database connection. Useful for
+      # when you need to call a proprietary method such as postgresql's lo_*
+      # methods
+      def raw_connection
+        @connection
+      end
+
+      protected
+        def log(sql, name)
+          if block_given?
+            if @logger and @logger.level <= Logger::INFO
+              result = nil
+              seconds = Benchmark.realtime { result = yield }
+              @runtime += seconds
+              log_info(sql, name, seconds)
+              result
+            else
+              yield
+            end
+          else
+            log_info(sql, name, 0)
+            nil
+          end
+        rescue Exception => e
+          # Log message and raise exception.
+          # Set last_verfication to 0, so that connection gets verified
+          # upon reentering the request loop
+          @last_verification = 0
+          message = "#{e.class.name}: #{e.message}: #{sql}"
+          log_info(message, name, 0)
+          raise ActiveRecord::StatementInvalid, message
+        end
+
+        def log_info(sql, name, runtime)
+          return unless @logger
+
+          @logger.debug(
+            format_log_entry(
+              "#{name.nil? ? "SQL" : name} (#{sprintf("%f", runtime)})",
+              sql.gsub(/ +/, " ")
+            )
+          )
+        end
+
+        def format_log_entry(message, dump = nil)
+          if ActiveRecord::Base.colorize_logging
+            if @@row_even
+              @@row_even = false
+              message_color, dump_color = "4;36;1", "0;1"
+            else
+              @@row_even = true
+              message_color, dump_color = "4;35;1", "0"
+            end
+
+            log_entry = "  \e[#{message_color}m#{message}\e[0m   "
+            log_entry << "\e[#{dump_color}m%#{String === dump ? 's' : 'p'}\e[0m" % dump if dump
+            log_entry
+          else
+            "%s  %s" % [message, dump]
+          end
+        end
+    end
+  end
+end
+
+
+# require 'singleton'
+# module ActiveRecord
+#   module ConnectionPool
+#     class Expired < Exception
+#     end
+#     
+#     # class PersistentConnection < ActiveRecord::Base
+#     #   self.abstract_class = true
+#     #   establish_connection RAILS_ENV.to_sym
+#     # end
+#     
+#     class Configuration
+#       include Singleton
+#       
+#       def initialize
+#         self.pool_size = 2
+#         self.usage_limit = 200
+#         self.ttl = 1.minutes
+#       end
+#       
+#       attr_accessor :pool_size
+#       attr_accessor :usage_limit
+#       attr_accessor :ttl
+#       
+#     end
+#     
+#     class Pool
+#       include Singleton
+#       
+#       def initialize
+#         self.pool = []
+#         ActiveRecord::ConnectionPool::Configuration.instance.pool_size.times do |i|
+#           self.pool << ActiveRecord::ConnectionPool::Connection.new(RAILS_ENV)
+#         end
+#       end
+#       
+#       def connection
+#         conn = self.pool[rand(self.pool.size)]
+#         begin
+#           return conn.connection
+#         rescue ActiveRecord::ConnectionPool::Expired => e
+#           msg e.inspect
+#           msg "Removing connection: #{conn.class_name}"
+#           conn.class_name.constantize.remove_connection
+#           msg "Deleting connection from pool... (#{self.pool.size})"
+#           self.pool.delete(conn)
+#           msg "Deleted connection from pool... (#{self.pool.size})"
+#           self.pool << ActiveRecord::ConnectionPool::Connection.new(RAILS_ENV)
+#           msg "Created new connection #{self.pool.last.class_name} (#{self.pool.size})"
+#           return connection
+#         end
+#       end
+#       
+#       protected
+#       attr_accessor :pool
+#       
+#     end
+#     
+#     class Connection
+#       
+#       attr_accessor :usage
+#       attr_accessor :connection_name
+#       attr_accessor :class_name
+#       attr_accessor :created_at
+#       attr_accessor :expired
+#       
+#       def initialize(con_name)
+#         self.usage = 0
+#         self.connection_name = con_name
+#         self.created_at = Time.now
+#         self.expired = false
+#         self.class_name = "ActiveRecord::ConnectionPool::#{connection_name.to_s.camelize}#{rand(100000)}"
+#         puts "self.connection_name = #{self.connection_name}"
+#         eval %{
+#           class #{self.class_name} < ActiveRecord::Base
+#             self.abstract_class = true
+#             establish_connection :#{self.connection_name}
+#           end
+#         }
+#         msg self.class_name
+#       end
+#       
+#       def connection
+#         self.usage += 1
+#         if self.expired || self.usage >= ActiveRecord::ConnectionPool::Configuration.instance.usage_limit ||
+#            (Time.now - self.created_at) >= ActiveRecord::ConnectionPool::Configuration.instance.ttl
+#            self.expired = true
+#           raise ActiveRecord::ConnectionPool::Expired.new(self.inspect)
+#         end
+#         msg "Selected: #{self.inspect}"
+#         self.class_name.constantize.ar_connection
+#       end
+#       
+#     end
+#   end
+# end
+# 
+# if RAILS_ENV == "development"
+#   def msg(x)
+#     txt = "!-----------------------------\n"
+#     txt << "AR: #{x}\n"
+#     txt << "-----------------------------!\n"
+#     puts txt
+#   end
+# else
+#   def msg(x)
+#   end
+# end
+# 
+# class ActiveRecord::Base
+#   
+#   alias_method :ar_connection, :connection
+#   
+#   def connection
+#     c = ivar_cache("ar_instance_connection") do
+#       ActiveRecord::Base.connection
+#     end
+#     msg(c)
+#     c
+#   end
+#   
+# end
+# 
+# class << ActiveRecord::Base
+# 
+#   alias_method :ar_connection, :connection
+#   
+#   def connection
+#     begin
+#       puts "RAILS_ENV = #{RAILS_ENV}"
+#       return ActiveRecord::ConnectionPool::Pool.instance.connection
+#     rescue Exception => e
+#       msg e.inspect
+#       raise e
+#     end
+#   end
+#   
+#   # def persistent_connection
+#   #   ActiveRecord::ConnectionPool::PersistentConnection.ar_connection
+#   # end
+#   
+# end

data/lib/tasks/rubyforge_config.yml

@@ -0,0 +1,5 @@
+--- !ruby/object:RubyForgeConfig 
+gem_name: ar_connection_pool
+package: ar_connection_pool
+project: magrathea
+version: 1.0.0

metadata

@@ -0,0 +1,52 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.2
+specification_version: 1
+name: ar_connection_pool
+version: !ruby/object:Gem::Version 
+  version: 1.0.0
+date: 2007-09-20 00:00:00 -04:00
+summary: ar_connection_pool
+require_paths: 
+- lib
+- lib
+- lib
+- lib/tasks
+email: 
+homepage: 
+rubyforge_project: magrathea
+description: "ar_connection_pool was developed by: markbates"
+autorequire: 
+- ar_connection_pool
+default_executable: 
+bindir: bin
+has_rdoc: false
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+post_install_message: 
+authors: 
+- markbates
+files: 
+- init.rb
+- lib/ar_connection_pool.rb
+- lib/tasks/rubyforge_config.yml
+test_files: []
+
+rdoc_options: []
+
+extra_rdoc_files: []
+
+executables: []
+
+extensions: []
+
+requirements: []
+
+dependencies: []
+