data_keeper 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 9c4e8095729b6927bc11ae296fc30571577d1dfd5f5d910b1092f924981efa69
+  data.tar.gz: bb646294c8847fd637b765fd6a2f16af605dabe656b663d2cb0e6f54ff396f79
+SHA512:
+  metadata.gz: cd3696d94b9ef70bf108e8c77ee880e1b97e68989955c6c7975b4f9cea9196b95417a17e6b5bf6e3a9baf2047cd0a1db524e2bc8dd660d2576f10385f38a038d
+  data.tar.gz: 1ecab9088e179625113bb3a490a83c60a16405924f527caa059ed1dc05c68527049f12cc985aa1280f6e094597903f5bf280420a21c98a1670eb527b4e766c52

data/.gitignore

@@ -0,0 +1,10 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+Gemfile.lock

data/.travis.yml

@@ -0,0 +1,6 @@
+---
+language: ruby
+cache: bundler
+rvm:
+  - 2.6.5
+before_install: gem install bundler -v 2.1.4

data/Gemfile

@@ -0,0 +1,7 @@
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in data_keeper.gemspec
+gemspec
+
+gem "rake", "~> 12.0"
+gem "minitest", "~> 5.0"

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2020 Roger Campos
+
+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,111 @@
+# DataKeeper
+
+In a rails app using postgresql, DataKeeper is a tool to create dumps of your database in production to be used later on for local development. 
+
+It automates the process of creating and storing them on the server, and applying them locally afterwards.
+
+It supports full dumps, as well as partial dumps per specific tables or even specific rows (you provide a sql select). 
+On partial dumps, note you'll need to manage possible issues around foreign keys and maybe other constraints. 
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'data_keeper'
+```
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself as:
+
+    $ gem install data_keeper
+
+## Usage
+
+Configure the storage to use to save the generated dumps.
+
+You can use a local storage, a simple option which stores the dumps in the same server running the code,
+in a path of your choosing (consider that it must be writable by the user running this code in production).
+You also configure how to reach that server from your local machine (currently only scp is supported), in
+order to download these dumps later. Ex:
+
+```ruby
+DataKeeper.storage = DataKeeper::LocalStorage.new(
+  local_store_dir: "/users/fredy/backups/...",
+  remote_access: {
+    type: "scp",
+    host: "141.12.241.22",
+    port: "8622",
+    user: "fredy"
+  }
+)
+```
+
+Other storages, like S3, could be implemented, but currently this gem only ships with local storage.
+If you want to do your own, you can assign as an storage whatever object that responds to:
+
+- `#save(file, filename, dump_name)`, where file is a File object and filename a string. This method should save the given
+  dump file. 
+
+- `#retrieve(dump_name) { |file| (...) }`, which should retrieve the latest stored dump with the given dump_name.
+  It should yield the given block passing the File object pointing to the retrieved dump file in the local filesystem,
+  which is expected to be cleaned up on block termination.
+
+
+Then, declare some dumps to work with:
+
+```ruby
+# Dump the whole database
+DataKeeper.define_dump(:whole_database, :full)
+
+# Dump only selected tables, and a custom SQL
+DataKeeper.define_dump(:config) do |d|
+  # Specific tables, all rows
+  d.table "products"
+  d.table "traits"
+
+  # Only some rows in the "vouchers" table. MAKE SURE your sql returns only columns from the target table!
+  d.sql(:vouchers, :used_vouchers) { Voucher.joins(cart: :order).where(orders: {status: "sent"}).to_sql }
+  
+  # Possible additional code to run after applying the dump locally
+  d.on_after_load do
+    User.create! email: "test@gmail.com", password: "password"
+  end
+end
+```
+
+Now, in production, you'll have run `DataKeeper.create_dump!("config")`, passing in the same of the dump
+you defined before. Running this will create the dump file, from the server you run this code from,
+and store it in the configured storage.
+
+If you want to have always an up-to-date dump, you'll need to call this periodically, for example once per day.
+
+Finally, to apply the dump locally, you can use the rake task:
+
+`bin/rake data_keeper:pull[config]`
+
+This will download the latest version available of the "config" dump, and apply it locally, destroying anything
+in your current database. It will give you an error if you try to run this in a production environment.
+
+Note when using raw sql, your statement is expected to return all columns for the configured table, in the default
+order (`select *`). This uses pg's COPY from/to for the full table internally. 
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/data_keeper.
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/*_test.rb"]
+end
+
+task :default => :test

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "data_keeper"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/data_keeper.gemspec

@@ -0,0 +1,31 @@
+require_relative 'lib/data_keeper/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "data_keeper"
+  spec.version       = DataKeeper::VERSION
+  spec.authors       = ["Roger Campos"]
+  spec.email         = ["roger@rogercampos.com"]
+
+  spec.summary       = %q{Easy management of database dumps for dev env}
+  spec.description   = %q{Easy management of database dumps for dev env}
+  spec.homepage      = "https://github.com/rogercampos/data_keeper"
+  spec.license       = "MIT"
+  spec.required_ruby_version = Gem::Requirement.new(">= 2.3.0")
+
+  spec.metadata["homepage_uri"] = spec.homepage
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "activerecord", ">= 5.2.0"
+  spec.add_dependency "terrapin", ">= 0.5.0"
+  spec.add_dependency "sshkit", ">= 1.20.0"
+  spec.add_dependency "rails", ">= 5.0.0"
+
+end

data/lib/data_keeper.rb

@@ -0,0 +1,61 @@
+require "data_keeper/version"
+require "terrapin"
+require "zlib"
+require "rubygems/package"
+
+require 'data_keeper/error'
+require 'data_keeper/definition'
+require 'data_keeper/dumper'
+require 'data_keeper/loader'
+require 'data_keeper/local_storage'
+require 'data_keeper/database_helper'
+require 'data_keeper/railtie' if defined?(Rails) && defined?(Rails::Railtie)
+
+module DataKeeper
+  DumpDoesNotExist = Class.new(Error)
+  NoStorageDefined = Class.new(Error)
+
+  @dumps = {}
+  @storage = nil
+
+  def self.define_dump(name, type = :partial, &block)
+    @dumps[name.to_sym] = DefinitionBuilder.build(type, block)
+  end
+
+  def self.create_dump!(name)
+    raise DumpDoesNotExist unless dump?(name)
+    raise NoStorageDefined if @storage.nil?
+
+    Dumper.new(name, @dumps[name.to_sym]).run! do |file, filename|
+      @storage.save(file, filename, name)
+    end
+  end
+
+  def self.fetch_and_load_dump!(name)
+    raise DumpDoesNotExist unless dump?(name)
+    raise NoStorageDefined if @storage.nil?
+
+    @storage.retrieve(name) do |file|
+      Loader.new(@dumps[name.to_sym], file).load!
+    end
+  end
+
+  def self.load_dump!(name, path)
+    raise DumpDoesNotExist unless File.file?(path)
+    raise NoStorageDefined if @storage.nil?
+
+    Loader.new(@dumps[name.to_sym], File.open(path)).load!
+  end
+
+  def self.dump?(name)
+    @dumps.key?(name.to_sym)
+  end
+
+  def self.storage=(value)
+    @storage = value
+  end
+
+  def self.clear_dumps!
+    @dumps = {}
+  end
+end

data/lib/data_keeper/database_config.rb

@@ -0,0 +1,31 @@
+module DataKeeper
+  module DatabaseConfig
+    def database_connection_config
+      Rails.configuration.database_configuration[Rails.env]
+    end
+
+    def psql_env
+      env = { 'PGUSER' => database_connection_config['username'] }
+      env['PGPASSWORD'] = database_connection_config['password'] if database_connection_config['password']
+      env
+    end
+
+    def host
+      database_connection_config['host'] || '127.0.0.1'
+    end
+
+    def database
+      database_connection_config['database']
+    end
+
+    def port
+      database_connection_config['port']
+    end
+
+    def connection_args
+      connection_opts = '--host=:host'
+      connection_opts += ' --port=:port' if database_connection_config['port']
+      connection_opts
+    end
+  end
+end

data/lib/data_keeper/database_helper.rb

@@ -0,0 +1,24 @@
+module DataKeeper
+  class DatabaseHelper
+    include DatabaseConfig
+
+    def kill
+      cmd = Terrapin::CommandLine.new(
+        'psql',
+        "-c :command #{connection_args} --dbname #{database} &> /dev/null || true",
+        environment: psql_env
+      )
+
+      cmd.run(
+        database: database,
+        host: host,
+        port: port,
+        command: "SELECT pid, pg_terminate_backend(pid) as terminated FROM pg_stat_activity WHERE pid <> pg_backend_pid();"
+      )
+    end
+
+    def self.kill
+      new.kill
+    end
+  end
+end

data/lib/data_keeper/definition.rb

@@ -0,0 +1,62 @@
+module DataKeeper
+  InvalidDumpType = Class.new(Error)
+  InvalidDumpDefinition = Class.new(Error)
+
+  class Definition
+    attr_reader :type, :on_after_load_block
+
+    def initialize(type, tables, sqls, on_after_load_block)
+      @type = type
+      @tables = tables
+      @sqls = sqls
+      @on_after_load_block = on_after_load_block
+    end
+
+    def full_tables
+      @tables
+    end
+
+    def sqls
+      @sqls
+    end
+
+    def full_tables_to_export
+      full_tables + ['schema_migrations']
+    end
+  end
+
+  class DefinitionBuilder
+    attr_reader :tables, :raw_sqls, :on_after_load_block
+
+    def initialize(definition_block)
+      @tables = []
+      @raw_sqls = {}
+      instance_eval(&definition_block) if definition_block
+    end
+
+    def self.build(type, block)
+      @type = type
+      raise InvalidDumpType, "Invalid type! use :partial or :full" unless [:partial, :full].include?(type)
+
+      builder = new(block)
+
+      Definition.new(type, builder.tables, builder.raw_sqls, builder.on_after_load_block)
+    end
+
+    def table(name)
+      raise InvalidDumpDefinition if @type == :full
+      raise(InvalidDumpDefinition, "table already defined") if @tables.include?(name)
+      @tables << name
+    end
+
+    def sql(table, name, &block)
+      raise InvalidDumpDefinition if @type == :full
+      raise(InvalidDumpDefinition, "sql already defined") if @raw_sqls.key?(name)
+      @raw_sqls[name] = [table, block]
+    end
+
+    def on_after_load(&block)
+      @on_after_load_block = block
+    end
+  end
+end

data/lib/data_keeper/dumper.rb

@@ -0,0 +1,143 @@
+require 'data_keeper/database_config'
+require 'tempfile'
+
+module DataKeeper
+  class Dumper
+    include DatabaseConfig
+
+    def initialize(name, definition)
+      @dump_name = name
+      @definition = definition
+    end
+
+    def run!(&block)
+      if @definition.type == :full
+        dump_full_database(&block)
+      else
+        dump_partial_database(&block)
+      end
+    end
+
+    private
+
+    def dump_full_database
+      Tempfile.create do |file|
+        cmd = Terrapin::CommandLine.new(
+          'pg_dump',
+          "#{connection_args} -x -Fc :database > :output_path",
+          environment: psql_env
+        )
+
+        cmd.run(
+          database: database,
+          host: host,
+          port: port,
+          output_path: file.path
+        )
+
+        yield file, "#{filename}.dump"
+      end
+    end
+
+    def dump_partial_database
+      Tempfile.create do |file|
+        file.binmode
+
+        Zlib::GzipWriter.wrap(file) do |gzip|
+          Gem::Package::TarWriter.new(gzip) do |tar|
+            dump_schema(tar)
+            dump_partial_tables(tar)
+            dump_sqls(tar)
+          end
+        end
+
+        yield file, "#{filename}.tar.gz"
+      end
+    end
+
+    def dump_sqls(tar)
+      @definition.sqls.each do |name, (_table, sql)|
+        Tempfile.create do |table_file|
+          cmd = Terrapin::CommandLine.new(
+            'psql',
+            "#{connection_args} -d :database -c :command > #{table_file.path}",
+            environment: psql_env
+          )
+
+          cmd.run(
+            database: database,
+            host: host,
+            port: port,
+            command: "COPY (#{sql.call}) to STDOUT DELIMITER ',' CSV HEADER"
+          )
+
+          tar.add_file_simple("#{name}.csv", 0644, File.size(table_file.path)) do |io|
+            table_file.reopen(table_file)
+
+            while !table_file.eof?
+              io.write(table_file.read(2048))
+            end
+          end
+        end
+      end
+    end
+
+    def dump_partial_tables(tar)
+      Tempfile.create do |tables_dump_file|
+        tables_dump_file.binmode
+        table_args = @definition.full_tables_to_export.map { |table| "-t #{table}" }.join(' ')
+        cmd = Terrapin::CommandLine.new(
+          'pg_dump',
+          "#{connection_args} -x -Fc :database #{table_args} > :output_path",
+          environment: psql_env
+        )
+
+        cmd.run(
+          database: database,
+          host: host,
+          port: port,
+          output_path: tables_dump_file.path
+        )
+
+        tar.add_file_simple("tables.dump", 0644, File.size(tables_dump_file.path)) do |io|
+          tables_dump_file.reopen(tables_dump_file)
+
+          while !tables_dump_file.eof?
+            io.write(tables_dump_file.read(2048))
+          end
+        end
+      end
+    end
+
+    def dump_schema(tar)
+      Tempfile.create do |schema_dump_file|
+        schema_dump_file.binmode
+
+        cmd = Terrapin::CommandLine.new(
+          'pg_dump',
+          "#{connection_args} -x --schema-only -Fc :database > :output_path",
+          environment: psql_env
+        )
+
+        cmd.run(
+          database: database,
+          host: host,
+          port: port,
+          output_path: schema_dump_file.path
+        )
+
+        tar.add_file_simple("schema.dump", 0644, File.size(schema_dump_file.path)) do |io|
+          schema_dump_file.reopen(schema_dump_file)
+
+          while !schema_dump_file.eof?
+            io.write(schema_dump_file.read(2048))
+          end
+        end
+      end
+    end
+
+    def filename
+      "#{@dump_name}-#{Time.now.strftime("%Y%m%d-%H%M")}"
+    end
+  end
+end

data/lib/data_keeper/error.rb

@@ -0,0 +1,3 @@
+module DataKeeper
+  class Error < StandardError; end
+end

data/lib/data_keeper/loader.rb

@@ -0,0 +1,161 @@
+require 'data_keeper/database_config'
+
+module DataKeeper
+  class Loader
+    include DatabaseConfig
+
+    def initialize(dump, file)
+      @dump = dump
+      @file = file
+    end
+
+    def load!
+      if @dump.type == :full
+        load_full_database!
+      else
+        load_partial_database!
+      end
+
+      if @dump.on_after_load_block
+        @dump.on_after_load_block.call
+      end
+    end
+
+    private
+
+    def load_full_database!
+      pg_restore = Terrapin::CommandLine.new(
+        'pg_restore',
+        "#{connection_args} -j 4 --no-owner --dbname #{database} #{@file.path} 2>/dev/null",
+        environment: psql_env
+      )
+
+      pg_restore.run(
+        database: database,
+        host: host,
+        port: port
+      )
+
+      cmd = Terrapin::CommandLine.new(
+        'psql',
+        "#{connection_args} -d :database -c :sql",
+        environment: psql_env
+      )
+
+      cmd.run(
+        database: database,
+        host: host,
+        port: port,
+        sql: "UPDATE ar_internal_metadata SET value = 'development'"
+      )
+    end
+
+    def load_partial_database!
+      inflate(@file.path) do |schema_path, tables_path, sql_files|
+        pg_restore = Terrapin::CommandLine.new(
+          'pg_restore',
+          "#{connection_args} -j 4 --no-owner --dbname #{database} #{schema_path} 2>/dev/null",
+          environment: psql_env
+        )
+
+        pg_restore.run(
+          database: database,
+          host: host,
+          port: port
+        )
+
+        pg_restore = Terrapin::CommandLine.new(
+          'pg_restore',
+          "#{connection_args} -c -j 4 --no-owner --dbname #{database} #{tables_path} 2>/dev/null",
+          environment: psql_env
+        )
+
+        pg_restore.run(
+          database: database,
+          host: host,
+          port: port
+        )
+
+        sql_files.each do |table, csv_path|
+          cmd = Terrapin::CommandLine.new(
+            'psql',
+            "#{connection_args} -d :database -c :command < :csv_path",
+            environment: psql_env
+          )
+
+          cmd.run(
+            database: database,
+            host: host,
+            port: port,
+            csv_path: csv_path,
+            command: "COPY #{table} FROM stdin DELIMITER ',' CSV HEADER"
+          )
+        end
+
+        Rake::Task['db:environment:set'].invoke
+      end
+    end
+
+    class InflatedFiles
+      attr_reader :errors
+
+      def initialize(dump, paths)
+        @dump = dump
+        @paths = paths
+        @errors = []
+      end
+
+      def valid?
+        @errors = []
+
+        validate("Schema file is missing") { !!schema_path } &&
+          validate("Tables file is missing") { !!tables_path } &&
+          validate("Not all sql custom dumps are present") do
+            sql_dumps.size == @dump.sqls.keys.size
+          end
+      end
+
+      def schema_path
+        @schema_path ||= @paths.find { |x| File.basename(x) == "schema.dump" }
+      end
+
+      def tables_path
+        @tables_path ||= @paths.find { |x| File.basename(x) == "tables.dump" }
+      end
+
+      def sql_dumps
+        @sql_dumps ||= @dump.sqls.map do |name, (table, _proc)|
+          path = @paths.find { |x| File.basename(x) == "#{name}.csv" }
+          next unless path
+
+          [table, path]
+        end.compact
+      end
+
+      private
+
+      def validate(error_message)
+        result = yield
+        @errors << error_message unless result
+        result
+      end
+    end
+
+    def inflate(path)
+      Dir.mktmpdir do |dir|
+        File.open(path, "rb") do |f|
+          Gem::Package.new("").extract_tar_gz(f, dir)
+
+          inflated_files = InflatedFiles.new(@dump, Dir.glob(File.join(dir, "*")))
+          raise inflated_files.errors.join(", ") unless inflated_files.valid?
+
+          yield(
+            inflated_files.schema_path,
+            inflated_files.tables_path,
+            inflated_files.sql_dumps
+          )
+        end
+      end
+    end
+  end
+end

data/lib/data_keeper/local_storage.rb

@@ -0,0 +1,46 @@
+require 'sshkit'
+require 'tempfile'
+require 'fileutils'
+
+module DataKeeper
+  class LocalStorage
+    include SSHKit::DSL
+
+    def initialize(data)
+      @local_store_dir = data[:local_store_dir]
+      @remote_access = data[:remote_access]
+    end
+
+    def save(file, filename, dump_name)
+      path = dump_path(dump_name, filename)
+      FileUtils.mkdir_p(File.dirname(path))
+
+      FileUtils.cp(file.path, path)
+    end
+
+    def retrieve(dump_name)
+      tempfile = Tempfile.new
+      local_store_dir = @local_store_dir
+
+      on complete_host do
+        last_dump = capture :ls, "-1t #{File.join(local_store_dir, dump_name.to_s)} | head -n 1"
+
+        download! File.join(local_store_dir, dump_name.to_s, last_dump), tempfile.path
+      end
+
+      yield(tempfile)
+    ensure
+      tempfile.delete
+    end
+
+    private
+
+    def complete_host
+      "#{@remote_access[:user]}@#{@remote_access[:host]}:#{@remote_access[:port]}"
+    end
+
+    def dump_path(dump_name, filename)
+      File.join(@local_store_dir, dump_name.to_s, filename)
+    end
+  end
+end

data/lib/data_keeper/railtie.rb

@@ -0,0 +1,10 @@
+module DataKeeper
+  class Railtie < Rails::Railtie
+    railtie_name :data_keeper
+
+    rake_tasks do
+      path = File.expand_path(__dir__)
+      Dir.glob("#{path}/tasks/*.rake").each { |f| load f }
+    end
+  end
+end

data/lib/data_keeper/tasks/data_keeper.rake

@@ -0,0 +1,38 @@
+namespace :data_keeper do
+  task :kill do
+    raise "Cannot be run in production!" if Rails.env.production?
+
+    DataKeeper::DatabaseHelper.kill
+  end
+
+  desc "Fetches and loads the given dump in your local database. WARN: Will remove all your current data."
+  task :pull, [:name] => [:kill, "db:drop", "db:create"] do |_t, args|
+    raise "NOT IN PRODUCTION" if Rails.env.production?
+
+    name = args[:name]
+
+    if name.blank? || !DataKeeper.dump?(name)
+      raise "Please use this rake task giving a name of a configured dump. Ex: bin/rake data_keeper:pull[full]"
+    end
+
+    DataKeeper.fetch_and_load_dump!(name)
+  end
+
+  desc "Loads the given dump (found on the given local path) and applies it to your local database. WARN: Will remove all your current data."
+  task :load, [:name, :path] => [:kill, "db:drop", "db:create"] do |_t, args|
+    raise "NOT IN PRODUCTION" if Rails.env.production?
+
+    name = args[:name]
+    path = args[:path]
+
+    if name.blank? || !DataKeeper.dump?(name)
+      raise "Please use this rake task giving a name of a configured dump."
+    end
+
+    unless File.file?(path)
+      raise "The given file '#{path}' does not exist."
+    end
+
+    DataKeeper.load_dump!(name, path)
+  end
+end

data/lib/data_keeper/version.rb

@@ -0,0 +1,3 @@
+module DataKeeper
+  VERSION = "0.1.0"
+end

data/todo.md

@@ -0,0 +1,14 @@
+- decouple from rails / ar
+
+- implement partial loads. What about the structure? load from schema.rb first (db:schema:load or db:structure:apply),
+  then load db.
+  
+- add anonymizing feature of certain columns
+
+- skip download if present in cache. Clear cache.
+
+- add s3 storage
+
+- add option to apply dump but creating tables with "create table unlogged", can be useful for performance in tests
+  or even locally
+  

metadata

@@ -0,0 +1,121 @@
+--- !ruby/object:Gem::Specification
+name: data_keeper
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Roger Campos
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2020-12-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.2.0
+- !ruby/object:Gem::Dependency
+  name: terrapin
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.5.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.5.0
+- !ruby/object:Gem::Dependency
+  name: sshkit
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.20.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.20.0
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.0.0
+description: Easy management of database dumps for dev env
+email:
+- roger@rogercampos.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- data_keeper.gemspec
+- lib/data_keeper.rb
+- lib/data_keeper/database_config.rb
+- lib/data_keeper/database_helper.rb
+- lib/data_keeper/definition.rb
+- lib/data_keeper/dumper.rb
+- lib/data_keeper/error.rb
+- lib/data_keeper/loader.rb
+- lib/data_keeper/local_storage.rb
+- lib/data_keeper/railtie.rb
+- lib/data_keeper/tasks/data_keeper.rake
+- lib/data_keeper/version.rb
+- todo.md
+homepage: https://github.com/rogercampos/data_keeper
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/rogercampos/data_keeper
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.3.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3
+signing_key: 
+specification_version: 4
+summary: Easy management of database dumps for dev env
+test_files: []