fresh_connection 0.0.1

data/History.txt

@@ -0,0 +1,4 @@
+== 0.0.1 2011-10-16
+
+* 1 major enhancement:
+  * Initial release

data/Manifest.txt

@@ -0,0 +1,9 @@
+History.txt
+Manifest.txt
+README
+Rakefile
+fresh_connection.gemspec
+lib/fresh_connection.rb
+lib/fresh_connection/slave_connection.rb
+lib/fresh_connection/rack/connection_management.rb
+rails/initializers/active_record_base.rb

data/README.rdoc

@@ -0,0 +1,57 @@
+= FreshConnection
+
+ * https://github.com/tsukasaoishi/fresh_connection
+
+== Description
+
+ FreshConnection supports of connect with Mysql slave servers via Load Balancers.
+ Currently, I have only tested with Rails2.3.14.
+ In the future, I plan to support Rails3.
+
+ All connections will be disconnected every time at the end of the action.
+
+== How to use at Rails
+
+=== Gemfile
+  gem "fresh_connection", "=0.0.1"
+
+=== config/database.yml
+  production:
+    adapter: mysql
+    encoding: utf8
+    reconnect: true
+    database: kaeru
+    pool: 5
+    username: master
+    password: master
+    host: localhost
+    socket: /var/run/mysqld/mysqld.sock
+
+    slave:
+      username: slave
+      password: slave
+      host: slave
+      max_connection: 5
+
+slave is config to connect to slave servers.
+max_connection is max connection number to connect to slave.
+Others will use the master setting. If you want to change, write in the slave.
+
+
+=== config/environment.rb
+  require 'fresh_connection'
+  ActionController::Dispatcher.middleware.swap ActiveRecord::ConnectionAdapters::ConnectionManagement, FreshConnection::Rack::ConnectionManagement
+
+== Synopis
+Read query will be access to slave server.
+  Article.where(:id => 1)
+
+If you want to access to master saver, use readonly(false).
+  Article.where(:id => 1).readonly(false)
+
+In transaction, Always will be access to master server.
+  Article.transaction do
+    Article.where(:id => 1)
+  end
+
+

data/Rakefile

@@ -0,0 +1,27 @@
+%w[rubygems rake rake/clean fileutils newgem rubigen].each { |f| require f }
+require File.dirname(__FILE__) + '/lib/fresh_connection'
+
+# Generate all the Rake tasks
+# Run 'rake -T' to see list of generated tasks (from gem root directory)
+$hoe = Hoe.new('fresh_connection', FreshConnection::VERSION) do |p|
+  p.developer('Tsukasa OISHI', 'tsukasa.oishi@gmail.com')
+  p.changes              = p.paragraphs_of("History.txt", 0..1).join("\n\n")
+  p.rubyforge_name       = p.name # TODO this is default value
+  # p.extra_deps         = [
+  #   ['activesupport','>= 2.0.2'],
+  # ]
+  p.extra_dev_deps = [
+    ['newgem', ">= #{::Newgem::VERSION}"]
+  ]
+  
+  p.clean_globs |= %w[**/.DS_Store tmp *.log]
+  path = (p.rubyforge_name == p.name) ? p.rubyforge_name : "\#{p.rubyforge_name}/\#{p.name}"
+  p.remote_rdoc_dir = File.join(path.gsub(/^#{p.rubyforge_name}\/?/,''), 'rdoc')
+  p.rsync_args = '-av --delete --ignore-errors'
+end
+
+require 'newgem/tasks' # load /tasks/*.rake
+Dir['tasks/**/*.rake'].each { |t| load t }
+
+# TODO - want other tests/tasks run by default? Add them to the list
+# task :default => [:spec, :features]

data/fresh_connection.gemspec

@@ -0,0 +1,29 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{fresh_connection}
+  s.version = "0.0.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Tsukasa OISHI"]
+  s.date = %q{2010-10-16}
+  s.description = %q{MiyazakiResistance is a library like ActiveRecord to use Tokyo Tyrant.}
+  s.email = ["tsukasa.oishi@gmail.com"]
+  s.extra_rdoc_files = ["History.txt", "Manifest.txt", "README.rdoc"]
+  s.files = %w|
+    Rakefile
+    fresh_connection.gemspec
+    lib/fresh_connection.rb
+    lib/fresh_connection/slave_connection.rb
+    lib/fresh_connection/rack/connection_management.rb
+    rails/initializers/active_record_base.rb
+  |
+  s.has_rdoc = true
+  s.homepage = %q{http://www.kaeruspoon.net/keywords/MiyazakiResistance}
+  s.post_install_message = %q{PostInstall.txt}
+  s.rdoc_options = ["--main", "README.rdoc"]
+  s.require_paths = ["lib"]
+  s.rubyforge_project = %q{miyazakiresistance}
+  s.rubygems_version = %q{1.3.1}
+  s.summary = %q{MiyazakiResistance is a library like ActiveRecord to use Tokyo Tyrant.}
+end

data/lib/fresh_connection/rack/connection_management.rb

@@ -0,0 +1,18 @@
+module FreshConnection
+  module Rack
+    class ConnectionManagement
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        @app.call(env)
+      ensure
+        unless env.key?("rack.test")
+          ActiveRecord::Base.clear_all_connections!
+          FreshConnection::SlaveConnection.clear_all_connections!
+        end
+      end
+    end
+  end
+end

data/lib/fresh_connection/slave_connection.rb

@@ -0,0 +1,66 @@
+module FreshConnection
+  class SlaveConnection
+    class << self
+      def connection
+        slave_connections[slave_pointer] ||= new_connection
+      end
+
+      def clear_all_connections!
+        if @slave_connections.present?
+          @slave_connections.values.each{|conns| conns.each{|c| c.disconnect!}}
+        end
+        @slave_connections = {}
+      end
+
+      def slave_access_in
+        Thread.current[:slave_access] = true
+      end
+
+      def slave_access_out
+        Thread.current[:slave_access] = false
+      end
+
+      def slave_access?
+        Thread.current[:slave_access] ||= false
+      end
+
+      def shift_slave_pointer
+        Thread.current[:slave_pointer] = slave_pointer + 1
+        Thread.current[:slave_pointer] = 0 if slave_pointer > max_slave_pointer
+      end
+      
+      private
+
+      def new_connection
+        ActiveRecord::Base.send("#{spec["adapter"]}_connection", spec)
+      end
+
+      def slave_connections
+        @slave_connections ||= {}
+        @slave_connections[current_thread_id] ||= []
+      end
+
+
+      def slave_pointer
+        Thread.current[:slave_pointer] ||= 0
+      end
+
+      def max_slave_pointer
+        @max_slave_pointer ||= (spec["max_connection"] || 1) - 1
+      end
+
+      def spec
+        @spec ||= get_spec
+      end
+
+      def get_spec
+        ret = ActiveRecord::Base.configurations[Rails.env]
+        ret.merge(ret["slave"] || {})
+      end
+
+      def current_thread_id
+        Thread.current.object_id
+      end
+    end
+  end
+end

data/lib/fresh_connection.rb

@@ -0,0 +1,8 @@
+module FreshConnection
+  VERSION = "0.0.1"
+end
+
+require "fresh_connection/slave_connection"
+require "fresh_connection/rack/connection_management"
+
+Dir.glob("#{File.join(File.dirname(__FILE__), "../rails/initializers")}/*.rb").each{|path| require path}

data/rails/initializers/active_record_base.rb

@@ -0,0 +1,93 @@
+module ActiveRecord
+  module ConnectionAdapters
+    class AbstractAdapter
+      def select_all_with_slave_cluster(*args)
+        if FreshConnection::SlaveConnection.slave_access?
+          change_connection {select_all_without_slave_cluster(*args)}
+        else
+          select_all_without_slave_cluster(*args)
+        end
+      end
+      alias_method_chain :select_all, :slave_cluster
+
+      def columns_with_slave_cluster(*args)
+        if FreshConnection::SlaveConnection.slave_access?
+          change_connection {columns_without_slave_cluster(*args)}
+        else
+          columns_without_slave_cluster(*args)
+        end
+      end
+      alias_method_chain :columns, :slave_cluster
+
+      def log_info_with_slave_cluster(sql, name, ms)
+        name = "[MASTER] " + (name || "SQL") if !FreshConnection::SlaveConnection.slave_access? && name != "CACHE"
+        log_info_without_slave_cluster(sql, name, ms)
+      end
+      alias_method_chain :log_info, :slave_cluster
+
+      private
+
+      def change_connection
+        master_con, @connection = @connection, FreshConnection::SlaveConnection.connection.raw_connection
+        yield
+      ensure
+        @connection = master_con
+      end
+    end
+  end
+
+  class Base
+    class << self
+      def find_every_with_slave_cluster(options)
+        run_on_db(options) { find_every_without_slave_cluster(options) }
+      end
+      alias_method_chain :find_every, :slave_cluster
+
+      def find_by_sql_with_slave_cluster(sql, options = nil)
+        run_on_db(options) { find_by_sql_without_slave_cluster(sql) }
+      end
+      alias_method_chain :find_by_sql, :slave_cluster
+
+      def count_by_sql_with_slave_cluster(sql, options = nil)
+        run_on_db(options) { count_by_sql_without_slave_cluster(sql) }
+      end
+      alias_method_chain :count_by_sql, :slave_cluster
+
+      def calculate_with_slave_cluster(operation, column_name, options = {})
+        run_on_db(options) do
+          options.delete(:readonly)
+          calculate_without_slave_cluster(operation, column_name, options)
+        end
+      end
+      alias_method_chain :calculate, :slave_cluster
+
+      private
+
+      def run_on_db(options)
+        in_run_on_db[:go_slave] = go_slave?(options) if in_run_on_db[:count] == 0
+        in_run_on_db[:count] += 1
+
+        in_run_on_db[:go_slave] ? run_on_readonly_db{yield} : yield
+      ensure
+        in_run_on_db[:count] -= 1
+      end
+
+      def in_run_on_db
+        Thread.current[:in_run_on_db] ||= {:count => 0, :go_slave => false}
+      end
+
+      def go_slave?(options)
+        connection.open_transactions == 0 && (!options.is_a?(Hash) || !options.key?(:readonly) || options[:readonly].nil? || options[:readonly])
+      end
+
+      def run_on_readonly_db
+        FreshConnection::SlaveConnection.slave_access_in
+        yield
+      ensure
+        FreshConnection::SlaveConnection.shift_slave_pointer
+        FreshConnection::SlaveConnection.slave_access_out
+      end
+    end
+  end
+end
+

metadata

@@ -0,0 +1,77 @@
+--- !ruby/object:Gem::Specification 
+name: fresh_connection
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: 
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Tsukasa OISHI
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-10-16 00:00:00 Z
+dependencies: []
+
+description: MiyazakiResistance is a library like ActiveRecord to use Tokyo Tyrant.
+email: 
+- tsukasa.oishi@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- History.txt
+- Manifest.txt
+- README.rdoc
+files: 
+- Rakefile
+- fresh_connection.gemspec
+- lib/fresh_connection.rb
+- lib/fresh_connection/slave_connection.rb
+- lib/fresh_connection/rack/connection_management.rb
+- rails/initializers/active_record_base.rb
+- History.txt
+- Manifest.txt
+- README.rdoc
+homepage: http://www.kaeruspoon.net/keywords/MiyazakiResistance
+licenses: []
+
+post_install_message: PostInstall.txt
+rdoc_options: 
+- --main
+- README.rdoc
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: miyazakiresistance
+rubygems_version: 1.7.2
+signing_key: 
+specification_version: 3
+summary: MiyazakiResistance is a library like ActiveRecord to use Tokyo Tyrant.
+test_files: []
+