activerecord-bogacs 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 63fff373845781b28c456f85fe34f88f4bf70a50
+  data.tar.gz: 6b3a8ce661500ec191eff3405d6d3e92d9d90c9e
+SHA512:
+  metadata.gz: ba7c559f09102200a324592448dd7f283ac2b604dd1cdbc5f8e3a0309c07181ebcfbb7fbb576dfa3421cff9faf1cb2c3c5907b64c519c3dbe6da8ab039daaa01
+  data.tar.gz: bfc98ebdacaab29b8d73be82da0327af06bab79d861426c538106de8918bd3ca90581bde24112d1ce4cce76bb3027d186d14ff9f3f017a7205a262696b8c5657

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/jars
+test/tmp
+test/version_tmp
+tmp

data/.travis.yml

@@ -0,0 +1,26 @@
+language: ruby
+jdk:
+  - openjdk6
+  - oraclejdk7
+  - oraclejdk8
+rvm:
+  - jruby
+  #- jruby-head
+  #- jruby-18mode
+  #- jruby-19mode
+  #- 2.1.0
+before_install:
+  - ((jruby -v | grep 1.8.7) && jruby --1.9 -S gem update --system 2.1.11) || true
+before_script:
+  - echo "JRUBY_OPTS: $JRUBY_OPTS"
+  - export JRUBY_OPTS="--server -Xcext.enabled=false -Xcompile.invokedynamic=false"
+  - export JAVA_OPTS="$JAVA_OPTS" # -Xmx600M
+  - echo "JAVA_OPTS: $JAVA_OPTS"
+script:
+  - bundle exec rake tomcat:jndi:download tomcat:jdbc:download tomcat:dbcp:download
+  - bundle exec rake db:create:mysql db:create:postgresql
+env:
+  - JRUBY_OPTS="--1.8 $JRUBY_OPTS" AR_ADAPTER=mysql
+  - JRUBY_OPTS="$JRUBY_OPTS" AR_ADAPTER=postgresql AR_VERSION="~> 3.2.18"
+  - JRUBY_OPTS="--1.8 $JRUBY_OPTS" AR_ADAPTER=mysql AR_VERSION="~> 3.2.18"
+  - JRUBY_OPTS="$JRUBY_OPTS" AR_ADAPTER=postgresql

data/Gemfile

@@ -0,0 +1,33 @@
+source 'https://rubygems.org'
+
+gemspec
+
+if version = ENV['AR_VERSION']
+  if version.index('/') && ::File.exist?(version)
+    gem 'activerecord', :path => version
+  elsif version =~ /^[0-9abcdef]+$/
+    gem 'activerecord', :github => 'rails/rails', :ref => version
+  elsif version.index('.').nil?
+    gem 'activerecord', :github => 'rails/rails', :branch => version
+  else
+    gem 'activerecord', version, :require => nil
+  end
+else
+  gem 'activerecord', :require => nil
+end
+
+gem 'activerecord-jdbc-adapter', :require => nil, :platform => :jruby
+
+#gem 'thread_safe', :require => nil # "optional" - we can roll without it
+
+if defined?(JRUBY_VERSION) && JRUBY_VERSION < '1.7.0'
+gem 'jruby-openssl', :platform => :jruby
+end
+
+group :test do
+  gem 'jdbc-mysql', :require => nil, :platform => :jruby
+  gem 'jdbc-postgres', :require => nil, :platform => :jruby
+
+  gem 'mysql2', :require => nil, :platform => :mri
+  gem 'pg', :require => nil, :platform => :mri
+end

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013-2014 [Karol Bucek](http://kares.org)
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,124 @@
+# ActiveRecord::Bogacs
+
+ActiveRecord pooling "hacks" ... in a relaxed 'spa' fashion!
+
+![Bogacs][0]
+
+Bogács is a village in Borsod-Abaúj-Zemplén county, Hungary.
+
+**WiP: don't even thing about putting this on production (TEST IT OUT FIRST)!**
+
+## Install
+
+add this line to your application's *Gemfile*:
+
+    gem 'activerecord-bogacs', :require => 'active_record/bogacs'
+
+... or install it yourself as:
+
+    $ gem install activerecord-bogacs
+
+## Setup
+
+Bogacs' pools rely on a small monkey-patch that allows to change the AR pool.
+The desired pool class needs to be set before `establish_connection` happens,
+thus an initializer won't work, you might consider setting the pool class at
+the bottom of your *application.rb* e.g. :
+
+```ruby
+Bundler.require(*Rails.groups)
+
+module MyApp
+  class Application < Rails::Application
+    # config.middleware.delete 'ActiveRecord::QueryCache'
+  end
+end
+
+# sample configuration using the "false" pool
+if Rails.env.production?
+  pool_class = ActiveRecord::Bogacs::FalsePool
+  ActiveRecord::ConnectionAdapters::ConnectionHandler.connection_pool_class = pool_class
+end
+```
+
+pools are expected to work with older ActiveRecord versions, if not let us know.
+
+### Default Pool
+
+Meant as a back-port for users stuck with old Rails versions (< 4.0) on production,
+facing potential (pool related) concurrency bugs e.g. with high-loads under JRuby.
+
+Based on pool code from 4.x (which works much better than any previous version),
+with a few minor tunings and extensions such as `pool_initial: 0.5` which allows
+to specify how many connections to prefill when the pool is created.
+
+### False Pool
+
+The false pool won't do any actual pooling, it is assumes that an underlying pool
+is configured. But it does maintain a cache of AR connections mapped to threads.
+Ignores all pool related configuration `pool: 42`, `checkout_timeout: 2.5` etc.
+
+**NOTE:** be sure to configure an underlying pool e.g. with Trinidad (using the
+default Tomcat JDBC pool) :
+
+```yaml
+---
+  http: # true
+    port: 3000
+    # ...
+  extensions:
+    mysql_dbpool:
+      url: jdbc:mysql:///my_production
+      username: root
+      jndi: jdbc/BogacsDB
+      initialSize: <%= ENV['POOL_INITIAL'] || 25 %> # connections created on start
+      maxActive: <%= ENV['POOL_SIZE'] || 100 %> # default 100 (AR pool: size)
+      maxIdle: <%= ENV['POOL_SIZE'] || 100 %> # max connections kept in the pool
+      minIdle: <%= ENV['POOL_SIZE'] || 50 %>
+      # idle connections are checked periodically (if enabled) and connections
+      # that been idle for longer than minEvictableIdleTimeMillis will be released
+      minEvictableIdleTimeMillis: <%= 3 * 60 * 1000 %> # default 60s
+      # AR checkout_timeout: 5
+      maxWait: <%= (( ENV['POOL_TIMEOUT'] || 5.0 ).to_f * 1000).to_i %> # default 30s
+```
+
+ActiveRecord-JDBC adapter allows you to lookup connection from JNDI using the
+following configuration :
+
+```
+production:
+  adapter: mysql2
+  jndi: java:/comp/env/jdbc/BogacsDB
+```
+
+**NOTE:** using the `FalsePool` there's nothing to configure (in *database.yml*)
+that is `no_pool: 5` or `checkout_timeout: 5` defaults!
+
+### Shareable Pool
+
+This pool allows for a database connection to be "shared" among threads, this is
+very **dangerous** normally. You will need to understand the underlying driver's
+connection whether it is thread-safe.
+
+You'll need to manually declare blocks that run with a shared connection (**make
+sure** only read operations happen within such blocks) similar to the built-in
+`with_connection` e.g. :
+
+```ruby
+cache_fetch( [ 'user', user_id ] ) do
+  ActiveRecord::Base.with_shared_connection { User.find(user_id) }
+end
+```
+
+The pool will only share connections among such blocks and only if it runs out
+of all connections (until than it will always prefer checking out a connection
+just like a "regular" pool).
+
+Only tested with ActiveRecord-JDBC-Adapter using the official Postgres' driver.
+
+## Copyright
+
+Copyright (c) 2014 [Karol Bucek](http://kares.org).
+See LICENSE (http://en.wikipedia.org/wiki/MIT_License) for details.
+
+[0]: http://res.cloudinary.com/kares/image/upload/c_scale,h_600,w_800/v1406451696/bogacs.jpg

data/Rakefile

@@ -0,0 +1,167 @@
+require 'bundler/gem_tasks'
+
+require 'rake/testtask'
+Rake::TestTask.new do |t|
+  t.pattern = "test/**/*_test.rb"
+end
+
+task :default => :test
+
+desc "Creates a (test) MySQL database"
+task 'db:create:mysql' do
+  fail "could not create database: mysql executable not found" unless mysql = _which('mysql')
+  ENV['Rake'] = true; ENV['AR_ADAPTER'] ||= 'mysql'
+  load File.expand_path('test/test_helper.rb', File.dirname(__FILE__))
+
+  script = "DROP DATABASE IF EXISTS `#{AR_CONFIG[:database]}`;"
+  script << "CREATE DATABASE `#{AR_CONFIG[:database]}` DEFAULT CHARACTER SET `utf8` COLLATE `utf8_general_ci`;"
+  if AR_CONFIG[:username]
+    script << "GRANT ALL PRIVILEGES ON `#{AR_CONFIG[:database]}`.* TO #{AR_CONFIG[:username]}@localhost;"
+    script << "SET PASSWORD FOR #{AR_CONFIG[:username]}@localhost = PASSWORD('#{AR_CONFIG[:password]}');"
+  end
+  params = { '-u' => 'root' }
+  if ENV['DATABASE_YML']
+    require 'yaml'
+    password = YAML.load(File.new(ENV['DATABASE_YML']))["production"]["password"]
+    params['--password'] = password
+  end
+  puts "Creating MySQL database: #{AR_CONFIG[:database]}"
+  sh "cat #{_sql_script(script).path} | #{mysql} #{params.to_a.join(' ')}", :verbose => $VERBOSE
+  puts "... run tests with MySQL using: `rake test AR_ADAPTER=mysql`"
+end
+
+desc "Creates a (test) PostgreSQL database"
+task 'db:create:postgresql' do
+  fail 'could not create database: psql executable not found' unless psql = _which('psql')
+  fail 'could not create database: missing "postgres" role' unless PostgresHelper.postgres_role?
+  ENV['Rake'] = true; ENV['AR_ADAPTER'] ||= 'postgresql'
+  load File.expand_path('test/test_helper.rb', File.dirname(__FILE__))
+
+  script = "DROP DATABASE IF EXISTS #{AR_CONFIG[:database]};"
+  if pg_user = AR_CONFIG[:username] || ENV['PGUSER'] || ENV_JAVA['user.name']
+    script << "DROP USER IF EXISTS #{pg_user};"
+    pg_password = AR_CONFIG[:password] || ENV['PGPASSWORD']
+    script << "CREATE USER #{pg_user} CREATEDB SUPERUSER LOGIN PASSWORD '#{pg_password}';"
+  end
+  script << "CREATE DATABASE #{AR_CONFIG[:database]} OWNER #{pg_user || 'postgres'};"
+  params = { '-U' => ENV['PSQL_USER'] || 'postgres' }; params['-q'] = nil unless $VERBOSE
+  puts "Creating PostgreSQL database: #{AR_CONFIG[:database]}"
+  sh "cat #{_sql_script(script).path} | #{psql} #{params.to_a.join(' ')}", :verbose => $VERBOSE
+  puts "... run tests with PostgreSQL using: `rake test AR_ADAPTER=postgresql`"
+end
+
+def _sql_script(content, name = '_sql_script')
+  require 'tempfile'
+  script = Tempfile.new(name)
+  script.puts content
+  yield(script) if block_given?
+  script.close
+  at_exit { script.unlink }
+  script
+end
+
+def _which(cmd)
+  exts = ENV['PATHEXT'] ? ENV['PATHEXT'].split(';') : ['']
+  ( ENV['PATH'] || '' ).split(File::PATH_SEPARATOR).each do |path|
+    exts.each do |ext|
+      exe = File.join(path, "#{cmd}#{ext}")
+      return exe if File.executable? exe
+    end
+  end
+  nil
+end
+
+namespace :tomcat do
+
+  tomcat_maven_repo = 'http://repo2.maven.org/maven2/org/apache/tomcat'
+  download_dir = File.expand_path('test/jars', File.dirname(__FILE__))
+  version_default = '7.0.54'
+
+  [ 'tomcat-jdbc', 'tomcat-dbcp' ].each do |tomcat_pool|
+    namespace tomcat_pool.sub('tomcat-', '') do # rake tomcat:dbcp:download
+
+      tomcat_pool_jar = "#{tomcat_pool}.jar"
+
+      task :download, :version do |_,args| # rake tomcat:jdbc:download[7.0.54]
+        version = args[:version] || version_default
+
+        uri = "#{tomcat_maven_repo}/#{tomcat_pool}/#{version}/#{tomcat_pool}-#{version}.jar"
+
+        require 'open-uri'; require 'tmpdir'
+
+        temp_dir = File.join(Dir.tmpdir, (Time.now.to_f * 1000).to_i.to_s)
+        FileUtils.mkdir temp_dir
+
+        Dir.chdir(temp_dir) do
+          FileUtils.mkdir download_dir unless File.exist?(download_dir)
+          puts "downloading #{uri}"
+          file = open(uri)
+          FileUtils.cp file.path, File.join(download_dir, tomcat_pool_jar)
+        end
+
+        FileUtils.rm_r temp_dir
+      end
+
+      task :check do
+        jar_path = File.join(download_dir, tomcat_pool_jar)
+        unless File.exist?(jar_path)
+          Rake::Task["#{tomcat_pool.sub('-',':')}:download"].invoke
+        end
+      end
+
+      task :clear do
+        jar_path = File.join(download_dir, tomcat_pool_jar)
+        rm jar_path if File.exist?(jar_path)
+      end
+
+    end
+  end
+
+  namespace 'jndi' do # contains a FS JNDI impl (for tests)
+
+    catalina_jar = 'tomcat-catalina.jar'; juli_jar = 'tomcat-juli.jar'
+
+    task :download, :version do |_,args|
+      version = args[:version] || version_default
+
+      catalina_uri = "#{tomcat_maven_repo}/tomcat-catalina/#{version}/tomcat-catalina-#{version}.jar"
+      juli_uri = "#{tomcat_maven_repo}/tomcat-juli/#{version}/tomcat-juli-#{version}.jar"
+
+      require 'open-uri'; require 'tmpdir'
+
+      temp_dir = File.join(Dir.tmpdir, (Time.now.to_f * 1000).to_i.to_s)
+      FileUtils.mkdir temp_dir
+
+      downloads = Hash.new
+      downloads[catalina_jar] = catalina_uri
+      downloads[juli_jar] = juli_uri
+
+      Dir.chdir(temp_dir) do
+        FileUtils.mkdir download_dir unless File.exist?(download_dir)
+        downloads.each do |jar, uri|
+          puts "downloading #{uri}"
+          file = open(uri)
+          FileUtils.cp file.path, File.join(download_dir, jar)
+        end
+      end
+
+      FileUtils.rm_r temp_dir
+    end
+
+    task :check do
+      jar_path = File.join(download_dir, catalina_jar)
+      unless File.exist?(jar_path)
+        Rake::Task['tomcat:jndi:download'].invoke
+      end
+    end
+
+    task :clear do
+      jar_path = File.join(download_dir, catalina_jar)
+      rm jar_path if File.exist?(jar_path)
+      jar_path = File.join(download_dir, juli_jar)
+      rm jar_path if File.exist?(jar_path)
+    end
+
+  end
+
+end

data/activerecord-bogacs.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+
+Gem::Specification.new do |gem|
+  gem.name = 'activerecord-bogacs'
+
+  path = File.expand_path('lib/active_record/bogacs/version.rb', File.dirname(__FILE__))
+  gem.version = File.read(path).match( /.*VERSION\s*=\s*['"](.*)['"]/m )[1]
+
+  gem.authors = ['Karol Bucek']
+  gem.email = ['self@kares.org']
+  gem.description = %q{(experimental) alternatives for ActiveRecord::ConnectionAdapters::ConnectionPool}
+  gem.summary = %q{A small body of still water, usually fresh ... for ActiveRecord!}
+  gem.homepage = "http://github.com/kares/activerecord-bogacs"
+  #gem.licenses = ['MIT']
+
+  gem.files = `git ls-files`.split($/)
+  gem.executables = gem.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  gem.test_files = gem.files.grep(%r{^test/})
+  gem.require_paths = ["lib"]
+
+  gem.add_runtime_dependency 'atomic', '~> 1.1'
+  gem.add_runtime_dependency 'thread_safe', '~> 0.3'
+
+  gem.add_development_dependency 'rake', '~> 10.3'
+  gem.add_development_dependency 'test-unit', '~> 2.5'
+end

data/lib/active_record/bogacs.rb

@@ -0,0 +1,55 @@
+require 'active_record/bogacs/version'
+
+require 'active_record'
+require 'active_record/version'
+require 'active_record/connection_adapters/abstract/connection_pool'
+
+module ActiveRecord
+  module Bogacs
+    autoload :DefaultPool, 'active_record/bogacs/default_pool'
+    autoload :FalsePool, 'active_record/bogacs/false_pool'
+    autoload :ShareablePool, 'active_record/bogacs/shareable_pool'
+  end
+  autoload :SharedConnection, 'active_record/shared_connection'
+end
+
+# NOTE: needs explicit configuration - before connection gets established e.g.
+#
+#   klass = ActiveRecord::Bogacs::FalsePool
+#   ActiveRecord::ConnectionAdapters::ConnectionHandler.connection_pool_class = klass
+#
+module ActiveRecord
+  module ConnectionAdapters
+    # @private there's no other way to change the pool class to use but to patch :(
+    ConnectionHandler.class_eval do
+
+      @@connection_pool_class = ConnectionAdapters::ConnectionPool
+
+      def connection_pool_class; @@connection_pool_class end
+      def self.connection_pool_class=(klass); @@connection_pool_class = klass end
+
+      if ActiveRecord::VERSION::MAJOR > 3 # 4.x
+
+        def establish_connection(owner, spec)
+          @class_to_pool.clear
+          owner_to_pool[owner.name] = connection_pool_class.new(spec)
+        end
+
+      elsif ActiveRecord::VERSION::MAJOR == 3 && ActiveRecord::VERSION::MINOR == 2
+
+        def establish_connection(name, spec)
+          @class_to_pool[name] =
+            ( @connection_pools[spec] ||= connection_pool_class.new(spec) )
+        end
+
+      else # 2.3/3.0/3.1
+
+        def establish_connection(name, spec)
+          @connection_pools[name] = connection_pool_class.new(spec)
+        end
+
+      end
+
+    end
+  end
+end