console_kit 1.4.0 → 1.5.1

data/lib/console_kit/tenant_orchestrator.rb

@@ -1,28 +1,35 @@
 # frozen_string_literal: true
 
+require_relative 'tenant_state'
+require_relative 'tenant_selector'
+require_relative 'tenant_configurator'
+require_relative 'output'
+require_relative 'setup_ui'
+
 module ConsoleKit
-  # Orchestrates tenant lifecycle, selection, and configuration
   class TenantOrchestrator
+    NO_TENANT_SELECTED = 'No tenant selected. Loading without tenant configuration.'
+
     class << self
       def auto_select? = (tenants.size == 1) || !$stdin.tty?
 
-      def current_tenant = Setup.current_tenant
+      def current_tenant = StateStore.tenant_key
 
       def current_tenant=(val)
-        Setup.current_tenant = val
+        return if StateStore.tenant_key == val
+
+        val.nil? ? StateStore.clear! : StateStore.current = TenantState.new(tenant_key: val)
       end
 
       def reapply
-        return unless tenant_setup_successful?
-
-        Output.silence do
-          TenantConfigurator.current_tenant_key = nil
-          TenantConfigurator.configure_tenant(current_tenant)
-        end
+        key = current_tenant
+        Output.silence { TenantSwitch.call(key) } if tenant_setup_successful?
+      rescue StandardError => e
+        Output.print_error("Failed to reapply tenant '#{key}': #{scrub(e.message)}")
       end
 
       def reset
-        return warn_no_tenants unless tenants?
+        return Output.print_warning('Cannot reset tenant: No tenants configured.') unless tenants?
 
         perform_reset
       end
@@ -38,9 +45,6 @@ module ConsoleKit
       def tenants = ConsoleKit.configuration.tenants
       def tenants? = tenants&.any?
       def select_tenant_key = auto_select? ? tenants.keys.first : TenantSelector.select
-      def warn_no_tenants = Output.print_warning('Cannot reset tenant: No tenants configured.')
-      def cancel_switch = Output.print_warning('Tenant switch cancelled.')
-      def skip_tenant_message = Output.print_info('No tenant selected. Loading without tenant configuration.')
 
       private
 
@@ -48,13 +52,17 @@ module ConsoleKit
 
       def perform_reset
         key = select_tenant_key
-        return cancel_switch if key == :abort || key.blank?
-        return already_on_tenant?(key) if key == current_tenant
+        return Output.print_warning('Tenant switch cancelled.') if key == :abort || key.blank?
+        return Output.print_info("Already using tenant: #{key}. No changes made.") if key == current_tenant
 
-        clear_current_tenant
-        return skip_tenant_message if %i[exit none].include?(key)
+        apply_reset(key)
+      end
 
-        configure(key)
+      def apply_reset(key)
+        return configure(key) unless %i[exit none].include?(key)
+
+        clear_current_tenant
+        Output.print_info(NO_TENANT_SELECTED)
       end
 
       def perform_setup
@@ -68,7 +76,7 @@ module ConsoleKit
       def handle_selection_result(key)
         exit_on_key if %i[exit abort].include?(key)
 
-        skip_tenant_message if key == :none
+        Output.print_info(NO_TENANT_SELECTED) if key == :none
         Output.print_error('Tenant selection failed. Loading without tenant configuration.') if key.blank?
       end
 
@@ -81,16 +89,10 @@ module ConsoleKit
         TenantConfigurator.configure_tenant(key)
         return unless TenantConfigurator.configuration_success
 
-        Setup.current_tenant = key
-        Prompt.apply
+        self.current_tenant = key
         SetupUI.print_tenant_banner(key, ConsoleKit.configuration)
       end
 
-      def already_on_tenant?(key)
-        Output.print_info("Already using tenant: #{key}. No changes made.")
-        true
-      end
-
       def clear_current_tenant
         if current_tenant
           Output.print_warning("Resetting tenant: #{current_tenant}")
@@ -100,9 +102,11 @@ module ConsoleKit
       end
 
       def handle_error(error)
-        Output.print_error("Error setting up tenant: #{error.message}")
+        Output.print_error("Error setting up tenant: #{scrub(error.message)}")
         Output.print_backtrace(error)
       end
+
+      def scrub(message) = Connections::DiagnosticHelpers.scrub(message)
     end
   end
 end

data/lib/console_kit/tenant_plan.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require_relative 'errors'
+
+module ConsoleKit
+  class TenantPlan
+    REQUIRED_KEYS = %i[shard partner_code].freeze
+
+    attr_reader :tenant_key
+
+    def initialize(tenant_key, constants: nil)
+      @tenant_key = tenant_key
+      @constants = constants
+    end
+
+    def constants = @constants ||= resolve_constants
+
+    def targets_for(handlers)
+      handlers.to_h { |handler| [handler.backend_key, target_for(handler)] }
+    end
+
+    private
+
+    def target_for(handler) = constants[handler.class.constants_key]
+
+    def resolve_constants
+      return {} if tenant_key.nil?
+
+      found = lookup_constants
+      raise TenantNotFoundError, not_found_message unless found
+
+      validate!(found)
+      found
+    end
+
+    def not_found_message
+      tenants = ConsoleKit.configuration.tenants
+      keys = tenants.is_a?(Hash) ? tenants.keys : []
+      known = keys.any? ? "Configured tenants: #{keys.map(&:inspect).join(', ')}." : 'No tenants are configured.'
+      "No configuration found for tenant: #{tenant_key.inspect}. #{known}"
+    end
+
+    def lookup_constants
+      tenants = ConsoleKit.configuration.tenants
+      entry = tenants.is_a?(Hash) ? tenants[tenant_key] : nil
+      constants_from(entry) unless entry.nil?
+    end
+
+    def constants_from(entry)
+      raise ConfigurationError, "Tenant #{tenant_key.inspect} configuration must be a Hash, got #{entry.class}." \
+        unless entry.is_a?(Hash)
+
+      entry[:constants]
+    end
+
+    def validate!(constants)
+      tenant = tenant_key.inspect
+      unless constants.is_a?(Hash)
+        raise ConfigurationError, "Tenant #{tenant} `:constants` must be a Hash, got #{constants.class}."
+      end
+
+      missing = REQUIRED_KEYS - constants.keys
+      return if missing.empty?
+
+      raise ConfigurationError, "Tenant #{tenant} constants missing keys: #{missing.join(', ')}"
+    end
+  end
+end

data/lib/console_kit/tenant_rollback.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require_relative 'instrumentation'
+
+module ConsoleKit
+  class TenantRollback
+    EVENT = 'console_kit.rollback'
+    MISSING_HANDLER = 'no connection handler is available to restore it, so it may still be serving the tenant ' \
+                      'that was being unwound'
+
+    class << self
+      def unwind(state, previous)
+        failures = restore(state, state.context_object || ConsoleKit.configuration.context_class)
+        StateStore.current = previous
+        raise RollbackError, failures unless failures.empty?
+
+        previous
+      end
+
+      private
+
+      def restore(state, ctx)
+        wrapper = TenantConfigurator::ContextWrapper.new(ctx, state.undo_context.keys)
+        live, missing = resolve_handlers(state, ctx)
+        new(state.undo, wrapper).call(live, missing)
+      end
+
+      def resolve_handlers(state, ctx)
+        live = Connections::ConnectionManager.available_handlers(ctx)
+                                             .to_h { |handler| [handler.backend_key, handler] }
+        present, missing = state.undo_backends.keys.partition { |key| live.key?(key) }
+        [live.values_at(*present), missing]
+      end
+    end
+
+    def initialize(undo, context_wrapper)
+      @undo = undo
+      @context_wrapper = context_wrapper
+    end
+
+    def call(handlers, unrestorable = [])
+      return [] if undo.nil?
+
+      Instrumentation.increment(EVENT)
+      abandoned(unrestorable) + restore_backends(handlers) + restore_context
+    end
+
+    private
+
+    attr_reader :undo, :context_wrapper
+
+    def abandoned(keys)
+      keys.map { |key| failure(key, UnsupportedBackendError.new("ConsoleKit: #{key} - #{MISSING_HANDLER}.")) }
+    end
+
+    def restore_backends(handlers)
+      handlers.reverse.filter_map do |handler|
+        handler.restore(undo[:backends][handler.backend_key])
+        nil
+      rescue StandardError, NotImplementedError => e
+        failure(handler.display_name, e)
+      end
+    end
+
+    def restore_context
+      context_wrapper.restore(undo[:context])
+      []
+    rescue StandardError, NotImplementedError => e
+      [failure('context', e)]
+    end
+
+    def failure(backend, error)
+      Instrumentation.increment('console_kit.rollback_failure')
+      { backend: backend, error: error }
+    end
+  end
+end

data/lib/console_kit/tenant_selector.rb

@@ -3,7 +3,6 @@
 require_relative 'output'
 
 module ConsoleKit
-  # For tenant selection
   module TenantSelector
     RETRY_LIMIT = 3
     DEFAULT_SELECTION = '1'
@@ -37,12 +36,10 @@ module ConsoleKit
       end
 
       def menu_items
-        tenants = ConsoleKit.tenants.keys
-        items = ['0. Skip (load without tenant configuration)']
-        tenants.each_with_index.map do |key, index|
-          items << "#{index + 1}. #{key} (partner: #{tenant_partner(key)})"
+        numbered = ConsoleKit.tenants.keys.map.with_index(1) do |key, index|
+          "#{index}. #{key} (partner: #{tenant_partner(key)})"
         end
-        items
+        ['0. Skip (load without tenant configuration)'] + numbered
       end
 
       def tenant_partner(key) = ConsoleKit.tenants.dig(key, :constants, :partner_code) || 'N/A'

data/lib/console_kit/tenant_state.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module ConsoleKit
+  class TenantState
+    NO_DROPPED = [].freeze
+    EMPTY_UNDO = { context: {}.freeze, backends: {}.freeze, dropped: NO_DROPPED, context_object: nil }.freeze
+
+    attr_reader :tenant_key, :constants, :undo
+
+    module OwnCopy
+      class << self
+        def call(value)
+          case value
+          when Hash then value.transform_values { |entry| call(entry) }.freeze
+          when Array then value.map { |entry| call(entry) }.freeze
+          else value
+          end
+        end
+      end
+    end
+
+    class << self
+      def empty = new
+
+      def undo_bundle(context:, backends:, dropped: NO_DROPPED, context_object: nil)
+        { context: OwnCopy.call(context), backends: OwnCopy.call(backends),
+          dropped: OwnCopy.call(dropped), context_object: context_object }.freeze
+      end
+    end
+
+    def initialize(tenant_key: nil, constants: {}, undo: EMPTY_UNDO, configured: false)
+      @tenant_key = tenant_key
+      @configured = configured
+      @constants = OwnCopy.call(constants)
+      @undo = undo
+      freeze
+    end
+
+    def configured? = @configured
+    def undo_context = @undo[:context]
+    def undo_backends = @undo[:backends]
+
+    def context_object = @undo[:context_object]
+
+    def dropped_backends = @undo[:dropped] || NO_DROPPED
+    def snapshot_for(backend) = @undo[:backends][backend]
+
+    def backends_missing_from(live) = @undo[:backends].keys - live
+
+    def inspect = "#<ConsoleKit::TenantState #{@tenant_key.inspect} backends=#{@undo[:backends].keys.inspect}>"
+  end
+
+  module StateStore
+    STATE_KEY = :console_kit_state
+
+    class << self
+      def current = stored || TenantState.empty
+
+      def stored = Thread.current.thread_variable_get(STATE_KEY)
+
+      def current=(state)
+        Thread.current.thread_variable_set(STATE_KEY, state)
+      end
+
+      def tenant_key = current.tenant_key
+      def configured? = current.configured?
+
+      def clear!
+        Thread.current.thread_variable_set(STATE_KEY, nil)
+      end
+    end
+  end
+end

data/lib/console_kit/tenant_switch.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+require_relative 'errors'
+require_relative 'tenant_state'
+require_relative 'instrumentation'
+require_relative 'tenant_rollback'
+require_relative 'tenant_plan'
+require_relative 'connections/connection_manager'
+
+module ConsoleKit
+  class TenantSwitch
+    EVENT = 'console_kit.tenant_switch'
+
+    class << self
+      def call(tenant_key) = new(tenant_key).call
+
+      def clear(context: nil) = new(nil, context: context).call
+
+      def verify_current!(dropped = nil)
+        state = StateStore.current
+        raise ConfigurationError, 'No tenant is currently configured.' unless state.configured?
+
+        new(state.tenant_key).send(:verify_committed, state, dropped)
+        state
+      end
+
+      def unwind(state, previous) = TenantRollback.unwind(state, previous)
+    end
+
+    def initialize(tenant_key, context: nil)
+      @tenant_key = tenant_key
+      @context = context || ConsoleKit.configuration.context_class
+      @failing_handler = nil
+      @dropped_backends = []
+      @handlers = []
+    end
+
+    def call
+      Instrumentation.instrument(EVENT, tenant: @tenant_key, from: StateStore.tenant_key) { perform }
+    end
+
+    private
+
+    attr_reader :tenant_key, :context
+
+    def perform
+      plan = TenantPlan.new(tenant_key)
+      @handlers = Connections::ConnectionManager.available_handlers(context, @dropped_backends)
+      targets = plan.targets_for(@handlers)
+      prepare_all(targets)
+      run_transaction(plan.constants, targets, snapshot_state)
+    end
+
+    def prepare_all(targets)
+      @handlers.each { |handler| handler.prepare(targets[handler.backend_key]) }
+    end
+
+    def snapshot_state
+      snapshots = @handlers.to_h { |handler| [handler.backend_key, handler.snapshot] }
+      TenantState.undo_bundle(context: context_wrapper.current_values, backends: snapshots,
+                              dropped: @dropped_backends, context_object: context)
+    rescue StandardError, NotImplementedError => e
+      raise switch_error(e)
+    end
+
+    def run_transaction(constants, targets, undo)
+      attempted = []
+      apply(constants, targets, attempted)
+      commit(constants, undo)
+    rescue StandardError, NotImplementedError => e
+      raise switch_error(e, TenantRollback.new(undo, context_wrapper).call(attempted))
+    end
+
+    def apply(constants, targets, attempted)
+      context_wrapper.assign(constants, TenantConfigurator.context_mapping)
+      connect_all(targets, attempted)
+      verify_all(attempted, targets)
+    end
+
+    def connect_all(targets, attempted)
+      @handlers.each do |handler|
+        attempted << handler
+        instrument_backend('console_kit.backend_connect', handler) { handler.connect!(targets[handler.backend_key]) }
+      end
+    end
+
+    def verify_all(handlers, targets)
+      handlers.each { |handler| verify_one(handler, targets[handler.backend_key]) }
+    end
+
+    def verify_one(handler, target)
+      instrument_backend('console_kit.backend_verify', handler) { handler.verify!(target) }
+    rescue ConnectionVerificationError => e
+      Instrumentation.increment('console_kit.verification_failure')
+      raise e
+    end
+
+    def instrument_backend(event, handler, &)
+      @failing_handler = handler
+      Instrumentation.instrument(event, backend: handler.backend_key, tenant: tenant_key, &)
+    end
+
+    def commit(constants, undo)
+      StateStore.current = TenantState.new(tenant_key: tenant_key, constants: constants, undo: undo,
+                                           configured: !tenant_key.nil?)
+    end
+
+    def switch_error(error, rollback_failures = [])
+      TenantSwitchError.new(
+        from_tenant: StateStore.tenant_key, to_tenant: tenant_key, original_error: error,
+        backend: error.try(:backend) || @failing_handler&.display_name, rollback_failures: rollback_failures
+      )
+    end
+
+    def verify_committed(state, dropped = nil)
+      handlers = Connections::ConnectionManager.available_handlers(context, dropped)
+      dropped&.concat(state.backends_missing_from(handlers.map(&:backend_key)) - dropped)
+      verify_all(handlers, TenantPlan.new(state.tenant_key, constants: state.constants).targets_for(handlers))
+      nil
+    end
+
+    def context_wrapper = @context_wrapper ||= TenantConfigurator::ContextWrapper.for_context(context)
+  end
+end

data/lib/console_kit/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ConsoleKit
-  VERSION = '1.4.0'
+  VERSION = '1.5.1'
 end

data/lib/console_kit.rb

@@ -1,20 +1,28 @@
 # frozen_string_literal: true
 
+require 'English'
+require 'logger'
+require 'active_support'
 require 'active_support/core_ext/object/blank'
-require 'active_support/core_ext/object/inclusion'
+require 'active_support/core_ext/object/try'
 require 'active_support/core_ext/string/inflections'
+require 'active_support/core_ext/time/calculations'
 
 require_relative 'console_kit/version'
+require_relative 'console_kit/errors'
+require_relative 'console_kit/tenant_state'
+require_relative 'console_kit/instrumentation'
 require_relative 'console_kit/configuration'
+require_relative 'console_kit/tenant_orchestrator'
 require_relative 'console_kit/setup'
 require_relative 'console_kit/console_helpers'
 require_relative 'console_kit/prompt'
 require_relative 'console_kit/railtie' if defined?(Rails::Railtie)
 
-# Main module for ConsoleKit
 module ConsoleKit
-  # Base error class for ConsoleKit-related exceptions.
-  class Error < StandardError; end
+  INCOMPLETE_VERIFICATION = 'ConsoleKit: tenant %<tenant>p is verified only for the backends ConsoleKit could ' \
+                            'drive. Never switched, verified or rolled back, and possibly still serving another ' \
+                            'tenant: %<backends>s.'
 
   class << self
     def configure = yield(configuration)
@@ -22,37 +30,56 @@ module ConsoleKit
 
     def reset_configuration!
       @configuration = nil
-      Setup.current_tenant = nil
-      TenantConfigurator.configuration_success = false if defined?(TenantConfigurator)
-    end
-
-    def pretty_output = configuration.pretty_output
-
-    def pretty_output=(val)
-      configuration.pretty_output = val
+      StateStore.clear!
     end
 
     def tenants = configuration.tenants
 
-    def tenants=(val)
-      configuration.tenants = val
-    end
+    def current_tenant = StateStore.tenant_key
+    def reset_current_tenant = TenantOrchestrator.reset
 
-    def context_class = configuration.context_class
+    def switch_tenant(key) = TenantSwitch.call(key)
 
-    def context_class=(val)
-      configuration.context_class = val
+    def verify_tenant!
+      dropped_now = []
+      state = TenantSwitch.verify_current!(dropped_now)
+      report_dropped_backends(state, dropped_now)
+      state
     end
 
-    def show_dashboard = configuration.show_dashboard
-
-    def show_dashboard=(val)
-      configuration.show_dashboard = val
+    def with_tenant(key, &)
+      previous = StateStore.current
+      state = TenantSwitch.call(key)
+      unwind_after(state, previous, &)
     end
 
-    def current_tenant = Setup.current_tenant
-    def reset_current_tenant = Setup.reset_current_tenant
     def enable_pretty_output = configuration.pretty_output = true
     def disable_pretty_output = configuration.pretty_output = false
+
+    private
+
+    def report_dropped_backends(state, dropped_now)
+      dropped = state.dropped_backends | dropped_now
+      return if dropped.empty?
+
+      Instrumentation.increment('console_kit.incomplete_verification')
+      Output.print_warning(format(INCOMPLETE_VERIFICATION, tenant: state.tenant_key, backends: dropped.join(', ')))
+    end
+
+    def unwind_after(state, previous)
+      completed = false
+      yield.tap { completed = true }
+    ensure
+      unwind_scope(state, previous, completed ? nil : $ERROR_INFO)
+    end
+
+    def unwind_scope(state, previous, in_flight)
+      TenantSwitch.unwind(state, previous)
+    rescue RollbackError => e
+      raise e unless in_flight
+
+      Output.print_error("#{e.message}\nThis rollback failure did not replace the in-flight " \
+                         "#{in_flight.class}: #{in_flight.message}")
+    end
   end
 end

data/lib/generators/console_kit/install_generator.rb

@@ -5,22 +5,11 @@ require 'rails/generators/base'
 
 module ConsoleKit
   module Generators
-    # Generates the required files
     class InstallGenerator < Rails::Generators::Base
       source_root File.expand_path('templates', __dir__)
 
-      class_option :force, type: :boolean, default: false, desc: 'Overwrite existing files'
-
       def copy_initializer
-        force = options[:force]
-        initializer_path = Rails.root.join('config', 'initializers', 'console_kit.rb')
-
-        if File.exist?(initializer_path) && !force
-          say_status :skipped, "Initializer already exists: #{initializer_path}", :yellow
-        else
-          template 'console_kit.rb', 'config/initializers/console_kit.rb', force: force
-          say_status :created, "Initializer generated at #{initializer_path}", :green
-        end
+        template 'console_kit.rb', 'config/initializers/console_kit.rb'
       end
 
       def remind_about_customization

data/lib/generators/console_kit/templates/console_kit.rb

@@ -6,6 +6,10 @@
 Rails.application.config.after_initialize do
   ConsoleKit.configure do |config|
     # TODO: Set your tenants source, example:
+    # `shard` and `partner_code` are required for every tenant; `mongo_db`, `redis_db` and
+    # `elasticsearch_prefix` are optional. Extra keys (like `environment` below) are fine -
+    # they're just not read by ConsoleKit - but `config.validate!` will warn about them in
+    # case they're actually a typo of one of the keys above.
     # {
     #   tenant_a: {
     #     constants: {