puzzle-apartment 2.12.0

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

data/lib/apartment/adapters/postgresql_adapter.rb

@@ -0,0 +1,284 @@
+# frozen_string_literal: true
+
+require 'apartment/adapters/abstract_adapter'
+require 'apartment/active_record/postgresql_adapter'
+
+module Apartment
+  module Tenant
+    def self.postgresql_adapter(config)
+      adapter = Adapters::PostgresqlAdapter
+      adapter = Adapters::PostgresqlSchemaAdapter if Apartment.use_schemas
+      adapter = Adapters::PostgresqlSchemaFromSqlAdapter if Apartment.use_sql && Apartment.use_schemas
+      adapter.new(config)
+    end
+  end
+
+  module Adapters
+    # Default adapter when not using Postgresql Schemas
+    class PostgresqlAdapter < AbstractAdapter
+      private
+
+      def rescue_from
+        PG::Error
+      end
+    end
+
+    # Separate Adapter for Postgresql when using schemas
+    class PostgresqlSchemaAdapter < AbstractAdapter
+      def initialize(config)
+        super
+
+        reset
+      end
+
+      def default_tenant
+        @default_tenant = Apartment.default_tenant || 'public'
+      end
+
+      #   Reset schema search path to the default schema_search_path
+      #
+      #   @return {String} default schema search path
+      #
+      def reset
+        @current = default_tenant
+        Apartment.connection.schema_search_path = full_search_path
+      end
+
+      def init
+        super
+        Apartment.connection.schema_search_path = full_search_path
+      end
+
+      def current
+        @current || default_tenant
+      end
+
+      protected
+
+      def process_excluded_model(excluded_model)
+        excluded_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 drop_command(conn, tenant)
+        conn.execute(%(DROP SCHEMA "#{tenant}" CASCADE))
+      end
+
+      #   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
+
+        # When the PostgreSQL version is < 9.3,
+        # there is a issue for prepared statement with changing search_path.
+        # https://www.postgresql.org/docs/9.3/static/sql-prepare.html
+        Apartment.connection.clear_cache! if postgresql_version < 90_300
+      rescue *rescuable_exceptions => e
+        raise_schema_connect_to_new(tenant, e)
+      end
+
+      private
+
+      def tenant_exists?(tenant)
+        return true unless Apartment.tenant_presence_check
+
+        Apartment.connection.schema_exists?(tenant)
+      end
+
+      def create_tenant_command(conn, tenant)
+        # NOTE: This was causing some tests to fail because of the database strategy for rspec
+        if ActiveRecord::Base.connection.open_transactions.positive?
+          conn.execute(%(CREATE SCHEMA "#{tenant}"))
+        else
+          schema = %(BEGIN;
+          CREATE SCHEMA "#{tenant}";
+          COMMIT;)
+
+          conn.execute(schema)
+        end
+      rescue *rescuable_exceptions => e
+        rollback_transaction(conn)
+        raise e
+      end
+
+      def rollback_transaction(conn)
+        conn.execute('ROLLBACK;')
+      end
+
+      #   Generate the final search path to set including persistent_schemas
+      #
+      def full_search_path
+        persistent_schemas.map(&:inspect).join(', ')
+      end
+
+      def persistent_schemas
+        [@current, Apartment.persistent_schemas].flatten
+      end
+
+      def postgresql_version
+        # ActiveRecord::ConnectionAdapters::PostgreSQLAdapter#postgresql_version is
+        # public from Rails 5.0.
+        Apartment.connection.send(:postgresql_version)
+      end
+
+      def schema_exists?(schemas)
+        return true unless Apartment.tenant_presence_check
+
+        Array(schemas).all? { |schema| Apartment.connection.schema_exists?(schema.to_s) }
+      end
+
+      def raise_schema_connect_to_new(tenant, exception)
+        raise TenantNotFound, <<~EXCEPTION_MESSAGE
+          Could not set search path to schemas, they may be invalid: "#{tenant}" #{full_search_path}.
+          Original error: #{exception.class}: #{exception}
+        EXCEPTION_MESSAGE
+      end
+    end
+
+    # Another Adapter for Postgresql when using schemas and SQL
+    class PostgresqlSchemaFromSqlAdapter < PostgresqlSchemaAdapter
+      PSQL_DUMP_BLACKLISTED_STATEMENTS = [
+        /SET search_path/i,                           # overridden later
+        /SET lock_timeout/i,                          # new in postgresql 9.3
+        /SET row_security/i,                          # new in postgresql 9.5
+        /SET idle_in_transaction_session_timeout/i,   # new in postgresql 9.6
+        /SET default_table_access_method/i,           # new in postgresql 12
+        /CREATE SCHEMA public/i,
+        /COMMENT ON SCHEMA public/i
+
+      ].freeze
+
+      def import_database_schema
+        preserving_search_path do
+          clone_pg_schema
+          copy_schema_migrations
+        end
+      end
+
+      private
+
+      # Re-set search path after the schema is imported.
+      # Postgres now sets search path to empty before dumping the schema
+      # and it mut be reset
+      #
+      def preserving_search_path
+        search_path = Apartment.connection.execute('show search_path').first['search_path']
+        yield
+        Apartment.connection.execute("set search_path = #{search_path}")
+      end
+
+      # Clone default schema into new schema named after current tenant
+      #
+      def clone_pg_schema
+        pg_schema_sql = patch_search_path(pg_dump_schema)
+        Apartment.connection.execute(pg_schema_sql)
+      end
+
+      # Copy data from schema_migrations into new schema
+      #
+      def copy_schema_migrations
+        pg_migrations_data = patch_search_path(pg_dump_schema_migrations_data)
+        Apartment.connection.execute(pg_migrations_data)
+      end
+
+      #   Dump postgres default schema
+      #
+      #   @return {String} raw SQL contaning only postgres schema dump
+      #
+      def pg_dump_schema
+        # Skip excluded tables? :/
+        # excluded_tables =
+        #   collect_table_names(Apartment.excluded_models)
+        #   .map! {|t| "-T #{t}"}
+        #   .join(' ')
+
+        # `pg_dump -s -x -O -n #{default_tenant} #{excluded_tables} #{dbname}`
+
+        with_pg_env { `pg_dump -s -x -O -n #{default_tenant} #{dbname}` }
+      end
+
+      #   Dump data from schema_migrations table
+      #
+      #   @return {String} raw SQL contaning inserts with data from schema_migrations
+      #
+      # rubocop:disable Layout/LineLength
+      def pg_dump_schema_migrations_data
+        with_pg_env { `pg_dump -a --inserts -t #{default_tenant}.schema_migrations -t #{default_tenant}.ar_internal_metadata #{dbname}` }
+      end
+      # rubocop:enable Layout/LineLength
+
+      # Temporary set Postgresql related environment variables if there are in @config
+      #
+      def with_pg_env
+        pghost = ENV['PGHOST']
+        pgport = ENV['PGPORT']
+        pguser = ENV['PGUSER']
+        pgpassword = ENV['PGPASSWORD']
+
+        ENV['PGHOST'] = @config[:host] if @config[:host]
+        ENV['PGPORT'] = @config[:port].to_s if @config[:port]
+        ENV['PGUSER'] = @config[:username].to_s if @config[:username]
+        ENV['PGPASSWORD'] = @config[:password].to_s if @config[:password]
+
+        yield
+      ensure
+        ENV['PGHOST'] = pghost
+        ENV['PGPORT'] = pgport
+        ENV['PGUSER'] = pguser
+        ENV['PGPASSWORD'] = pgpassword
+      end
+
+      #   Remove "SET search_path ..." line from SQL dump and prepend search_path set to current tenant
+      #
+      #   @return {String} patched raw SQL dump
+      #
+      def patch_search_path(sql)
+        search_path = "SET search_path = \"#{current}\", #{default_tenant};"
+
+        swap_schema_qualifier(sql)
+          .split("\n")
+          .select { |line| check_input_against_regexps(line, PSQL_DUMP_BLACKLISTED_STATEMENTS).empty? }
+          .prepend(search_path)
+          .join("\n")
+      end
+
+      def swap_schema_qualifier(sql)
+        sql.gsub(/#{default_tenant}\.\w*/) do |match|
+          if Apartment.pg_excluded_names.any? { |name| match.include? name }
+            match
+          else
+            match.gsub("#{default_tenant}.", %("#{current}".))
+          end
+        end
+      end
+
+      #   Checks if any of regexps matches against input
+      #
+      def check_input_against_regexps(input, regexps)
+        regexps.select { |c| input.match c }
+      end
+
+      #   Collect table names from AR Models
+      #
+      def collect_table_names(models)
+        models.map do |m|
+          m.constantize.table_name
+        end
+      end
+
+      # Convenience method for current database name
+      #
+      def dbname
+        Apartment.connection_config[:database]
+      end
+    end
+  end
+end

data/lib/apartment/adapters/sqlite3_adapter.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require 'apartment/adapters/abstract_adapter'
+
+module Apartment
+  module Tenant
+    def self.sqlite3_adapter(config)
+      Adapters::Sqlite3Adapter.new(config)
+    end
+  end
+
+  module Adapters
+    class Sqlite3Adapter < AbstractAdapter
+      def initialize(config)
+        @default_dir = File.expand_path(File.dirname(config[:database]))
+
+        super
+      end
+
+      def drop(tenant)
+        unless File.exist?(database_file(tenant))
+          raise TenantNotFound,
+                "The tenant #{environmentify(tenant)} cannot be found."
+        end
+
+        File.delete(database_file(tenant))
+      end
+
+      def current
+        File.basename(Apartment.connection.instance_variable_get(:@config)[:database], '.sqlite3')
+      end
+
+      protected
+
+      def connect_to_new(tenant)
+        return reset if tenant.nil?
+
+        unless File.exist?(database_file(tenant))
+          raise TenantNotFound,
+                "The tenant #{environmentify(tenant)} cannot be found."
+        end
+
+        super database_file(tenant)
+      end
+
+      def create_tenant(tenant)
+        if File.exist?(database_file(tenant))
+          raise TenantExists,
+                "The tenant #{environmentify(tenant)} already exists."
+        end
+
+        begin
+          f = File.new(database_file(tenant), File::CREAT)
+        ensure
+          f.close
+        end
+      end
+
+      private
+
+      def database_file(tenant)
+        "#{@default_dir}/#{environmentify(tenant)}.sqlite3"
+      end
+    end
+  end
+end

data/lib/apartment/console.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+def st(schema_name = nil)
+  if schema_name.nil?
+    tenant_list.each { |t| puts t }
+
+  elsif tenant_list.include? schema_name
+    Apartment::Tenant.switch!(schema_name)
+  else
+    puts "Tenant #{schema_name} is not part of the tenant list"
+
+  end
+end
+
+def tenant_list
+  tenant_list = [Apartment.default_tenant]
+  tenant_list += Apartment.tenant_names
+  tenant_list.uniq
+end
+
+def tenant_info_msg
+  puts "Available Tenants: #{tenant_list}\n"
+  puts "Use `st 'tenant'` to switch tenants & `tenant_list` to see list\n"
+end

data/lib/apartment/custom_console.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require_relative 'console'
+
+module Apartment
+  module CustomConsole
+    begin
+      require 'pry-rails'
+    rescue LoadError
+      # rubocop:disable Layout/LineLength
+      puts '[Failed to load pry-rails] If you want to use Apartment custom prompt you need to add pry-rails to your gemfile'
+      # rubocop:enable Layout/LineLength
+    end
+
+    desc = "Includes the current Rails environment and project folder name.\n" \
+          '[1] [project_name][Rails.env][Apartment::Tenant.current] pry(main)>'
+
+    prompt_procs = [
+      proc { |target_self, nest_level, pry| prompt_contents(pry, target_self, nest_level, '>') },
+      proc { |target_self, nest_level, pry| prompt_contents(pry, target_self, nest_level, '*') }
+    ]
+
+    if Gem::Version.new(Pry::VERSION) >= Gem::Version.new('0.13')
+      Pry.config.prompt = Pry::Prompt.new 'ros', desc, prompt_procs
+    else
+      Pry::Prompt.add 'ros', desc, %w[> *] do |target_self, nest_level, pry, sep|
+        prompt_contents(pry, target_self, nest_level, sep)
+      end
+      Pry.config.prompt = Pry::Prompt[:ros][:value]
+    end
+
+    Pry.config.hooks.add_hook(:when_started, 'startup message') do
+      tenant_info_msg
+    end
+
+    def self.prompt_contents(pry, target_self, nest_level, sep)
+      "[#{pry.input_ring.size}] [#{PryRails::Prompt.formatted_env}][#{Apartment::Tenant.current}] " \
+      "#{pry.config.prompt_name}(#{Pry.view_clip(target_self)})" \
+      "#{":#{nest_level}" unless nest_level.zero?}#{sep} "
+    end
+  end
+end

data/lib/apartment/deprecation.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require 'active_support/deprecation'
+
+module Apartment
+  module Deprecation
+    def self.warn(message)
+      ActiveSupport::Deprecation.warn message
+    end
+  end
+end

data/lib/apartment/elevators/domain.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require 'apartment/elevators/generic'
+
+module Apartment
+  module Elevators
+    #   Provides a rack based tenant switching solution based on domain
+    #   Assumes that tenant name should match domain
+    #   Parses request host for second level domain, ignoring www
+    #   eg. example.com       => example
+    #       www.example.bc.ca => example
+    #       a.example.bc.ca   => a
+    #
+    #
+    class Domain < Generic
+      def parse_tenant_name(request)
+        return nil if request.host.blank?
+
+        request.host.match(/(www\.)?(?<sld>[^.]*)/)['sld']
+      end
+    end
+  end
+end

data/lib/apartment/elevators/first_subdomain.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require 'apartment/elevators/subdomain'
+
+module Apartment
+  module Elevators
+    # Provides a rack based tenant switching solution based on the first subdomain
+    # of a given domain name.
+    # eg:
+    #     - example1.domain.com               => example1
+    #     - example2.something.domain.com     => example2
+    class FirstSubdomain < Subdomain
+      def parse_tenant_name(request)
+        super.split('.')[0] unless super.nil?
+      end
+    end
+  end
+end

data/lib/apartment/elevators/generic.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require 'rack/request'
+require 'apartment/tenant'
+
+module Apartment
+  module Elevators
+    #   Provides a rack based tenant switching solution based on request
+    #
+    class Generic
+      def initialize(app, processor = nil)
+        @app = app
+        @processor = processor || method(:parse_tenant_name)
+      end
+
+      def call(env)
+        request = Rack::Request.new(env)
+
+        database = @processor.call(request)
+
+        if database
+          Apartment::Tenant.switch(database) { @app.call(env) }
+        else
+          @app.call(env)
+        end
+      end
+
+      def parse_tenant_name(_request)
+        raise 'Override'
+      end
+    end
+  end
+end