postamt 0.9.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 34ca7a878f7cd7eb35c89e13148ff5bcc1ee9902
+  data.tar.gz: 019233a57d48dcddfefd6ea65025e4a98d59ee78
+SHA512:
+  metadata.gz: 40034cd7b4e0016401f4a98893b2e70a48556a340b9fe541e7693369eb039ea02f1e1c104ec9a81bb2a0b6becbb0e53f06fa1af3145ce4b993eb9bd4c348258b
+  data.tar.gz: 2f7f090a657609cd192b44add07d8dd28e88773d299f6e8f792500f62f997d9917dfee86fa0192e2128f54381d6b126a108902a141919786169896c98cc87b55

data/.gitignore

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

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in pg_charmer.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Martin Schürrer
+
+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,90 @@
+# Postamt
+
+Performs (some of) your read-only queries on a hot standby.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'pg_charmer'
+
+## Example usage
+
+```yaml
+# database.yml
+development:
+  adapter: postgresql
+  database: app
+  username: app
+  password:
+  host: master.db.internal
+  encoding: utf8
+  slave:
+    host: slave.db.internal
+    username: app_readonly
+```
+
+```ruby
+class UserController < ApplicationController
+  use_db_connection :slave, for: ['User'], only: [:search]
+
+  def search
+    # SELECTs here are sent to slave
+    # User#save and User.create would be sent to master anyways.
+    # Everything in a transaction block too.
+    @users = User.where(...) # sent to slave
+    @something_else = SomethingElse.first # sent to master
+  end
+
+  def create
+    @user = User.new(params[:user])
+    @user.save! # sent to master
+  end
+
+  def invoice
+    transaction do
+      @user = User.where(...) # sent to master
+      @invoices = Invoice.create(...) # sent to master
+    end
+  end
+end
+```
+
+```ruby
+class ArchivedItem < ActiveRecord::Base
+  # default_connection can be overwritten with 
+  # * Postamt.on(...) { ... },
+  # * ActiveRecord::Base.transaction { ... }, and
+  # * use_db_connection :other_connection, for: ['ArchivedItem'] in a controller.
+  self.default_connection = :slave
+end
+
+User.where(...) # sent to master
+item = ArchivedItem.where(...) # sent to slave
+item.title = "changed title"
+item.save! # sent to master
+item.reload # sent to slave, beware of replication lag here!
+
+ActiveRecord::Base.transaction do
+  ArchivedItem.where(...) # sent to master, since we're in a transaction
+  User.where(...) # sent to master
+end
+
+Postamt.on(:master) do
+  ArchivedItem.where(...) # sent to master
+  User.where(...) # sent to master
+end
+```
+
+```ruby
+# If you don't want to test with a slave DB put this in config/environments/test.rb
+Postamt.force_connection = :master
+```
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/lib/postamt.rb

@@ -0,0 +1,118 @@
+require 'action_controller'
+require 'active_record'
+require 'postamt/connection_handler'
+require 'postamt/railtie'
+
+module Postamt
+  mattr_accessor :default_connection
+  mattr_accessor :transaction_connection
+  mattr_accessor :force_connection
+
+  # Setup defaults
+  self.default_connection = :master
+  self.transaction_connection = :master
+  self.force_connection = nil
+
+  def self.on(connection)
+    self.connection_stack << connection
+    begin
+      yield
+    ensure
+      self.connection_stack.pop
+    end
+  end
+
+  def self.configurations
+    @configurations ||= begin
+      input = ActiveRecord::Base.configurations[Rails.env]
+      configs = input.select { |k, v| v.is_a? Hash }
+      master_config = input.reject { |k, v| v.is_a? Hash }
+      configs.each { |k, v| v.reverse_merge!(master_config) }
+      configs['master'] = master_config
+      configs
+    end
+  end
+
+  def self.connection_stack
+    Thread.current[:postamt_connection_stack] ||= []
+  end
+
+  # Used by use_db_connection. Cleared in an after_filter.
+  def self.overwritten_default_connections
+    Thread.current[:postamt_overwritten_default_connections] ||= {}
+  end
+
+  if Rails::VERSION::MAJOR == 4 and Rails::VERSION::MINOR == 0
+    Postamt::ConnectionSpecificationResolver = ActiveRecord::ConnectionAdapters::ConnectionSpecification::Resolver
+  elsif Rails::VERSION::MAJOR == 3 and Rails::VERSION::MINOR == 2
+    Postamt::ConnectionSpecificationResolver = ActiveRecord::Base::ConnectionSpecification::Resolver
+  else
+    abort "Postamt doesn't support Rails version #{Rails.version}"
+  end
+
+  # Called by Postamt::Railtie
+  def self.hook!
+    if Rails::VERSION::MAJOR == 4 and Rails::VERSION::MINOR == 0
+      ActiveRecord::Base.default_connection_handler = Postamt::ConnectionHandler.new
+    elsif Rails::VERSION::MAJOR == 3 and Rails::VERSION::MINOR == 2
+      ActiveRecord::Base.connection_handler = Postamt::ConnectionHandler.new
+    end
+
+    ActiveRecord::Base.instance_eval do
+      class_attribute :default_connection
+
+      # disable Model.establish_connection
+      def establish_connection(*args)
+        # This would be the only place Model.connection_handler.establish_connection is called.
+        nil
+      end
+
+      # a transaction runs on Postamt.transaction_connection or on the :on option
+      def transaction(options = {}, &block)
+        if connection = (options.delete(:on) || Postamt.transaction_connection)
+          Postamt.on(connection) { super }
+        else
+          super
+        end
+      end
+    end
+
+    ActiveRecord::Relation.class_eval do
+      # Also make sure that actions that don't instantiate the model and
+      # therefore don't call #save or #destroy run on master.
+      # update_column calls update_all, delete calls delete_all, so we don't
+      # have to monkey patch them.
+
+      def delete_all_with_postamt(conditions = nil)
+        Postamt.on(:master) { delete_all_without_postamt(conditions) }
+      end
+
+      def update_all_with_postamt(updates, conditions = nil, options = {})
+        Postamt.on(:master) { update_all_without_postamt(updates, conditions, options) }
+      end
+
+      # TODO: Switch to Module#prepend once we are Ruby-2.0.0-only
+      alias_method_chain :delete_all, :postamt
+      alias_method_chain :update_all, :postamt
+    end
+
+    ActionController::Base.instance_eval do
+      def use_db_connection(connection, args)
+        default_connections = {}
+        klass_names = args.delete(:for)
+        klass_names.each do |klass_name|
+          default_connections[klass_name] = connection
+        end
+
+        before_filter(args) do |controller|
+          Postamt.overwritten_default_connections.merge!(default_connections)
+        end
+      end
+
+      after_filter do
+        Postamt.overwritten_default_connections.clear
+      end
+    end
+  end
+end
+

data/lib/postamt/connection_handler.rb

@@ -0,0 +1,124 @@
+require 'atomic'
+require 'thread_safe'
+
+module Postamt
+  class ConnectionHandler
+    def initialize
+      @process_pid = Atomic.new(nil)
+    end
+
+    def connection_pools
+      # See https://github.com/rails/rails/commit/c3ca7ac09e960fa1287adc730e8ddc713e844c37
+      Hash[self.connection_pool_list.map { |pool| [pool.spec, pool] }]
+    end
+
+    def connection_pool_list
+      self.ensure_ready
+      @pools.values
+    end
+
+    # Returns true if there are any active connections among the connection
+    # pools that the ConnectionHandler is managing.
+    def active_connections?
+      self.ensure_ready
+      self.connection_pool_list.any?(&:active_connection?)
+    end
+
+    # Returns any connections in use by the current thread back to the pool,
+    # and also returns connections to the pool cached by threads that are no
+    # longer alive.
+    def clear_active_connections!
+      self.ensure_ready
+      self.connection_pool_list.each(&:release_connection)
+    end
+
+    # Clears the cache which maps classes.
+    def clear_reloadable_connections!
+      self.ensure_ready
+      self.connection_pool_list.each(&:clear_reloadable_connections!)
+    end
+
+    def clear_all_connections!
+      self.ensure_ready
+      self.connection_pool_list.each(&:disconnect!)
+    end
+
+    # Locate the connection of the nearest super class. This can be an
+    # active or defined connection: if it is the latter, it will be
+    # opened and set as the active connection for the class it was defined
+    # for (not necessarily the current class).
+    def retrieve_connection(klass) #:nodoc:
+      self.ensure_ready
+      pool = self.retrieve_connection_pool(klass)
+      (pool && pool.connection) or raise ActiveRecord::ConnectionNotEstablished
+    end
+
+    # Returns true if a connection that's accessible to this class has
+    # already been opened.
+    def connected?(klass)
+      return false if Process.pid != @process_pid.get
+      conn = self.retrieve_connection_pool(klass)
+      conn && conn.connected?
+    end
+
+    # Only called in ActiveRecord test code, so performance isn't an issue.
+    def remove_connection(owner)
+      self.clear_cache
+      # Don't return a ConnectionSpecification hash since we've disabled establish_connection anyway
+      return nil
+    end
+
+    # Called by ActiveRecord::ConnectionHandling#connection_pool.
+    def retrieve_connection_pool(klass)
+      self.ensure_ready
+      self.pool_for(klass)
+    end
+
+    protected
+
+    def prepare
+      @process_pid.set(Process.pid)
+      @pools = ThreadSafe::Cache.new(initial_capacity: 2)
+    end
+
+    def ensure_ready
+      if Process.pid != @process_pid.get
+        # We've been forked -> throw away connection pools
+        prepare
+      end
+    end
+
+    # Throw away all pools on next request
+    def clear_cache
+      @process_pid.set(nil)
+    end
+
+    def connection_for(klass)
+      Postamt.force_connection || Postamt.connection_stack.last || Postamt.overwritten_default_connections[klass.name] || klass.default_connection || Postamt.default_connection
+    end
+
+    def pool_for(klass)
+      # Sauspiel's reportable dependency makes Rails 3.2 request a connection early,
+      # before the App is initialized. Return nil in that case, Rails deals with that
+      return nil if ActiveRecord::Base.configurations[Rails.env].nil?
+
+      connection = connection_for(klass)
+      # Ideally we would use #fetch here, as class_to_pool[klass] may sometimes be nil.
+      # However, benchmarking (https://gist.github.com/jonleighton/3552829) showed that
+      # #fetch is significantly slower than #[]. So in the nil case, no caching will
+      # take place, but that's ok since the nil case is not the common one that we wish
+      # to optimise for.
+      @pools[connection] ||= begin
+        Postamt.configurations[connection.to_s] ||= Postamt.configurations['master']
+        resolver = Postamt::ConnectionSpecificationResolver.new connection, Postamt.configurations
+        spec = resolver.spec
+
+        unless ActiveRecord::Base.respond_to?(spec.adapter_method)
+          raise ActiveRecord::AdapterNotFound, "database configuration specifies nonexistent #{spec.config[:adapter]} adapter"
+        end
+
+        ActiveRecord::ConnectionAdapters::ConnectionPool.new(spec)
+      end
+    end
+  end
+end

data/lib/postamt/railtie.rb

@@ -0,0 +1,21 @@
+module Postamt
+  class Railtie < Rails::Railtie
+    railtie_name "postamt"
+
+    initializer "postamt.hook", before: "active_record.initialize_database" do |app|
+      if (defined?($rails_rake_task) && $rails_rake_task)
+        # We mustn't hook into AR when db:migrate or db:test:load_schema
+        # run, but user-defined Rake tasks still need us
+        task_names = []
+        tasks_to_examine = Rake.application.top_level_tasks.map{ |task_name| Rake.application[task_name] }
+        until tasks_to_examine.empty?
+          task = tasks_to_examine.pop
+          task_names << task.name
+          tasks_to_examine += task.prerequisite_tasks
+        end
+        next if task_names.any? { |task_name| task_name.start_with? "db:" }
+      end
+      Postamt.hook!
+    end
+  end
+end

data/lib/postamt/version.rb

@@ -0,0 +1,3 @@
+module Postamt
+  VERSION = "0.9.0"
+end

data/postamt.gemspec

@@ -0,0 +1,25 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'postamt/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "postamt"
+  spec.version       = Postamt::VERSION
+  spec.authors       = ["Martin Schürrer"]
+  spec.email         = ["martin@schuerrer.org"]
+  spec.description   = %q{Choose per model and/or controller&action whether a read-only query should be sent to master or a hot standby. Or just use Postamt.on(:slave) { ... }. }
+  spec.summary       = %q{Performs (some of) your read-only queries on a hot standby}
+  spec.homepage      = "https://github.com/sauspiel/postamt"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/).reject { |f| f.start_with? 'testapp' }
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "thread_safe", "~> 0.1"
+  spec.add_dependency "railties", [">= 3.2.0", "< 4.1.0"]
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+end

metadata

@@ -0,0 +1,119 @@
+--- !ruby/object:Gem::Specification
+name: postamt
+version: !ruby/object:Gem::Version
+  version: 0.9.0
+platform: ruby
+authors:
+- Martin Schürrer
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-04-16 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: thread_safe
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.1'
+- !ruby/object:Gem::Dependency
+  name: railties
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 3.2.0
+    - - <
+      - !ruby/object:Gem::Version
+        version: 4.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 3.2.0
+    - - <
+      - !ruby/object:Gem::Version
+        version: 4.1.0
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 'Choose per model and/or controller&action whether a read-only query
+  should be sent to master or a hot standby. Or just use Postamt.on(:slave) { ...
+  }. '
+email:
+- martin@schuerrer.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/postamt.rb
+- lib/postamt/connection_handler.rb
+- lib/postamt/railtie.rb
+- lib/postamt/version.rb
+- postamt.gemspec
+homepage: https://github.com/sauspiel/postamt
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.3
+signing_key: 
+specification_version: 4
+summary: Performs (some of) your read-only queries on a hot standby
+test_files: []
+has_rdoc: