departure-76c9880 6.2.0

data/lib/departure/logger.rb

@@ -0,0 +1,42 @@
+module Departure
+  # Copies the ActiveRecord::Migration #say and #write plus a new
+  # #write_no_newline to log the migration's status. It's not possible to reuse
+  # the from ActiveRecord::Migration because the migration's instance can't be
+  # seen from the connection adapter.
+  class Logger
+    def initialize(sanitizers)
+      @sanitizers = sanitizers
+    end
+
+    # Outputs the message through the stdout, following the
+    # ActiveRecord::Migration log format
+    #
+    # @param message [String]
+    # @param subitem [Boolean] whether to show message as a nested log item
+    def say(message, subitem = false)
+      write "#{subitem ? '   ->' : '--'} #{message}"
+    end
+
+    # Outputs the text through the stdout adding a new line at the end
+    #
+    # @param text [String]
+    def write(text = '')
+      puts(sanitize(text))
+    end
+
+    # Outputs the text through the stdout without adding a new line at the end
+    #
+    # @param text [String]
+    def write_no_newline(text)
+      print(sanitize(text))
+    end
+
+    private
+
+    attr_accessor :sanitizers
+
+    def sanitize(text)
+      sanitizers.inject(text) { |memo, sanitizer| sanitizer.execute(memo) }
+    end
+  end
+end

data/lib/departure/logger_factory.rb

@@ -0,0 +1,16 @@
+module Departure
+  module LoggerFactory
+    # Returns the appropriate logger instance for the given configuration. Use
+    # :verbose option to log to the stdout
+    #
+    # @param verbose [Boolean]
+    # @return [#say, #write]
+    def self.build(sanitizers: [], verbose: true)
+      if verbose
+        Departure::Logger.new(sanitizers)
+      else
+        Departure::NullLogger.new
+      end
+    end
+  end
+end

data/lib/departure/migration.rb

@@ -0,0 +1,96 @@
+module Departure
+  # Hooks Departure into Rails migrations by replacing the configured database
+  # adapter.
+  #
+  # It also patches ActiveRecord's #migrate method so that it patches LHM
+  # first. This will make migrations written with LHM to go through the
+  # regular Rails Migration DSL.
+  module Migration
+    extend ActiveSupport::Concern
+
+    included do
+      # Holds the name of the adapter that was configured by the app.
+      mattr_accessor :original_adapter
+
+      # Declare on a per-migration class basis whether or not to use Departure.
+      # The default for this attribute is set based on
+      # Departure.configuration.enabled_by_default (default true).
+      class_attribute :uses_departure
+      self.uses_departure = true
+
+      alias_method :active_record_migrate, :migrate
+      remove_method :migrate
+    end
+
+    module ClassMethods
+      # Declare `uses_departure!` in the class body of your migration to enable
+      # Departure for that migration only when
+      # Departure.configuration.enabled_by_default is false.
+      def uses_departure!
+        self.uses_departure = true
+      end
+
+      # Declare `disable_departure!` in the class body of your migration to
+      # disable Departure for that migration only (when
+      # Departure.configuration.enabled_by_default is true, the default).
+      def disable_departure!
+        self.uses_departure = false
+      end
+    end
+
+    # Replaces the current connection adapter with the PerconaAdapter and
+    # patches LHM, then it continues with the regular migration process.
+    #
+    # @param direction [Symbol] :up or :down
+    def departure_migrate(direction)
+      reconnect_with_percona
+      include_foreigner if defined?(Foreigner)
+
+      ::Lhm.migration = self
+      active_record_migrate(direction)
+    end
+
+    # Migrate with or without Departure based on uses_departure class
+    # attribute.
+    def migrate(direction)
+      if uses_departure?
+        departure_migrate(direction)
+      else
+        reconnect_without_percona
+        active_record_migrate(direction)
+      end
+    end
+
+    # Includes the Foreigner's Mysql2Adapter implemention in
+    # DepartureAdapter to support foreign keys
+    def include_foreigner
+      Foreigner::Adapter.safe_include(
+        :DepartureAdapter,
+        Foreigner::ConnectionAdapters::Mysql2Adapter
+      )
+    end
+
+    # Make all connections in the connection pool to use PerconaAdapter
+    # instead of the current adapter.
+    def reconnect_with_percona
+      return if connection_config[:adapter] == 'percona'
+      Departure::ConnectionBase.establish_connection(connection_config.merge(adapter: 'percona'))
+    end
+
+    # Reconnect without percona adapter when Departure is disabled but was
+    # enabled in a previous migration.
+    def reconnect_without_percona
+      return unless connection_config[:adapter] == 'percona'
+      Departure::ConnectionBase.establish_connection(connection_config.merge(adapter: original_adapter))
+    end
+
+    private
+
+    # Capture the type of the adapter configured by the app if not already set.
+    def connection_config
+      ActiveRecord::Base.connection_config.tap do |config|
+        self.class.original_adapter ||= config[:adapter]
+      end
+    end
+  end
+end

data/lib/departure/null_logger.rb

@@ -0,0 +1,15 @@
+module Departure
+  class NullLogger
+    def say(_message, _subitem = false)
+      # noop
+    end
+
+    def write(_text)
+      # noop
+    end
+
+    def write_no_newline(_text)
+      # noop
+    end
+  end
+end

data/lib/departure/option.rb

@@ -0,0 +1,75 @@
+module Departure
+  class Option
+    attr_reader :name, :value
+
+    # Builds an instance by parsing its name and value out of the given string.
+    #
+    # @param string [String]
+    # @return [Option]
+    def self.from_string(string)
+      name, value = string.split(/\s|=/, 2)
+      new(name, value)
+    end
+
+    # Constructor
+    #
+    # @param name [String]
+    # @param optional value [String]
+    def initialize(name, value = nil)
+      @name = normalize_option(name)
+      @value = value
+    end
+
+    # Compares two options
+    #
+    # @param [Option]
+    # @return [Boolean]
+    def ==(other)
+      name == other.name
+    end
+    alias eql? ==
+
+    # Returns the option's hash
+    #
+    # @return [Fixnum]
+    def hash
+      name.hash
+    end
+
+    # Returns the option as string following the "--<name>=<value>" format or
+    # the short "-n=value" format
+    #
+    # @return [String]
+    def to_s
+      "#{name}#{value_as_string}"
+    end
+
+    private
+
+    # Returns the option name in "long" format, e.g., "--name"
+    #
+    # @return [String]
+    def normalize_option(name)
+      if name.start_with?('-')
+        name
+      elsif name.length == 1
+        "-#{name}"
+      else
+        "--#{name}"
+      end
+    end
+
+    # Returns the value fragment of the option string if any value is specified
+    #
+    # @return [String]
+    def value_as_string
+      if value.nil?
+        ''
+      elsif value.include?('=')
+        " #{value}"
+      else
+        "=#{value}"
+      end
+    end
+  end
+end

data/lib/departure/railtie.rb

@@ -0,0 +1,21 @@
+require 'departure'
+require 'lhm' # It's our own Lhm adapter, not the gem
+require 'rails'
+
+module Departure
+  class Railtie < Rails::Railtie
+    railtie_name :departure
+
+    initializer 'departure.configure' do |app|
+      Departure.configure do |config|
+        config.tmp_path = app.paths['tmp'].first
+      end
+    end
+
+    config.after_initialize do
+      Departure.configure do |dc|
+        ActiveRecord::Migration.uses_departure = dc.enabled_by_default
+      end
+    end
+  end
+end

data/lib/departure/runner.rb

@@ -0,0 +1,62 @@
+require 'open3'
+
+module Departure
+  # It executes pt-online-schema-change commands in a new process and gets its
+  # output and status
+  class Runner
+    # Constructor
+    #
+    # @param logger [#say, #write]
+    # @param cli_generator [CliGenerator]
+    # @param mysql_adapter [ActiveRecord::ConnectionAdapter] it must implement
+    #   #execute and #raw_connection
+    def initialize(logger, cli_generator, mysql_adapter, config = Departure.configuration)
+      @logger = logger
+      @cli_generator = cli_generator
+      @mysql_adapter = mysql_adapter
+      @error_log_path = config.error_log_path
+    end
+
+    # Executes the passed sql statement using pt-online-schema-change for ALTER
+    # TABLE statements, or the specified mysql adapter otherwise.
+    #
+    # @param sql [String]
+    def query(sql)
+      if alter_statement?(sql)
+        command_line = cli_generator.parse_statement(sql)
+        execute(command_line)
+      else
+        mysql_adapter.execute(sql)
+      end
+    end
+
+    # Returns the number of rows affected by the last UPDATE, DELETE or INSERT
+    # statements
+    #
+    # @return [Integer]
+    def affected_rows
+      mysql_adapter.raw_connection.affected_rows
+    end
+
+    # TODO: rename it so we don't confuse it with AR's #execute
+    # Runs and logs the given command
+    #
+    # @param command_line [String]
+    # @return [Boolean]
+    def execute(command_line)
+      Command.new(command_line, error_log_path, logger).run
+    end
+
+    private
+
+    attr_reader :logger, :cli_generator, :mysql_adapter, :error_log_path
+
+    # Checks whether the sql statement is an ALTER TABLE
+    #
+    # @param sql [String]
+    # @return [Boolean]
+    def alter_statement?(sql)
+      sql =~ /\Aalter table/i
+    end
+  end
+end

data/lib/departure/user_options.rb

@@ -0,0 +1,44 @@
+module Departure
+  # Encapsulates the pt-online-schema-change options defined by the user
+  class UserOptions
+    delegate :each, :merge, to: :to_set
+
+    # Constructor
+    #
+    # @param arguments [String]
+    def initialize(arguments = ENV['PERCONA_ARGS'])
+      @arguments = arguments
+    end
+
+    private
+
+    attr_reader :arguments
+
+    # Returns the arguments the user defined but without duplicates
+    #
+    # @return [Set]
+    def to_set
+      Set.new(user_options)
+    end
+
+    # Returns Option instances from the arguments the user specified, if any
+    #
+    # @return [Array]
+    def user_options
+      if arguments
+        build_options
+      else
+        []
+      end
+    end
+
+    # Builds Option instances from the user arguments
+    #
+    # @return [Array<Option>]
+    def build_options
+      arguments.split(/\s(?=-)/).map do |argument|
+        Option.from_string(argument)
+      end
+    end
+  end
+end

data/lib/departure/version.rb

@@ -0,0 +1,3 @@
+module Departure
+  VERSION = '6.2.0'.freeze
+end

data/lib/lhm.rb

@@ -0,0 +1,23 @@
+require 'lhm/adapter'
+
+# Defines the same global namespace as LHM's gem does to mimic its API
+# while providing a different behaviour. We delegate all LHM's methods to
+# ActiveRecord so that you don't need to modify your old LHM migrations
+module Lhm
+  # Yields an adapter instance so that Lhm migration Dsl methods get
+  # delegated to ActiveRecord::Migration ones instead
+  #
+  # @param table_name [String]
+  # @param _options [Hash]
+  # @param block [Block]
+  def self.change_table(table_name, _options = {}, &block) # rubocop:disable Lint/UnusedMethodArgument
+    yield Adapter.new(@migration, table_name)
+  end
+
+  # Sets the migration to apply the adapter to
+  #
+  # @param migration [ActiveRecord::Migration]
+  def self.migration=(migration)
+    @migration = migration
+  end
+end

data/lib/lhm/adapter.rb

@@ -0,0 +1,107 @@
+require 'lhm/column_with_sql'
+require 'lhm/column_with_type'
+
+module Lhm
+  # Translates Lhm DSL to ActiveRecord's one, so Lhm migrations will now go
+  # through Percona as well, without any modification on the migration's
+  # code
+  class Adapter
+    # Constructor
+    #
+    # @param migration [ActiveRecord::Migtration]
+    # @param table_name [String, Symbol]
+    def initialize(migration, table_name)
+      @migration = migration
+      @table_name = table_name
+    end
+
+    # Adds the specified column through ActiveRecord
+    #
+    # @param column_name [String, Symbol]
+    # @param definition [String, Symbol]
+    def add_column(column_name, definition)
+      attributes = column_attributes(column_name, definition)
+      migration.add_column(*attributes)
+    end
+
+    # Removes the specified column through ActiveRecord
+    #
+    # @param column_name [String, Symbol]
+    def remove_column(column_name)
+      migration.remove_column(table_name, column_name)
+    end
+
+    # Adds an index in the specified columns through ActiveRecord. Note you
+    # can provide a name as well
+    #
+    # @param columns [Array<String>, Array<Symbol>, String, Symbol]
+    # @param index_name [String]
+    def add_index(columns, index_name = nil)
+      options = { name: index_name } if index_name
+      migration.add_index(table_name, columns, options || {})
+    end
+
+    # Removes the index in the given columns or by its name
+    #
+    # @param columns [Array<String>, Array<Symbol>, String, Symbol]
+    # @param index_name [String]
+    def remove_index(columns, index_name = nil)
+      options = if index_name
+                  { name: index_name }
+                else
+                  { column: columns }
+                end
+      migration.remove_index(table_name, options)
+    end
+
+    # Change the column to use the provided definition, through ActiveRecord
+    #
+    # @param column_name [String, Symbol]
+    # @param definition [String, Symbol]
+    def change_column(column_name, definition)
+      attributes = column_attributes(column_name, definition)
+      migration.change_column(*attributes)
+    end
+
+    # Renames the old_name column to new_name by using ActiveRecord
+    #
+    # @param old_name [String, Symbol]
+    # @param new_name [String, Symbol]
+    def rename_column(old_name, new_name)
+      migration.rename_column(table_name, old_name, new_name)
+    end
+
+    # Adds a unique index on the given columns, with the provided name if passed
+    #
+    # @param columns [Array<String>, Array<Symbol>, String, Symbol]
+    # @param index_name [String]
+    def add_unique_index(columns, index_name = nil)
+      options = { unique: true }
+      options.merge!(name: index_name) if index_name # rubocop:disable Performance/RedundantMerge
+
+      migration.add_index(table_name, columns, options)
+    end
+
+    private
+
+    attr_reader :migration, :table_name
+
+    # Returns the instance of ActiveRecord column with the given name and
+    # definition
+    #
+    # @param name [String, Symbol]
+    # @param definition [String]
+    def column(name, definition)
+      @column ||= if definition.is_a?(Symbol)
+                    ColumnWithType.new(name, definition)
+                  else
+                    ColumnWithSql.new(name, definition)
+                  end
+    end
+
+    def column_attributes(name, definition)
+      attributes = column(name, definition).attributes
+      [table_name, name].concat(attributes)
+    end
+  end
+end