ros-apartment 2.3.0.alpha1

data/lib/apartment/adapters/postgresql_adapter.rb

@@ -0,0 +1,236 @@
+require 'apartment/adapters/abstract_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
+
+      #   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 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.new("Could not find schema #{tenant}") unless Apartment.connection.schema_exists?(tenant.to_s)
+
+        @current = 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
+        if postgresql_version < 90300
+          Apartment.connection.clear_cache!
+        end
+
+      rescue *rescuable_exceptions
+        raise TenantNotFound, "One of the following schema(s) is invalid: \"#{tenant}\" #{full_search_path}"
+      end
+
+    private
+
+      def create_tenant_command(conn, tenant)
+        conn.execute(%{CREATE SCHEMA "#{tenant}"})
+      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
+    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
+        /CREATE SCHEMA public/i,
+        /COMMENT ON SCHEMA public/i,
+
+      ]
+
+      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
+      #
+      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
+
+      # Temporary set Postgresql related environment variables if there are in @config
+      #
+      def with_pg_env(&block)
+        pghost, pgport, pguser, pgpassword =  ENV['PGHOST'], ENV['PGPORT'], ENV['PGUSER'], 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]
+
+        block.call
+      ensure
+        ENV['PGHOST'], ENV['PGPORT'], ENV['PGUSER'], ENV['PGPASSWORD'] = pghost, pgport, pguser, 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,56 @@
+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)
+        raise TenantNotFound,
+          "The tenant #{environmentify(tenant)} cannot be found." unless File.exists?(database_file(tenant))
+
+        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)
+        raise TenantNotFound,
+          "The tenant #{environmentify(tenant)} cannot be found." unless File.exists?(database_file(tenant))
+
+        super database_file(tenant)
+      end
+
+      def create_tenant(tenant)
+        raise TenantExists,
+          "The tenant #{environmentify(tenant)} already exists." if File.exists?(database_file(tenant))
+
+        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,12 @@
+# A workaraound to get `reload!` to also call Apartment::Tenant.init
+# This is unfortunate, but I haven't figured out how to hook into the reload process *after* files are reloaded
+
+# reloads the environment
+def reload!(print=true)
+  puts "Reloading..." if print
+  # This triggers the to_prepare callbacks
+  ActionDispatch::Callbacks.new(Proc.new {}).call({})
+  # Manually init Apartment again once classes are reloaded
+  Apartment::Tenant.init
+  true
+end

data/lib/apartment/deprecation.rb

@@ -0,0 +1,10 @@
+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,22 @@
+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,17 @@
+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,32 @@
+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,30 @@
+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
+
+      def self.ignored_first_subdomains=(arg)
+        @ignored_first_subdomains = arg
+      end
+
+      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,22 @@
+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)
+        raise TenantNotFound,
+          "Cannot find tenant for host #{request.host}" unless @hash.has_key?(request.host)
+
+        @hash[request.host]
+      end
+    end
+  end
+end