arrival 0.1.0

data/lib/arrival/railtie.rb

@@ -0,0 +1,28 @@
+require 'arrival'
+require 'lhm' # It's our own Lhm adapter, not the gem
+require 'rails'
+
+module Arrival
+  class Railtie < Rails::Railtie
+    railtie_name :arrival
+
+    # 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 'arrival.configure_rails_initialization' do
+      ActiveSupport.on_load(:active_record) do
+        Arrival.load
+      end
+    end
+
+    initializer 'arrival.configure' do |app|
+      Arrival.configure do |config|
+        config.tmp_path = app.paths['tmp'].first
+      end
+    end
+  end
+end

data/lib/arrival/runner.rb

@@ -0,0 +1,62 @@
+require 'open3'
+
+module Arrival
+  # 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 = Arrival.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/arrival/user_options.rb

@@ -0,0 +1,44 @@
+module Arrival
+  # 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/arrival/version.rb

@@ -0,0 +1,3 @@
+module Arrival
+  VERSION = '0.1.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

data/lib/lhm/column_with_sql.rb

@@ -0,0 +1,96 @@
+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::ArrivalAdapter::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
+      cast_type = ActiveRecord::Base.connection.send(:lookup_cast_type, definition)
+      metadata = ActiveRecord::ConnectionAdapters::SqlTypeMetadata.new(
+        type: cast_type.type,
+        sql_type: definition,
+        limit: cast_type.limit
+      )
+      mysql_metadata = ActiveRecord::ConnectionAdapters::MySQL::TypeMetadata.new(metadata)
+      @column ||= self.class.column_factory.new(
+        name,
+        default_value,
+        mysql_metadata,
+        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,29 @@
+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

data/main/conf/mysql.conf.cnf

@@ -0,0 +1,9 @@
+[mysqld]
+
+skip-host-cache
+skip-name-resolve
+
+server-id = 1
+log_bin = /var/log/mysql/mysql-bin.log
+binlog_format = ROW
+; binlog_do_db = mydb

data/main/mysql_main.env

@@ -0,0 +1,7 @@
+# Note, by default mysql root does not have a password. You need to restart a server to bring MYSQL_ROOT_PASSWORD working. Use "docker-compose restart" command.
+MYSQL_ROOT_PASSWORD=111
+MYSQL_PORT=3306
+MYSQL_USER=mydb_user
+MYSQL_PASSWORD=mydb_pwd
+MYSQL_DATABASE=mydb
+MYSQL_LOWER_CASE_TABLE_NAMES=0

data/replica/conf/mysql.conf.cnf

@@ -0,0 +1,10 @@
+[mysqld]
+
+skip-host-cache
+skip-name-resolve
+
+server-id=2
+relay-log = /var/log/mysql/mysql-relay-bin.log
+log_bin = /var/log/mysql/mysql-bin.log
+log_slave_updates=on
+binlog_format = ROW

data/replica/mysql_replica.env

@@ -0,0 +1,7 @@
+# Note, by default mysql root does not have a password. You need to restart a server to bring MYSQL_ROOT_PASSWORD working. Use "docker-compose restart" command.
+MYSQL_ROOT_PASSWORD=111
+MYSQL_PORT=3306
+MYSQL_USER=mydb_slave_user
+MYSQL_PASSWORD=mydb_slave_pwd
+MYSQL_DATABASE=mydb
+MYSQL_LOWER_CASE_TABLE_NAMES=0

data/test_database.rb

@@ -0,0 +1,80 @@
+require 'active_record'
+require 'active_record/connection_adapters/mysql2_adapter'
+
+# Setups the test database with the schema_migrations table that ActiveRecord
+# requires for the migrations, plus a table for the Comment model used throught
+# the tests.
+#
+class TestDatabase
+  # Constructor
+  #
+  # @param config [Hash]
+  def initialize(config)
+    @config = config
+    @database = config['database']
+  end
+
+  # Creates the test database, the schema_migrations and the comments tables.
+  # It drops any of them if they already exist
+  def setup
+    setup_test_database
+    drop_and_create_schema_migrations_table
+  end
+
+  # Creates the #{@database} database and the comments table in it.
+  # Before, it drops both if they already exist
+  def setup_test_database
+    drop_and_create_test_database
+    drop_and_create_comments_table
+  end
+
+  # Creates the ActiveRecord's schema_migrations table required for
+  # migrations to work. Before, it drops the table if it already exists
+  def drop_and_create_schema_migrations_table
+    sql = [
+      "USE #{@database}",
+      'DROP TABLE IF EXISTS schema_migrations',
+      'CREATE TABLE schema_migrations ( version varchar(255) COLLATE utf8_unicode_ci NOT NULL, UNIQUE KEY unique_schema_migrations (version)) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_unicode_ci'
+    ]
+
+    run_commands(sql)
+  end
+
+  private
+
+  attr_reader :config, :database
+
+  def drop_and_create_test_database
+    sql = [
+      "DROP DATABASE IF EXISTS #{@database}",
+      "CREATE DATABASE #{@database} DEFAULT CHARACTER SET utf8 DEFAULT COLLATE utf8_unicode_ci"
+    ]
+
+    run_commands(sql)
+  end
+
+  def drop_and_create_comments_table
+    sql = [
+      "USE #{@database}",
+      'DROP TABLE IF EXISTS comments',
+      'CREATE TABLE comments ( id bigint(20) NOT NULL AUTO_INCREMENT, PRIMARY KEY (id)) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_unicode_ci'
+    ]
+
+    run_commands(sql)
+  end
+
+  def run_commands(sql)
+    conn.execute('START TRANSACTION')
+    sql.each { |str| conn.execute(str) }
+    conn.execute('COMMIT')
+  end
+
+  def conn
+    @conn ||= ActiveRecord::Base.mysql2_connection(
+      host: @config['hostname'],
+      username: @config['username'],
+      password: @config['password'],
+      reconnect: true
+    )
+  end
+end