Move dbconsole logic to Active Record connection adapter.

Instead of hosting the connection logic in the command object, the
database adapter should be responsible for connecting to a console session.
This patch moves #find_cmd_and_exec to the adapter and exposes a new API to
lookup the adapter class without instantiating it.

Co-authored-by: Paarth Madan <[email protected]>

Author: gmcgibbon

activerecord/lib/active_record/connection_adapters/abstract_adapter.rb

@@ -89,6 +89,39 @@ def self.quoted_table_names # :nodoc:
         @quoted_table_names ||= {}
       end
 
+      def self.find_cmd_and_exec(commands, *args) # :doc:
+        commands = Array(commands)
+
+        dirs_on_path = ENV["PATH"].to_s.split(File::PATH_SEPARATOR)
+        unless (ext = RbConfig::CONFIG["EXEEXT"]).empty?
+          commands = commands.map { |cmd| "#{cmd}#{ext}" }
+        end
+
+        full_path_command = nil
+        found = commands.detect do |cmd|
+          dirs_on_path.detect do |path|
+            full_path_command = File.join(path, cmd)
+            begin
+              stat = File.stat(full_path_command)
+            rescue SystemCallError
+            else
+              stat.file? && stat.executable?
+            end
+          end
+        end
+
+        if found
+          exec full_path_command, *args
+        else
+          abort("Couldn't find database client: #{commands.join(', ')}. Check your $PATH and try again.")
+        end
+      end
+
+      # Opens a database console session.
+      def self.dbconsole(config, options = {})
+        raise NotImplementedError
+      end
+
       def initialize(config_or_deprecated_connection, deprecated_logger = nil, deprecated_connection_options = nil, deprecated_config = nil) # :nodoc:
         super()
 

activerecord/lib/active_record/connection_adapters/abstract_mysql_adapter.rb

@@ -51,6 +51,36 @@ def dealloc(stmt)
           end
       end
 
+      class << self
+        def dbconsole(config, options = {})
+          mysql_config = config.configuration_hash
+
+          args = {
+            host: "--host",
+            port: "--port",
+            socket: "--socket",
+            username: "--user",
+            encoding: "--default-character-set",
+            sslca: "--ssl-ca",
+            sslcert: "--ssl-cert",
+            sslcapath: "--ssl-capath",
+            sslcipher: "--ssl-cipher",
+            sslkey: "--ssl-key",
+            ssl_mode: "--ssl-mode"
+          }.filter_map { |opt, arg| "#{arg}=#{mysql_config[opt]}" if mysql_config[opt] }
+
+          if mysql_config[:password] && options[:include_password]
+            args << "--password=#{mysql_config[:password]}"
+          elsif mysql_config[:password] && !mysql_config[:password].to_s.empty?
+            args << "-p"
+          end
+
+          args << config.database
+
+          find_cmd_and_exec(["mysql", "mysql5"], *args)
+        end
+      end
+
       def get_database_version # :nodoc:
         full_version_string = get_full_version
         version_string = version_string(full_version_string)

activerecord/lib/active_record/connection_adapters/mysql2_adapter.rb

@@ -8,9 +8,13 @@
 
 module ActiveRecord
   module ConnectionHandling # :nodoc:
+    def mysql2_connection_class
+      ConnectionAdapters::Mysql2Adapter
+    end
+
     # Establishes a connection to the database that's used by all Active Record objects.
     def mysql2_connection(config)
-      ConnectionAdapters::Mysql2Adapter.new(config)
+      mysql2_connection_class.new(config)
     end
   end
 

activerecord/lib/active_record/connection_adapters/postgresql_adapter.rb

@@ -21,9 +21,13 @@
 
 module ActiveRecord
   module ConnectionHandling # :nodoc:
+    def postgresql_connection_class
+      ConnectionAdapters::PostgreSQLAdapter
+    end
+
     # Establishes a connection to the database that's used by all Active Record objects
     def postgresql_connection(config)
-      ConnectionAdapters::PostgreSQLAdapter.new(config)
+      postgresql_connection_class.new(config)
     end
   end
 
@@ -72,6 +76,25 @@ def new_client(conn_params)
             raise ActiveRecord::ConnectionNotEstablished, error.message
           end
         end
+
+        def dbconsole(config, options = {})
+          pg_config = config.configuration_hash
+
+          ENV["PGUSER"]         = pg_config[:username] if pg_config[:username]
+          ENV["PGHOST"]         = pg_config[:host] if pg_config[:host]
+          ENV["PGPORT"]         = pg_config[:port].to_s if pg_config[:port]
+          ENV["PGPASSWORD"]     = pg_config[:password].to_s if pg_config[:password] && options[:include_password]
+          ENV["PGSSLMODE"]      = pg_config[:sslmode].to_s if pg_config[:sslmode]
+          ENV["PGSSLCERT"]      = pg_config[:sslcert].to_s if pg_config[:sslcert]
+          ENV["PGSSLKEY"]       = pg_config[:sslkey].to_s if pg_config[:sslkey]
+          ENV["PGSSLROOTCERT"]  = pg_config[:sslrootcert].to_s if pg_config[:sslrootcert]
+          if pg_config[:variables]
+            ENV["PGOPTIONS"] = pg_config[:variables].filter_map do |name, value|
+              "-c #{name}=#{value.to_s.gsub(/[ \\]/, '\\\\\0')}" unless value == ":default" || value == :default
+            end.join(" ")
+          end
+          find_cmd_and_exec("psql", config.database)
+        end
       end
 
       ##

activerecord/lib/active_record/connection_adapters/sqlite3_adapter.rb

@@ -15,8 +15,12 @@
 
 module ActiveRecord
   module ConnectionHandling # :nodoc:
+    def sqlite3_connection_class
+      ConnectionAdapters::SQLite3Adapter
+    end
+
     def sqlite3_connection(config)
-      ConnectionAdapters::SQLite3Adapter.new(config)
+      sqlite3_connection_class.new(config)
     end
   end
 
@@ -40,6 +44,16 @@ def new_client(config)
             raise
           end
         end
+
+        def dbconsole(config, options = {})
+          args = []
+
+          args << "-#{options[:mode]}" if options[:mode]
+          args << "-header" if options[:header]
+          args << File.expand_path(config.database, Rails.respond_to?(:root) ? Rails.root : nil)
+
+          find_cmd_and_exec("sqlite3", *args)
+        end
       end
 
       include SQLite3::Quoting

activerecord/lib/active_record/database_configurations/database_config.rb

@@ -17,6 +17,10 @@ def adapter_method
         "#{adapter}_connection"
       end
 
+      def adapter_class_method
+        "#{adapter}_connection_class"
+      end
+
       def host
         raise NotImplementedError
       end

activerecord/test/cases/adapters/mysql2/dbconsole_test.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "active_support/testing/method_call_assertions"
+
+module ActiveRecord
+  module ConnectionAdapters
+    class Mysql2DbConsoleTest < ActiveRecord::Mysql2TestCase
+      include ActiveSupport::Testing::MethodCallAssertions
+
+      def test_mysql
+        config = make_db_config(adapter: "mysql2", database: "db")
+
+        assert_find_cmd_and_exec_called_with([%w[mysql mysql5], "db"]) do
+          Mysql2Adapter.dbconsole(config)
+        end
+      end
+
+      def test_mysql_full
+        config = make_db_config(
+          adapter:   "mysql2",
+          database:  "db",
+          host:      "localhost",
+          port:      1234,
+          socket:    "socket",
+          username:  "user",
+          password:  "qwerty",
+          encoding:  "UTF-8",
+          sslca:     "/path/to/ca-cert.pem",
+          sslcert:   "/path/to/client-cert.pem",
+          sslcapath: "/path/to/cacerts",
+          sslcipher: "DHE-RSA-AES256-SHA",
+          sslkey:    "/path/to/client-key.pem",
+          ssl_mode:  "VERIFY_IDENTITY"
+        )
+
+        args = [
+          %w[mysql mysql5],
+          "--host=localhost",
+          "--port=1234",
+          "--socket=socket",
+          "--user=user",
+          "--default-character-set=UTF-8",
+          "--ssl-ca=/path/to/ca-cert.pem",
+          "--ssl-cert=/path/to/client-cert.pem",
+          "--ssl-capath=/path/to/cacerts",
+          "--ssl-cipher=DHE-RSA-AES256-SHA",
+          "--ssl-key=/path/to/client-key.pem",
+          "--ssl-mode=VERIFY_IDENTITY",
+          "-p", "db"
+        ]
+
+        assert_find_cmd_and_exec_called_with(args) do
+          Mysql2Adapter.dbconsole(config)
+        end
+      end
+
+      def test_mysql_include_password
+        config = make_db_config(adapter: "mysql2", database: "db", username: "user", password: "qwerty")
+
+        assert_find_cmd_and_exec_called_with([%w[mysql mysql5], "--user=user", "--password=qwerty", "db"]) do
+          Mysql2Adapter.dbconsole(config, include_password: true)
+        end
+      end
+
+      private
+        def make_db_config(config)
+          ActiveRecord::DatabaseConfigurations::HashConfig.new("test", "primary", config)
+        end
+
+        def assert_find_cmd_and_exec_called_with(args, &block)
+          assert_called_with(Mysql2Adapter, :find_cmd_and_exec, args, &block)
+        end
+    end
+  end
+end

activerecord/test/cases/adapters/postgresql/dbconsole_test.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "active_support/testing/method_call_assertions"
+
+module ActiveRecord
+  module ConnectionAdapters
+    class PostgresqlDbConsoleTest < ActiveRecord::PostgreSQLTestCase
+      include ActiveSupport::Testing::MethodCallAssertions
+
+      ENV_VARS = %w(PGUSER PGHOST PGPORT PGPASSWORD PGSSLMODE PGSSLCERT PGSSLKEY PGSSLROOTCERT PGOPTIONS)
+
+      def run(*)
+        preserve_pg_env do
+          super
+        end
+      end
+
+      def test_postgresql
+        config = make_db_config(adapter: "postgresql", database: "db")
+
+        assert_find_cmd_and_exec_called_with(["psql", "db"]) do
+          PostgreSQLAdapter.dbconsole(config)
+        end
+      end
+
+      def test_postgresql_full
+        config = make_db_config(
+          adapter: "postgresql",
+          database: "db",
+          username: "user",
+          password: "q1w2e3",
+          host: "host",
+          port: 5432,
+        )
+
+        assert_find_cmd_and_exec_called_with(["psql", "db"]) do
+          PostgreSQLAdapter.dbconsole(config)
+        end
+
+        assert_equal "user", ENV["PGUSER"]
+        assert_equal "host", ENV["PGHOST"]
+        assert_equal "5432", ENV["PGPORT"]
+        assert_not_equal "q1w2e3", ENV["PGPASSWORD"]
+      end
+
+      def test_postgresql_with_ssl
+        config = make_db_config(adapter: "postgresql", database: "db", sslmode: "verify-full", sslcert: "client.crt", sslkey: "client.key", sslrootcert: "root.crt")
+
+        assert_find_cmd_and_exec_called_with(["psql", "db"]) do
+          PostgreSQLAdapter.dbconsole(config)
+        end
+
+        assert_equal "verify-full", ENV["PGSSLMODE"]
+        assert_equal "client.crt", ENV["PGSSLCERT"]
+        assert_equal "client.key", ENV["PGSSLKEY"]
+        assert_equal "root.crt", ENV["PGSSLROOTCERT"]
+      end
+
+      def test_postgresql_include_password
+        config = make_db_config(adapter: "postgresql", database: "db", username: "user", password: "q1w2e3")
+
+        assert_find_cmd_and_exec_called_with(["psql", "db"]) do
+          PostgreSQLAdapter.dbconsole(config, include_password: true)
+        end
+
+        assert_equal "user", ENV["PGUSER"]
+        assert_equal "q1w2e3", ENV["PGPASSWORD"]
+      end
+
+      def test_postgresql_include_variables
+        config = make_db_config(adapter: "postgresql", database: "db", variables: { search_path: "my_schema, default, \\my_schema", statement_timeout: 5000, lock_timeout: ":default" })
+
+        assert_find_cmd_and_exec_called_with(["psql", "db"]) do
+          PostgreSQLAdapter.dbconsole(config)
+        end
+
+        assert_equal "-c search_path=my_schema,\\ default,\\ \\\\my_schema -c statement_timeout=5000", ENV["PGOPTIONS"]
+      end
+
+      private
+        def preserve_pg_env
+          old_values = ENV_VARS.map { |var| ENV[var] }
+          yield
+        ensure
+          ENV_VARS.zip(old_values).each { |var, value| ENV[var] = value }
+        end
+
+        def make_db_config(config)
+          ActiveRecord::DatabaseConfigurations::HashConfig.new("test", "primary", config)
+        end
+
+        def assert_find_cmd_and_exec_called_with(args, &block)
+          assert_called_with(PostgreSQLAdapter, :find_cmd_and_exec, args, &block)
+        end
+    end
+  end
+end