dbhijacker 0.4.0

data/Gemfile

@@ -0,0 +1,3 @@
+source "https://rubygems.org"
+gemspec
+

data/Gemfile.lock

@@ -0,0 +1,61 @@
+PATH
+  remote: .
+  specs:
+    dbhijacker (0.4.0)
+      rails (~> 2.3.14)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    actionmailer (2.3.14)
+      actionpack (= 2.3.14)
+    actionpack (2.3.14)
+      activesupport (= 2.3.14)
+      rack (~> 1.1.0)
+    activerecord (2.3.14)
+      activesupport (= 2.3.14)
+    activeresource (2.3.14)
+      activesupport (= 2.3.14)
+    activesupport (2.3.14)
+    columnize (0.3.6)
+    diff-lcs (1.1.3)
+    linecache (0.46)
+      rbx-require-relative (> 0.0.4)
+    rack (1.1.3)
+    rack-test (0.6.1)
+      rack (>= 1.0)
+    rails (2.3.14)
+      actionmailer (= 2.3.14)
+      actionpack (= 2.3.14)
+      activerecord (= 2.3.14)
+      activeresource (= 2.3.14)
+      activesupport (= 2.3.14)
+      rake (>= 0.8.3)
+    rake (0.9.2.2)
+    rbx-require-relative (0.0.5)
+    rspec (2.8.0)
+      rspec-core (~> 2.8.0)
+      rspec-expectations (~> 2.8.0)
+      rspec-mocks (~> 2.8.0)
+    rspec-core (2.8.0)
+    rspec-expectations (2.8.0)
+      diff-lcs (~> 1.1.2)
+    rspec-mocks (2.8.0)
+    ruby-debug (0.10.4)
+      columnize (>= 0.1)
+      ruby-debug-base (~> 0.10.4.0)
+    ruby-debug-base (0.10.4)
+      linecache (>= 0.3)
+    sqlite3 (1.3.5)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  dbhijacker!
+  rack (~> 1.1.0)
+  rack-test (~> 0.6.1)
+  rake (~> 0.9.2)
+  rspec (~> 2.8.0)
+  ruby-debug (~> 0.10.4)
+  sqlite3 (~> 1.3.5)

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 [name of plugin creator]
+
+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.rdoc

@@ -0,0 +1,67 @@
+Hijacker
+========
+
+One application, multiple client databases. Although customizable, by default uses a combination of database and regular expression matching against the host domain to figure out which database to connect to.
+
+Example
+=======
+
+    class ApplicationController < ActionController::Base
+      hijack_connection({
+        # First thing it does is look for static routes. If this option
+        # exists and returns a string, it'll use that as the database
+        :static_routes => Proc.new {
+          case RAILS_ENV
+          when "development" then "site_development"
+          when "test" then "site_test"
+          end
+        },
+        # If it can't find the host in root.databases, it'll try pattern matching.
+        # Grabs $1 after a successful match.
+        :domain_patterns => [
+          /^(.+)\.domain\.com/, /^.+\.(.+)\..+/, /^(.+)\..+/
+        ],
+        :after_hijack => Proc.new {
+          # Classes using acts_as_nested_set load the table info when preloading code in production.
+          # This is wrong 'cause at that point AR is connected to the root database.
+          Category.reset_column_information
+        }
+      })
+    end
+    
+For copy/pasters, a shorter version:
+
+    hijack_connection({
+      :static_routes => Proc.new { "site_#{Rails.env}" if !(Rails.env == "production") },
+      :domain_patterns => [/^(.+)\.site\.com/, /^.+\.(.+)\..+/, /^(.+)\..+/],
+      :after_hijack => Proc.new { Category.reset_column_information }
+    })
+
+Configuration
+=============
+
+Your database.yml needs a "root" connection like so:
+
+    ...
+    
+    root: &root
+      database: root
+      <<: *defaults
+    
+    production:
+      <<: *root
+    
+    ...
+
+Other parts of database.yml will remain the same (development, test) but production
+apps will initially start up on this root database, then hijack when the first connection
+comes in.
+
+Running tests
+=============
+
+To run the tests, just invoke RSpec:
+
+    rspec spec
+
+Copyright (c) 2012 Michael Xavier, Donald Plummer, Woody Peterson, released under the MIT license

data/Rakefile

@@ -0,0 +1,33 @@
+require 'rake'
+require 'rake/rdoctask'
+require 'spec/rake/spectask'
+
+desc 'Default: run unit tests.'
+task :default => :spec
+
+desc 'Test the hijacker plugin.'
+Spec::Rake::SpecTask.new(:spec) do |t|
+  t.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+desc 'Generate documentation for the hijacker plugin.'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'Hijacker'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gemspec|
+    gemspec.name = "hijacker"
+    gemspec.summary = "One application, multiple client databases"
+    gemspec.description = "Allows a single Rails appliation to access many different databases"
+    gemspec.email = "woody@crystalcommerce.com"
+    gemspec.authors = ["Woody Peterson"]
+  end
+rescue LoadError
+  puts "Jeweler not available. Install it with: sudo gem install jeweler"
+end

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/example_root_schema.rb

@@ -0,0 +1,21 @@
+ActiveRecord::Schema.define(:version => 2) do
+  create_table "databases", :force => true do |t|
+    t.string "database"
+    t.integer "master_id"
+    t.integer "host_id"
+  end
+
+  add_index "databases", "database"
+  add_index "databases", "master_id"
+
+  create_table "aliases", :force => true do |t|
+    t.integer "database_id"
+    t.string "name"
+  end
+
+  add_index "aliases", "name"
+
+  create_table "hosts", :force => true do |t|
+    t.string "hostname"
+  end
+end

data/hijacker.gemspec

@@ -0,0 +1,74 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{dbhijacker}
+  s.homepage = "https://github.com/crystalcommerce/hijacker"
+  s.version = "0.4.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Michael Xavier", "Donald Plummer", "Woody Peterson"]
+  s.date = %q{2012-03-21}
+  s.description = %q{Allows a single Rails appliation to access many different databases}
+  s.email = %q{developers@crystalcommerce.com}
+  s.add_dependency("rails", "~>2.3.14")
+  s.add_development_dependency("rake", "~>0.9.2")
+  s.add_development_dependency("rack-test", "~>0.6.1")
+  s.add_development_dependency("rack", "~>1.1.0")
+  s.add_development_dependency("rspec", "~>2.8.0")
+  s.add_development_dependency("sqlite3", "~>1.3.5")
+  s.add_development_dependency("ruby-debug", "~>0.10.4")
+  s.extra_rdoc_files = [
+    "README.rdoc"
+  ]
+  s.files = %w{
+    Gemfile
+    Gemfile.lock
+    MIT-LICENSE
+    README.rdoc
+    Rakefile
+    VERSION
+    example_root_schema.rb
+    hijacker.gemspec
+    init.rb
+    install.rb
+    lib/dbhijacker.rb
+    lib/hijacker.rb
+    lib/hijacker/active_record_ext.rb
+    lib/hijacker/alias.rb
+    lib/hijacker/controller_methods.rb
+    lib/hijacker/database.rb
+    lib/hijacker/host.rb
+    lib/hijacker/middleware.rb
+    spec/hijacker/alias_spec.rb
+    spec/hijacker/database_spec.rb
+    spec/hijacker/host_spec.rb
+    spec/hijacker/middleware_spec.rb
+    spec/hijacker_spec.rb
+    spec/spec_helper.rb
+    tasks/hijacker_tasks.rake
+    uninstall.rb
+  }
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.8.15}
+  s.summary = %q{One application, multiple client databases}
+  s.test_files = %w{
+    spec/hijacker/alias_spec.rb
+    spec/hijacker/database_spec.rb
+    spec/hijacker/host_spec.rb
+    spec/hijacker/middleware_spec.rb
+    spec/hijacker_spec.rb
+    spec/spec_helper.rb
+  }
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end
+

data/init.rb

@@ -0,0 +1,2 @@
+# Include hook code here
+require 'hijacker'

data/install.rb

@@ -0,0 +1 @@
+# Install hook code here

data/lib/dbhijacker.rb

@@ -0,0 +1 @@
+require File.dirname(__FILE__) + '/hijacker'

data/lib/hijacker/active_record_ext.rb

@@ -0,0 +1,8 @@
+module ActiveRecord
+  module ConnectionAdapters
+    class MysqlAdapter
+      attr_accessor :config
+    end
+  end
+end
+  

data/lib/hijacker/alias.rb

@@ -0,0 +1,7 @@
+module Hijacker
+  class Alias < ActiveRecord::Base
+    establish_connection(Hijacker.root_config)
+
+    belongs_to :database, :class_name => "Hijacker::Database"
+  end
+end

data/lib/hijacker/controller_methods.rb

@@ -0,0 +1,46 @@
+module Hijacker::ControllerMethods
+  module Instance
+    def hijack_connection
+      host = request.host
+  
+      master, sister = determine_databases(host)
+
+      Hijacker.connect(master, sister)
+      
+      return true
+    rescue Hijacker::InvalidDatabase => e
+      render_invalid_db
+  
+      # If we've encountered a bad database connection, we don't want
+      # to continue rendering the rest of the before_filters on this, which it will
+      # try to do even when just rendering the bit of text above. If any filters
+      # return false, though, it will halt the filter chain.
+      return false
+    end
+
+    # Returns 2-member array of the main database to connect to, and the sister
+    # (sister will be nil if no master is found, which means we are on the master).
+    def determine_databases(host)
+      if Hijacker.do_hijacking?
+        Hijacker.config[:domain_patterns].find {|pattern| host =~ pattern}
+        client = $1
+      else # development, test, etc
+        client = ActiveRecord::Base.configurations[Rails.env]['database']
+      end
+
+      raise Hijacker::UnparseableURL, "cannot parse '#{host}'" if client.nil?
+
+      master, sister = Hijacker::Database.find_master_and_sister_for(client)
+
+      return [master, sister]
+    end
+
+    def render_invalid_db
+      render :text => "You do not appear to have an account with us (#{request.host})"
+    end
+  end
+end
+
+class ActionController::Base
+  include Hijacker::ControllerMethods::Instance
+end

data/lib/hijacker/database.rb

@@ -0,0 +1,113 @@
+class Hijacker::Database < ActiveRecord::Base
+  establish_connection(Hijacker.root_config)
+
+  has_many :aliases, :class_name => "Hijacker::Alias"
+  belongs_to :master, :foreign_key => 'master_id', :class_name => 'Hijacker::Database'
+  has_many :sisters, :foreign_key => 'master_id', :class_name => 'Hijacker::Database'
+  belongs_to :host, :class_name => "Hijacker::Host"
+
+  validates_uniqueness_of :database
+
+  validates_presence_of :host_id
+
+  alias_attribute :name, :database
+
+  def self.find_by_name(name)
+    find_by_database(name)
+  end
+
+  def self.current
+    find(:first, :conditions => {:database => Hijacker.current_client})
+  end
+  
+  # returns a string or nil
+  def self.find_master_for(client)
+    @masters ||= {}
+    @masters[client] ||= self.connection.select_values(
+        "SELECT master.database 
+        FROM `databases` AS master, `databases` AS sister
+        WHERE sister.database = #{ActiveRecord::Base.connection.quote(client)}
+        AND sister.master_id = master.id"
+      ).first
+  end
+
+  # always returns a master, sister can be nil
+  def self.find_master_and_sister_for(client)
+    master = self.find_master_for(client)
+    sister = master.nil? ? nil : client
+    master ||= client
+    
+    return master, sister
+  end
+
+  def self.shared_sites
+    self.find_shared_sites_for(Hijacker.current_client)
+  end
+
+  def self.connect_to_each_shared_site(&block)
+    connect_each(find_shared_sites_for(Hijacker.current_client), &block)
+  end
+
+  def self.connect_to_each_sister_site(&block)
+    sites = find_shared_sites_for(Hijacker.current_client)
+    sites.delete(Hijacker.current_client)
+    connect_each(sites, &block)
+  end
+  
+  def self.find_shared_sites_for(client)
+    @shared_sites ||= {}
+    return @shared_sites[client] if @shared_sites[client].present?
+
+    current = self.find(:first, :conditions => {:database => client})
+    master_id = current.master_id || current.id
+
+    @shared_sites[client] = self.connection.select_values(
+      "SELECT `database`
+      FROM `databases`
+      WHERE master_id = '#{master_id}' OR id = '#{master_id}'
+      ORDER BY id"
+    )
+  end
+
+  def self.connect_each(sites = all.map(&:database))
+    original_database = Hijacker.current_client
+    begin
+      sites.each do |db|
+        Hijacker.connect_to_master(db)
+        yield db
+      end
+    ensure
+      begin
+        Hijacker.connect_to_master(original_database)
+      rescue Hijacker::InvalidDatabase
+      end
+    end
+  end
+
+  def self.count_each(&blk)
+    acc = {}
+    connect_each do |db|
+      count = blk.call
+      acc[db] = count if count > 0
+    end
+    width = acc.keys.map(&:length).max
+    acc.sort_by(&:last).each do |db, count|
+      puts("%#{width}s: %s" % [db, count])
+    end
+    acc
+  end
+
+  def self.disabled_databases
+    Hijacker::Database.connection.select_values("SELECT `database_name` FROM `disabled_databases`")
+  end
+
+  def disable!
+    Hijacker::Database.connection.
+      execute("REPLACE INTO `disabled_databases` (`database_name`) VALUES ('#{database}')")
+  end
+
+  def enable!
+    Hijacker::Database.connection.
+      execute("DELETE FROM `disabled_databases` WHERE `database_name` = '#{database}'")
+  end
+end

data/lib/hijacker/host.rb

@@ -0,0 +1,5 @@
+class Hijacker::Host < ActiveRecord::Base
+  establish_connection(Hijacker.root_config)
+
+  validates_format_of :hostname, :with => /^(#{URI::REGEXP::PATTERN::HOST}|#{URI::REGEXP::PATTERN::IPV6ADDR})$/
+end

data/lib/hijacker/middleware.rb

@@ -0,0 +1,18 @@
+module Hijacker
+  class Middleware
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      if env['HTTP_X_HIJACKER_DB'].present?
+        begin
+          Hijacker.connect(env['HTTP_X_HIJACKER_DB'])
+        rescue Hijacker::InvalidDatabase => e
+          return [404, {}, ""]
+        end
+      end
+      @app.call(env)
+    end
+  end
+end

data/lib/hijacker.rb

@@ -0,0 +1,222 @@
+require 'hijacker/active_record_ext'
+require 'active_record'
+require 'action_controller'
+
+module Hijacker
+  class UnparseableURL < StandardError;end
+  class InvalidDatabase < StandardError;end
+
+  class << self
+    attr_accessor :config, :master, :sister
+    attr_writer :valid_routes
+  end
+
+  def self.valid_routes
+    @valid_routes ||= {}
+  end
+
+  def self.connect_to_master(db_name)
+    connect(*Hijacker::Database.find_master_and_sister_for(db_name))
+  end
+
+  # Manually establishes a new connection to the database.
+  # 
+  # Background: every time rails gets information
+  # from the database, it uses the last established connection. So,
+  # although we've already established a connection to a "dummy" db
+  # ("crystal", in this case), if we establish a new connection, all
+  # subsequent database calls will use these settings instead (well,
+  # until it's called again when it gets another request).
+  # 
+  # Note that you can manually call this from script/console (or wherever)
+  # to connect to the database you want, ex Hijacker.connect("database")
+  def self.connect(target_name, sister_name = nil, options = {})
+    raise InvalidDatabase, 'master cannot be nil' if target_name.nil?
+
+    target_name = target_name.downcase
+    sister_name = sister_name.downcase unless sister_name.nil?
+
+    return if already_connected?(target_name, sister_name) || test?
+
+    verify = options.fetch(:verify, Hijacker.do_hijacking?)
+
+    database = determine_database(target_name, sister_name, verify)
+
+    establish_connection_to_database(database)
+
+    check_connection
+
+    self.master = database.name
+    self.sister = sister_name
+
+    # don't cache sister site
+    cache_database_route(target_name, database) unless sister_name
+
+    connect_sister_site_models(target_name)
+    
+    reenable_query_caching
+    
+    self.config[:after_hijack].call if self.config[:after_hijack]
+  rescue
+    self.establish_root_connection
+    raise
+  end
+
+  # very small chance this will raise, but if it does, we will still handle it the
+  # same as +Hijacker.connect+ so we don't lock up the app.
+  # 
+  # Also note that sister site models share a connection via minor management of
+  # AR's connection_pool stuff, and will use ActiveRecord::Base.connection_pool if
+  # we're not in a sister-site situation
+  def self.connect_sister_site_models(db)
+    return if db.nil?
+    
+    sister_db_connection_pool = self.processing_sister_site? ? nil : ActiveRecord::Base.connection_pool
+    self.config[:sister_site_models].each do |model_name|
+      ar_model = model_name.constantize
+      
+      if !sister_db_connection_pool
+        ar_model.establish_connection(self.root_connection.config.merge(:database => db))
+        begin
+          ar_model.connection
+        rescue
+          ar_model.establish_connection(self.root_connection.config)
+          raise Hijacker::InvalidDatabase, db
+        end
+        sister_db_connection_pool = ar_model.connection_pool
+      else
+        ActiveRecord::Base.connection_handler.connection_pools[model_name] = sister_db_connection_pool
+      end
+    end
+  end
+
+  # connects the sister_site_models to +db+ while calling the block
+  # if +db+ and self.master differ
+  def self.temporary_sister_connect(db, &block)
+    processing_sister_site = (db != self.master && db != self.sister)
+    self.sister = db if processing_sister_site
+    self.connect_sister_site_models(db) if processing_sister_site
+    result = block.call
+    self.connect_sister_site_models(self.master) if processing_sister_site
+    self.sister = nil if processing_sister_site
+    return result
+  end
+  
+  # maintains and returns a connection to the "dummy" database.
+  # 
+  # The advantage of using this over just calling
+  # ActiveRecord::Base.establish_connection (without arguments) to reconnect
+  # to the dummy database is that reusing the same connection greatly reduces
+  # context switching overhead etc involved with establishing a connection to
+  # the database. It may seem trivial, but it actually seems to speed things
+  # up by ~ 1/3 for already fast requests (probably less noticeable on slower
+  # pages).
+  # 
+  # Note: does not hijack, just returns the root connection (i.e. AR::Base will
+  # maintain its connection)
+  def self.root_connection
+    unless $hijacker_root_connection
+      current_config = ActiveRecord::Base.connection.config
+      ActiveRecord::Base.establish_connection('root') # establish with defaults
+      $hijacker_root_connection = ActiveRecord::Base.connection
+      ActiveRecord::Base.establish_connection(current_config) # reconnect, we don't intend to hijack
+    end
+
+    return $hijacker_root_connection
+  end
+  
+  def self.root_config
+    ActiveRecord::Base.configurations['root']
+  end
+  
+  # this should establish a connection to a database containing the bare minimum
+  # for loading the app, usually a sessions table if using sql-based sessions.
+  def self.establish_root_connection
+    ActiveRecord::Base.establish_connection('root')
+  end
+  
+  def self.processing_sister_site?
+    !sister.nil?
+  end
+  
+  def self.master
+    @master || ActiveRecord::Base.configurations[ENV['RAILS_ENV'] || RAILS_ENV]['database']
+  end
+  
+  def self.current_client
+    sister || master
+  end
+
+  def self.do_hijacking?
+    (Hijacker.config[:hosted_environments] || %w[staging production]).
+      include?(ENV['RAILS_ENV'])
+  end
+
+  # just calling establish_connection doesn't actually check to see if
+  # we've established a VALID connection. a call to connection will check
+  # this, and throw an error if the connection's invalid. It is important 
+  # to catch the error and reconnect to a known valid database or rails
+  # will get stuck. This is because once we establish a connection to an
+  # invalid database, the next request will do a courteousy touch to the
+  # invalid database before reaching establish_connection and throw an error,
+  # preventing us from retrying to establish a valid connection and effectively
+  # locking us out of the app.
+  def self.check_connection
+    ::ActiveRecord::Base.connection
+  end
+
+  def self.test?
+    ['test', 'cucumber'].include?(RAILS_ENV)
+  end
+
+private
+
+  def self.already_connected?(new_master, new_sister)
+    current_client == new_master && sister == new_sister
+  end
+
+  def self.determine_database(target_name, sister_name, verify)
+    if sister_name
+      database = Hijacker::Database.find_by_name(sister_name)
+      raise(Hijacker::InvalidDatabase, sister_name) if database.nil?
+      database
+    elsif valid_routes[target_name]
+      valid_routes[target_name] # cached valid database
+    else
+      database = Hijacker::Alias.find_by_name(target_name).try(:database) ||
+                 Hijacker::Database.find_by_name(target_name)
+      raise(Hijacker::InvalidDatabase, target_name) if database.nil?
+      database
+    end
+  end
+
+  def self.cache_database_route(requested_db_name, actual_database)
+    valid_routes[requested_db_name] ||= actual_database
+  end
+
+  def self.establish_connection_to_database(database)
+    hijacked_config = self.root_connection.config.dup
+    ::ActiveRecord::Base.establish_connection(hijacked_config.merge(:database => database.name,
+                                                                    :host => database.host.hostname))
+  end
+
+  # This is a hack to get query caching back on. For some reason when we
+  # reconnect the database during the request, it stops doing query caching.
+  # We couldn't find how it's used by rails originally, but if you turn on
+  # query caching then start a cache block to initialize the @query_cache
+  # instance variable in the connection, AR will from then on build on that
+  # empty @query_cache hash. You have to do both 'cuz without the latter there
+  # will be no @query_cache available. Maybe someday we'll submit a ticket to Rails.
+  def self.reenable_query_caching
+    if ::ActionController::Base.perform_caching
+      ::ActiveRecord::Base.connection.instance_variable_set("@query_cache_enabled", true)
+      ::ActiveRecord::Base.connection.cache do;end
+    end
+  end
+end
+
+require 'hijacker/database'
+require 'hijacker/alias'
+require 'hijacker/host'
+require 'hijacker/middleware'
+require 'hijacker/controller_methods'

data/spec/hijacker/alias_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+describe Hijacker::Alias do
+  it "belongs to a database" do
+    lambda { subject.database }.should_not raise_error
+  end
+end

data/spec/hijacker/database_spec.rb

@@ -0,0 +1,76 @@
+require "spec_helper"
+
+module Hijacker
+  describe Database do
+    let(:host) { Hijacker::Host.create!(:hostname => "localhost") }
+    let(:alias_db) { Hijacker::Alias.new(:name => "alias_db") }
+
+    it "has many aliases" do
+      subject.aliases << alias_db
+      subject.aliases.should == [alias_db]
+    end
+
+    it "belongs to a host" do
+      subject.host = host
+      subject.host.should == host
+    end
+
+    it "requires a host" do
+      subject.host = nil
+      subject.should_not be_valid
+      subject.errors.on(:host_id).should == "can't be blank"
+
+      subject.host = host
+      subject.should be_valid
+    end
+
+    it "aliases name to database" do
+      subject.database = "foo"
+      subject.name.should == "foo"
+      subject.name = "bar"
+      subject.database.should == "bar"
+    end
+
+    it "aliases find_by_name to find_by_database" do
+      Hijacker::Database.should_receive(:find_by_database).with("foo")
+      Hijacker::Database.find_by_name("foo")
+    end
+
+    describe "#connect_each" do
+      def db(name)
+        mock("#{name}_db", :database => name)
+      end
+
+      before (:each) do
+        Database.stub!(:all).and_return([ db("one"), db("two"), db("three") ])
+        Hijacker.stub!(:connect)
+      end
+
+      it "Calls the block once for each database" do
+        count = 0
+        Database.connect_each do |db|
+          count += 1
+        end
+        count.should == Database.all.size
+      end
+
+      it "Passes the name of the database to the block" do
+        db_names = []
+        Database.connect_each do |db|
+          db_names << db
+        end
+        db_names.should == Database.all.map(&:database)
+      end
+
+      it "connects to each of the database and reconnects to the original" do
+        original_db = Hijacker::Database.current
+        Hijacker.should_receive(:connect).exactly(Database.all.size + 1).times
+        Database.connect_each do |db|
+          # noop
+        end
+
+        Hijacker::Database.current.should == original_db
+      end
+    end
+  end
+end

data/spec/hijacker/host_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+describe Hijacker::Host do
+  it "validates the format of the hostname" do
+    subject.hostname = "lol nope"
+    subject.should_not be_valid
+    subject.errors.on(:hostname).should == "is invalid"
+
+    subject.hostname = nil
+    subject.should_not be_valid
+    subject.errors.on(:hostname).should == "is invalid"
+
+    subject.hostname = "db-01.example.com"
+    subject.should be_valid
+
+    subject.hostname = "192.168.1.1"
+    subject.should be_valid
+
+    subject.hostname = "2001:cdba::3257:9652"
+    subject.should be_valid
+  end
+end

data/spec/hijacker/middleware_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+require 'rack/test'
+
+require 'hijacker/middleware'
+
+module Hijacker
+  describe Middleware do
+    include Rack::Test::Methods
+
+    def app
+      Rack::Builder.new do
+        use Hijacker::Middleware
+        run lambda { |env| [200, { 'blah' => 'blah' }, "success"] }
+      end
+    end
+
+    describe "#call" do
+      context "When the 'X-Hijacker-DB' header is set" do
+        it "connects to the database from the header" do
+          Hijacker.should_receive(:connect).with("sample-db")
+          get '/',{}, 'HTTP_X_HIJACKER_DB' => 'sample-db'
+        end
+      end
+
+      context "When the 'X-Hijacker-DB' header is not set" do
+        it "doesn't connect to any database" do
+          Hijacker.should_not_receive(:connect)
+          get '/',{}, "x-not-db-header" => "something"
+        end
+      end
+    end
+  end
+end

data/spec/hijacker_spec.rb

@@ -0,0 +1,181 @@
+require "spec_helper"
+
+describe Hijacker do
+  let(:hosted_environments) { %w[staging production] }
+
+  before(:each) do
+    Hijacker.config = {
+      :hosted_environments => hosted_environments
+    } 
+  end
+
+  let!(:host) { Hijacker::Host.create!(:hostname => "localhost") }
+  let!(:master) { Hijacker::Database.create!(:database => "master_db", :host => host) }
+
+  describe ".find_shared_sites_for" do
+    let!(:sister) {Hijacker::Database.create(:database => "sister_db",
+                                             :master => master,
+                                             :host => host)}
+    let!(:sister2) {Hijacker::Database.create(:database => "sister_db2",
+                                              :master => master,
+                                              :host => host)}
+    let!(:unrelated) {Hijacker::Database.create(:database => "unrelated_db",
+                                                :host => host)}
+    let!(:unrelated_sister) {Hijacker::Database.create(:database => "unrelated_sister",
+                                                       :master => unrelated,
+                                                       :host => host)}
+
+    it "find shared sites given a master or sister database" do
+      dbs = ["master_db","sister_db","sister_db2"]
+      Hijacker::Database.find_shared_sites_for("master_db").should == dbs
+      Hijacker::Database.find_shared_sites_for("sister_db").should == dbs
+    end
+  end
+
+  describe "class methods" do 
+    subject { Hijacker }
+
+    describe ".connect" do
+      let(:perform_caching) { false }
+
+      before(:each) do
+        subject.master = nil
+        subject.sister = nil
+        subject.valid_routes = {}
+        subject.stub(:test?).and_return(false)
+        ActiveRecord::Base.stub(:establish_connection)
+        subject.stub(:root_connection).and_return(stub(:config => {}))
+        subject.stub(:connect_sister_site_models)
+        Hijacker.stub(:do_hijacking?).and_return(true)
+        ::ActionController::Base.stub(:perform_caching).
+                                 and_return(perform_caching)
+      end
+
+      it "raises an InvalidDatabase exception if master is nil" do
+        expect { subject.connect(nil) }.to raise_error(Hijacker::InvalidDatabase)
+      end
+
+      it "establishes a connection merging in the db name and the hostname"  do
+        Hijacker::Database.create!(:database => 'elsewhere', :host => host)
+        ActiveRecord::Base.should_receive(:establish_connection).
+          with({:database => 'elsewhere', :host => "localhost"})
+        subject.connect('elsewhere')
+      end
+
+      it "checks the connection by calling ActiveRecord::Base.connection" do
+        subject.should_receive(:check_connection)
+        subject.connect("master_db")
+      end
+
+      it "attempts to find an alias" do
+        Hijacker::Alias.should_receive(:find_by_name).with('alias_db')
+        subject.connect('alias_db') rescue nil
+      end
+
+      it "caches the valid route at the class level :(" do
+        subject.connect('master_db')
+        subject.valid_routes['master_db'].should == master
+      end
+
+      context "there's an alias for the master" do
+        let!(:alias_db) { Hijacker::Alias.create(:name => 'alias_db', :database => master)}
+
+        it "connects with the alias to the master and the host" do
+          ActiveRecord::Base.should_receive(:establish_connection).
+            with({:database => 'master_db', :host => "localhost"})
+          subject.connect('alias_db')
+        end
+
+        it "caches the valid route at the class level :(" do
+          subject.connect('alias_db')
+          subject.valid_routes['alias_db'].should == master
+        end
+      end
+
+      context "ActiveRecord reports the connection is invalid" do
+        before(:each) do
+          subject.stub(:check_connection).and_raise("oh no you didn't")
+        end
+
+        it "reestablishes the root connection" do
+          ActiveRecord::Base.should_receive(:establish_connection).with('root')
+          subject.connect('master_db') rescue nil
+        end
+
+        it "re-raises the error" do
+          expect { subject.connect("master_db") }.to raise_error("oh no you didn't")
+        end
+      end
+
+      context "already connected to database" do
+        before(:each) do
+          Hijacker.master = 'master_db'
+          Hijacker.sister = nil
+        end
+
+        after(:each) do
+          Hijacker.master = nil
+        end
+
+        it "does not reconnect" do
+          ActiveRecord::Base.should_not_receive(:establish_connection)
+          subject.connect('master_db')
+        end
+      end
+
+      context "sister site specified" do
+        let!(:sister_db) { Hijacker::Database.create!(:database => 'sister_db',
+                                                      :master => master,
+                                                      :host => host)}
+        it "does reconnect if specifying a different sister" do
+          ActiveRecord::Base.should_receive(:establish_connection)
+          subject.connect('master_db', 'sister_db')
+        end
+
+        it "does not cache the route" do
+          subject.connect('master_db', 'sister_db')
+          subject.valid_routes.should_not have_key('sister_db')
+        end
+
+        it "raises InvalidDatabase if the sister does not exist" do
+          expect do
+            subject.connect("master_db", "adopted_sister_db")
+          end.to raise_error(Hijacker::InvalidDatabase)
+        end
+      end
+
+      context "actioncontroller configured for caching" do
+        let(:perform_caching) { true }
+
+        it "enables the query cache on ActiveRecord::Base" do
+          subject.connect('master_db')
+          ::ActiveRecord::Base.connection.query_cache_enabled.should be_true
+        end
+
+        it "calls cache on the connection" do
+          ::ActiveRecord::Base.connection.should_receive(:cache)
+          subject.connect('master_db')
+        end
+      end
+
+      context "after_hijack call specified" do
+        let(:spy) { stub.as_null_object }
+        before(:each) do
+          Hijacker.config.merge!(:after_hijack => spy)
+        end
+
+        it "calls the callback" do
+          spy.should_receive(:call)
+          subject.connect('master_db')
+        end
+      end
+    end
+
+    describe ".check_connection" do
+      it "calls connection on ActiveRecord::Base" do
+        ::ActiveRecord::Base.should_receive(:connection)
+        subject.check_connection
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,28 @@
+require 'rubygems'
+require 'active_support'
+require 'active_support/test_case'
+require 'ruby-debug'
+
+require 'active_record'
+
+RAILS_ENV="test"
+ENV['RAILS_ENV'] = 'test'
+$:.unshift '../lib'
+ActiveRecord::Base.configurations = {
+  "test" => {
+    :adapter => 'sqlite3',
+    :database => File.dirname(__FILE__) + "/test_database.sqlite3"
+  }
+}
+
+ActiveRecord::Base.establish_connection
+require File.dirname(__FILE__) + "/../example_root_schema"
+
+require 'hijacker'
+
+RSpec.configure do |config|
+  config.before(:each) do
+    Hijacker::Database.delete_all
+    Hijacker::Alias.delete_all
+  end
+end

data/tasks/hijacker_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :hijacker do
+#   # Task goes here
+# end

data/uninstall.rb

@@ -0,0 +1 @@
+# Uninstall hook code here

metadata

@@ -0,0 +1,209 @@
+--- !ruby/object:Gem::Specification 
+name: dbhijacker
+version: !ruby/object:Gem::Version 
+  hash: 15
+  prerelease: 
+  segments: 
+  - 0
+  - 4
+  - 0
+  version: 0.4.0
+platform: ruby
+authors: 
+- Michael Xavier
+- Donald Plummer
+- Woody Peterson
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-03-21 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rails
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 31
+        segments: 
+        - 2
+        - 3
+        - 14
+        version: 2.3.14
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rake
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 63
+        segments: 
+        - 0
+        - 9
+        - 2
+        version: 0.9.2
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: rack-test
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 5
+        segments: 
+        - 0
+        - 6
+        - 1
+        version: 0.6.1
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: rack
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 19
+        segments: 
+        - 1
+        - 1
+        - 0
+        version: 1.1.0
+  type: :development
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 47
+        segments: 
+        - 2
+        - 8
+        - 0
+        version: 2.8.0
+  type: :development
+  version_requirements: *id005
+- !ruby/object:Gem::Dependency 
+  name: sqlite3
+  prerelease: false
+  requirement: &id006 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 17
+        segments: 
+        - 1
+        - 3
+        - 5
+        version: 1.3.5
+  type: :development
+  version_requirements: *id006
+- !ruby/object:Gem::Dependency 
+  name: ruby-debug
+  prerelease: false
+  requirement: &id007 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 63
+        segments: 
+        - 0
+        - 10
+        - 4
+        version: 0.10.4
+  type: :development
+  version_requirements: *id007
+description: Allows a single Rails appliation to access many different databases
+email: developers@crystalcommerce.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+files: 
+- Gemfile
+- Gemfile.lock
+- MIT-LICENSE
+- README.rdoc
+- Rakefile
+- VERSION
+- example_root_schema.rb
+- hijacker.gemspec
+- init.rb
+- install.rb
+- lib/dbhijacker.rb
+- lib/hijacker.rb
+- lib/hijacker/active_record_ext.rb
+- lib/hijacker/alias.rb
+- lib/hijacker/controller_methods.rb
+- lib/hijacker/database.rb
+- lib/hijacker/host.rb
+- lib/hijacker/middleware.rb
+- spec/hijacker/alias_spec.rb
+- spec/hijacker/database_spec.rb
+- spec/hijacker/host_spec.rb
+- spec/hijacker/middleware_spec.rb
+- spec/hijacker_spec.rb
+- spec/spec_helper.rb
+- tasks/hijacker_tasks.rake
+- uninstall.rb
+homepage: https://github.com/crystalcommerce/hijacker
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+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: 
+rubygems_version: 1.8.15
+signing_key: 
+specification_version: 3
+summary: One application, multiple client databases
+test_files: 
+- spec/hijacker/alias_spec.rb
+- spec/hijacker/database_spec.rb
+- spec/hijacker/host_spec.rb
+- spec/hijacker/middleware_spec.rb
+- spec/hijacker_spec.rb
+- spec/spec_helper.rb
+has_rdoc: