synchronised_migration 2.1.1 → 3.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cc7b4ada6d890ac183de30b375e6ead7de8dde32827aa870808552420637a006
-  data.tar.gz: 1826cd77772547266f1dcf309a52574960aa0fdd6efb96a148264ad995979b08
+  metadata.gz: 460b790e8a1c958ba08357abfaa6927c5da2b969a5d7a83c3a31c33125dfbeaa
+  data.tar.gz: d4eb86d31a9803a0077a952aa04b26e6b3bc063e52c0efcc871dce6ec72a1d53
 SHA512:
-  metadata.gz: 5748c0d00c031d6bea8400d598c39f97a6bde99eebfe9273e018fd346ca79186a809ef6f16d9ce6a4213a583e88b7f1fce3e713fd2a9dc40a7adb70340016a0c
-  data.tar.gz: 18442e4f7ddcbdb497af3a05852b59677840871c24844945ddf4da3fca9a5edf2857f6090c5c01067d69c88ee7098a7e5e0ca5f8632e273399c614b537c36de2
+  metadata.gz: 4b8a0b703645774490fea5ae09115e43772543dbe2d629c73eea4fec2a1dc8a2e48ba12a10ea9387d4894f9fa893f9f2d402fd22e5a82ed000564a7d82ea51c8
+  data.tar.gz: b9449bf96097a76f23d617cfaca864389caad35e94402d89b459333f839f250ce43d9780e3327d2526a10be74f9c5304ecb9ccbff74230886aedced7c8bad4eb

data/CHANGELOG.md

@@ -1,5 +1,22 @@
 # Synchronised Migration
 
+
+## 3.1.0
+
+- [PLAT-183] Ruby 3.1 and publish coverage with github action
+
+## 3.0.0
+
+- [OPS-201] Migrate library to CLI tool
+
+## 2.2.0
+
+- [TT-8617] Update to build with github actions / ruby 3.0
+
+## 2.1.2
+
+* [TT-7511] Use the correct `ex` option for key value expiry times instead of `ttl`
+
 ## 2.1.1
 
 * [TT-5896] Early exit from migration inside lock if already completed

data/README.md

@@ -1,50 +1,70 @@
 # Synchronised Migration
 
-[![Build Status](https://travis-ci.org/sealink/synchronised-migration-rb.svg?branch=master)](https://travis-ci.org/sealink/synchronised-migration-rb)
+[![Gem Version](https://badge.fury.io/rb/synchronised_migration.svg)](http://badge.fury.io/rb/synchronised_migration)
+[![Build Status](https://github.com/sealink/synchronised-migration-rb/workflows/Build%20and%20Test/badge.svg?branch=master)](https://github.com/sealink/synchronised-migration-rb/actions)
 
 This gem makes it possible to deploy multiple instances with data migration
-simultaneously.  It uses Redis to ensure that there will be only one migration
+simultaneously. It uses Redis to ensure that there will be only one migration
 running.
 
-This gem works out of the box with a Rails project.  It should work with other
-Ruby projects so long as you load the rake task in Rakefile instead of relying
-on Railtie.
+## Usage
 
-This is a Ruby port of the same logic written in PHP in our [Craft
-Docker](https://github.com/sealink/craft-docker) project.
+### Migrating an application
 
-## Usage
+```
+bundle exec synchronised-migration migrate --config=migration.yml --version=1.2.3
+```
 
-Module `SynchronisedMigration` needs to be configured as below.
+### Checking lock stats
 
 ```
-  SynchronisedMigration.configure do |config|
-    config.host = 'example.com'
-    config.port = 6379
-    config.db = 0
-  end
+bundle exec synchronised-migration status --config=migration.yml --version=1.2.3
 ```
 
-Configuration can be called by using
-```SynchronisedMigration.redis_config.host``` or similar.
+### Clearing locks
+
+If a previous migration has failed a new one will not be allowed to start
+unless it is first cleared.
+
+```
+bundle exec synchronised-migration clear --config=migration.yml
+```
 
-You may override these settings through environment variables.
+If you wish to clear all locks, \*including the running lock then you must also provide version
 
 ```
-SYNCHRONISED_COMMAND=bin/launch/migrate
-WITH_CLEAN_BUNDLER_ENV=1 # Non-empty for true
-REDLOCK_TIMEOUT_MS=3600000
-REDLOCK_RETRY_DELAY_MS=200
-REDLOCK_LOCK_KEY=migration-in-progress
-REDLOCK_FAIL_KEY=migration-failed
+bundle exec synchronised-migration clear --config=migration.yml --version=1.2.3 --all
 ```
 
-Run this before you launch the application during deployment.
+### Configuration
+
+| Key                      | Description                             |
+| ------------------------ | --------------------------------------- |
+| redis_uri                | Redis server to use for locking         |
+| application              | Application being migrated              |
+| version                  | Version being migrated too              |
+| debug                    | Enable additional debug information     |
+| command                  | Command to execute for the migration    |
+| timeout_milliseconds     | Timeout to wait for the lock            |
+| retry_delay_milliseconds | Retry for the lock every x milliseconds |
+
+### Overriding config file options
+
+You may override certain config options such as the `redis-uri` and the ```debug``` flag
+by providing them via cli options.
 
 ```
-$ rake synchronised_migrate:execute
+bundle exec synchronised-migration migrate --config=migration.yml --version=1.2.3 --redis_uri=redis://127.0.0.1:6379/0
 ```
 
-## Testing
+## Release
+
+To publish a new version of this gem the following steps must be taken.
 
-Please refer to `.travis.yml` for testing.
+- Update the version in the following files
+  ```
+    CHANGELOG.md
+    lib/synchronised_migration/version.rb
+  ```
+- Create a tag using the format v0.1.0
+- Follow build progress in GitHub actions

data/exe/synchronised-migration

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "synchronised_migration"
+
+Dry::CLI.new(SynchronisedMigration::Commands).call

data/lib/synchronised_migration/commands.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+module SynchronisedMigration
+  module Commands
+    extend Dry::CLI::Registry
+
+    class Migrate < Dry::CLI::Command
+      desc "Run the provided command in a migration lock"
+
+      option :config, type: :string, required: true, desc: "Configuration file location"
+      option :version, type: :string, required: true, desc: "Version we are migrating to"
+      option :application, type: :string, desc: "Application we are migrating"
+      option :redis_uri, type: :string, desc: "Redis Server URI"
+      option :debug, type: :boolean, desc: "Enable additional debugging output"
+
+      def call(**options)
+        abort "Config location must be provided" if options[:config].nil?
+        abort "Version must be provided" if options[:version].nil?
+
+        config = SynchronisedMigration::Configuration.from_cli(options)
+        result = SynchronisedMigration::Main.new(config).call
+
+        abort(result.error_msg) if result.failure?
+        $stdout.puts "Complete!"
+      end
+    end
+
+    class Clear < Dry::CLI::Command
+      desc "Clear the migration keys"
+
+      option :config, type: :string, required: true, desc: "Configuration file"
+      option :version, type: :string, required: true, desc: "Version we are migrating to"
+      option :application, type: :string, desc: "Application we are migrating"
+      option :redis_uri, type: :string, desc: "Redis Server URI"
+      option :debug, type: :boolean, desc: "Enable additional debugging output"
+      option :all, type: :boolean, default: false, desc: "Clear all keys including success and lock"
+
+      def call(**options)
+        abort "Config location must be provided" if options[:config].nil?
+
+        config = SynchronisedMigration::Configuration.from_cli(options)
+
+        redis_opts = {url: config.redis_uri}
+        redis_opts[:logger] = Logger.new($stdout) if config.debug?
+
+        redis = Redis.new(redis_opts)
+        redis.del(config.fail_key)
+
+        if options[:all]
+          abort "Version must be provided" if options[:version].nil?
+          redis.del(config.success_key)
+          redis.del(config.lock_key)
+        end
+
+        $stdout.puts "Complete!"
+      end
+    end
+
+    class Status < Dry::CLI::Command
+      desc "Shows the current status the redis failure if any"
+
+      option :config, type: :string, required: true, desc: "Configuration file"
+      option :version, type: :string, required: true, desc: "Version we are migrating to"
+      option :application, type: :string, desc: "Application we are migrating"
+      option :redis_uri, type: :string, desc: "Redis Server URI"
+      option :debug, type: :boolean, desc: "Enable additional debugging output"
+
+      def call(**options)
+        abort "Config location must be provided" if options[:config].nil?
+        abort "Version must be provided" if options[:version].nil?
+
+        config = SynchronisedMigration::Configuration.from_cli(options)
+
+        redis_opts = {url: config.redis_uri}
+        redis_opts[:logger] = Logger.new($stdout) if config.debug?
+        redis = Redis.new(redis_opts)
+
+        rows = []
+        fail_key = config.fail_key
+        rows << if redis.exists?(fail_key)
+          [fail_key, "true", "Failed Migration"]
+        else
+          [fail_key, "false", nil]
+        end
+
+        success_key = config.success_key
+        rows << if redis.exists?(success_key)
+          [success_key, "true", "successfully Migrated"]
+        else
+          [success_key, "false", nil]
+        end
+
+        lock_key = config.lock_key
+        rows << if redis.exists?(lock_key)
+          [lock_key, "true", "Running Migration"]
+        else
+          [lock_key, "false", nil]
+        end
+
+        table = TTY::Table.new(["key", "status", "message"], rows)
+        $stdout.puts table.render(:ascii)
+      end
+    end
+
+    register "migrate", Migrate
+    register "clear", Clear
+    register "status", Status
+  end
+end

data/lib/synchronised_migration/configuration.rb

@@ -0,0 +1,50 @@
+module SynchronisedMigration
+  class Configuration
+    attr_accessor :redis_uri
+    attr_accessor :command
+    attr_accessor :application
+    attr_accessor :debug
+    attr_accessor :version
+
+    def self.from_cli(options)
+      config_yml = YAML.load_file(options[:config]).transform_keys(&:to_sym).to_h
+      new(config_yml.merge(options.compact))
+    end
+
+    def initialize(options = {})
+      @application = options.fetch(:application, nil)
+      @version = options.fetch(:version, nil)
+      @redis_uri = options.fetch(:redis_uri, "redis://127.0.0.1:6379/0")
+      @debug = options.fetch(:debug, false)
+      @command = options.fetch(:command, "bin/launch/migrate")
+      @timeout_milliseconds = options.fetch(:timeout_milliseconds, 3_600_000).to_i
+      @retry_delay_milliseconds = options.fetch(:retry_delay_milliseconds, 3000).to_i
+
+      raise OptionParser::InvalidArgument, "Application must be configured" if @application.nil?
+    end
+
+    def timeout_milliseconds
+      @timeout_milliseconds.to_i
+    end
+
+    def retry_delay_milliseconds
+      @retry_delay_milliseconds.to_i
+    end
+
+    def debug?
+      debug
+    end
+
+    def success_key
+      "migration-success-#{application}-#{version}"
+    end
+
+    def fail_key
+      "migration-failed-#{application}"
+    end
+
+    def lock_key
+      "migration-lock-#{application}"
+    end
+  end
+end

data/lib/synchronised_migration/main.rb

@@ -1,144 +1,84 @@
-require 'synchronised_migration'
-require 'synchronised_migration/result'
-require 'redis'
-require 'redlock'
-require 'singleton'
+module SynchronisedMigration
+  class Main
+    FAIL_TIMEOUT = 3600 # 1 Hour
+    SUCCESS_TIMEOUT = 3600 * 24 * 30 # 30 dyas
 
-class SynchronisedMigration::Main
-  include Singleton
-
-  Result = SynchronisedMigration::Result
-
-  class << self
-    extend Forwardable
-    def_delegators :instance, :call
-  end
-
-  def call
-    done_or_execute
-  end
-
-  private
-
-  def done_or_execute
-    return Result.ok if migration_already_completed?
-    lock_and_execute
-  end
-
-  def lock_and_execute
-    redlock.lock! lock_key, timeout do
-      execute
+    def initialize(config)
+      @config = config
     end
-  end
 
-  def execute
-    return Result.ok if migration_already_completed?
-    return Result.fail 'Halting the script because the previous migration failed.' if previous_failed?
-    mark_failed
-    migration_success = migrate
-    return Result.fail 'Migration failed.' unless migration_success
-    mark_successful
-    remove_fail_marker
-    return Result.ok
-  end
+    def call
+      return Result.migration_already_completed if migration_already_completed?
 
-  def migration_already_completed?
-    return false if !success_key
-    value = redis.get(success_key)
-    not value.nil? and not value.empty?
-  end
-
-  def mark_successful
-    if success_key
-      redis.set success_key, timestamp, ttl: 3600*24*30
+      lock_and_execute
     end
-  end
-
-  def previous_failed?
-    value = redis.get(fail_key)
-    not value.nil? and not value.empty?
-  end
-
-  def mark_failed
-    redis.set fail_key, timestamp, ttl: 3600
-  end
 
-  def remove_fail_marker
-    redis.del fail_key
-  end
-
-  def migrate
-    if with_clean_env?
-      Bundler.with_original_env do
-        Kernel.system target_command
+    private
+
+    def lock_and_execute
+      client = Redlock::Client.new(
+        [@config.redis_uri], {
+          retry_count: retry_count,
+          retry_delay: @config.retry_delay_milliseconds
+        }
+      )
+      client.lock!(@config.lock_key, @config.timeout_milliseconds) do
+        execute_within_lock
       end
-    else
-       Kernel.system target_command
     end
-    $?.success?
-  end
-
-  def with_clean_env?
-    not ENV.fetch('WITH_CLEAN_BUNDLER_ENV', '').empty?
-  end
 
-  def target_command
-    ENV.fetch 'SYNCHRONISED_COMMAND', 'bin/launch/migrate'
-  end
-
-  def redis
-    @redis ||= Redis.new(url: redis_url)
-  end
+    def execute_within_lock
+      return Result.ok if migration_already_completed?
+      return Result.previous_migration_failed if previous_failed?
+      mark_failed
+      migration_success = migrate
+      return Result.migration_failed unless migration_success
+      mark_successful
+      remove_fail_marker
+      Result.ok
+    end
 
-  def redlock
-    @redlock ||= Redlock::Client.new(
-      [ redis_url ], {
-        retry_count: retry_count,
-        retry_delay: retry_delay
-      }
-    )
-  end
+    def migration_already_completed?
+      redis.exists?(@config.success_key)
+    end
 
-  def redis_url
-    sprintf(
-      'redis://%s:%s/%s',
-      SynchronisedMigration.redis_config.host,
-      SynchronisedMigration.redis_config.port,
-      SynchronisedMigration.redis_config.db
-    )
-  end
+    def mark_successful
+      success_obj = {application: @config.application, version: @config.version, command: @config.command, timestamp: timestamp}.to_json
+      redis.set(@config.success_key, success_obj, ex: SUCCESS_TIMEOUT)
+    end
 
-  def timestamp
-    Time.now.to_i
-  end
+    def previous_failed?
+      redis.exists?(@config.fail_key)
+    end
 
-  def timeout
-    ENV.fetch('REDLOCK_TIMEOUT_MS', 3_600_000).to_i
-  end
+    def mark_failed
+      redis.set(@config.fail_key, timestamp, ex: FAIL_TIMEOUT)
+    end
 
-  def retry_delay
-    ENV.fetch('REDLOCK_RETRY_DELAY_MS', 3000).to_i
-  end
+    def remove_fail_marker
+      redis.del(@config.fail_key)
+    end
 
-  def retry_count
-    timeout / retry_delay
-  end
+    def migrate
+      Kernel.system @config.command
+      $?.success?
+    end
 
-  def lock_key
-    ENV.fetch 'REDLOCK_LOCK_KEY', 'migration-in-progress'
-  end
+    def redis
+      @redis ||= begin
+        redis_opts = {url: @config.redis_uri}
+        redis_opts[:logger] = Logger.new($stdout) if @config.debug?
 
-  def fail_key
-    ENV.fetch 'REDLOCK_FAIL_KEY', 'migration-failed' + version_suffix
-  end
+        Redis.new(redis_opts)
+      end
+    end
 
-  def success_key
-    return false if version_suffix.empty?
-    'migration-success' + version_suffix
-  end
+    def timestamp
+      Time.now.to_i
+    end
 
-  def version_suffix
-    suffix = ENV.fetch 'REDLOCK_VERSION_SUFFIX', false
-    suffix ? '-' + suffix : ''
+    def retry_count
+      @config.timeout_milliseconds / @config.retry_delay_milliseconds
+    end
   end
 end

data/lib/synchronised_migration/result.rb

@@ -1,21 +1,52 @@
-require 'synchronised_migration'
+require "synchronised_migration"
 
-class SynchronisedMigration::Result
-  attr_accessor :error
+module SynchronisedMigration
+  MIGRATION_SUCCESS = 0
+  PREVIOUS_SUCCESS = 1
+  PREVIOUS_FAILED = 2
+  MIGRATION_FAILED = 3
 
-  def initialize(error = nil)
-    @error = error
-  end
+  PREVIOUS_FAILED_MSG = "Halting the script because the previous migration failed."
+  MIGRATION_FAILED_MSG = "Migration command failed."
 
-  def success?
-    error.nil?
-  end
+  class Result
+    attr_reader :code
 
-  def self.ok
-    self.new
-  end
+    def initialize(code)
+      @code = code
+    end
+
+    def successful?
+      [MIGRATION_SUCCESS, PREVIOUS_SUCCESS].include?(code)
+    end
+
+    def failure?
+      !successful?
+    end
+
+    def error_msg
+      case code
+      when MIGRATION_FAILED
+        MIGRATION_FAILED_MSG
+      when PREVIOUS_FAILED
+        PREVIOUS_FAILED_MSG
+      end
+    end
+
+    def self.ok
+      new(MIGRATION_SUCCESS)
+    end
+
+    def self.migration_already_completed
+      new(PREVIOUS_SUCCESS)
+    end
+
+    def self.previous_migration_failed
+      new(PREVIOUS_FAILED)
+    end
 
-  def self.fail(error)
-    self.new error
+    def self.migration_failed
+      new(MIGRATION_FAILED)
+    end
   end
 end

data/lib/synchronised_migration/version.rb

@@ -1,3 +1,3 @@
 module SynchronisedMigration
-  VERSION = '2.1.1'
+  VERSION = "3.1.0"
 end

data/lib/synchronised_migration.rb

@@ -1,22 +1,14 @@
 module SynchronisedMigration
-  class << self
-    attr_accessor :redis_config
-  end
-
-  def self.configure
-    self.redis_config ||= Configuration.new
-    yield(redis_config)
-  end
-
-  class Configuration
-    attr_accessor :host, :port, :db
-
-    def initialize
-      @host = ''
-      @port = 0
-      @db   = 0
-    end
-  end
 end
 
-require 'synchronised_migration/railtie' if defined?(Rails)
+require "redis"
+require "logger"
+require "json"
+require "redlock"
+require "yaml"
+require "dry/cli"
+require "tty/table"
+require "synchronised_migration/commands"
+require "synchronised_migration/configuration"
+require "synchronised_migration/main"
+require "synchronised_migration/result"

metadata

@@ -1,15 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: synchronised_migration
 version: !ruby/object:Gem::Version
-  version: 2.1.1
+  version: 3.1.0
 platform: ruby
 authors:
 - Alvin Yim
 - Stefan Cooper
 autorequire: 
-bindir: bin
+bindir: exe
 cert_chain: []
-date: 2019-08-22 00:00:00.000000000 Z
+date: 2022-01-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redlock
@@ -25,6 +25,48 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0.2'
+- !ruby/object:Gem::Dependency
+  name: redis
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.2.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.2.1
+- !ruby/object:Gem::Dependency
+  name: dry-cli
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: tty-table
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -40,19 +82,19 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: simplecov-rcov
+  name: coverage-kit
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0.2'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0.2'
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -81,29 +123,50 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '3.5'
+- !ruby/object:Gem::Dependency
+  name: standardrb
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: timecop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Use Redis to record the data migration status
 email: support@travellink.com.au
-executables: []
+executables:
+- synchronised-migration
 extensions: []
 extra_rdoc_files: []
 files:
-- ".gitignore"
-- ".ruby-version"
-- ".travis.yml"
 - CHANGELOG.md
-- Gemfile
-- LICENSE
 - README.md
-- Rakefile
+- exe/synchronised-migration
 - lib/synchronised_migration.rb
+- lib/synchronised_migration/commands.rb
+- lib/synchronised_migration/configuration.rb
 - lib/synchronised_migration/main.rb
-- lib/synchronised_migration/railtie.rb
 - lib/synchronised_migration/result.rb
 - lib/synchronised_migration/version.rb
-- lib/tasks/synchronised_migration.rake
-- spec/spec_helper.rb
-- spec/synchronised_migration/main_spec.rb
-- synchronised_migration.gemspec
 homepage: https://github.com/sealink/synchronised-migration-rb
 licenses: []
 metadata: {}
@@ -115,17 +178,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 2.6.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
+rubygems_version: 3.3.3
 signing_key: 
 specification_version: 4
 summary: For deploying to multiple instances simultaneously
-test_files:
-- spec/spec_helper.rb
-- spec/synchronised_migration/main_spec.rb
+test_files: []

data/.gitignore

@@ -1,5 +0,0 @@
-/.bundle
-/vendor
-/coverage
-/*.gem
-Gemfile.lock

data/.ruby-version

@@ -1 +0,0 @@
-2.6.3

data/.travis.yml

@@ -1,10 +0,0 @@
-language: ruby
-rvm:
-  - 2.4
-  - 2.5
-  - 2.6
-script: bundle exec rspec
-sudo: false
-cache: bundler
-before_install:
-  - gem install bundler

data/Gemfile

@@ -1,2 +0,0 @@
-source 'https://rubygems.org'
-gemspec

data/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2017 SeaLink Travel Group Limited
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

data/Rakefile

@@ -1,2 +0,0 @@
-require "bundler/gem_tasks"
-require 'rspec/core/rake_task'

data/lib/synchronised_migration/railtie.rb

@@ -1,5 +0,0 @@
-class SynchronisedMigration::Railtie < Rails::Railtie
-  rake_tasks do
-    load 'tasks/synchronised_migration.rake'
-  end
-end

data/lib/tasks/synchronised_migration.rake

@@ -1,9 +0,0 @@
-require 'synchronised_migration/main'
-
-namespace :synchronised_migration do
-  task :execute do
-    result = SynchronisedMigration::Main.call
-    next if result.success?
-    fail result.error
-  end
-end

data/spec/spec_helper.rb

@@ -1,9 +0,0 @@
-require 'pry'
-require 'simplecov'
-require 'simplecov-rcov'
-
-SimpleCov.formatter = SimpleCov::Formatter::RcovFormatter
-SimpleCov.minimum_coverage 100
-SimpleCov.start do
-  add_filter %r{^/vendor}
-end

data/spec/synchronised_migration/main_spec.rb

@@ -1,164 +0,0 @@
-require 'spec_helper'
-require 'synchronised_migration/main'
-
-describe SynchronisedMigration::Main do
-  subject { described_class }
-  let(:result) { subject.call }
-
-  context 'when the prerequisites are meet' do
-    let(:redis) { double }
-    let(:redlock) { double }
-    let(:fail_marker_value) { nil }
-    let(:success_marker_value) { nil }
-    let(:version_suffix) { 'bork' }
-    let(:set_version_suffix) { ENV['REDLOCK_VERSION_SUFFIX'] = version_suffix }
-    let(:time_value) { double(to_i: 123456789) }
-
-    before do
-      set_version_suffix
-
-      subject.instance.instance_variable_set :@redis, nil
-      subject.instance.instance_variable_set :@redlock, nil
-
-      allow(subject.instance).to receive(:execute).and_call_original
-      allow(subject.instance).to receive(:migrate).and_call_original
-
-      allow(Redis).to receive(:new).and_return(redis)
-      allow(redis).to receive(:get) { |key|
-        case key
-        when "migration-failed-#{version_suffix}"
-          fail_marker_value
-        when "migration-failed"
-          fail_marker_value
-        when "migration-success-#{version_suffix}"
-          success_marker_value
-        when "migration-success"
-          success_marker_value
-        else
-          raise "invalid key for redis get: #{key}"
-        end
-      }
-      allow(redis).to receive(:set)
-      allow(redis).to receive(:del)
-
-      allow(Redlock::Client).to receive(:new).and_return(redlock)
-      allow(redlock).to receive(:lock!) { |lock_key, timeout, &block| block.call }
-
-      allow(Time).to receive(:now).and_return(time_value)
-
-      allow(Kernel).to receive(:system).and_wrap_original { |method, *args|
-        next if args == [ 'bin/launch/migrate' ]
-        method.call *args
-      }
-
-      allow(Bundler).to receive(:with_original_env).and_call_original
-
-      SynchronisedMigration.configure do |config|
-        config.host = 'example.com'
-        config.port = 6379
-        config.db = 0
-      end
-    end
-
-    context 'in the happy path' do
-      it 'executes the migration successfully' do
-        expect(result).to be_success
-        expect(redlock).to have_received(:lock!)
-        expect(redis).to have_received(:get).with('migration-failed-bork')
-        expect(redis).to have_received(:set).with('migration-failed-bork', 123456789, ttl: 3600)
-        expect(redis).to have_received(:set).with('migration-success-bork', 123456789, ttl: 3600*24*30)
-        expect(Kernel).to have_received(:system)
-        expect(Bundler).not_to have_received(:with_original_env)
-        expect(redis).to have_received(:del).with('migration-failed-bork')
-      end
-
-      context 'and migration completed previously' do
-        let(:success_marker_value) { '1' }
-        it 'contines without executing' do
-          expect(result).to be_success
-          expect(redlock).not_to have_received(:lock!)
-        end
-      end
-
-      context 'executing in lock waiter' do
-        let(:result2) { subject.call }
-
-        before do
-          # Note: bypasses the first success flag check so it can enter lock.
-          expect(result).to be_success
-          allow(redis).to receive(:get).and_return(nil, '1')
-        end
-
-        it 'early exits and does not execute again', :aggregate_failures do
-          expect(result2).to be_success
-          expect(redlock).to have_received(:lock!).exactly(2).times
-          expect(Kernel).to have_received(:system).exactly(1).times
-          expect(subject.instance).to have_received(:execute).exactly(2).times
-          expect(subject.instance).to have_received(:migrate).exactly(1).times
-        end
-      end
-    end
-
-    context 'when require a clean Bundler environment' do
-      before do
-        allow(ENV).to receive(:fetch).and_call_original
-        allow(ENV).to receive(:fetch).with('WITH_CLEAN_BUNDLER_ENV', '').and_return('1')
-      end
-
-      it 'executes it with a clean Bundler environment' do
-        expect(result).to be_success
-        expect(Kernel).to have_received(:system)
-        expect(Bundler).to have_received(:with_original_env)
-      end
-    end
-
-    context 'after a deployment failed previously' do
-      let(:fail_marker_value) { '1' }
-
-      it "doesn't execute the migration" do
-        expect(result).not_to be_success
-        expect(Kernel).not_to have_received(:system)
-      end
-    end
-
-    context 'when the task crashed' do
-      before do
-        allow_any_instance_of(Process::Status).to receive(:success?).and_return(false)
-      end
-
-      it 'marks the failure in Redis' do
-        expect(result).not_to be_success
-        expect(redis).to have_received(:set).with('migration-failed-bork', 123456789, ttl: 3600)
-        expect(redis).not_to have_received(:del)
-      end
-    end
-
-    context 'without version suffix' do
-      let(:set_version_suffix) { ENV.delete 'REDLOCK_VERSION_SUFFIX' }
-
-      context 'in the happy path' do
-        it 'executes the migration successfully' do
-          expect(result).to be_success
-          expect(redlock).to have_received(:lock!)
-          expect(redis).to have_received(:get).with('migration-failed')
-          expect(redis).to have_received(:set).with('migration-failed', 123456789, ttl: 3600)
-          expect(Kernel).to have_received(:system)
-          expect(Bundler).not_to have_received(:with_original_env)
-          expect(redis).to have_received(:del).with('migration-failed')
-        end
-      end
-
-      context 'when the task crashed' do
-        before do
-          allow_any_instance_of(Process::Status).to receive(:success?).and_return(false)
-        end
-
-        it 'marks the failure in Redis' do
-          expect(result).not_to be_success
-          expect(redis).to have_received(:set).with('migration-failed', 123456789, ttl: 3600)
-          expect(redis).not_to have_received(:del)
-        end
-      end
-    end
-  end
-end

data/synchronised_migration.gemspec

@@ -1,24 +0,0 @@
-lib = File.expand_path('../lib', __FILE__)
-$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'synchronised_migration/version'
-
-Gem::Specification.new do |spec|
-  spec.name          = 'synchronised_migration'
-  spec.version       = SynchronisedMigration::VERSION
-  spec.authors       = ['Alvin Yim', 'Stefan Cooper']
-  spec.email         = 'support@travellink.com.au'
-  spec.description   = 'Use Redis to record the data migration status'
-  spec.summary       = 'For deploying to multiple instances simultaneously'
-  spec.homepage      = 'https://github.com/sealink/synchronised-migration-rb'
-
-  spec.files         = `git ls-files`.split($INPUT_RECORD_SEPARATOR)
-  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
-  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
-  spec.require_paths = ['lib']
-
-  spec.add_dependency 'redlock', '>= 0.2'
-  spec.add_development_dependency 'rake'
-  spec.add_development_dependency 'simplecov-rcov', '>= 0.2'
-  spec.add_development_dependency 'rspec', '>= 3.6'
-  spec.add_development_dependency 'pry-byebug', '>= 3.5'
-end