activerecord-tenanted 0.4.1 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2dbae49297c735850801a4994217ba8ce3ff794345159748c881c6e5e33a6b86
-  data.tar.gz: 42e0b45e14927d7c403db84baf20499c9297572993d30526522e0ecb810ad87f
+  metadata.gz: e6045a554346528724708d7acfcefa45c3445f5dd1bbc184426ce13e995bbb83
+  data.tar.gz: 5c752644fcb587efff882e8c117933147dccc5771e74c3ea3d9b967eaa33f5dc
 SHA512:
-  metadata.gz: d897569771373793bb56468562b9070d523d1cebe1a2fa1acd7da8e7db40d92f59c8e51439161f33d5c9e3456c9d5797499b2596fc5dcc515b5a4b93959f8122
-  data.tar.gz: f4edce93a3be90e901251be1b00f788753056c94d4fe0c1df71fcccd0b28aba52f9116c2f144ac94a1b72acb194d44a1e7736df0d971c520088c4a2fd5cddb85
+  metadata.gz: cb160898373d824906708a959d59b40d1f76fa398b2fcdebadd57b590ddd63a3da2fcbe53eb8787a5af041f108eb27516afb27febe4aa62eb76c9a1cd7cccd4f
+  data.tar.gz: e001ccf67a7e4891df031ee6ceb34c20f227cb3ef3499decf2e5cce59b638a76f9a8b4200c55105910a74c3f7478c11b32aeb34d8f7da481d8b388a51997b899

data/lib/active_record/tenanted/database_adapter.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Tenanted
+    class DatabaseAdapter # :nodoc:
+      ADAPTERS = {
+        "sqlite3" => "ActiveRecord::Tenanted::DatabaseAdapters::SQLite",
+      }.freeze
+
+      class << self
+        def new(db_config)
+          adapter_class_name = ADAPTERS[db_config.adapter]
+
+          if adapter_class_name.nil?
+            raise ActiveRecord::Tenanted::UnsupportedDatabaseError,
+                  "Unsupported database adapter for tenanting: #{db_config.adapter}. " \
+                  "Supported adapters: #{ADAPTERS.keys.join(', ')}"
+          end
+
+          adapter_class_name.constantize.new(db_config)
+        end
+      end
+    end
+  end
+end

data/lib/active_record/tenanted/database_adapters/sqlite.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Tenanted
+    module DatabaseAdapters # :nodoc:
+      #
+      #  TODO: This still feels to me like it's not _quite_ right. I think we could further refactor this by:
+      #
+      #  1. Moving tenant_databases and validate_tenant_name to BaseConfig, and subclassing it for
+      #     each database
+      #  2. Moving create_database, drop_database, database_exist?, database_ready?,
+      #     acquire_ready_lock, ensure_database_directory_exists, and database_path to the SQLite
+      #     connection adapter, possibly into Rails
+      #  3. Moving test_workerize and path_for to be SQLite connection adapter class methods,
+      #     possibly into Rails
+      #
+      class SQLite
+        attr_reader :db_config
+
+        def initialize(db_config)
+          @db_config = db_config
+        end
+
+        def tenant_databases
+          glob = path_for(db_config.database_for("*"))
+          scanner = Regexp.new(path_for(db_config.database_for("(.+)")))
+
+          Dir.glob(glob).filter_map do |path|
+            result = path.scan(scanner).flatten.first
+            if result.nil?
+              Rails.logger.warn "ActiveRecord::Tenanted: Cannot parse tenant name from filename #{path.inspect}"
+            end
+            result
+          end
+        end
+
+        def validate_tenant_name(tenant_name)
+          if tenant_name.match?(%r{[/'"`]})
+            raise BadTenantNameError, "Tenant name contains an invalid character: #{tenant_name.inspect}"
+          end
+        end
+
+        def create_database
+          ensure_database_directory_exists
+          FileUtils.touch(database_path)
+        end
+
+        def drop_database
+          # Remove the SQLite database file and associated files
+          FileUtils.rm_f(database_path)
+          FileUtils.rm_f("#{database_path}-wal")  # Write-Ahead Logging file
+          FileUtils.rm_f("#{database_path}-shm")  # Shared Memory file
+        end
+
+        def database_exist?
+          File.exist?(database_path)
+        end
+
+        def database_ready?
+          File.exist?(database_path) && !ActiveRecord::Tenanted::Mutex::Ready.locked?(database_path)
+        end
+
+        def acquire_ready_lock(&block)
+          ActiveRecord::Tenanted::Mutex::Ready.lock(database_path, &block)
+        end
+
+        def ensure_database_directory_exists
+          return unless database_path
+
+          database_dir = File.dirname(database_path)
+          unless File.directory?(database_dir)
+            FileUtils.mkdir_p(database_dir)
+          end
+        end
+
+        def database_path
+          path_for(db_config.database)
+        end
+
+        def test_workerize(db, test_worker_id)
+          test_worker_suffix = "_#{test_worker_id}"
+
+          if db.start_with?("file:") && db.include?("?")
+            db.sub(/(\?.*)$/, "#{test_worker_suffix}\\1")
+          else
+            # This check is needed because of https://github.com/rails/rails/pull/55769 adding
+            # replicas to the parallelization setup by using `include_hidden: true` which pulls in
+            # the BaseConfig. We don't want to double-suffix the database name.
+            #
+            # TODO: Ideally we should have finer-grained filtering of database configurations in Rails
+            # (other than simply hidden or not-hidden).
+            if db.end_with?(test_worker_suffix)
+              db
+            else
+              db + test_worker_suffix
+            end
+          end
+        end
+
+        # A sqlite database path can be a file path or a URI (either relative or absolute).  We
+        # can't parse it as a standard URI in all circumstances, though, see
+        # https://sqlite.org/uri.html
+        def path_for(database)
+          if database.start_with?("file:/")
+            URI.parse(database).path
+          elsif database.start_with?("file:")
+            URI.parse(database.sub(/\?.*$/, "")).opaque
+          else
+            database
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_record/tenanted/database_configurations/base_config.rb

@@ -11,6 +11,11 @@ module ActiveRecord
         def initialize(...)
           super
           @test_worker_id = nil
+          @config_adapter = nil
+        end
+
+        def config_adapter
+          @config_adapter ||= ActiveRecord::Tenanted::DatabaseAdapter.new(self)
         end
 
         def database_tasks?
@@ -20,33 +25,19 @@ module ActiveRecord
         def database_for(tenant_name)
           tenant_name = tenant_name.to_s
 
-          validate_tenant_name(tenant_name)
+          config_adapter.validate_tenant_name(tenant_name)
 
-          path = sprintf(database, tenant: tenant_name)
+          db = sprintf(database, tenant: tenant_name)
 
           if test_worker_id
-            test_worker_path(path)
-          else
-            path
+            db = config_adapter.test_workerize(db, test_worker_id)
           end
-        end
 
-        def database_path_for(tenant_name)
-          coerce_path(database_for(tenant_name))
+          db
         end
 
         def tenants
-          glob = database_path_for("*")
-          scanner = Regexp.new(database_path_for("(.+)"))
-
-          Dir.glob(glob).map do |path|
-            result = path.scan(scanner).flatten.first
-            if result.nil?
-              warn "WARN: ActiveRecord::Tenanted: Cannot parse tenant name from filename #{path.inspect}. " \
-                   "This is a bug, please report it to https://github.com/basecamp/activerecord-tenanted/issues"
-            end
-            result
-          end
+          config_adapter.tenant_databases
         end
 
         def new_tenant_config(tenant_name)
@@ -54,7 +45,6 @@ module ActiveRecord
           config_hash = configuration_hash.dup.tap do |hash|
             hash[:tenant] = tenant_name
             hash[:database] = database_for(tenant_name)
-            hash[:database_path] = database_path_for(tenant_name)
             hash[:tenanted_config_name] = name
           end
           Tenanted::DatabaseConfigurations::TenantConfig.new(env_name, config_name, config_hash)
@@ -70,35 +60,6 @@ module ActiveRecord
         def max_connection_pools
           (configuration_hash[:max_connection_pools] || DEFAULT_MAX_CONNECTION_POOLS).to_i
         end
-
-        private
-          # A sqlite database path can be a file path or a URI (either relative or absolute).
-          # We can't parse it as a standard URI in all circumstances, though, see https://sqlite.org/uri.html
-          def coerce_path(path)
-            if path.start_with?("file:/")
-              URI.parse(path).path
-            elsif path.start_with?("file:")
-              URI.parse(path.sub(/\?.*$/, "")).opaque
-            else
-              path
-            end
-          end
-
-          def validate_tenant_name(tenant_name)
-            if tenant_name.match?(%r{[/'"`]})
-              raise BadTenantNameError, "Tenant name contains an invalid character: #{tenant_name.inspect}"
-            end
-          end
-
-          def test_worker_path(path)
-            test_worker_suffix = "_#{test_worker_id}"
-
-            if path.start_with?("file:") && path.include?("?")
-              path.sub(/(\?.*)$/, "#{test_worker_suffix}\\1")
-            else
-              path + test_worker_suffix
-            end
-          end
       end
     end
   end

data/lib/active_record/tenanted/database_configurations/tenant_config.rb

@@ -4,12 +4,24 @@ module ActiveRecord
   module Tenanted
     module DatabaseConfigurations
       class TenantConfig < ActiveRecord::DatabaseConfigurations::HashConfig
+        def initialize(...)
+          super
+          @config_adapter = nil
+        end
+
         def tenant
           configuration_hash.fetch(:tenant)
         end
 
+        def config_adapter
+          @config_adapter ||= ActiveRecord::Tenanted::DatabaseAdapter.new(self)
+        end
+
         def new_connection
-          ensure_database_directory_exists # adapter doesn't handle this if the database is a URI
+          # TODO: The Rails SQLite adapter doesn't handle directory creation for file: URIs. I would
+          # like to fix that upstream, and remove this line.
+          config_adapter.ensure_database_directory_exists
+
           super.tap { |conn| conn.tenant = tenant }
         end
 
@@ -36,20 +48,6 @@ module ActiveRecord
             File.join(db_dir, "#{tenanted_config_name}_schema_cache.yml")
           end
         end
-
-        def database_path
-          configuration_hash[:database_path]
-        end
-
-        private
-          def ensure_database_directory_exists
-            return unless database_path
-
-            database_dir = File.dirname(database_path)
-            unless File.directory?(database_dir)
-              FileUtils.mkdir_p(database_dir)
-            end
-          end
       end
     end
   end

data/lib/active_record/tenanted/database_tasks.rb

@@ -6,38 +6,34 @@ module ActiveRecord
       extend self
 
       def migrate_all
-        raise ArgumentError, "Could not find a tenanted database" unless root_config = root_database_config
+        raise ArgumentError, "Could not find a tenanted database" unless config = base_config
 
-        tenants = root_config.tenants.presence || [ get_current_tenant ].compact
+        tenants = config.tenants.presence || [ get_current_tenant ].compact
         tenants.each do |tenant|
-          tenant_config = root_config.new_tenant_config(tenant)
+          tenant_config = config.new_tenant_config(tenant)
           migrate(tenant_config)
         end
       end
 
       def migrate_tenant(tenant_name = set_current_tenant)
-        raise ArgumentError, "Could not find a tenanted database" unless root_config = root_database_config
+        raise ArgumentError, "Could not find a tenanted database" unless config = base_config
 
-        tenant_config = root_config.new_tenant_config(tenant_name)
+        tenant_config = config.new_tenant_config(tenant_name)
 
         migrate(tenant_config)
       end
 
       def drop_all
-        raise ArgumentError, "Could not find a tenanted database" unless root_config = root_database_config
-
-        root_config.tenants.each do |tenant|
-          # NOTE: This is obviously a sqlite-specific implementation.
-          # TODO: Create a `drop_database` method upstream in the sqlite3 adapter, and call it.
-          #       Then this would delegate to the adapter and become adapter-agnostic.
-          root_config.database_path_for(tenant).tap do |path|
-            FileUtils.rm(path)
-            $stdout.puts "Dropped database '#{path}'" if verbose?
-          end
+        raise ArgumentError, "Could not find a tenanted database" unless config = base_config
+
+        config.tenants.each do |tenant|
+          db_config = config.new_tenant_config(tenant)
+          db_config.config_adapter.drop_database
+          $stdout.puts "Dropped database '#{db_config.database}'" if verbose?
         end
       end
 
-      def root_database_config
+      def base_config
         db_configs = ActiveRecord::Base.configurations.configs_for(
           env_name: ActiveRecord::Tasks::DatabaseTasks.env,
           include_hidden: true

data/lib/active_record/tenanted/tenant.rb

@@ -13,11 +13,13 @@ module ActiveRecord
       end
 
       def cache_key
-        tenant ? "#{super}?tenant=#{tenant}" : super
+        tenant ? "#{tenant}/#{super}" : super
       end
 
       def inspect
-        tenant ? super.sub(/>$/, ", tenant=#{tenant.inspect}>") : super
+        return super unless tenant
+
+        super.sub(/\A#<\S+ /, "\\0tenant: #{tenant.inspect}, ")
       end
 
       def to_global_id(options = {})
@@ -99,10 +101,7 @@ module ActiveRecord
         end
 
         def tenant_exist?(tenant_name)
-          # this will have to be an adapter-specific implementation if we support other than sqlite
-          database_path = tenanted_root_config.database_path_for(tenant_name)
-
-          File.exist?(database_path) && !ActiveRecord::Tenanted::Mutex::Ready.locked?(database_path)
+          tenanted_root_config.new_tenant_config(tenant_name).config_adapter.database_ready?
         end
 
         def with_tenant(tenant_name, prohibit_shard_swapping: true, &block)
@@ -121,14 +120,11 @@ module ActiveRecord
 
         def create_tenant(tenant_name, if_not_exists: false, &block)
           created_db = false
-          database_path = tenanted_root_config.database_path_for(tenant_name)
+          adapter = tenanted_root_config.new_tenant_config(tenant_name).config_adapter
 
-          ActiveRecord::Tenanted::Mutex::Ready.lock(database_path) do
-            unless File.exist?(database_path)
-              # NOTE: This is obviously a sqlite-specific implementation.
-              # TODO: Add a `create_database` method upstream in the sqlite3 adapter, and call it.
-              #       Then this would delegate to the adapter and become adapter-agnostic.
-              FileUtils.touch(database_path)
+          adapter.acquire_ready_lock do
+            unless adapter.database_exist?
+              adapter.create_database
 
               with_tenant(tenant_name) do
                 connection_pool(schema_version_check: false)
@@ -138,7 +134,7 @@ module ActiveRecord
               created_db = true
             end
           rescue
-            FileUtils.rm_f(database_path)
+            adapter.drop_database
             raise
           end
 
@@ -158,10 +154,7 @@ module ActiveRecord
             end
           end
 
-          # NOTE: This is obviously a sqlite-specific implementation.
-          # TODO: Create a `drop_database` method upstream in the sqlite3 adapter, and call it.
-          #       Then this would delegate to the adapter and become adapter-agnostic.
-          FileUtils.rm_f(tenanted_root_config.database_path_for(tenant_name))
+          tenanted_root_config.new_tenant_config(tenant_name).config_adapter.drop_database
         end
 
         def tenants
@@ -211,12 +204,12 @@ module ActiveRecord
           return superclass._create_tenanted_pool unless connection_class?
 
           tenant = current_tenant
-          unless File.exist?(tenanted_root_config.database_path_for(tenant))
-            raise TenantDoesNotExistError, "The database file for tenant #{tenant.inspect} does not exist."
-          end
+          db_config = tenanted_root_config.new_tenant_config(tenant)
 
-          config = tenanted_root_config.new_tenant_config(tenant)
-          pool = establish_connection(config)
+          unless db_config.config_adapter.database_exist?
+            raise TenantDoesNotExistError, "The database for tenant #{tenant.inspect} does not exist."
+          end
+          pool = establish_connection(db_config)
 
           if schema_version_check
             pending_migrations = pool.migration_context.open.pending_migrations

data/lib/active_record/tenanted/version.rb

@@ -2,6 +2,6 @@
 
 module ActiveRecord
   module Tenanted
-    VERSION = "0.4.1"
+    VERSION = "0.5.0"
   end
 end

data/lib/active_record/tenanted.rb

@@ -4,6 +4,9 @@ require "active_record"
 
 require "zeitwerk"
 loader = Zeitwerk::Loader.for_gem_extension(ActiveRecord)
+loader.inflector.inflect(
+  "sqlite" => "SQLite",
+)
 loader.setup
 
 module ActiveRecord
@@ -35,6 +38,9 @@ module ActiveRecord
     # Raised when the Rails integration is being invoked but has not been configured.
     class IntegrationNotConfiguredError < Error; end
 
+    # Raised when an unsupported database adapter is used.
+    class UnsupportedDatabaseError < Error; end
+
     def self.connection_class
       # TODO: cache this / speed this up
       Rails.application.config.active_record_tenanted.connection_class&.constantize

data/lib/tasks/active_record/tenanted_tasks.rake

@@ -8,7 +8,7 @@ namespace :db do
       next
     end
 
-    unless ActiveRecord::Tenanted::DatabaseTasks.root_database_config
+    unless ActiveRecord::Tenanted::DatabaseTasks.base_config
       warn "WARNING: No tenanted database found, skipping tenanted migration"
     else
       begin
@@ -42,7 +42,7 @@ namespace :db do
 
   desc "Drop all tenanted databases for the current environment"
   task "drop:tenant" => "load_config" do
-    unless ActiveRecord::Tenanted::DatabaseTasks.root_database_config
+    unless ActiveRecord::Tenanted::DatabaseTasks.base_config
       warn "WARNING: No tenanted database found, skipping tenanted reset"
     else
       begin

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: activerecord-tenanted
 version: !ruby/object:Gem::Version
-  version: 0.4.1
+  version: 0.5.0
 platform: ruby
 authors:
 - Mike Dalessio
@@ -73,6 +73,8 @@ files:
 - lib/active_record/tenanted/cable_connection.rb
 - lib/active_record/tenanted/connection_adapter.rb
 - lib/active_record/tenanted/console.rb
+- lib/active_record/tenanted/database_adapter.rb
+- lib/active_record/tenanted/database_adapters/sqlite.rb
 - lib/active_record/tenanted/database_configurations.rb
 - lib/active_record/tenanted/database_configurations/base_config.rb
 - lib/active_record/tenanted/database_configurations/tenant_config.rb