synerma-apartment 3.1.0

data/lib/apartment/active_record/connection_handling.rb

@@ -0,0 +1,31 @@
+# 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.release <= Gem::Version.new('6.2')
+      def connected_to_with_tenant(database: nil, role: nil, prevent_writes: false, &blk)
+        current_tenant = Apartment::Tenant.current
+
+        connected_to_without_tenant(database: database, role: role, prevent_writes: prevent_writes) do
+          Apartment::Tenant.switch!(current_tenant)
+          yield(blk)
+        end
+      end
+    else
+      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
+    end
+
+    alias connected_to_without_tenant connected_to
+    alias connected_to connected_to_with_tenant
+  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/postgres/schema_dumper.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+# This patch prevents `create_schema` from being added to db/schema.rb as schemas are managed by Apartment
+# not ActiveRecord like they would be in a vanilla Rails setup.
+
+require 'active_record/connection_adapters/abstract/schema_dumper'
+require 'active_record/connection_adapters/postgresql/schema_dumper'
+
+module ActiveRecord
+  module ConnectionAdapters
+    module PostgreSQL
+      class SchemaDumper
+        alias _original_schemas schemas
+        def schemas(stream)
+          _original_schemas(stream) unless Apartment.use_schemas
+        end
+      end
+    end
+  end
+end

data/lib/apartment/active_record/postgresql_adapter.rb

@@ -0,0 +1,58 @@
+# 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
+
+    # for JDBC driver, if rescued in super_method, trim leading and trailing quotes
+    res.delete!('"') if defined?(JRUBY_VERSION)
+
+    schema_prefix = "#{sequence_schema(res)}."
+
+    # NOTE: Excluded models should always access the sequence from the default
+    # tenant schema
+    if excluded_model?(table)
+      default_tenant_prefix = "#{Apartment::Tenant.default_tenant}."
+
+      # Unless the res is already prefixed with the default_tenant_prefix
+      # we should delete the schema_prefix and add the default_tenant_prefix
+      unless res&.starts_with?(default_tenant_prefix)
+        res&.delete_prefix!(schema_prefix)
+        res = default_tenant_prefix + res
+      end
+
+      return res
+    end
+
+    # Delete the schema_prefix from the res if it is present
+    res&.delete_prefix!(schema_prefix)
+
+    res
+  end
+
+  private
+
+  def sequence_schema(sequence_name)
+    current = Apartment::Tenant.current
+    return current unless current.is_a?(Array)
+
+    current.find { |schema| sequence_name.starts_with?("#{schema}.") }
+  end
+
+  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,11 @@
+# frozen_string_literal: true
+
+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.verify! # 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

data/lib/apartment/adapters/abstract_jdbc_adapter.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'apartment/adapters/abstract_adapter'
+
+module Apartment
+  module Adapters
+    # JDBC Abstract adapter
+    class AbstractJDBCAdapter < AbstractAdapter
+      private
+
+      def multi_tenantify_with_tenant_db_name(config, tenant)
+        config[:url] = "#{config[:url].gsub(%r{(\S+)/.+$}, '\1')}/#{environmentify(tenant)}"
+      end
+
+      def rescue_from
+        ActiveRecord::JDBCError
+      end
+    end
+  end
+end

data/lib/apartment/adapters/jdbc_mysql_adapter.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'apartment/adapters/abstract_jdbc_adapter'
+
+module Apartment
+  module Tenant
+    def self.jdbc_mysql_adapter(config)
+      Adapters::JDBCMysqlAdapter.new config
+    end
+  end
+
+  module Adapters
+    class JDBCMysqlAdapter < AbstractJDBCAdapter
+      def reset_on_connection_exception?
+        true
+      end
+    end
+  end
+end

data/lib/apartment/adapters/jdbc_postgresql_adapter.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require 'apartment/adapters/postgresql_adapter'
+
+module Apartment
+  # JDBC helper to decide wether to use JDBC Postgresql Adapter or JDBC Postgresql Adapter with Schemas
+  module Tenant
+    def self.jdbc_postgresql_adapter(config)
+      if Apartment.use_schemas
+        Adapters::JDBCPostgresqlSchemaAdapter.new(config)
+      else
+        Adapters::JDBCPostgresqlAdapter.new(config)
+      end
+    end
+  end
+
+  module Adapters
+    # Default adapter when not using Postgresql Schemas
+    class JDBCPostgresqlAdapter < PostgresqlAdapter
+      private
+
+      def multi_tenantify_with_tenant_db_name(config, tenant)
+        config[:url] = "#{config[:url].gsub(%r{(\S+)/.+$}, '\1')}/#{environmentify(tenant)}"
+      end
+
+      def create_tenant_command(conn, tenant)
+        conn.create_database(environmentify(tenant), thisisahack: '')
+      end
+
+      def rescue_from
+        ActiveRecord::JDBCError
+      end
+    end
+
+    # Separate Adapter for Postgresql when using schemas
+    class JDBCPostgresqlSchemaAdapter < PostgresqlSchemaAdapter
+      #   Set schema search path to new schema
+      #
+      def connect_to_new(tenant = nil)
+        return reset if tenant.nil?
+        raise ActiveRecord::StatementInvalid, "Could not find schema #{tenant}" unless schema_exists?(tenant)
+
+        @current = tenant.is_a?(Array) ? tenant.map(&:to_s) : tenant.to_s
+        Apartment.connection.schema_search_path = full_search_path
+      rescue ActiveRecord::StatementInvalid, ActiveRecord::JDBCError
+        raise TenantNotFound, "One of the following schema(s) is invalid: #{full_search_path}"
+      end
+
+      private
+
+      def tenant_exists?(tenant)
+        return true unless Apartment.tenant_presence_check
+
+        Apartment.connection.all_schemas.include? tenant
+      end
+
+      def rescue_from
+        ActiveRecord::JDBCError
+      end
+    end
+  end
+end

data/lib/apartment/adapters/mysql2_adapter.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require 'apartment/adapters/abstract_adapter'
+
+module Apartment
+  # Helper module to decide wether to use mysql2 adapter or mysql2 adapter with schemas
+  module Tenant
+    def self.mysql2_adapter(config)
+      if Apartment.use_schemas
+        Adapters::Mysql2SchemaAdapter.new(config)
+      else
+        Adapters::Mysql2Adapter.new(config)
+      end
+    end
+  end
+
+  module Adapters
+    # Mysql2 Adapter
+    class Mysql2Adapter < AbstractAdapter
+      def initialize(config)
+        super
+
+        @default_tenant = config[:database]
+      end
+
+      protected
+
+      def rescue_from
+        Mysql2::Error
+      end
+    end
+
+    # Mysql2 Schemas Adapter
+    class Mysql2SchemaAdapter < AbstractAdapter
+      def initialize(config)
+        super
+
+        @default_tenant = config[:database]
+        reset
+      end
+
+      #   Reset current tenant to the default_tenant
+      #
+      def reset
+        return unless default_tenant
+
+        Apartment.connection.execute "use `#{default_tenant}`"
+      end
+
+      protected
+
+      #   Connect to new tenant
+      #
+      def connect_to_new(tenant)
+        return reset if tenant.nil?
+
+        Apartment.connection.execute "use `#{environmentify(tenant)}`"
+      rescue ActiveRecord::StatementInvalid => e
+        Apartment::Tenant.reset
+        raise_connect_error!(tenant, e)
+      end
+
+      def process_excluded_model(model)
+        model.constantize.tap do |klass|
+          # Ensure that if a schema *was* set, we override
+          table_name = klass.table_name.split('.', 2).last
+
+          klass.table_name = "#{default_tenant}.#{table_name}"
+        end
+      end
+
+      def reset_on_connection_exception?
+        true
+      end
+    end
+  end
+end

data/lib/apartment/adapters/postgis_adapter.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+# handle postgis adapter as if it were postgresql,
+# only override the adapter_method used for initialization
+require 'apartment/adapters/postgresql_adapter'
+
+module Apartment
+  module Tenant
+    def self.postgis_adapter(config)
+      postgresql_adapter(config)
+    end
+  end
+end