synchronised_migration 2.2.0 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 178cde6a23ffc12e5074df16e0c8b2f5503ce460727607fc3af824c98a92bce1
-  data.tar.gz: 0e3ebd525d0e55ffeabe3565f811ed3ff57ea272d042a3b72386ae6a627ba03c
+  metadata.gz: fdaaef7abd9ca7478b25d2e8ddc330db3aa699eb5a9027d3aac05b9626fc0a1b
+  data.tar.gz: ec0d069a1bedf336381d3241b9f869b2c41b8e25f4e6138abda5dc0b34bbdddd
 SHA512:
-  metadata.gz: bc7a499baac225c7f3e11467f84c44eae41a2af3ef6c016b3a8b674fdd177c53930efb86ec5951da2ce5b220fb697ff87faa62ba557a3de14767293a10a71371
-  data.tar.gz: 6d07aad5e40d68ac72c240f39875e2686416c1d2c38e1fb7555fe18626a47dbdc510116d51e6c19776ed5c22a3ef4e3bcc77b20b5c3672ed94098768dffdd35c
+  metadata.gz: 66a3e6dca6186f13049eae942c13cca91afa9652b6c3dfc69e3e693e5dd8433023f57f98fa3f94502cfb04edafeb323df2f90230b7b8e38f9cd48490b324744a
+  data.tar.gz: ae260978d7cca055fe2b361514482175c921361a4a00b944ba0bf3fecce24885f104b6bd4d3f19e205814481e7621f502f8398ad3bd85a55931b648288c87247

data/CHANGELOG.md

@@ -1,5 +1,9 @@
 # Synchronised Migration
 
+## 3.0.0
+
+- [OPS-201] Migrate library to CLI tool
+
 ## 2.2.0
 
 - [TT-8617] Update to build with github actions / ruby 3.0

data/README.md

@@ -4,56 +4,67 @@
 [![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
 
-```ruby
-  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
 
-You may override these settings through environment variables.
+If a previous migration has failed a new one will not be allowed to start
+unless it is first cleared.
 
 ```
-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
 ```
 
-Run this before you launch the application during deployment.
+If you wish to clear all locks, \*including the running lock then you must also provide version
 
 ```
-$ rake synchronised_migrate:execute
+bundle exec synchronised-migration clear --config=migration.yml --version=1.2.3 --all
+```
+
+### 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.
+
+```
+bundle exec synchronised-migration migrate --config=migration.yml --version=1.2.3 --redis_uri=redis://127.0.0.1:6379/0
 ```
 
 ## Release
 
 To publish a new version of this gem the following steps must be taken.
 
-* Update the version in the following files
+- 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
+  ```
+- 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, ex: 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, ex: 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.2.0'
+  VERSION = "3.0.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.2.0
+  version: 3.0.0
 platform: ruby
 authors:
 - Alvin Yim
 - Stefan Cooper
 autorequire: 
-bindir: bin
+bindir: exe
 cert_chain: []
-date: 2021-01-06 00:00:00.000000000 Z
+date: 2021-09-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redlock
@@ -27,6 +27,34 @@ dependencies:
         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:
     - - ">="
@@ -95,31 +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:
-- ".github/dependabot.yml"
-- ".github/workflows/release.yml"
-- ".github/workflows/ruby.yml"
-- ".gitignore"
-- ".ruby-version"
 - 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: {}
@@ -138,10 +185,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.3
+rubygems_version: 3.2.22
 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/.github/dependabot.yml

@@ -1,6 +0,0 @@
-version: 2
-updates:
-  - package-ecosystem: "bundler"
-    directory: "/"
-    schedule:
-      interval: "daily"

data/.github/workflows/release.yml

@@ -1,59 +0,0 @@
-name: Release
-
-on:
-  push:
-    tags:
-      - "v*"
-
-jobs:
-  build:
-    name: Build
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v2
-      - uses: ruby/setup-ruby@v1
-        with:
-          bundler-cache: true
-      - run: bundle exec rake
-
-  release:
-    needs: build
-    name: Release
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v2
-
-      - name: Generate Changelog
-        run: |
-          # Get version from github ref (remove 'refs/tags/' and prefix 'v')
-          version="${GITHUB_REF#refs/tags/v}"
-          npx changelog-parser CHANGELOG.md | jq -cr ".versions | .[] | select(.version == \"$version\") | .body" > ${{ github.workflow }}-CHANGELOG.txt
-
-      - name: Release
-        uses: softprops/action-gh-release@v1
-        with:
-          body_path: ${{ github.workflow }}-CHANGELOG.txt
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-
-  publish:
-    needs: [build, release]
-    name: Publish
-    runs-on: ubuntu-latest
-
-    steps:
-      - uses: actions/checkout@v2
-      - uses: ruby/setup-ruby@v1
-
-      - name: Publish to RubyGems
-        run: |
-          mkdir -p $HOME/.gem
-          touch $HOME/.gem/credentials
-          chmod 0600 $HOME/.gem/credentials
-          printf -- "---\n:rubygems_api_key: ${GEM_HOST_API_KEY}\n" > $HOME/.gem/credentials
-          gem build *.gemspec
-          gem push *.gem
-        env:
-          GEM_HOST_API_KEY: "${{secrets.RUBYGEMS_AUTH_TOKEN}}"

data/.github/workflows/ruby.yml

@@ -1,16 +0,0 @@
-name: Build and Test
-on: [push, pull_request]
-jobs:
-  test:
-    strategy:
-      fail-fast: false
-      matrix:
-        ruby: ["2.6", "2.7", "3.0"]
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2
-      - uses: ruby/setup-ruby@v1
-        with:
-          ruby-version: ${{ matrix.ruby }}
-          bundler-cache: true
-      - run: bundle exec rake

data/.gitignore

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

data/.ruby-version

@@ -1 +0,0 @@
-3.0.0

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,12 +0,0 @@
-require "bundler/gem_tasks"
-
-desc 'Default: run specs.'
-task :default => :spec
-
-require 'rspec/core/rake_task'
-
-desc "Run specs"
-RSpec::Core::RakeTask.new do |t|
-  t.pattern = "./spec/**/*_spec.rb" # don't need this, it's default.
-  # Put spec opts in a file named .rspec in root
-end

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,165 +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, ex: 3600)
-        expect(redis).to have_received(:set).with('migration-success-bork', 123456789, ex: 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
-      it 'marks the failure in Redis' do
-        fork { exit 1 }
-        Process.wait
-
-        expect(result).not_to be_success
-        expect(redis).to have_received(:set).with('migration-failed-bork', 123456789, ex: 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
-          fork { exit 0 }
-          Process.wait
-
-          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, ex: 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
-        it 'marks the failure in Redis' do
-          fork { exit 1 }
-          Process.wait
-
-          expect(result).not_to be_success
-          expect(redis).to have_received(:set).with('migration-failed', 123456789, ex: 3600)
-          expect(redis).not_to have_received(:del)
-        end
-      end
-    end
-  end
-end

data/synchronised_migration.gemspec

@@ -1,26 +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.required_ruby_version = '>= 2.6.0'
-
-  spec.add_dependency 'redlock', '>= 0.2'
-  spec.add_dependency 'redis'
-  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