puzzle-apartment 2.12.0

data/Rakefile

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+begin
+  require 'bundler'
+rescue StandardError
+  'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+Bundler.setup
+Bundler::GemHelper.install_tasks
+
+require 'appraisal'
+
+require 'rspec'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(spec: %w[db:copy_credentials db:test:prepare]) do |spec|
+  spec.pattern = 'spec/**/*_spec.rb'
+  # spec.rspec_opts = '--order rand:47078'
+end
+
+namespace :spec do
+  %i[tasks unit adapters integration].each do |type|
+    RSpec::Core::RakeTask.new(type => :spec) do |spec|
+      spec.pattern = "spec/#{type}/**/*_spec.rb"
+    end
+  end
+end
+
+task :console do
+  require 'pry'
+  require 'apartment'
+  ARGV.clear
+  Pry.start
+end
+
+task default: :spec
+
+namespace :db do
+  namespace :test do
+    task prepare: %w[postgres:drop_db postgres:build_db mysql:drop_db mysql:build_db]
+  end
+
+  desc "copy sample database credential files over if real files don't exist"
+  task :copy_credentials do
+    require 'fileutils'
+    apartment_db_file = 'spec/config/database.yml'
+    rails_db_file = 'spec/dummy/config/database.yml'
+
+    unless File.exist?(apartment_db_file)
+      FileUtils.copy("#{apartment_db_file}.sample", apartment_db_file, verbose: true)
+    end
+    FileUtils.copy("#{rails_db_file}.sample", rails_db_file, verbose: true) unless File.exist?(rails_db_file)
+  end
+end
+
+namespace :postgres do
+  require 'active_record'
+  require File.join(File.dirname(__FILE__), 'spec', 'support', 'config').to_s
+
+  desc 'Build the PostgreSQL test databases'
+  task :build_db do
+    params = []
+    params << '-E UTF8'
+    params << pg_config['database']
+    params << "-U#{pg_config['username']}"
+    params << "-h#{pg_config['host']}" if pg_config['host']
+    params << "-p#{pg_config['port']}" if pg_config['port']
+
+    begin
+      `createdb #{params.join(' ')}`
+    rescue StandardError
+      'test db already exists'
+    end
+    ActiveRecord::Base.establish_connection pg_config
+    migrate
+  end
+
+  desc 'drop the PostgreSQL test database'
+  task :drop_db do
+    puts "dropping database #{pg_config['database']}"
+    params = []
+    params << pg_config['database']
+    params << "-U#{pg_config['username']}"
+    params << "-h#{pg_config['host']}" if pg_config['host']
+    params << "-p#{pg_config['port']}" if pg_config['port']
+    `dropdb #{params.join(' ')}`
+  end
+end
+
+namespace :mysql do
+  require 'active_record'
+  require File.join(File.dirname(__FILE__), 'spec', 'support', 'config').to_s
+
+  desc 'Build the MySQL test databases'
+  task :build_db do
+    params = []
+    params << "-h #{my_config['host']}" if my_config['host']
+    params << "-u #{my_config['username']}" if my_config['username']
+    params << "-p#{my_config['password']}" if my_config['password']
+    params << "--port #{my_config['port']}" if my_config['port']
+    begin
+      `mysqladmin #{params.join(' ')} create #{my_config['database']}`
+    rescue StandardError
+      'test db already exists'
+    end
+    ActiveRecord::Base.establish_connection my_config
+    migrate
+  end
+
+  desc 'drop the MySQL test database'
+  task :drop_db do
+    puts "dropping database #{my_config['database']}"
+    params = []
+    params << "-h #{my_config['host']}" if my_config['host']
+    params << "-u #{my_config['username']}" if my_config['username']
+    params << "-p#{my_config['password']}" if my_config['password']
+    params << "--port #{my_config['port']}" if my_config['port']
+    `mysqladmin #{params.join(' ')} drop #{my_config['database']} --force`
+  end
+end
+
+# TODO: clean this up
+def config
+  Apartment::Test.config['connections']
+end
+
+def pg_config
+  config['postgresql']
+end
+
+def my_config
+  config['mysql']
+end
+
+def activerecord_below_5_2?
+  ActiveRecord.version.release < Gem::Version.new('5.2.0')
+end
+
+def activerecord_below_6_0?
+  ActiveRecord.version.release < Gem::Version.new('6.0.0')
+end
+
+def activerecord_above_7_0?
+  ActiveRecord.version.release > Gem::Version.new('7.0.0')
+end
+
+def migrate
+  if activerecord_below_5_2?
+    ActiveRecord::Migrator.migrate('spec/dummy/db/migrate')
+  elsif activerecord_below_6_0? || activerecord_above_7_0?
+    ActiveRecord::MigrationContext.new('spec/dummy/db/migrate').migrate
+  else
+    # TODO: Figure out if there is any other possibility that can/should be
+    # passed here as the second argument for the migration context
+    ActiveRecord::MigrationContext.new('spec/dummy/db/migrate', ActiveRecord::SchemaMigration).migrate
+  end
+end

data/TODO.md

@@ -0,0 +1,50 @@
+# Apartment TODOs
+
+### Below is a list of tasks in the approximate order to be completed of for Apartment
+### Any help along the way is greatly appreciated (on any items, not particularly in order)
+
+1.  Apartment was originally written (and TDD'd) with just Postgresql in mind. Different adapters were added at a later date.
+    As such, the test suite is a bit of a mess. There's no formal structure for fully integration testing all adapters to ensure
+    proper quality and prevent regressions.
+
+    There's also a test order dependency as some tests run assuming a db connection and if that test randomly ran before a previous
+    one that makes the connection, it would fail.
+
+    I'm proposing the first thing to be done is to write up a standard, high livel integration test case that can be applied to all adapters
+    and makes no assumptions about implementation. It should ensure that each adapter conforms to the Apartment Interface and CRUD's properly.
+    It would be nice if a user can 'register' an adapter such that it would automatically be tested (nice to have). Otherwise one could just use
+    a shared behaviour to run through all of this.
+
+    Then, I'd like to see all of the implementation specific tests just in their own test file for each adapter (ie the postgresql schema adapter checks a lot of things with `schema_search_path`)
+
+    This should ensure that going forward nothing breaks, and we should *ideally* be able to randomize the test order
+
+2.  <del>`Apartment::Database` is the wrong abstraction. When dealing with a multi-tenanted system, users shouldn't thing about 'Databases', they should
+    think about Tenants. I proprose that we deprecate the `Apartment::Database` constant in favour of `Apartment::Tenant` for a nicer abstraction. See
+    http://myronmars.to/n/dev-blog/2011/09/deprecating-constants-and-classes-in-ruby for ideas on how to achieve this.</del>
+
+4.  Apartment::Database.process should be deprecated in favour of just passing a block to `switch`
+5.  Apartment::Database.switch should be renamed to switch! to indicate that using it on its own has side effects
+
+6.  Migrations right now can be a bit of a pain. Apartment currently migrates a single tenant completely up to date, then goes onto the next. If one of these
+    migrations fails on a tenant, the previous one does NOT get reverted and leaves you in an awkward state. Ideally we'd want to wrap all of the migrations in
+    a transaction so if one fails, the whole thing reverts. Once we can ensure an all-or-nothing approach to migrations, we can optimize the migration strategy
+    to not even iterate over the tenants if there are no migrations to run on public.
+
+7.  Apartment has be come one of the most popular/robust Multi-tenant gems for Rails, but it still doesn't work for everyone's use case. It's fairly limited in implementation to either schema based (ie postgresql schemas) or connection based. I'd like to abstract out these implementation details such that one could write a pluggable strategy for Apartment and choose it based on a config selection (something like `config.strategy = :schema`). The next implementation I'd like to see is a scoped based approach that uses a `tenant_id` scoping on all records for multi-tenancy. This is probably the most popular multi-tenant approach and is db independent and really the simplest mechanism for a type of multi-tenancy.
+
+8.  Right now excluded tables still live in all tenanted environments. This is basically because it doesn't matter if they're there, we always query from the public.
+    It's a bit of an annoyance though and confuses lots of people. I'd love to see only tenanted tables in the tenants and only excluded tables in the public tenant.
+    This will be hard because Rails uses public to generate schema.rb. One idea is to have an `excluded` schema that holds all the excluded models and the public can
+    maintain everything.
+
+9.  This one is pretty lofty, but I'd also like to abstract out the fact that Apartment uses ActiveRecord. With the new DataMapper coming out soon and other popular
+    DBMS's (ie. mongo, couch etc...), it'd be nice if Apartment could be the de-facto interface for multi-tenancy on these systems.
+
+
+===================
+
+Quick TODOs
+
+2. deprecation.rb rescues everything, we have a hard dependency on ActiveSupport so this is unnecessary
+3.

data/docker-compose.yml

@@ -0,0 +1,33 @@
+version: '2.3'
+services:
+  postgresql:
+    image: postgres:9.5.12
+    environment:
+      POSTGRES_PASSWORD: ""
+    ports:
+      - "5432:5432"
+    healthcheck:
+      test: pg_isready -U postgres
+      start_period: 10s
+      interval: 10s
+      timeout: 30s
+      retries: 3
+  mysql:
+    image: mysql:5.7
+    environment:
+      MYSQL_ALLOW_EMPTY_PASSWORD: "yes"
+    ports:
+      - "3306:3306"
+    healthcheck:
+      test: mysqladmin -h 127.0.0.1 -uroot ping
+      start_period: 15s
+      interval: 10s
+      timeout: 30s
+      retries: 3
+  healthcheck:
+    image: busybox
+    depends_on:
+      postgresql:
+        condition: service_healthy
+      mysql:
+        condition: service_healthy

data/gemfiles/rails_6_1.gemfile

@@ -0,0 +1,17 @@
+# This file was generated by Appraisal
+
+source "http://rubygems.org"
+
+gem "rails", "~> 6.1.0"
+
+platforms :ruby do
+  gem "sqlite3", "~> 1.4"
+end
+
+platforms :jruby do
+  gem "activerecord-jdbc-adapter", "~> 61.0"
+  gem "activerecord-jdbcpostgresql-adapter", "~> 61.0"
+  gem "activerecord-jdbcmysql-adapter", "~> 61.0"
+end
+
+gemspec path: "../"

data/gemfiles/rails_7_0.gemfile

@@ -0,0 +1,17 @@
+# This file was generated by Appraisal
+
+source "http://rubygems.org"
+
+gem "rails", "~> 7.0.0"
+
+platforms :ruby do
+  gem "sqlite3", "~> 1.4"
+end
+
+platforms :jruby do
+  gem "activerecord-jdbc-adapter", "~> 61.0"
+  gem "activerecord-jdbcpostgresql-adapter", "~> 61.0"
+  gem "activerecord-jdbcmysql-adapter", "~> 61.0"
+end
+
+gemspec path: "../"

data/gemfiles/rails_7_1.gemfile

@@ -0,0 +1,17 @@
+# This file was generated by Appraisal
+
+source "http://rubygems.org"
+
+gem "rails", "~> 7.1.0"
+
+platforms :ruby do
+  gem "sqlite3", "~> 1.6"
+end
+
+platforms :jruby do
+  gem "activerecord-jdbc-adapter", "~> 61.0"
+  gem "activerecord-jdbcpostgresql-adapter", "~> 61.0"
+  gem "activerecord-jdbcmysql-adapter", "~> 61.0"
+end
+
+gemspec path: "../"

data/gemfiles/rails_master.gemfile

@@ -0,0 +1,17 @@
+# This file was generated by Appraisal
+
+source "http://rubygems.org"
+
+gem "rails", git: "https://github.com/rails/rails.git"
+
+platforms :ruby do
+  gem "sqlite3", "~> 1.4"
+end
+
+platforms :jruby do
+  gem "activerecord-jdbc-adapter", "~> 61.0"
+  gem "activerecord-jdbcpostgresql-adapter", "~> 61.0"
+  gem "activerecord-jdbcmysql-adapter", "~> 61.0"
+end
+
+gemspec path: "../"

data/lib/apartment/active_record/connection_handling.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module ActiveRecord # :nodoc:
+  # This is monkeypatching Active Record to ensure that whenever a new connection is established it
+  # switches to the same tenant as before the connection switching. This problem is more evident when
+  # using read replica in Rails 6
+  module ConnectionHandling
+    if ActiveRecord::VERSION::MAJOR >= 6 && ActiveRecord::VERSION::MAJOR < 7.1
+      def connected_to_with_tenant(role: nil, prevent_writes: false, &blk)
+        current_tenant = Apartment::Tenant.current
+
+        connected_to_without_tenant(role: role, prevent_writes: prevent_writes) do
+          Apartment::Tenant.switch!(current_tenant)
+          yield(blk)
+        end
+      end
+
+      alias connected_to_without_tenant connected_to
+      alias connected_to connected_to_with_tenant
+    elsif ActiveRecord::VERSION::MAJOR >= 7.1
+      def connected_to_with_tenant(role: nil, shard: nil, prevent_writes: false, &blk)
+        current_tenant = Apartment::Tenant.current
+
+        connected_to_without_tenant(role: role, shard: shard, prevent_writes: prevent_writes) do
+          Apartment::Tenant.switch!(current_tenant)
+          yield(blk)
+        end
+      end
+
+      alias connected_to_without_tenant connected_to
+      alias connected_to connected_to_with_tenant
+    end
+  end
+end

data/lib/apartment/active_record/internal_metadata.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+class InternalMetadata < ActiveRecord::Base # :nodoc:
+  class << self
+    def table_exists?
+      connection.table_exists?(table_name)
+    end
+  end
+end

data/lib/apartment/active_record/postgresql_adapter.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+# rubocop:disable Style/ClassAndModuleChildren
+
+# NOTE: This patch is meant to remove any schema_prefix appart from the ones for
+# excluded models. The schema_prefix would be resolved by apartment's setting
+# of search path
+module Apartment::PostgreSqlAdapterPatch
+  def default_sequence_name(table, _column)
+    res = super
+    schema_prefix = "#{Apartment::Tenant.current}."
+    default_tenant_prefix = "#{Apartment::Tenant.default_tenant}."
+
+    # NOTE: Excluded models should always access the sequence from the default
+    # tenant schema
+    if excluded_model?(table)
+      res.sub!(schema_prefix, default_tenant_prefix) if schema_prefix != default_tenant_prefix
+      return res
+    end
+
+    res.delete_prefix!(schema_prefix) if res&.starts_with?(schema_prefix)
+
+    res
+  end
+
+  private
+
+  def excluded_model?(table)
+    Apartment.excluded_models.any? { |m| m.constantize.table_name == table }
+  end
+end
+
+require 'active_record/connection_adapters/postgresql_adapter'
+
+# NOTE: inject this into postgresql adapters
+class ActiveRecord::ConnectionAdapters::PostgreSQLAdapter
+  include Apartment::PostgreSqlAdapterPatch
+end
+# rubocop:enable Style/ClassAndModuleChildren

data/lib/apartment/active_record/schema_migration.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require 'active_record/schema_migration'
+
+module ActiveRecord
+  class SchemaMigration # :nodoc:
+    class << self
+      def table_exists?
+        connection.table_exists?(table_name)
+      end
+    end
+  end
+end

data/lib/apartment/adapters/abstract_adapter.rb

@@ -0,0 +1,275 @@
+# frozen_string_literal: true
+
+module Apartment
+  module Adapters
+    # Abstract adapter from which all the Apartment DB related adapters will inherit the base logic
+    class AbstractAdapter
+      include ActiveSupport::Callbacks
+      define_callbacks :create, :switch
+
+      attr_writer :default_tenant
+
+      #   @constructor
+      #   @param {Hash} config Database config
+      #
+      def initialize(config)
+        @config = config
+      end
+
+      #   Create a new tenant, import schema, seed if appropriate
+      #
+      #   @param {String} tenant Tenant name
+      #
+      def create(tenant)
+        run_callbacks :create do
+          create_tenant(tenant)
+
+          switch(tenant) do
+            import_database_schema
+
+            # Seed data if appropriate
+            seed_data if Apartment.seed_after_create
+
+            yield if block_given?
+          end
+        end
+      end
+
+      #   Initialize Apartment config options such as excluded_models
+      #
+      def init
+        process_excluded_models
+      end
+
+      #   Note alias_method here doesn't work with inheritence apparently ??
+      #
+      def current
+        Apartment.connection.current_database
+      end
+
+      #   Return the original public tenant
+      #
+      #   @return {String} default tenant name
+      #
+      def default_tenant
+        @default_tenant || Apartment.default_tenant
+      end
+
+      #   Drop the tenant
+      #
+      #   @param {String} tenant name
+      #
+      def drop(tenant)
+        with_neutral_connection(tenant) do |conn|
+          drop_command(conn, tenant)
+        end
+      rescue *rescuable_exceptions => e
+        raise_drop_tenant_error!(tenant, e)
+      end
+
+      #   Switch to a new tenant
+      #
+      #   @param {String} tenant name
+      #
+      def switch!(tenant = nil)
+        run_callbacks :switch do
+          connect_to_new(tenant).tap do
+            Apartment.connection.clear_query_cache
+          end
+        end
+      end
+
+      #   Connect to tenant, do your biz, switch back to previous tenant
+      #
+      #   @param {String?} tenant to connect to
+      #
+      def switch(tenant = nil)
+        previous_tenant = current
+        switch!(tenant)
+        yield
+      ensure
+        begin
+          switch!(previous_tenant)
+        rescue StandardError => _e
+          reset
+        end
+      end
+
+      #   Iterate over all tenants, switch to tenant and yield tenant name
+      #
+      def each(tenants = Apartment.tenant_names)
+        tenants.each do |tenant|
+          switch(tenant) { yield tenant }
+        end
+      end
+
+      #   Establish a new connection for each specific excluded model
+      #
+      def process_excluded_models
+        # All other models will shared a connection (at Apartment.connection_class)
+        # and we can modify at will
+        Apartment.excluded_models.each do |excluded_model|
+          process_excluded_model(excluded_model)
+        end
+      end
+
+      #   Reset the tenant connection to the default
+      #
+      def reset
+        Apartment.establish_connection @config
+      end
+
+      #   Load the rails seed file into the db
+      #
+      def seed_data
+        # Don't log the output of seeding the db
+        silence_warnings { load_or_raise(Apartment.seed_data_file) } if Apartment.seed_data_file
+      end
+      alias seed seed_data
+
+      #   Prepend the environment if configured and the environment isn't already there
+      #
+      #   @param {String} tenant Database name
+      #   @return {String} tenant name with Rails environment *optionally* prepended
+      #
+      def environmentify(tenant)
+        return tenant if tenant.nil? || tenant.include?(Rails.env)
+
+        if Apartment.prepend_environment
+          "#{Rails.env}_#{tenant}"
+        elsif Apartment.append_environment
+          "#{tenant}_#{Rails.env}"
+        else
+          tenant
+        end
+      end
+
+      protected
+
+      def process_excluded_model(excluded_model)
+        excluded_model.constantize.establish_connection @config
+      end
+
+      def drop_command(conn, tenant)
+        # connection.drop_database   note that drop_database will not throw an exception, so manually execute
+        conn.execute("DROP DATABASE #{conn.quote_table_name(environmentify(tenant))}")
+      end
+
+      #   Create the tenant
+      #
+      #   @param {String} tenant Database name
+      #
+      def create_tenant(tenant)
+        with_neutral_connection(tenant) do |conn|
+          create_tenant_command(conn, tenant)
+        end
+      rescue *rescuable_exceptions => e
+        raise_create_tenant_error!(tenant, e)
+      end
+
+      def create_tenant_command(conn, tenant)
+        conn.create_database(environmentify(tenant), @config)
+      end
+
+      #   Connect to new tenant
+      #
+      #   @param {String} tenant Database name
+      #
+      def connect_to_new(tenant)
+        return reset if tenant.nil?
+
+        query_cache_enabled = ActiveRecord::Base.connection.query_cache_enabled
+
+        Apartment.establish_connection multi_tenantify(tenant)
+        Apartment.connection.active? # call active? to manually check if this connection is valid
+
+        Apartment.connection.enable_query_cache! if query_cache_enabled
+      rescue *rescuable_exceptions => e
+        Apartment::Tenant.reset if reset_on_connection_exception?
+        raise_connect_error!(tenant, e)
+      end
+
+      #   Import the database schema
+      #
+      def import_database_schema
+        ActiveRecord::Schema.verbose = false # do not log schema load output.
+
+        load_or_raise(Apartment.database_schema_file) if Apartment.database_schema_file
+      end
+
+      #   Return a new config that is multi-tenanted
+      #   @param {String}  tenant: Database name
+      #   @param {Boolean} with_database: if true, use the actual tenant's db name
+      #                                   if false, use the default db name from the db
+      # rubocop:disable Style/OptionalBooleanParameter
+      def multi_tenantify(tenant, with_database = true)
+        db_connection_config(tenant).tap do |config|
+          multi_tenantify_with_tenant_db_name(config, tenant) if with_database
+        end
+      end
+      # rubocop:enable Style/OptionalBooleanParameter
+
+      def multi_tenantify_with_tenant_db_name(config, tenant)
+        config[:database] = environmentify(tenant)
+      end
+
+      #   Load a file or raise error if it doesn't exists
+      #
+      def load_or_raise(file)
+        raise FileNotFound, "#{file} doesn't exist yet" unless File.exist?(file)
+
+        load(file)
+      end
+      # Backward compatibility
+      alias load_or_abort load_or_raise
+
+      #   Exceptions to rescue from on db operations
+      #
+      def rescuable_exceptions
+        [ActiveRecord::ActiveRecordError] + Array(rescue_from)
+      end
+
+      #   Extra exceptions to rescue from
+      #
+      def rescue_from
+        []
+      end
+
+      def db_connection_config(tenant)
+        Apartment.db_config_for(tenant).dup
+      end
+
+      def with_neutral_connection(tenant, &_block)
+        if Apartment.with_multi_server_setup
+          # neutral connection is necessary whenever you need to create/remove a database from a server.
+          # example: when you use postgresql, you need to connect to the default postgresql database before you create
+          # your own.
+          SeparateDbConnectionHandler.establish_connection(multi_tenantify(tenant, false))
+          yield(SeparateDbConnectionHandler.connection)
+          SeparateDbConnectionHandler.connection.close
+        else
+          yield(Apartment.connection)
+        end
+      end
+
+      def reset_on_connection_exception?
+        false
+      end
+
+      def raise_drop_tenant_error!(tenant, exception)
+        raise TenantNotFound, "Error while dropping tenant #{environmentify(tenant)}: #{exception.message}"
+      end
+
+      def raise_create_tenant_error!(tenant, exception)
+        raise TenantExists, "Error while creating tenant #{environmentify(tenant)}: #{exception.message}"
+      end
+
+      def raise_connect_error!(tenant, exception)
+        raise TenantNotFound, "Error while connecting to tenant #{environmentify(tenant)}: #{exception.message}"
+      end
+
+      class SeparateDbConnectionHandler < ::ActiveRecord::Base
+      end
+    end
+  end
+end