synerma-apartment 3.1.0

data/lib/apartment/adapters/postgresql_adapter.rb

@@ -0,0 +1,280 @@
+# 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
+      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/i,
+        /COMMENT ON SCHEMA/i,
+        /SET transaction_timeout/i,                   # new in postgresql 17
+
+      ].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
+        exclude_table =
+          if Apartment.pg_exclude_clone_tables
+            excluded_tables.map! { |t| "-T #{t}" }.join(' ')
+          else
+            ''
+          end
+        with_pg_env { `pg_dump -s -x -O -n #{default_tenant} #{dbname} #{exclude_table}` }
+      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
+          elsif Apartment.pg_exclude_clone_tables && excluded_tables.any?(match)
+            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
+
+      # Convenience method for excluded table names
+      #
+      def excluded_tables
+        Apartment.excluded_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/adapters/trilogy_adapter.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'apartment/adapters/mysql2_adapter'
+
+module Apartment
+  # Helper module to decide wether to use trilogy adapter or trilogy adapter with schemas
+  module Tenant
+    def self.trilogy_adapter(config)
+      if Apartment.use_schemas
+        Adapters::TrilogySchemaAdapter.new(config)
+      else
+        Adapters::TrilogyAdapter.new(config)
+      end
+    end
+  end
+
+  module Adapters
+    class TrilogyAdapter < Mysql2Adapter
+      protected
+
+      def rescue_from
+        Trilogy::Error
+      end
+    end
+
+    class TrilogySchemaAdapter < Mysql2SchemaAdapter
+    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,8 @@
+# frozen_string_literal: true
+
+require 'active_support/deprecation'
+require_relative 'version'
+
+module Apartment
+  DEPRECATOR = ActiveSupport::Deprecation.new(Apartment::VERSION, 'Apartment')
+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

data/lib/apartment/elevators/host.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require 'apartment/elevators/generic'
+
+module Apartment
+  module Elevators
+    #   Provides a rack based tenant switching solution based on the host
+    #   Assumes that tenant name should match host
+    #   Strips/ignores first subdomains in ignored_first_subdomains
+    #   eg. example.com       => example.com
+    #       www.example.bc.ca => www.example.bc.ca
+    #   if ignored_first_subdomains = ['www']
+    #       www.example.bc.ca => example.bc.ca
+    #       www.a.b.c.d.com   => a.b.c.d.com
+    #
+    class Host < Generic
+      def self.ignored_first_subdomains
+        @ignored_first_subdomains ||= []
+      end
+
+      # rubocop:disable Style/TrivialAccessors
+      def self.ignored_first_subdomains=(arg)
+        @ignored_first_subdomains = arg
+      end
+      # rubocop:enable Style/TrivialAccessors
+
+      def parse_tenant_name(request)
+        return nil if request.host.blank?
+
+        parts = request.host.split('.')
+        self.class.ignored_first_subdomains.include?(parts[0]) ? parts.drop(1).join('.') : request.host
+      end
+    end
+  end
+end

data/lib/apartment/elevators/host_hash.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require 'apartment/elevators/generic'
+
+module Apartment
+  module Elevators
+    #   Provides a rack based tenant switching solution based on hosts
+    #   Uses a hash to find the corresponding tenant name for the host
+    #
+    class HostHash < Generic
+      def initialize(app, hash = {}, processor = nil)
+        super app, processor
+        @hash = hash
+      end
+
+      def parse_tenant_name(request)
+        unless @hash.key?(request.host)
+          raise TenantNotFound,
+                "Cannot find tenant for host #{request.host}"
+        end
+
+        @hash[request.host]
+      end
+    end
+  end
+end

data/lib/apartment/elevators/subdomain.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require 'apartment/elevators/generic'
+require 'public_suffix'
+
+module Apartment
+  module Elevators
+    #   Provides a rack based tenant switching solution based on subdomains
+    #   Assumes that tenant name should match subdomain
+    #
+    class Subdomain < Generic
+      def self.excluded_subdomains
+        @excluded_subdomains ||= []
+      end
+
+      # rubocop:disable Style/TrivialAccessors
+      def self.excluded_subdomains=(arg)
+        @excluded_subdomains = arg
+      end
+      # rubocop:enable Style/TrivialAccessors
+
+      def parse_tenant_name(request)
+        request_subdomain = subdomain(request.host)
+
+        # If the domain acquired is set to be excluded, set the tenant to whatever is currently
+        # next in line in the schema search path.
+        tenant = if self.class.excluded_subdomains.include?(request_subdomain)
+                   nil
+                 else
+                   request_subdomain
+                 end
+
+        tenant.presence
+      end
+
+      protected
+
+      # *Almost* a direct ripoff of ActionDispatch::Request subdomain methods
+
+      # Only care about the first subdomain for the database name
+      def subdomain(host)
+        subdomains(host).first
+      end
+
+      def subdomains(host)
+        host_valid?(host) ? parse_host(host) : []
+      end
+
+      def host_valid?(host)
+        !ip_host?(host) && domain_valid?(host)
+      end
+
+      def ip_host?(host)
+        !/^[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}$/.match(host).nil?
+      end
+
+      def domain_valid?(host)
+        PublicSuffix.valid?(host, ignore_private: true)
+      end
+
+      def parse_host(host)
+        (PublicSuffix.parse(host, ignore_private: true).trd || '').split('.')
+      end
+    end
+  end
+end