dr-apartment 0.14.1

data/lib/apartment/delayed_job/active_record.rb

@@ -0,0 +1,20 @@
+module ActiveRecord
+  class Base
+    
+    # Overriding Delayed Job's monkey_patch of ActiveRecord so that it works with Apartment
+    yaml_as "tag:ruby.yaml.org,2002:ActiveRecord"
+    
+    def self.yaml_new(klass, tag, val)
+      Apartment::Database.process(val['database']) do
+        klass.find(val['attributes']['id'])
+      end
+    rescue ActiveRecord::RecordNotFound
+      raise Delayed::DeserializationError
+    end
+    
+    def to_yaml_properties
+      ['@attributes', '@database']    # add in database attribute for serialization
+    end
+    
+  end
+end

data/lib/apartment/delayed_job/enqueue.rb

@@ -0,0 +1,20 @@
+require 'delayed_job'
+require 'apartment/delayed_job/active_record'   # ensure that our AR hooks are loaded when queueing
+
+module Apartment
+  module Delayed
+    module Job
+      
+      # Will enqueue a job ensuring that it happens within the main 'public' database
+      # 
+      # Note that this should not longer be required for versions >= 0.11.0 when using postgresql schemas
+      # 
+      def self.enqueue(payload_object, options = {})
+        Apartment::Database.process do
+          ::Delayed::Job.enqueue(payload_object, options)
+        end
+      end
+      
+    end
+  end
+end

data/lib/apartment/delayed_job/hooks.rb

@@ -0,0 +1,25 @@
+require 'apartment/delayed_job/enqueue'
+
+module Apartment
+  module Delayed
+    module Job
+      
+      # Before and after hooks for performing Delayed Jobs within a particular apartment database
+      # Include these in your delayed jobs models and make sure provide a @database attr that will be serialized by DJ
+      # Note also that any models that are being serialized need the Apartment::Delayed::Requirements module mixed in to it
+      module Hooks
+        
+        attr_accessor :database
+        
+        def before(job)
+          Apartment::Database.switch(job.payload_object.database) if job.payload_object.database
+        end
+        
+        def after
+          Apartment::Database.reset
+        end
+        
+      end
+    end
+  end
+end

data/lib/apartment/delayed_job/requirements.rb

@@ -0,0 +1,23 @@
+require 'apartment/delayed_job/enqueue'
+
+module Apartment
+  module Delayed
+    
+    # Mix this module into any ActiveRecord model that gets serialized by DJ
+    module Requirements
+      attr_accessor :database
+      
+      def self.included(klass)
+        klass.after_find :set_database      # set db when records are pulled so they deserialize properly
+        klass.before_save :set_database     # set db before records are saved so that they also get deserialized properly 
+      end
+      
+    private
+    
+      def set_database
+        @database = Apartment::Database.current_database
+      end
+    
+    end
+  end
+end

data/lib/apartment/elevators/subdomain.rb

@@ -0,0 +1,27 @@
+module Apartment
+  module Elevators
+    # Provides a rack based db switching solution based on subdomains
+    # Assumes that database name should match subdomain
+    class Subdomain
+      
+      def initialize(app)
+        @app = app
+      end
+      
+      def call(env)
+        request = ActionDispatch::Request.new(env)
+        
+        database = subdomain(request)
+        
+        Apartment::Database.switch database if database
+        
+        @app.call(env)
+      end
+      
+      def subdomain(request)
+        request.subdomain.present? && request.subdomain || nil
+      end
+      
+    end
+  end
+end

data/lib/apartment/migrator.rb

@@ -0,0 +1,23 @@
+module Apartment
+  
+  module Migrator
+    
+    extend self
+  
+    # Migrate to latest
+    def migrate(database)
+      Database.process(database){ ActiveRecord::Migrator.migrate(ActiveRecord::Migrator.migrations_path) }
+    end
+  
+    # Migrate up/down to a specific version
+    def run(direction, database, version)
+      Database.process(database){ ActiveRecord::Migrator.run(direction, ActiveRecord::Migrator.migrations_path, version) }
+    end
+  
+    # rollback latest migration `step` number of times
+    def rollback(database, step = 1)
+      Database.process(database){ ActiveRecord::Migrator.rollback(ActiveRecord::Migrator.migrations_path, step) }
+    end
+  end
+    
+end

data/lib/apartment/railtie.rb

@@ -0,0 +1,54 @@
+require 'rails'
+
+module Apartment
+  class Railtie < Rails::Railtie
+    
+    # 
+    #   Set up our default config options
+    #   Do this before the app initializers run so we don't override custom settings
+    # 
+    config.before_initialize do
+      Apartment.configure do |config|
+        config.excluded_models = []
+        config.use_postgres_schemas = true
+        config.database_names = []
+        config.seed_after_create = false
+        config.prepend_environment = true
+      end
+    end
+    
+    #   Hook into ActionDispatch::Reloader to ensure Apartment is properly initialized
+    #   Note that this doens't entirely work as expected in Development, because this is called before classes are reloaded
+    #   See the above middleware/console declarations below to help with this.  Hope to fix that soon.
+    # 
+    config.to_prepare do
+      Apartment::Database.init
+    end
+    
+    # 
+    #   Ensure rake tasks are loaded
+    # 
+    rake_tasks do
+      load 'tasks/apartment.rake'
+    end
+    
+    # 
+    #   The following initializers are a workaround to the fact that I can't properly hook into the rails reloader
+    #   Note this is technically valid for any environment where cache_classes is false, for us, it's just development
+    # 
+    if Rails.env.development?
+      
+      # Apartment::Reloader is middleware to initialize things properly on each request to dev
+      initializer 'apartment.init' do |app|
+        app.config.middleware.use "Apartment::Reloader"
+      end
+    
+      # Overrides reload! to also call Apartment::Database.init as well so that the reloaded classes have the proper table_names
+      console do
+        require 'apartment/console'
+      end
+      
+    end
+    
+  end
+end

data/lib/apartment/reloader.rb

@@ -0,0 +1,24 @@
+module Apartment
+
+  class Reloader
+
+    #   Middleware used in development to init Apartment for each request
+    #   Necessary due to code reload (annoying).  When models are reloaded, they no longer have the proper table_name
+    #   That is prepended with the schema (if using postgresql schemas)
+    #   I couldn't figure out how to properly hook into the Rails reload process *after* files are reloaded
+    #   so I've used this in the meantime.
+    #
+    #   Also see apartment/console for the re-definition of reload! that re-init's Apartment
+    #
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      Database.init
+      @app.call(env)
+    end
+
+  end
+
+end

data/lib/apartment/version.rb

@@ -0,0 +1,3 @@
+module Apartment
+  VERSION = "0.14.1"
+end

data/lib/tasks/apartment.rake

@@ -0,0 +1,70 @@
+apartment_namespace = namespace :apartment do
+
+  desc "Migrate all multi-tenant databases"
+  task :migrate => 'db:migrate' do
+
+    Apartment.database_names.each do |db|
+      puts("Migrating #{db} database")
+      Apartment::Migrator.migrate db
+    end
+  end
+
+  desc "Seed all multi-tenant databases"
+  task :seed => 'db:seed' do
+
+    Apartment.database_names.each do |db|
+      puts("Seeding #{db} database")
+      Apartment::Database.process(db) do
+        Apartment::Database.seed
+      end
+    end
+  end
+
+  desc "Rolls the schema back to the previous version (specify steps w/ STEP=n) across all multi-tenant dbs."
+  task :rollback => 'db:rollback' do
+    step = ENV['STEP'] ? ENV['STEP'].to_i : 1
+
+    Apartment.database_names.each do |db|
+      puts("Rolling back #{db} database")
+      Apartment::Migrator.rollback db, step
+    end
+  end
+
+  namespace :migrate do
+
+    desc 'Runs the "up" for a given migration VERSION across all multi-tenant dbs.'
+    task :up => 'db:migrate:up' do
+      version = ENV['VERSION'] ? ENV['VERSION'].to_i : nil
+      raise 'VERSION is required' unless version
+
+      Apartment.database_names.each do |db|
+        puts("Migrating #{db} database up")
+        Apartment::Migrator.run :up, db, version
+      end
+    end
+
+    desc 'Runs the "down" for a given migration VERSION across all multi-tenant dbs.'
+    task :down => 'db:migrate:down' do
+      version = ENV['VERSION'] ? ENV['VERSION'].to_i : nil
+      raise 'VERSION is required' unless version
+
+      Apartment.database_names.each do |db|
+        puts("Migrating #{db} database down")
+        Apartment::Migrator.run :down, db, version
+      end
+    end
+
+    desc  'Rollbacks the database one migration and re migrate up (options: STEP=x, VERSION=x).'
+    task :redo => 'db:migrate:redo' do
+      if ENV['VERSION']
+        apartment_namespace['migrate:down'].invoke
+        apartment_namespace['migrate:up'].invoke
+      else
+        apartment_namespace['rollback'].invoke
+        apartment_namespace['migrate'].invoke
+      end
+    end
+
+  end
+
+end

data/spec/adapters/mysql_adapter_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+require 'apartment/adapters/mysql_adapter'   # specific adapters get dynamically loaded based on adapter name, so we must manually require here
+
+describe Apartment::Adapters::MysqlAdapter do
+  
+  before do
+    ActiveRecord::Base.establish_connection Apartment::Test.config['connections']['mysql']
+    @mysql = Apartment::Database.mysql_adapter Apartment::Test.config['connections']['mysql'].symbolize_keys
+  end
+  
+  after do
+    ActiveRecord::Base.clear_all_connections!
+  end
+  
+  context "using databases" do
+    
+    let(:database1){ 'first_database' }
+    
+    before do
+      @mysql.create(database1)
+    end
+  
+    after do
+      ActiveRecord::Base.connection.drop_database(@mysql.environmentify(database1))
+    end
+
+    describe "#create" do
+      it "should create the new database" do
+        ActiveRecord::Base.connection.execute("SELECT schema_name FROM information_schema.schemata").collect{|row| row[0]}.should include(@mysql.environmentify(database1))
+      end
+    end
+
+  end
+  
+  
+end

data/spec/adapters/postgresql_adapter_spec.rb

@@ -0,0 +1,137 @@
+require 'spec_helper'
+require 'apartment/adapters/postgresql_adapter'   # specific adapters get dynamically loaded based on adapter name, so we must manually require here
+
+describe Apartment::Adapters::PostgresqlAdapter do
+  
+  before do
+    ActiveRecord::Base.establish_connection Apartment::Test.config['connections']['postgresql']
+    @schema_search_path = ActiveRecord::Base.connection.schema_search_path
+  end
+  
+  after do
+    ActiveRecord::Base.clear_all_connections!
+  end
+  
+  context "using schemas" do
+    
+    let(:schema){ 'first_db_schema' }
+    let(:schema2){ 'another_db_schema' }
+    let(:database_names){ ActiveRecord::Base.connection.execute("SELECT nspname FROM pg_namespace;").collect{|row| row['nspname']} }
+    
+    subject{ Apartment::Database.postgresql_adapter Apartment::Test.config['connections']['postgresql'].symbolize_keys }
+  
+    before do
+      Apartment.use_postgres_schemas = true
+      subject.create(schema)
+      subject.create(schema2)
+    end
+  
+    after do
+      # sometimes we manually drop these schemas in testing, dont' care if we can't drop hence rescue
+      subject.drop(schema) rescue true 
+      subject.drop(schema2) rescue true
+    end
+    
+    describe "#create" do
+      
+      it "should create the new schema" do
+        database_names.should include(schema)
+      end
+    
+      it "should load schema.rb to new schema" do
+        ActiveRecord::Base.connection.schema_search_path = schema
+        ActiveRecord::Base.connection.tables.should include('companies')
+      end
+    
+      it "should reset connection when finished" do
+        ActiveRecord::Base.connection.schema_search_path.should_not == schema
+      end
+      
+      it "should yield to block if passed" do
+        subject.drop(schema2) # so we don't get errors on creation
+        
+        @count = 0  # set our variable so its visible in and outside of blocks
+        
+        subject.create(schema2) do
+          @count = User.count
+          ActiveRecord::Base.connection.schema_search_path.should == schema2
+          User.create
+        end
+        
+        subject.process(schema2){ User.count.should == @count + 1 }
+      end
+    end
+    
+    describe "#drop" do
+
+      it "should delete the database" do
+        subject.switch schema    # can't drop db we're currently connected to, ensure these are different
+        subject.drop schema2
+
+        database_names.should_not include(schema2)
+      end
+
+      it "should raise an error for unkown database" do
+        expect {
+          subject.drop "unknown_database"
+        }.to raise_error(Apartment::SchemaNotFound)
+      end
+    end
+    
+    
+    describe "#process" do
+      it "should connect" do
+        subject.process(schema) do
+          ActiveRecord::Base.connection.schema_search_path.should == schema
+        end
+      end
+      
+      it "should reset" do
+        subject.process(schema)
+        ActiveRecord::Base.connection.schema_search_path.should == @schema_search_path
+      end
+      
+      # We're often finding when using Apartment in tests, the `current_database` (ie the previously attached to schema)
+      # gets dropped, but process will try to return to that schema in a test.  We should just reset if it doesnt exist
+      it "should not throw exception if current_database (schema) is no longer accessible" do
+        subject.switch(schema2)
+        
+        expect {
+          subject.process(schema){ subject.drop(schema2) }
+        }.to_not raise_error(Apartment::SchemaNotFound)
+      end
+    end
+    
+    describe "#reset" do
+      it "should reset connection" do
+        subject.switch(schema)
+        subject.reset
+        ActiveRecord::Base.connection.schema_search_path.should == @schema_search_path
+      end
+    end
+    
+    describe "#switch" do
+      it "should connect to new schema" do
+        subject.switch(schema)
+        ActiveRecord::Base.connection.schema_search_path.should == schema
+      end
+      
+      it "should reset connection if database is nil" do
+        subject.switch
+        ActiveRecord::Base.connection.schema_search_path.should == @schema_search_path
+      end
+    end
+    
+    describe "#current_database" do
+      it "should return the current schema name" do
+        subject.switch(schema)
+        subject.current_database.should == schema
+      end
+    end
+    
+  end
+  
+  context "using databases" do
+    # TODO
+  end
+end