console_kit 1.4.0 → 1.5.1

data/lib/console_kit/connections/elasticsearch_connection_handler.rb

@@ -1,11 +1,23 @@
 # frozen_string_literal: true
 
 require_relative 'base_connection_handler'
+require_relative 'elasticsearch_prefix_registry'
 
 module ConsoleKit
   module Connections
-    # Handles Elasticsearch connections
     class ElasticsearchConnectionHandler < BaseConnectionHandler
+      backend :elasticsearch,
+              display_name: 'Elasticsearch',
+              context_attribute: :tenant_elasticsearch_prefix,
+              constants_key: :elasticsearch_prefix,
+              detail_label: 'ES Prefix'
+
+      UNSUPPORTED = 'Elasticsearch does not expose index_name_prefix= in this version.'
+      UNVERIFIABLE = 'Elasticsearch exposes no index_name_prefix reader in this version, so the process-wide prefix ' \
+                     'cannot be read back and a switch could not be verified or rolled back. Give each tenant its ' \
+                     'own index naming instead.'
+      NOT_A_NAME = 'expected a String or Symbol'
+
       class << self
         def elasticsearch_available?
           return false unless defined?(Elasticsearch::Model)
@@ -16,56 +28,99 @@ module ConsoleKit
           false
         end
 
-        def apply_prefix(prefix)
-          return unless defined?(Elasticsearch::Model)
+        def target_error(value)
+          return NOT_A_NAME unless value.nil? || value.is_a?(String) || value.is_a?(Symbol)
 
-          Elasticsearch::Model.try(:index_name_prefix=, prefix)
+          ElasticsearchPrefixRegistry.prefix_error(value.presence&.to_s)
         end
       end
 
-      def connect
-        prefix = context_attribute(:tenant_elasticsearch_prefix).presence
+      def available? = self.class.elasticsearch_available?
+      def isolation_model = :process_global
+      def thread_isolated? = false
+
+      def prepare(target)
+        validate_target!(target)
+        settable = registry.settable?
+        raise UnsupportedBackendError, UNSUPPORTED if normalize(target) && !settable
+        return unless settable
+
+        raise UnsupportedBackendError, UNVERIFIABLE unless registry.readable?
+      end
+
+      def snapshot = { global: registry.global, thread: registry.current }
+
+      def connect!(target)
+        prefix = normalize(target)
         Output.print_info(switch_message(prefix))
-        Thread.current[:console_kit_elasticsearch_prefix] = prefix
-        self.class.apply_prefix(prefix)
+        report_conflicts(prefix)
+        apply_global(prefix)
+        registry.record(prefix)
       end
 
-      def available? = self.class.elasticsearch_available?
+      def verify!(target)
+        expected = normalize(target)
+        actual = effective_prefix
+        return true if actual == expected
 
-      def diagnostics
-        return unavailable_diagnostics('Elasticsearch') unless available?
+        raise verification_error(expected, actual)
+      end
 
-        perform_diagnostics
-      rescue StandardError => e
-        error_diagnostics('Elasticsearch', e)
+      def restore(state)
+        apply_global(state[:global])
+        registry.record(state[:thread])
       end
 
+      def effective_prefix = registry.readable? ? registry.global : registry.current
+
+      def diagnostic_identity = effective_prefix
+
       private
 
-      def perform_diagnostics
-        client = Elasticsearch::Model.client
-        latency = measure_latency do
-          client.ping
-        rescue StandardError
-          nil
-        end
-        health = client.cluster.health
-        build_elasticsearch_diagnostics(health['cluster_name'], health['status'], latency)
+      def registry = ElasticsearchPrefixRegistry
+
+      def basic_diagnostics
+        {
+          name: display_name, status: :connected, latency_ms: nil,
+          details: { prefix: effective_prefix, isolation: isolation_model }
+        }
       end
 
-      def build_elasticsearch_diagnostics(cluster, status, latency)
+      def full_diagnostics
+        client = Elasticsearch::Model.client
+        latency = measure_latency { ping!(client) }
+        health = client.cluster.health
         {
-          name: 'Elasticsearch',
-          status: :connected,
-          latency_ms: latency,
-          details: {
-            prefix: context_attribute(:tenant_elasticsearch_prefix),
-            cluster: cluster,
-            health: status
-          }
+          name: display_name, status: :connected, latency_ms: latency,
+          details: { prefix: effective_prefix, cluster: health['cluster_name'], health: health['status'] }
         }
       end
 
+      def ping!(client)
+        client.ping
+      rescue StandardError => e
+        raise ConnectionError.new("#{display_name} cluster unreachable: #{scrub(e.message)}",
+                                  backend: display_name, operation: :diagnostics)
+      end
+
+      def apply_global(prefix)
+        raise UnsupportedBackendError, UNSUPPORTED if prefix && !registry.settable?
+
+        registry.global = prefix
+      end
+
+      def report_conflicts(prefix)
+        others = registry.unreported_conflicts(prefix)
+        return if others.empty?
+
+        Output.print_warning(
+          "#{display_name} index prefix is process-global: this thread wants #{prefix.inspect} while other " \
+          "live threads hold #{others.map(&:inspect).join(', ')}. The last writer wins for the whole process."
+        )
+      end
+
+      def normalize(target) = target.presence&.to_s
+
       def switch_message(prefix)
         prefix ? "Setting Elasticsearch index prefix: #{prefix}" : 'Resetting Elasticsearch index prefix to default'
       end

data/lib/console_kit/connections/elasticsearch_prefix_registry.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module ConsoleKit
+  module Connections
+    class ElasticsearchPrefixRegistry
+      THREAD_KEY = :console_kit_elasticsearch_prefix
+      REPORTED_KEY = :console_kit_elasticsearch_prefix_conflict
+
+      class << self
+        def prefix_error(prefix)
+          return unless prefix
+          return 'must be lowercase' if prefix.match?(/[[:upper:]]/)
+          return 'must not begin with _, - or +' if prefix.match?(/\A[_\-+]/)
+          return 'must not contain whitespace' if prefix.match?(/\s/)
+
+          'must not contain \\ / * ? " < > | , or #' if prefix.match?(%r{[\\/*?"<>|,#]})
+        end
+
+        def model = defined?(Elasticsearch::Model) ? Elasticsearch::Model : nil
+        def settable? = model.respond_to?(:index_name_prefix=)
+        def readable? = model.respond_to?(:index_name_prefix)
+        def global = readable? ? model.index_name_prefix.presence&.to_s : nil
+
+        def global=(prefix)
+          model.index_name_prefix = prefix if settable?
+        end
+
+        def current
+          synchronize do
+            prune
+            entries[Thread.current]
+          end
+        end
+
+        def record(prefix)
+          synchronize { store(Thread.current, prefix) }
+        end
+
+        def conflicts(prefix)
+          synchronize do
+            prune
+            entries.reject { |thread, held| thread.equal?(Thread.current) || held == prefix }.values.uniq
+          end
+        end
+
+        def unreported_conflicts(prefix)
+          thread = Thread.current
+          others = conflicts(prefix)
+          return [] if others.empty? || thread[REPORTED_KEY] == [prefix, others]
+
+          thread[REPORTED_KEY] = [prefix, others]
+          others
+        end
+
+        private
+
+        def store(thread, prefix)
+          prune
+          prefix ? (entries[thread] = prefix) : entries.delete(thread)
+          thread[THREAD_KEY] = prefix
+        end
+
+        def entries = @entries ||= {}
+        def mutex = @mutex ||= Mutex.new
+        def synchronize(&) = mutex.synchronize(&)
+        def prune = entries.select! { |thread, _prefix| thread.alive? }
+      end
+    end
+  end
+end

data/lib/console_kit/connections/mongo_connection_handler.rb

@@ -1,74 +1,79 @@
 # frozen_string_literal: true
 
 require_relative 'base_connection_handler'
+require_relative 'mongoid_support'
 
 module ConsoleKit
   module Connections
-    # Handles MongoDB connections
     class MongoConnectionHandler < BaseConnectionHandler
-      def connect
-        db = context_attribute(:tenant_mongo_db).presence
-        switch_mongo(db)
-      rescue NoMethodError
-        Output.print_warning('Mongoid client override is not available in this version of Mongoid.')
+      UNSUPPORTED_OVERRIDE = 'Mongoid.%<setter>s, which this target needs, is not available in this Mongoid version.'
+      UNVERIFIABLE = 'state cannot be read back in this Mongoid version, so a switch could not be verified or ' \
+                     'rolled back. Give each tenant its own Mongoid client instead.'
+
+      backend :mongo,
+              display_name: 'MongoDB',
+              context_attribute: :tenant_mongo_db,
+              constants_key: :mongo_db,
+              detail_label: 'Mongo DB'
+
+      class << self
+        def target_error(value) = identifier_error(value)
       end
 
-      def available? = defined?(Mongoid)
+      def available? = mongoid.available?
+
+      def prepare(target)
+        validate_target!(target)
+        setter = mongoid.setter_for(target)
+        raise UnsupportedBackendError, unsupported_message(setter) unless mongoid.settable?(setter)
+        raise UnsupportedBackendError, "#{display_name} #{UNVERIFIABLE}" unless mongoid.readable?
+      end
 
-      def diagnostics
-        return unavailable_diagnostics('MongoDB') unless available?
+      def snapshot = mongoid.overrides
 
-        perform_diagnostics
-      rescue StandardError => e
-        error_diagnostics('MongoDB', e)
+      def connect!(target) = mongoid.override(target)
+
+      def verify!(target)
+        if target.nil?
+          verify_reset!
+        elsif mongoid.named_client?(target)
+          verify_match!(target, mongoid.client_override)
+        else
+          verify_match!(target, mongoid.database_name)
+        end
       end
 
+      def restore(state) = mongoid.restore(state)
+
       private
 
-      def perform_diagnostics
-        db = tenant_database
-        latency = measure_latency { db.command(ping: 1) }
-        info = db.command(buildInfo: 1).first
-        build_mongo_diagnostics(db.name, info['version'], latency)
+      def mongoid = MongoidSupport
+
+      def basic_diagnostics
+        { name: display_name, status: :connected, latency_ms: nil, details: { database: mongoid.database_name } }
       end
 
-      def build_mongo_diagnostics(name, version, latency)
+      def full_diagnostics
+        latency = measure_latency { mongoid.ping }
         {
-          name: 'MongoDB',
-          status: :connected,
-          latency_ms: latency,
-          details: { database: name, version: version }
+          name: display_name, status: :connected, latency_ms: latency,
+          details: { database: mongoid.database_name, version: mongoid.server_version }
         }
       end
 
-      def tenant_database
-        override = context_attribute(:tenant_mongo_db).presence
-        client = Mongoid.default_client
-        (override ? client.use(override) : client).database
-      end
+      def unsupported_message(setter) = "#{display_name} #{format(UNSUPPORTED_OVERRIDE, setter: setter)}"
 
-      def switch_mongo(db)
-        if db.nil?
-          Output.print_info('Resetting MongoDB client to default')
-          reset_overrides
-        elsif named_client?(db)
-          Output.print_info("Switching to MongoDB client: #{db}")
-          Mongoid.override_client(db)
-        else
-          Output.print_info("Switching to MongoDB database: #{db}")
-          Mongoid.override_database(db)
-        end
-      end
+      def verify_match!(target, actual)
+        return if actual.to_s == target.to_s
 
-      def reset_overrides
-        Mongoid.override_client(nil) if Mongoid.respond_to?(:override_client)
-        Mongoid.override_database(nil)
+        raise verification_error(target, actual)
       end
 
-      def named_client?(name)
-        Mongoid::Config.clients.key?(name.to_s)
-      rescue StandardError
-        false
+      def verify_reset!
+        overrides = mongoid.overrides
+        return if overrides.values.none?
+
+        raise verification_error(nil, overrides)
       end
     end
   end

data/lib/console_kit/connections/mongoid_support.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module ConsoleKit
+  module Connections
+    module MongoidSupport
+      class << self
+        def available? = !!defined?(Mongoid)
+
+        def settable?(setter) = Mongoid.respond_to?(setter)
+
+        def readable?
+          return false unless Mongoid.respond_to?(:default_client) && threaded_readable?(:database_override)
+
+          !Mongoid.respond_to?(:override_client) || threaded_readable?(:client_override)
+        end
+
+        def setter_for(target) = named_client?(target) ? :override_client : :override_database
+
+        def named_client?(name)
+          return false unless defined?(Mongoid::Config) && Mongoid::Config.respond_to?(:clients)
+
+          Mongoid::Config.clients.key?(name.to_s)
+        end
+
+        def client_override = threaded_readable?(:client_override) ? Mongoid::Threaded.client_override : nil
+
+        def overrides = { client: client_override, database: database_override }
+
+        def override(target)
+          return restore({}) if target.nil?
+
+          Mongoid.public_send(setter_for(target), target)
+        end
+
+        def restore(state)
+          Mongoid.override_client(state[:client]) if Mongoid.respond_to?(:override_client)
+          Mongoid.override_database(state[:database])
+        end
+
+        def database_name = database.name
+        def ping = database.command(ping: 1)
+        def server_version = database.command(buildInfo: 1).first['version']
+
+        private
+
+        def database = Mongoid.default_client.database
+
+        def database_override = threaded_readable?(:database_override) ? Mongoid::Threaded.database_override : nil
+
+        def threaded_readable?(reader)
+          defined?(Mongoid::Threaded) && Mongoid::Threaded.respond_to?(reader)
+        end
+      end
+    end
+  end
+end

data/lib/console_kit/connections/redis_client_adapter.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+require_relative '../errors'
+
+module ConsoleKit
+  module Connections
+    class RedisClientAdapter
+      DIGITS = /\A\d+\z/
+      MEMO_KEY = :console_kit_redis_isolation
+
+      class << self
+        def db_index(value)
+          return value if value.is_a?(Integer) && !value.negative?
+          return nil unless value.is_a?(String) && value.match?(DIGITS)
+
+          value.to_i
+        end
+
+        def db_index_error(value)
+          'expected a non-negative Integer or a digit String' unless value.nil? || db_index(value)
+        end
+
+        def read_db(target)
+          return target.db if target.respond_to?(:db)
+
+          config = target.config if target.respond_to?(:config)
+          return config.db if config.respond_to?(:db)
+
+          info = target.connection if target.respond_to?(:connection)
+          info[:db] if info.respond_to?(:[])
+        end
+      end
+
+      def client = resolve
+
+      def selectable? = client.respond_to?(:select)
+      def db_readable? = !current_db.nil?
+      def isolation_model = @isolation_model ||= remembered_isolation
+
+      def current_db
+        Integer(client.then { |target| target && self.class.read_db(target) }, exception: false)
+      end
+
+      def movable_to?(db) = selectable? && ![nil, db].include?(current_db)
+
+      def select(db)
+        return unless selectable?
+
+        client.select(db)
+      end
+
+      private
+
+      def resolve
+        return nil unless defined?(::Redis) && ::Redis.respond_to?(:current)
+
+        ::Redis.current
+      rescue StandardError => e
+        raise e if ConsoleKit.programming_error?(e)
+
+        nil
+      end
+
+      def remembered_isolation
+        here = resolve
+        memo = Thread.current[MEMO_KEY]
+        return memo[:model] if memo && memo[:client].equal?(here)
+
+        model = probe_isolation(here)
+        Thread.current[MEMO_KEY] = { client: here, model: model } unless model == :unknown
+        model
+      end
+
+      def probe_isolation(here)
+        return :none unless here && resolve.equal?(here)
+
+        elsewhere = resolve_elsewhere
+        return :unknown unless elsewhere
+
+        elsewhere.equal?(here) ? :process_global : :scoped
+      end
+
+      def resolve_elsewhere
+        Thread.new { resolve }.value
+      rescue StandardError => e
+        raise e if ConsoleKit.programming_error?(e)
+
+        nil
+      end
+    end
+  end
+end

data/lib/console_kit/connections/redis_connection_handler.rb

@@ -1,75 +1,131 @@
 # frozen_string_literal: true
 
 require_relative 'base_connection_handler'
+require_relative 'redis_client_adapter'
 
 module ConsoleKit
   module Connections
-    # Handles Redis connections
     class RedisConnectionHandler < BaseConnectionHandler
+      backend :redis,
+              display_name: 'Redis',
+              context_attribute: :tenant_redis_db,
+              constants_key: :redis_db,
+              detail_label: 'Redis DB'
+
       DEFAULT_REDIS_DB = 0
 
+      PROCESS_GLOBAL_WARNING = 'Redis DB selection is process-wide with this client, so it is NOT isolated per ' \
+                               'thread. Threads on different tenants share one logical DB.'
+
       class << self
-        def redis_client = Redis.try(:current)
+        attr_accessor :isolation_warned
 
-        def warn_no_auto_select(db_index)
-          Output.print_warning("Redis DB #{db_index} configured but auto-select not supported with RedisClient. " \
-                               'Ensure your Redis configuration sets the correct DB.')
-        end
+        def target_error(value) = RedisClientAdapter.db_index_error(value)
       end
 
-      def connect
-        db_index = context_attribute(:tenant_redis_db) || DEFAULT_REDIS_DB
-        Output.print_info(switch_message(db_index))
-        select_redis_db(db_index)
+      def available? = !!defined?(Redis) || !!defined?(RedisClient)
+
+      def isolation_model = adapter.isolation_model
+      def thread_isolated? = isolation_model == :scoped
+
+      def diagnostic_identity = adapter.current_db
+
+      def prepare(target)
+        validate_target!(target)
+        db = coerce_db(target)
+        return if target.nil? || (adapter.selectable? && adapter.db_readable?)
+
+        raise UnsupportedBackendError, unsupported_message(db)
       end
 
-      def available? = defined?(Redis)
+      def snapshot = { db: adapter.current_db }
 
-      def diagnostics
-        redis = self.class.redis_client if available?
-        return unavailable_diagnostics('Redis') unless redis
+      def connect!(target)
+        db = coerce_db(target)
+        return unless adapter.movable_to?(db)
 
-        perform_diagnostics(redis)
-      rescue StandardError => e
-        error_diagnostics('Redis', e)
+        Output.print_info(switch_message(db))
+        warn_process_global
+        apply(db)
+      end
+
+      def verify!(target)
+        expected = coerce_db(target)
+        actual = adapter.current_db
+        return true if (actual || DEFAULT_REDIS_DB) == expected
+
+        raise verification_error(expected, actual)
+      end
+
+      def restore(state)
+        db = state && state[:db]
+        return unless db && adapter.current_db != db
+
+        apply(db)
       end
 
       private
 
-      def perform_diagnostics(redis)
+      def basic_diagnostics
+        {
+          name: display_name, status: adapter.selectable? ? :connected : :unknown, latency_ms: nil,
+          details: { db: resolved_db, isolation: isolation_model }
+        }
+      end
+
+      def full_diagnostics
+        redis = adapter.client
+        return basic_diagnostics unless redis
+
         latency = measure_latency { redis.ping }
-        info = redis.info
-        build_redis_diagnostics(info['redis_version'], info['used_memory_human'], latency)
+        connected_diagnostics(latency, redis.info)
       end
 
-      def build_redis_diagnostics(version, memory, latency)
+      def connected_diagnostics(latency, info)
         {
-          name: 'Redis',
-          status: :connected,
-          latency_ms: latency,
-          details: {
-            db: context_attribute(:tenant_redis_db) || DEFAULT_REDIS_DB,
-            version: version,
-            memory: memory
-          }
+          name: display_name, status: :connected, latency_ms: latency,
+          details: { db: resolved_db, version: info['redis_version'], memory: info['used_memory_human'] }
         }
       end
 
-      def select_redis_db(db_index)
-        klass = self.class
-        redis = klass.redis_client
-        if redis
-          redis.select(db_index)
-        elsif defined?(RedisClient) && db_index != DEFAULT_REDIS_DB
-          klass.warn_no_auto_select(db_index)
-        end
-      rescue NoMethodError
-        Output.print_warning('Redis.current is not available (deprecated in Redis v5+).')
+      def apply(db)
+        adapter.select(db)
+      rescue ConsoleKit::Error
+        raise
+      rescue StandardError => e
+        raise ConnectionError.new("#{display_name} SELECT #{db} failed: #{scrub(e.message)}",
+                                  backend: display_name, operation: :connect)
+      end
+
+      def warn_process_global
+        return unless isolation_model == :process_global
+
+        handler_class = self.class
+        return if handler_class.isolation_warned
+
+        handler_class.isolation_warned = true
+        Output.print_warning(PROCESS_GLOBAL_WARNING)
+      end
+
+      def coerce_db(target)
+        return DEFAULT_REDIS_DB if target.nil?
+
+        RedisClientAdapter.db_index(target) ||
+          raise(ConfigurationError, "ConsoleKit: Redis DB #{scrub(target.inspect)} is not a non-negative integer.")
       end
 
-      def switch_message(db_index)
-        db_index ? "Switching to Redis DB: #{db_index}" : 'Resetting Redis connection to default'
+      def unsupported_message(db)
+        "#{display_name} DB #{db} was requested but this client exposes no connection that can be selected and " \
+          "verified without a round-trip (isolation model: #{isolation_model}). " \
+          'Point each tenant at its own Redis URL instead.'
       end
+
+      def switch_message(db)
+        db == DEFAULT_REDIS_DB ? 'Resetting Redis connection to default' : "Switching to Redis DB: #{db}"
+      end
+
+      def resolved_db = adapter.current_db || coerce_db(target)
+      def adapter = @adapter ||= RedisClientAdapter.new
     end
   end
 end