activerecord-snapshot 0.2.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: dcf198dbf40940ddc9a3cc50767c89f8f6ca88f3
+  data.tar.gz: 3e41aa133c618b1f687417596ef836baff755902
+SHA512:
+  metadata.gz: 3e19714fd936fa8c671327b006ad08c8d8b2c2c0e20613ea05e36500e8627b19a3c1c24aeb66275e16ae6fae3c7461998f672a3434b70b86e499e3b06d1ee4de
+  data.tar.gz: 84cba03937050b8ed4ca0efb54420635c2b98ee400e1f7a7b11c962d5dc25411b919a43ee78a65a793fbe1b4cb9834352cfc19e19a83971e96d96892f8f1de84

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2017 Bernardo Farah
+
+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/README.md

@@ -0,0 +1,118 @@
+# ActiveRecord::Snapshot
+
+This gem provides rake tasks to create and import MySQL snapshots using S3. This
+is pretty specialized for how CoverHound uses snapshots.
+
+## Dependencies
+
+- S3
+- MySQL
+- bzip2
+- openssl
+
+## Usage
+
+### Configuration
+
+This file, looked for at `config/snapshot.yml`, allows for the following
+configuration:
+
+- `store.tmp` Working directory for snapshots
+- `store.local` Local storage of snapshots
+- `s3.*` S3 access keys, bucket, region and paths for storing regular and named
+  snapshots
+- `ssl_key` Path to the key that will be used to encrypt the snapshot
+- `tables` The tables that should be exported as part of the snapshot
+
+##### Sample
+
+```yml
+# config/snapshot.yml
+store:
+  tmp: <%= Rails.root.join("tmp/snapshots").to_s %>
+  local: <%= Rails.root.join("db/snapshots").to_s %>
+
+s3:
+  access_key_id: 'foo'
+  secret_access_key: 'bar'
+  bucket: 'metal-bucket'
+  region: 'us-west-1'
+  paths:
+    snapshots: 'snapshots'
+    named_snapshots: 'named_snapshots'
+
+ssl_key: "/dir/to/snapshots-secret.key"
+
+tables:
+- "example_table"
+```
+
+### Tasks
+
+##### `db:snapshot:create`
+
+Creates a snapshot with the following naming convention:
+`snapshot_YY-MM-DD_HH-MM.sql.bz2.enc`
+
+This snapshot is then stored at `s3.paths.snapshots`. It is assigned a version
+(incrementing off of a `snapshot_version` file, which is saved locally and on
+S3) which is stored alongside its filename in the file `snapshot_list`.
+
+This task only runs in production.
+
+##### `db:snapshot:create_named`
+
+Creates a named snapshot: `[name].sql.bz2.enc` which is stored at
+`s3.paths.named_snapshots`. These are not stored in `snapshot_list` or
+`snapshot_version`.
+
+##### `db:snapshot:import`
+
+When used without arguments, it imports the latest regular snapshot from S3,
+then drops and replaces the local database.
+
+Can be given arguments for the version:
+
+`db:snapshot:import[12]` gets you the 12th regular snapshot
+`db:snapshot:import['foo']` gets you your snapshot named `foo`
+
+##### `db:snapshot:import:only['foo bar']`
+
+Imports _only_ the tables given as arguments (`foo` and `bar` in this example)
+from the latest regular snapshot
+
+##### `db:snapshot:reload`
+
+Reloads the current snapshot
+
+##### `db:snapshot:list`
+
+Shows a list of snapshots
+
+##### `db:snapshot:list:load[n]`
+
+Shows a list of the last `n` snapshots
+
+## Installation
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'activerecord-snapshot'
+```
+
+And then execute:
+```bash
+$ bundle
+```
+
+Or install it yourself as:
+```bash
+$ gem install activerecord-snapshot
+```
+
+## Contributing
+
+Be nice!
+
+## License
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,33 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rdoc/task'
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'ActiveRecord::Snapshot'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.md')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+
+
+
+
+
+require 'bundler/gem_tasks'
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+
+task default: :test

data/lib/active_record/snapshot.rb

@@ -0,0 +1,12 @@
+require_relative "snapshot/configuration"
+require_relative "snapshot/utils/stepper"
+require_relative "snapshot/commands/all"
+require_relative "snapshot/files/all"
+require_relative "snapshot/railtie"
+require_relative "snapshot/actions/create"
+require_relative "snapshot/actions/import"
+
+module ActiveRecord
+  module Snapshot
+  end
+end

data/lib/active_record/snapshot/actions/create.rb

@@ -0,0 +1,70 @@
+require "active_record/snapshot/utils/logger"
+
+module ActiveRecord
+  module Snapshot
+    class Create
+      def self.call(*args)
+        new(*args).call
+      end
+
+      def initialize(name: nil)
+        @named_snapshot = !name.nil?
+        @snapshot = Snapshot.new(name)
+      end
+
+      def call
+        Stepper.call(self, **steps)
+      end
+
+      private
+
+      attr_reader :snapshot, :named_snapshot
+
+      def config
+        ActiveRecord::Snapshot.config
+      end
+
+      def steps
+        {
+          dump: "Create dump of #{config.db.database} at #{snapshot.dump}",
+          compress: "Compress snapshot to #{snapshot.compressed}",
+          encrypt: "Encrypt snapshot to #{snapshot.encrypted}",
+          upload_snapshot: "Upload files to #{config.s3.bucket}"
+        }.tap do |s|
+          next if named_snapshot
+          s[:update_list] = "Update list from #{Version.current} to #{Version.next} with #{snapshot.encrypted}"
+          s[:upload_version_info] = "Upload version info to #{config.s3.bucket}"
+        end
+      end
+
+      def dump
+        config.adapter.dump(tables: config.tables, output: snapshot.dump)
+      end
+
+      def compress
+        Bzip2.compress(snapshot.dump)
+      end
+
+      def encrypt
+        OpenSSL.encrypt(
+          input: snapshot.compressed,
+          output: snapshot.encrypted
+        )
+      end
+
+      def update_list
+        Version.increment
+        List.add(version: Version.current, file: snapshot.encrypted)
+      end
+
+      def upload_snapshot
+        snapshot.upload
+      end
+
+      def upload_version_info
+        Version.upload
+        List.upload
+      end
+    end
+  end
+end

data/lib/active_record/snapshot/actions/import.rb

@@ -0,0 +1,92 @@
+module ActiveRecord
+  module Snapshot
+    class Import
+      def self.call(*args)
+        new(*args).call
+      end
+
+      def initialize(version: nil, tables: [])
+        @version = version
+        if named_version?
+          name = version
+        else
+          @version, name = SelectSnapshot.call(version)
+        end
+        @snapshot = Snapshot.new(name)
+        @tables = tables
+      end
+
+      def call
+        Stepper.call(self, **steps)
+      end
+
+      private
+
+      attr_reader :snapshot, :tables, :version
+
+      def config
+        ActiveRecord::Snapshot.config
+      end
+
+      def named_version?
+        !version.blank? && version.to_i.to_s != version.to_s
+      end
+
+      def version_downloaded?
+        version.to_i == Version.current && File.file?(snapshot.dump)
+      end
+
+      def steps
+        steps = {}
+        unless version_downloaded?
+          steps[:download] = "Download snapshot to #{snapshot.encrypted}"
+          steps[:decrypt] = "Decrypt snapshot to #{snapshot.compressed}"
+          steps[:decompress] = "Decompress snapshot to #{snapshot.dump}"
+        end
+
+        if tables.empty?
+          steps[:reset_database] = "Reset database"
+        else
+          steps[:filter_tables] = "Filter tables"
+        end
+
+        steps[:import] = "Importing the snapshot into #{config.db.database}"
+        steps[:save] = "Caching the new snapshot version" unless named_version? || tables.present?
+        steps
+      end
+
+      def download
+        snapshot.download
+      end
+
+      def decrypt
+        OpenSSL.decrypt(
+          input: snapshot.encrypted,
+          output: snapshot.compressed
+        ) && FileUtils.rm(snapshot.encrypted)
+      end
+
+      def decompress
+        Bzip2.decompress(snapshot.compressed)
+      end
+
+      def reset_database
+        Rake::Task["db:drop"].invoke
+        Rake::Task["db:create"].invoke
+      end
+
+      def filter_tables
+        FilterTables.call(tables: tables, sql_dump: snapshot.dump)
+      end
+
+      def import
+        config.adapter.import(input: snapshot.dump)
+        Rake::Task["db:schema:dump"].invoke
+      end
+
+      def save
+        Version.write(version)
+      end
+    end
+  end
+end

data/lib/active_record/snapshot/commands/all.rb

@@ -0,0 +1,6 @@
+require_relative "bzip2"
+require_relative "filter_tables"
+require_relative "mysql"
+require_relative "openssl"
+require_relative "s3"
+require_relative "select_snapshot"

data/lib/active_record/snapshot/commands/bzip2.rb

@@ -0,0 +1,15 @@
+module ActiveRecord
+  module Snapshot
+    class Bzip2
+      def self.compress(path)
+        return false unless File.file?(path)
+        system("nice bzip2 -z #{path}")
+      end
+
+      def self.decompress(path)
+        return false unless File.file?(path)
+        system("nice bunzip2 -f #{path}")
+      end
+    end
+  end
+end

data/lib/active_record/snapshot/commands/filter_tables.rb

@@ -0,0 +1,41 @@
+module ActiveRecord
+  module Snapshot
+    class FilterTables
+      def self.call(*args)
+        new(*args).call
+      end
+
+      def initialize(tables:, sql_dump:)
+        @tables = tables
+        @sql_dump = sql_dump
+      end
+
+      def call
+        tables.each(&method(:extract_table))
+        unify_tables
+      end
+
+      private
+
+      attr_reader :tables, :sql_dump
+
+      def table_file(table)
+        ActiveRecord::Snapshot.config.store.tmp.join("#{table}.sql").to_s
+      end
+
+      def extract_table(table)
+        system(<<~SH)
+          sed -ne \\
+            '/Table structure for table `#{table}`/,/Table structure for table/p' \\
+            #{sql_dump} \\
+            > #{table_file(table)}
+        SH
+      end
+
+      def unify_tables
+        all = tables.map(&method(:table_file))
+        system("cat #{all.join(" ")} > #{sql_dump}") && FileUtils.rm(all)
+      end
+    end
+  end
+end

data/lib/active_record/snapshot/commands/mysql.rb

@@ -0,0 +1,46 @@
+module ActiveRecord
+  module Snapshot
+    class MySQL
+      def self.dump(*args)
+        new.dump(*args)
+      end
+
+      def dump(tables:, output:)
+        dump_command("--no-data #{database} > #{output}") &&
+          dump_command("--quick #{database} #{tables.join(" ")} >> #{output}")
+      end
+
+      def self.import(*args)
+        new.import(*args)
+      end
+
+      def import(input:)
+        system(<<~SH)
+          nice mysql \\
+            --user #{username} \\
+            #{password ? '--password' : ''} #{password} \\
+            --host #{host} \\
+            #{database} < #{input}
+        SH
+      end
+
+      private
+
+      delegate :username, :password, :host, :database, to: :db_config
+
+      def db_config
+        ActiveRecord::Snapshot.config.db
+      end
+
+      def dump_command(args = "")
+        system(<<~SH)
+          nice mysqldump \\
+            --user #{username} \\
+            --password #{password} \\
+            --host #{host} \\
+            #{args}
+        SH
+      end
+    end
+  end
+end

data/lib/active_record/snapshot/commands/openssl.rb

@@ -0,0 +1,23 @@
+module ActiveRecord
+  module Snapshot
+    class OpenSSL
+      def self.encrypt(input:, output:)
+        system(<<-SH)
+        nice openssl aes-256-cbc \\
+          -in #{input} \\
+          -out #{output} \\
+          -kfile #{ActiveRecord::Snapshot.config.ssl_key}
+        SH
+      end
+
+      def self.decrypt(input:, output:)
+        system(<<-SH)
+        nice openssl enc -d -aes-256-cbc \\
+          -in #{input} \\
+          -out #{output} \\
+          -kfile #{ActiveRecord::Snapshot.config.ssl_key}
+        SH
+      end
+    end
+  end
+end

data/lib/active_record/snapshot/commands/s3.rb

@@ -0,0 +1,45 @@
+require 'fog/aws'
+
+module ActiveRecord
+  module Snapshot
+    class S3
+      def initialize(directory:)
+        @connection = create_connection
+        @directory = directory
+      end
+
+      def upload(path)
+        connection.put_object(config.bucket, aws_key(path), File.open(path))
+      end
+
+      def download_to(path)
+        File.open(path, "wb") { |f| f.write(read(path)) }
+      end
+
+      def read(path)
+        connection.get_object(config.bucket, aws_key(path)).body
+      end
+
+      private
+
+      attr_reader :connection, :directory
+
+      def config
+        ActiveRecord::Snapshot.config.s3
+      end
+
+      def aws_key(path)
+        File.join(directory, File.basename(path))
+      end
+
+      def create_connection
+        ::Fog::Storage.new(
+          provider: "AWS",
+          region: config.region,
+          aws_access_key_id: config.access_key_id,
+          aws_secret_access_key: config.secret_access_key
+        )
+      end
+    end
+  end
+end

data/lib/active_record/snapshot/commands/select_snapshot.rb

@@ -0,0 +1,14 @@
+module ActiveRecord
+  module Snapshot
+    class SelectSnapshot
+      def self.call(selected_version = nil)
+        if selected_version.blank?
+          List.download
+          List.last
+        else
+          List.get(version: selected_version)
+        end
+      end
+    end
+  end
+end

data/lib/active_record/snapshot/configuration.rb

@@ -0,0 +1,74 @@
+require "yaml"
+require "hashie"
+
+# NOTE: Default lambdas below all have because of a bug with defaults + coercion
+#       Defaults aren't executed on class instantiation unless the lambda
+#       takes an argument. This is a problem, since the execution in #[]=
+#       happens AFTER the value is assigned - therefore AFTER the
+#       coercion happens
+
+module ActiveRecord
+  module Snapshot
+    class Configuration < Hashie::Dash
+      class S3Paths < Hashie::Dash
+        include Hashie::Extensions::Dash::IndifferentAccess
+
+        property :snapshots, required: true
+        property :named_snapshots, required: true
+      end
+
+      class S3Config < Hashie::Dash
+        include Hashie::Extensions::Dash::Coercion
+        include Hashie::Extensions::Dash::IndifferentAccess
+
+        property :access_key_id, required: true
+        property :secret_access_key, required: true
+        property :bucket, required: true
+        property :region, default: "us-west-1"
+        property :paths, required: true, coerce: S3Paths
+      end
+
+      class DBConfig < Hashie::Dash
+        include Hashie::Extensions::Dash::IndifferentAccess
+
+        def initialize(database_hash)
+          super database_hash.slice("database", "username", "password", "host")
+        end
+
+        property :database, required: true
+        property :username, required: true
+        property :host, required: true
+        property :password
+      end
+
+      class StoreConfig < Hashie::Dash
+        include Hashie::Extensions::Dash::Coercion
+        include Hashie::Extensions::Dash::IndifferentAccess
+
+        property :tmp, default: ->(_) { ::Rails.root.join("tmp/snapshots") }, coerce: Pathname
+        property :local, default: ->(_) { ::Rails.root.join("db/snapshots") }, coerce: Pathname
+      end
+
+      include Hashie::Extensions::Dash::Coercion
+      include Hashie::Extensions::Dash::IndifferentAccess
+
+      property :db, default: ->(_) { ::Rails.application.config.database_configuration[Rails.env] }, coerce: DBConfig
+      property :s3, required: true, coerce: S3Config
+      property :ssl_key, required: true
+      property :tables, required: true
+      property :store, coerce: StoreConfig
+
+      def adapter
+        ActiveRecord::Snapshot::MySQL
+      end
+    end
+
+    def self.config_file
+      ::Rails.root.join("config", "snapshot.yml")
+    end
+
+    def self.config
+      @config ||= Configuration.new(YAML.safe_load(ERB.new(::File.read(config_file)).result))
+    end
+  end
+end

data/lib/active_record/snapshot/files/all.rb

@@ -0,0 +1,3 @@
+require_relative "list"
+require_relative "snapshot"
+require_relative "version"

data/lib/active_record/snapshot/files/list.rb

@@ -0,0 +1,54 @@
+module ActiveRecord
+  module Snapshot
+    class List
+      class << self
+        def download
+          s3.download_to(path)
+        end
+
+        def upload
+          s3.upload(path)
+        end
+
+        def add(version:, file:)
+          contents = File.read(path)
+          File.open(path, "w") do |f|
+            f.puts "#{version.to_i} #{File.basename(file)}"
+            f.write contents
+          end
+        end
+
+        def get(version:)
+          File.readlines(path).each do |line|
+            version_str, filename = line.split(" ")
+            return [version_str.to_i, filename] if version_str.to_i == version.to_i
+          end
+          []
+        end
+
+        def last
+          version_str, filename = File.open(path, &:readline).split(" ")
+          [version_str.to_i, filename]
+        end
+
+        def filename
+          "snapshot_list".freeze
+        end
+
+        def path
+          config.store.local.join(filename).to_s.freeze
+        end
+
+        private
+
+        def s3
+          S3.new(directory: config.s3.paths.snapshots)
+        end
+
+        def config
+          ActiveRecord::Snapshot.config
+        end
+      end
+    end
+  end
+end

data/lib/active_record/snapshot/files/snapshot.rb

@@ -0,0 +1,63 @@
+module ActiveRecord
+  module Snapshot
+    class Snapshot
+      def initialize(filename = nil)
+        @filename = clean(filename) || dump_file
+        directory = named? ? paths.named_snapshots : paths.snapshots
+        @s3 = S3.new(directory: directory)
+      end
+
+      def named?
+        /\Asnapshot_\d{4}-\d{2}-\d{2}_\d{2}-\d{2}-\d{2}(\..+)?\z/ !~ File.basename(@filename)
+      end
+
+      def dump
+        @filename
+      end
+
+      def compressed
+        @filename + ".bz2"
+      end
+
+      def encrypted
+        compressed + ".enc"
+      end
+
+      def upload
+        s3.upload(encrypted)
+      end
+
+      def download
+        s3.download_to(encrypted)
+      end
+
+      private
+
+      attr_reader :s3
+
+      def paths
+        ActiveRecord::Snapshot.config.s3.paths
+      end
+
+      def clean(filename)
+        return unless filename
+        basename = File.basename(
+          filename.sub(/(\.sql)?(\.bz2)?(\.enc)?$/, ".sql")
+        )
+        local_path.join(basename).to_s
+      end
+
+      def dump_file
+        local_path.join("snapshot_#{timestamp}.sql").to_s
+      end
+
+      def local_path
+        ActiveRecord::Snapshot.config.store.local
+      end
+
+      def timestamp
+        Time.zone.now.strftime("%Y-%m-%d_%H-%M-%S")
+      end
+    end
+  end
+end

data/lib/active_record/snapshot/files/version.rb

@@ -0,0 +1,43 @@
+module ActiveRecord
+  module Snapshot
+    class Version
+      class << self
+        def current
+          return nil unless File.file?(path)
+          ::File.read(path).to_i
+        end
+
+        def next
+          current + 1
+        end
+
+        def increment
+          File.write(path, self.next)
+        end
+
+        def write(version)
+          return false unless version.to_i.to_s == version.to_s
+          File.write(path, version)
+        end
+
+        def upload
+          S3.new(directory: config.s3.paths.snapshots).upload(path)
+        end
+
+        def filename
+          "snapshot_version".freeze
+        end
+
+        def path
+          config.store.local.join(filename).to_s.freeze
+        end
+
+        private
+
+        def config
+          ActiveRecord::Snapshot.config
+        end
+      end
+    end
+  end
+end

data/lib/active_record/snapshot/railtie.rb

@@ -0,0 +1,9 @@
+module ActiveRecord
+  module Snapshot
+    class Railtie < ::Rails::Railtie
+      rake_tasks do
+        load "tasks/active_record/snapshot_tasks.rake"
+      end
+    end
+  end
+end

data/lib/active_record/snapshot/templates/snapshot.yml.tt

@@ -0,0 +1,17 @@
+store:
+  tmp: <%= Rails.root.join("tmp/snapshots").to_s %>
+  local: <%= Rails.root.join("db/snapshots").to_s %>
+
+s3:
+  access_key_id: 'key'
+  secret_access_key: 'key'
+  bucket: 'bucket'
+  region: 'region'
+  paths:
+    named_snapshots: 'custom_snapshots'
+    snapshots: 'snapshots'
+
+ssl_key: "/dir/to/snapshots-secret.key"
+
+tables:
+- "example_table"

data/lib/active_record/snapshot/utils/logger.rb

@@ -0,0 +1,32 @@
+module ActiveRecord
+  module Snapshot
+    class Logger
+      def self.call(*args, &block)
+        new(*args).call(&block)
+      end
+
+      def initialize(step)
+        @step = step
+      end
+
+      def call
+        start
+        yield.tap do |success|
+          success ? finish : failed
+        end
+      end
+
+      def start
+        puts "== Running: #{@step}"
+      end
+
+      def finish
+        puts "== Done"
+      end
+
+      def failed
+        $stderr.puts "== Failed: #{@step}"
+      end
+    end
+  end
+end

data/lib/active_record/snapshot/utils/stepper.rb

@@ -0,0 +1,13 @@
+require_relative "logger"
+
+module ActiveRecord
+  module Snapshot
+    class Stepper
+      def self.call(context, **steps)
+        steps.each do |step, message|
+          Logger.call(message, &context.method(step)) || abort
+        end
+      end
+    end
+  end
+end

data/lib/active_record/snapshot/version.rb

@@ -0,0 +1,5 @@
+module ActiveRecord
+  module Snapshot
+    VERSION = '0.2.1'
+  end
+end

data/lib/active_record_snapshot.rb

@@ -0,0 +1 @@
+require "activerecord-snapshot"

data/lib/activerecord-snapshot.rb

@@ -0,0 +1 @@
+require "active_record/snapshot.rb"

data/lib/activerecord_snapshot.rb

@@ -0,0 +1 @@
+require "activerecord-snapshot"

data/lib/tasks/active_record/snapshot_tasks.rake

@@ -0,0 +1,69 @@
+namespace :db do
+  namespace :snapshot do
+    desc "Create a snapshot of the current database and store it in S3"
+    task create: :load do
+      abort "Meant for production only!" unless Rails.env.production?
+      ActiveRecord::Snapshot::Create.call
+    end
+
+    desc "Take a snapshot of the current database and store it in S3"
+    task create_named: :load do
+      abort "Do not run in production!" if Rails.env.production?
+      puts <<~TEXT
+        Please enter a unique name for this snapshot. You will need to remember this to access it later:
+      TEXT
+
+      snapshot_name = STDIN.gets.strip
+
+      abort "Please don't use spaces in your snapshot name." if snapshot_name =~ /\s/
+      abort "Please ensure your name is a string, integers are used for daily snapshots" if snapshot_name.to_i.to_s == snapshot_name
+
+      ActiveRecord::Snapshot::Create.call(name: snapshot_name)
+    end
+
+    desc "Import production database snapshot."
+    task :import, [:version] => [:load] do |_t, args|
+      abort "Do not run in prodution mode!" if Rails.env.production?
+      version = args.fetch(:version, "").strip
+      ActiveRecord::Snapshot::Import.call(version: version)
+    end
+
+    namespace :import do
+      desc "Import only specific tables from the most recent snapshot"
+      task :only, [:tables] => :load do |_t, args|
+        abort "Do not run in production mode!" if Rails.env.production?
+
+        if args[:tables].blank?
+          abort "Usage: bundle exec rake db:snapshot:import:only['table1 table2']"
+        end
+
+        tables = args[:tables].split(/[, ;'"]+/).reject(&:blank?)
+        ActiveRecord::Snapshot::Import.call(tables: tables)
+      end
+    end
+
+    desc "Reload current snapshot version"
+    task reload: :load do
+      version = ActiveRecord::Snapshot::Version.current
+      abort "No current version found" unless version
+      Rake::Task["db:snapshot:import"].invoke(version.to_s)
+    end
+
+    desc "Show available snapshot versions"
+    task :list, [:count] => [:load] do |_t, args|
+      version = ActiveRecord::Snapshot::Version.current
+      puts "Current snapshot version is #{version}" if version
+
+      path = ActiveRecord::Snapshot::List.path
+      File.file?(path) || ActiveRecord::Snapshot::List.download
+      lines = File.readlines(path)
+      count = args.fetch(:count, 11).to_i - 1
+
+      puts lines[0..count]
+    end
+
+    task load: :environment do
+      FileUtils.mkdir_p(ActiveRecord::Snapshot.config.store.values)
+    end
+  end
+end

metadata

@@ -0,0 +1,161 @@
+--- !ruby/object:Gem::Specification
+name: activerecord-snapshot
+version: !ruby/object:Gem::Version
+  version: 0.2.1
+platform: ruby
+authors:
+- Bernardo Farah
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-06-20 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: railties
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.1.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '6.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.1.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '6.0'
+- !ruby/object:Gem::Dependency
+  name: fog-aws
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.0'
+- !ruby/object:Gem::Dependency
+  name: hashie
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.4.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.4.3
+- !ruby/object:Gem::Dependency
+  name: mocha
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: '1.1'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.10.3
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.10.3
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  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: Snapshots for ActiveRecord
+email:
+- ber@bernardo.me
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- README.md
+- Rakefile
+- lib/active_record/snapshot.rb
+- lib/active_record/snapshot/actions/create.rb
+- lib/active_record/snapshot/actions/import.rb
+- lib/active_record/snapshot/commands/all.rb
+- lib/active_record/snapshot/commands/bzip2.rb
+- lib/active_record/snapshot/commands/filter_tables.rb
+- lib/active_record/snapshot/commands/mysql.rb
+- lib/active_record/snapshot/commands/openssl.rb
+- lib/active_record/snapshot/commands/s3.rb
+- lib/active_record/snapshot/commands/select_snapshot.rb
+- lib/active_record/snapshot/configuration.rb
+- lib/active_record/snapshot/files/all.rb
+- lib/active_record/snapshot/files/list.rb
+- lib/active_record/snapshot/files/snapshot.rb
+- lib/active_record/snapshot/files/version.rb
+- lib/active_record/snapshot/railtie.rb
+- lib/active_record/snapshot/templates/snapshot.yml.tt
+- lib/active_record/snapshot/utils/logger.rb
+- lib/active_record/snapshot/utils/stepper.rb
+- lib/active_record/snapshot/version.rb
+- lib/active_record_snapshot.rb
+- lib/activerecord-snapshot.rb
+- lib/activerecord_snapshot.rb
+- lib/tasks/active_record/snapshot_tasks.rake
+homepage: https://github.com/coverhound/active-record-snapshot
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: Snapshots for ActiveRecord
+test_files: []