janus-ar 0.15.2 → 7.2.0

data/lib/{active_record → janus-ar/active_record}/connection_adapters/janus_trilogy_adapter.rb

@@ -1,144 +1,148 @@
-# frozen_string_literal: true
-
-require 'active_record/connection_adapters/abstract_adapter'
-require 'active_record/connection_adapters/trilogy_adapter'
-require_relative '../../janus'
-
-module ActiveRecord
-  module ConnectionHandling
-    def janus_trilogy_connection(config)
-      ActiveRecord::ConnectionAdapters::JanusTrilogyAdapter.new(config)
-    end
-  end
-end
-
-module ActiveRecord
-  class Base
-    def self.janus_trilogy_adapter_class
-      ActiveRecord::ConnectionAdapters::JanusTrilogyAdapter
-    end
-  end
-end
-
-module ActiveRecord
-  module ConnectionAdapters
-    class JanusTrilogyAdapter < ActiveRecord::ConnectionAdapters::TrilogyAdapter
-      FOUND_ROWS = 'FOUND_ROWS'
-
-      attr_reader :config
-
-      class << self
-        def dbconsole(config, options = {})
-          connection_config = Janus::DbConsoleConfig.new(config)
-
-          super(connection_config, options)
-        end
-      end
-
-      def initialize(*args)
-        args[0][:janus]['replica']['database'] = args[0][:database]
-        args[0][:janus]['primary']['database'] = args[0][:database]
-
-        @replica_config = args[0][:janus]['replica'].symbolize_keys
-        args[0] = args[0][:janus]['primary'].symbolize_keys
-
-        super(*args)
-        @connection_parameters ||= args[0]
-        update_config
-      end
-
-      def raw_execute(sql, name, async: false, allow_retry: false, materialize_transactions: true)
-        case where_to_send?(sql)
-        when :all
-          send_to_replica(sql, connection: :all, method: :execute)
-          super
-        when :replica
-          send_to_replica(sql, connection: :replica, method: :execute)
-        else
-          Janus::Context.stick_to_primary if write_query?(sql)
-          Janus::Context.used_connection(:primary)
-          super
-        end
-      end
-
-      def execute(sql)
-        case where_to_send?(sql)
-        when :all
-          send_to_replica(sql, connection: :all, method: :execute)
-          super(sql)
-        when :replica
-          send_to_replica(sql, connection: :replica, method: :execute)
-        else
-          Janus::Context.stick_to_primary if write_query?(sql)
-          Janus::Context.used_connection(:primary)
-          super(sql)
-        end
-      end
-
-      def execute_and_free(sql, name = nil, async: false)
-        case where_to_send?(sql)
-        when :all
-          send_to_replica(sql, connection: :all, method: :execute)
-          super(sql, name, async:)
-        when :replica
-          send_to_replica(sql, connection: :replica, method: :execute)
-        else
-          Janus::Context.stick_to_primary if write_query?(sql)
-          Janus::Context.used_connection(:primary)
-          super(sql, name, async:)
-        end
-      end
-
-      def connect!(...)
-        replica_connection.connect!(...)
-        super
-      end
-
-      def reconnect!(...)
-        replica_connection.reconnect!(...)
-        super
-      end
-
-      def disconnect!(...)
-        replica_connection.disconnect!(...)
-        super
-      end
-
-      def clear_cache!(...)
-        replica_connection.clear_cache!(...)
-        super
-      end
-
-      def replica_connection
-        @replica_connection ||= ActiveRecord::ConnectionAdapters::TrilogyAdapter.new(@replica_config)
-      end
-
-      private
-
-      def where_to_send?(sql)
-        Janus::QueryDirector.new(sql, open_transactions).where_to_send?
-      end
-
-      def send_to_replica(sql, connection: nil, method: :exec_query)
-        Janus::Context.used_connection(connection) if connection
-        if method == :execute
-          replica_connection.execute(sql)
-        elsif method == :raw_execute
-          replica_connection.execute(sql)
-        else
-          replica_connection.exec_query(sql)
-        end
-      end
-
-      def update_config
-        @config[:flags] ||= 0
-
-        if @config[:flags].is_a? Array
-          @config[:flags].push FOUND_ROWS
-        else
-          @config[:flags] |= ::Janus::Client::FOUND_ROWS
-        end
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+require 'active_record/connection_adapters/abstract_adapter'
+require 'active_record/connection_adapters/trilogy_adapter'
+require_relative '../../../janus-ar'
+
+module ActiveRecord
+  module ConnectionHandling
+    def janus_trilogy_connection(config)
+      ActiveRecord::ConnectionAdapters::JanusTrilogyAdapter.new(config)
+    end
+  end
+end
+
+module ActiveRecord
+  class Base
+    def self.janus_trilogy_adapter_class
+      ActiveRecord::ConnectionAdapters::JanusTrilogyAdapter
+    end
+  end
+end
+
+module ActiveRecord
+  module ConnectionAdapters
+    class JanusTrilogyAdapter < ActiveRecord::ConnectionAdapters::TrilogyAdapter
+      FOUND_ROWS = 'FOUND_ROWS'
+
+      attr_reader :config
+
+      class << self
+        def dbconsole(config, options = {})
+          connection_config = Janus::DbConsoleConfig.new(config)
+
+          super(connection_config, options)
+        end
+      end
+
+      def initialize(*args)
+        args[0][:janus]['replica']['database'] = args[0][:database]
+        args[0][:janus]['primary']['database'] = args[0][:database]
+
+        @replica_config = args[0][:janus]['replica'].symbolize_keys
+        args[0] = args[0][:janus]['primary'].symbolize_keys
+
+        super(*args)
+        @connection_parameters ||= args[0]
+        update_config
+      end
+
+      def raw_execute(sql, name, async: false, allow_retry: false, materialize_transactions: true)
+        case where_to_send?(sql)
+        when :all
+          send_to_replica(sql, connection: :all, method: :execute)
+          super
+        when :replica
+          send_to_replica(sql, connection: :replica, method: :execute)
+        else
+          Janus::Context.stick_to_primary if write_query?(sql)
+          Janus::Context.used_connection(:primary)
+          super
+        end
+      end
+
+      def execute(sql)
+        case where_to_send?(sql)
+        when :all
+          send_to_replica(sql, connection: :all, method: :execute)
+          super(sql)
+        when :replica
+          send_to_replica(sql, connection: :replica, method: :execute)
+        else
+          Janus::Context.stick_to_primary if write_query?(sql)
+          Janus::Context.used_connection(:primary)
+          super(sql)
+        end
+      end
+
+      def execute_and_free(sql, name = nil, async: false)
+        case where_to_send?(sql)
+        when :all
+          send_to_replica(sql, connection: :all, method: :execute)
+          super(sql, name, async:)
+        when :replica
+          send_to_replica(sql, connection: :replica, method: :execute)
+        else
+          Janus::Context.stick_to_primary if write_query?(sql)
+          Janus::Context.used_connection(:primary)
+          super(sql, name, async:)
+        end
+      end
+
+      def with_connection(_args = {})
+        self
+      end
+
+      def connect!(...)
+        replica_connection.connect!(...)
+        super
+      end
+
+      def reconnect!(...)
+        replica_connection.reconnect!(...)
+        super
+      end
+
+      def disconnect!(...)
+        replica_connection.disconnect!(...)
+        super
+      end
+
+      def clear_cache!(...)
+        replica_connection.clear_cache!(...)
+        super
+      end
+
+      def replica_connection
+        @replica_connection ||= ActiveRecord::ConnectionAdapters::TrilogyAdapter.new(@replica_config)
+      end
+
+      private
+
+      def where_to_send?(sql)
+        Janus::QueryDirector.new(sql, open_transactions).where_to_send?
+      end
+
+      def send_to_replica(sql, connection: nil, method: :exec_query)
+        Janus::Context.used_connection(connection) if connection
+        if method == :execute
+          replica_connection.execute(sql)
+        elsif method == :raw_execute
+          replica_connection.execute(sql)
+        else
+          replica_connection.exec_query(sql)
+        end
+      end
+
+      def update_config
+        @config[:flags] ||= 0
+
+        if @config[:flags].is_a? Array
+          @config[:flags].push FOUND_ROWS
+        else
+          @config[:flags] |= ::Janus::Client::FOUND_ROWS
+        end
+      end
+    end
+  end
+end

data/lib/{janus → janus-ar}/client.rb

@@ -1,6 +1,6 @@
-# frozen_string_literal: true
-module Janus
-  class Client
-    FOUND_ROWS = 2
-  end
-end
+# frozen_string_literal: true
+module Janus
+  class Client
+    FOUND_ROWS = 2
+  end
+end

data/lib/{janus → janus-ar}/context.rb

@@ -1,80 +1,80 @@
-# frozen_string_literal: true
-
-module Janus
-  class Context
-    THREAD_KEY = :janus_ar_context
-
-    # Stores the staged data with an expiration time based on the current time,
-    # and clears any expired entries. Returns true if any changes were made to
-    # the current store
-    def initialize(primary: false, expiry: nil)
-      @primary = primary
-      @expiry = expiry
-      @last_used_connection = :primary
-    end
-
-    def stick_to_primary
-      @primary = true
-    end
-
-    def potential_write
-      stick_to_primary
-    end
-
-    def release_all
-      @primary = false
-      @expiry = nil
-      @last_used_connection = nil
-    end
-
-    def use_primary?
-      @primary
-    end
-
-    def used_connection(connection)
-      @last_used_connection = connection
-    end
-
-    attr_reader :last_used_connection
-
-    class << self
-      def stick_to_primary
-        current.stick_to_primary
-      end
-
-      def release_all
-        current.release_all
-      end
-
-      def used_connection(connection)
-        current.used_connection(connection)
-      end
-
-      def use_primary?
-        current.use_primary?
-      end
-
-      def last_used_connection
-        current.last_used_connection
-      end
-
-      protected
-
-      def current
-        fetch(THREAD_KEY) { new }
-      end
-
-      def fetch(key)
-        get(key) || set(key, yield)
-      end
-
-      def get(key)
-        Thread.current.thread_variable_get(key)
-      end
-
-      def set(key, value)
-        Thread.current.thread_variable_set(key, value)
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Janus
+  class Context
+    THREAD_KEY = :janus_ar_context
+
+    # Stores the staged data with an expiration time based on the current time,
+    # and clears any expired entries. Returns true if any changes were made to
+    # the current store
+    def initialize(primary: false, expiry: nil)
+      @primary = primary
+      @expiry = expiry
+      @last_used_connection = :primary
+    end
+
+    def stick_to_primary
+      @primary = true
+    end
+
+    def potential_write
+      stick_to_primary
+    end
+
+    def release_all
+      @primary = false
+      @expiry = nil
+      @last_used_connection = nil
+    end
+
+    def use_primary?
+      @primary
+    end
+
+    def used_connection(connection)
+      @last_used_connection = connection
+    end
+
+    attr_reader :last_used_connection
+
+    class << self
+      def stick_to_primary
+        current.stick_to_primary
+      end
+
+      def release_all
+        current.release_all
+      end
+
+      def used_connection(connection)
+        current.used_connection(connection)
+      end
+
+      def use_primary?
+        current.use_primary?
+      end
+
+      def last_used_connection
+        current.last_used_connection
+      end
+
+      protected
+
+      def current
+        fetch(THREAD_KEY) { new }
+      end
+
+      def fetch(key)
+        get(key) || set(key, yield)
+      end
+
+      def get(key)
+        Thread.current.thread_variable_get(key)
+      end
+
+      def set(key, value)
+        Thread.current.thread_variable_set(key, value)
+      end
+    end
+  end
+end

data/lib/{janus → janus-ar}/db_console_config.rb

@@ -1,17 +1,17 @@
-# frozen_string_literal: true
-
-module Janus
-  class DbConsoleConfig
-    def initialize(config)
-      @_config = config.configuration_hash
-    end
-
-    def configuration_hash
-      @_config[:janus]['replica'].symbolize_keys
-    end
-
-    def database
-      @_config[:database]
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Janus
+  class DbConsoleConfig
+    def initialize(config)
+      @_config = config.configuration_hash
+    end
+
+    def configuration_hash
+      @_config[:janus]['replica'].symbolize_keys
+    end
+
+    def database
+      @_config[:database]
+    end
+  end
+end

data/lib/{janus → janus-ar}/logging/logger.rb

@@ -1,15 +1,15 @@
-# frozen_string_literal: true
-
-module Janus
-  module Logging
-    class Logger
-      class << self
-        def log(message, format = :info)
-          logger&.send(format, "[Janus] #{message}")
-        end
-
-        attr_accessor :logger
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Janus
+  module Logging
+    class Logger
+      class << self
+        def log(message, format = :info)
+          logger&.send(format, "[Janus] #{message}")
+        end
+
+        attr_accessor :logger
+      end
+    end
+  end
+end

data/lib/{janus → janus-ar}/logging/subscriber.rb

@@ -1,27 +1,27 @@
-# frozen_string_literal: true
-
-module Janus
-  module Logging
-    module Subscriber
-      IGNORE_PAYLOAD_NAMES = %w(SCHEMA EXPLAIN).freeze
-
-      def sql(event)
-        name = event.payload[:name]
-        unless IGNORE_PAYLOAD_NAMES.include?(name)
-          name = [current_wrapper_name(event), name].compact.join(' ')
-          event.payload[:name] = name
-        end
-        super(event)
-      end
-
-      protected
-
-      def current_wrapper_name(_event)
-        connection = Janus::Context.last_used_connection
-        return nil unless connection
-
-        "[#{connection}]"
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Janus
+  module Logging
+    module Subscriber
+      IGNORE_PAYLOAD_NAMES = %w(SCHEMA EXPLAIN).freeze
+
+      def sql(event)
+        name = event.payload[:name]
+        unless IGNORE_PAYLOAD_NAMES.include?(name)
+          name = [current_wrapper_name(event), name].compact.join(' ')
+          event.payload[:name] = name
+        end
+        super(event)
+      end
+
+      protected
+
+      def current_wrapper_name(_event)
+        connection = Janus::Context.last_used_connection
+        return nil unless connection
+
+        "[#{connection}]"
+      end
+    end
+  end
+end