departure 1.0.0

data/lib/departure/logger_factory.rb

@@ -0,0 +1,17 @@
+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(verbose: true)
+      if verbose
+        Departure::Logger.new
+      else
+        Departure::NullLogger.new
+      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/railtie.rb

@@ -0,0 +1,28 @@
+require 'departure'
+require 'lhm' # It's our own Lhm adapter, not the gem
+require 'rails'
+
+module Departure
+  class Railtie < Rails::Railtie
+    railtie_name :departure
+
+    # It drops all previous database connections and reconnects using this
+    # PerconaAdapter. By doing this, all later ActiveRecord methods called in
+    # the migration will use this adapter instead of Mysql2Adapter.
+    #
+    # 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.
+    initializer 'departure.configure_rails_initialization' do
+      ActiveSupport.on_load(:active_record) do
+        Departure.load
+      end
+    end
+
+    initializer 'departure.configure' do |app|
+      Departure.configure do |config|
+        config.tmp_path = app.paths['tmp'].first
+      end
+    end
+  end
+end

data/lib/departure/runner.rb

@@ -0,0 +1,136 @@
+require 'open3'
+
+module Departure
+
+  # It executes pt-online-schema-change commands in a new process and gets its
+  # output and status
+  class Runner
+    COMMAND_NOT_FOUND = 127
+
+    # 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
+      @status = nil
+      @config = config
+    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 = cli_generator.parse_statement(sql)
+        execute(command)
+      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 [String]
+    # @return [Boolean]
+    def execute(command)
+      @command = command
+      logging { run_command }
+      validate_status
+      status
+    end
+
+    private
+
+    attr_reader :command, :logger, :status, :cli_generator, :mysql_adapter, :config
+
+    # Checks whether the sql statement is an ALTER TABLE
+    #
+    # @param sql [String]
+    # @return [Boolean]
+    def alter_statement?(sql)
+      sql =~ /\Aalter table/i
+    end
+
+    # Logs the start and end of the execution
+    #
+    # @yield
+    def logging
+      log_deprecations
+      log_started
+      yield
+      log_finished
+    end
+
+    def log_deprecations
+      logger.write("\n")
+      logger.write("[DEPRECATION] This gem has been renamed to Departure and will no longer be supported. Please switch to Departure as soon as possible.")
+    end
+
+    # Logs when the execution started
+    def log_started
+      logger.write("\n")
+      logger.say("Running #{command}\n\n", true)
+    end
+
+    # Executes the command and prints its output to the stdout
+    def run_command
+      Open3.popen3("#{command} 2> #{error_log_path}") do |_stdin, stdout, _stderr, waith_thr|
+        begin
+          loop do
+            IO.select([stdout])
+            data = stdout.read_nonblock(8)
+            logger.write_no_newline(data)
+          end
+        rescue EOFError
+          # noop
+        ensure
+          @status = waith_thr.value
+        end
+      end
+    end
+
+    # Validates the status of the execution
+    #
+    # @raise [NoStatusError] if the spawned process' status can't be retrieved
+    # @raise [SignalError] if the spawned process received a signal
+    # @raise [CommandNotFoundError] if pt-online-schema-change can't be found
+    def validate_status
+      raise SignalError.new(status) if status.signaled?
+      raise CommandNotFoundError if status.exitstatus == COMMAND_NOT_FOUND
+      raise Error, error_message unless status.success?
+    end
+
+    # Prints a line break to keep the logs separate from the execution time
+    # print by the migration
+    def log_finished
+      logger.write("\n")
+    end
+
+    # The path where the percona toolkit stderr will be written
+    #
+    # @return [String]
+    def error_log_path
+      config.error_log_path
+    end
+
+    # @return [String]
+    def error_message
+      File.read(error_log_path)
+    end
+  end
+end

data/lib/departure/version.rb

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

data/lib/lhm.rb

@@ -0,0 +1,25 @@
+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)
+    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,109 @@
+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
+
+      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

data/lib/lhm/column_with_sql.rb

@@ -0,0 +1,90 @@
+require 'forwardable'
+
+module Lhm
+
+  # Abstracts the details of a table column definition when specified with a MySQL
+  # column definition string
+  class ColumnWithSql
+    extend Forwardable
+
+    # Returns the column's class to be used
+    #
+    # @return [Constant]
+    def self.column_factory
+      ::ActiveRecord::ConnectionAdapters::DepartureAdapter::Column
+    end
+
+    # Constructor
+    #
+    # @param name [String, Symbol]
+    # @param definition [String]
+    def initialize(name, definition)
+      @name = name
+      @definition = definition
+    end
+
+    # Returns the column data as an Array to be used with the splat operator.
+    # See Lhm::Adaper#add_column
+    #
+    # @return [Array]
+    def attributes
+      [type, column_options]
+    end
+
+    private
+
+    def_delegators :column, :limit, :type, :default, :null
+
+    attr_reader :name, :definition
+
+    # TODO: investigate
+    #
+    # Rails doesn't take into account lenght argument of INT in the
+    # definition, as an integer it will default it to 4 not an integer
+    #
+    # Returns the columns data as a Hash
+    #
+    # @return [Hash]
+    def column_options
+      { limit: column.limit, default: column.default, null: column.null }
+    end
+
+    # Returns the column instance with the provided data
+    #
+    # @return [column_factory]
+    def column
+      @column ||= self.class.column_factory.new(
+        name,
+        default_value,
+        definition,
+        null_value
+      )
+    end
+
+    # Gets the DEFAULT value the column takes as specified in the
+    # definition, if any
+    #
+    # @return [String, NilClass]
+    def default_value
+      match = if definition =~ /timestamp|datetime/i
+                /default '?(.+[^'])'?/i.match(definition)
+              else
+                /default '?(\w+)'?/i.match(definition)
+              end
+
+      return unless match
+
+      match[1].downcase != 'null' ? match[1] : nil
+    end
+
+    # Checks whether the column accepts NULL as specified in the definition
+    #
+    # @return [Boolean]
+    def null_value
+      match = /((\w*) NULL)/i.match(definition)
+      return true unless match
+
+      match[2].downcase == 'not' ? false : true
+    end
+  end
+end

data/lib/lhm/column_with_type.rb

@@ -0,0 +1,31 @@
+module Lhm
+
+  # Abstracts the details of a table column definition when specified with a type
+  # as a symbol. This is the regular ActiveRecord's #add_column syntax:
+  #
+  #   add_column :tablenames, :field, :string
+  #
+  class ColumnWithType
+
+    # Constructor
+    #
+    # @param name [String, Symbol]
+    # @param definition [Symbol]
+    def initialize(name, definition)
+      @name = name
+      @definition = definition
+    end
+
+    # Returns the column data as an Array to be used with the splat operator.
+    # See Lhm::Adaper#add_column
+    #
+    # @return [Array]
+    def attributes
+      [definition]
+    end
+
+    private
+
+    attr_reader :definition
+  end
+end