capistrano-db_sync 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 560f9902b7556b03a2206f1b3125d68d906000ed
+  data.tar.gz: fc422d26be8a12e80bae35f88e9918286439a3ec
+SHA512:
+  metadata.gz: 001d12a9c6bbfce2689c49d47d6c9c8752d7792fa28355149b120306da264a33e40f4047ca41255067fb57ec4080832611006699619bed491dd009abbc2d2ca8
+  data.tar.gz: 1b0d4fdfd2210b57bedba454ef62446c952196462e5affd89effece893ba10d6fcf3b531d704b573ecfe837b72b1b60bc07ec0111c0ba3aaa3bccda5f9141909

data/.gitignore

@@ -0,0 +1,34 @@
+*.gem
+*.rbc
+/.config
+/coverage/
+/InstalledFiles
+/pkg/
+/spec/reports/
+/test/tmp/
+/test/version_tmp/
+/tmp/
+
+## Specific to RubyMotion:
+.dat*
+.repl_history
+build/
+
+## Documentation cache and generated files:
+/.yardoc/
+/_yardoc/
+/doc/
+/rdoc/
+
+## Environment normalisation:
+/.bundle/
+/lib/bundler/man/
+
+# for a library or gem, you might want to ignore these files since the code is
+# intended to run in multiple environments; otherwise, check them in:
+Gemfile.lock
+.ruby-version
+.ruby-gemset
+
+# unless supporting rvm < 1.11.0 or doing something fancy, ignore this:
+.rvmrc

data/Gemfile

@@ -0,0 +1,15 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in capistrano-pg_sync.gemspec
+gemspec
+
+group :development, :test do
+  gem "bundler", "~> 1.7"
+  gem "rake", "~> 10.0"
+  gem "pry-byebug"
+end
+
+group :test do
+  gem "minitest"
+  gem "mocha"
+end

data/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Rafael Sales
+
+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,83 @@
+## Capistrano::DBSync
+
+Fast and sophisticated remote database import using the best of **Postgres 9.2.x**
+
+### Features
+
+* Allows dump data selectively - partial table data or no data
+* Uses Postgres parallel restore
+* Uses Postgres custom dump format that is automatically compressed
+
+### Requirements
+
+* Capistrano 3.x
+* Postgres 9.2.x
+* It was tested with Rails only, but it is expected to work in any project containing
+  `config/database.yml` file in both local and remote machine.
+
+### Installation
+
+1. Add this line to your application's Gemfile:
+
+   ```ruby
+   gem 'capistrano-pg_sync', require: false
+   ```
+
+2. Define your custom settings, if needed. We suggest to locate this file at `lib/capistrano/tasks/db_sync.rake`.
+   Capistrano 3.x should load all `*.rake` files by default in `Capfile`.
+   [See the complete configuration reference](/lib/capistrano/db_sync/configuration.rb)
+
+   ```ruby
+   require 'capistrano/db_sync'
+
+   set :db_sync_options, -> do
+      {
+        # Hash mapping a table name to a query with data selection or nil in case no data
+        # is wanted for a table. Tables not listed here will be dumped entirely.
+        data_selection: {
+          posts:    "SELECT * FROM posts    WHERE created_at > NOW() - interval '60 days'",
+          comments: "SELECT * FROM comments WHERE created_at > NOW() - interval '30 days'",
+          likes: nil
+        },
+
+        local: {
+          cleanup: false, # If the downloaded dump directory should be removed after restored
+          pg_jobs: 2, # Number of jobs to run in parallel on pg_restore
+        },
+
+        remote: {
+          cleanup: true, # If the remote dump directory should be removed after downloaded
+        }
+      }
+    end
+    ```
+
+### Usage
+
+```sh-session
+$ cap production db_sync:import
+```
+
+### How it works
+
+The following steps describe what happens when executing `cap production db_sync:import`:
+
+1. SSH into production server with primary db role on capistrano stages configuration
+2. Connect to the remote Postgres using credentials of `config/database.yml` in the
+   deployed server
+3. Dump the database schema, data, triggers, constraints, rules and indexes
+4. Download the compressed dump files to local machine
+5. Restore the dumps in local machine in following sequence
+   1. database schema
+   2. data for tables with entire data dumped
+   3. data for tables with partial data specified in configuration
+   4. triggers, constraints, rules and indexes
+
+
+### Contributing
+
+1. Fork it ( https://github.com/rafaelsales/capistrano-db_sync/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,7 @@
+require "bundler/gem_tasks"
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.libs += ["spec", "lib"]
+  t.test_files = FileList['spec/**/*_spec.rb']
+end

data/capistrano-db_sync.gemspec

@@ -0,0 +1,22 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'capistrano/db_sync/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "capistrano-db_sync"
+  spec.version       = Capistrano::DBSync::VERSION
+  spec.authors       = ["Rafael Sales"]
+  spec.email         = ["rafaelcds@gmail.com"]
+  spec.summary       = %q{A capistrano task to import remote Postgres databases}
+  spec.description   = %q{Fast download and restore dumps using edge features of Postgres 9.x}
+  spec.homepage      = "https://github.com/rafaelsales/capistrano-db_sync"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  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_runtime_dependency "capistrano", ">= 3.0.0"
+end

data/lib/capistrano/db_sync/configuration.rb

@@ -0,0 +1,61 @@
+module Capistrano::DBSync
+  class Configuration
+    extend Forwardable
+
+    DEFAULT_OPTIONS = ->(cap) do
+      {
+        # Hash mapping a table name to a query or nil in case no data is wanted for a table.
+        # E.g.: {
+        #   posts:    "SELECT * FROM posts    WHERE created_at > NOW() - interval '60 days'",
+        #   comments: "SELECT * FROM comments WHERE created_at > NOW() - interval '30 days'",
+        #   likes: nil
+        # }
+        data_selection: {},
+
+        data_sync_confirmation: true, # Ask for user input confirmation
+
+        local: {
+          cleanup: false, # If the downloaded dump directory should be removed after restored
+
+          pg_jobs: 1, # Number of jobs to run in parallel on pg_restore
+
+          working_dir: "./tmp",
+          env: ENV.fetch('RAILS_ENV', 'development'),
+        },
+
+        remote: {
+          cleanup: true, # If the remote dump directory should be removed after downloaded
+
+          working_dir: "/tmp",
+          env: cap.fetch(:stage).to_s,
+        },
+      }
+    end
+
+    def initialize(cap_instance = Capistrano.env)
+      @cap = cap_instance
+      @options = load_options
+    end
+
+    def load_options
+      user_options = cap.fetch(:db_sync_options)
+      DEFAULT_OPTIONS.call(cap).deep_merge(user_options)
+    end
+
+    def data_sync_confirmed?
+      skip = options[:data_sync_confirmation].to_s.downcase == "false"
+      skip || prompt("Confirm replace local database with remote database?")
+    end
+
+    def_delegators :@options, :[], :fetch
+
+    private
+
+    attr_reader :cap, :options
+
+    def prompt(message, prompt = "(y)es, (n)o")
+      cap.ask(:prompt_answer, "#{message} #{prompt}")
+      (cap.fetch(:prompt_answer) =~ /^y|yes$/i) == 0
+    end
+  end
+end

data/lib/capistrano/db_sync/executor/base.rb

@@ -0,0 +1,35 @@
+module Capistrano::DBSync
+  module Executor
+    class Base
+
+      # +side+ must be :local or :remote
+      def initialize(cap, config, side)
+        @cap        = cap
+        @config     = config
+        @session_id = Time.now.strftime("%Y-%m-%d-%H%M%S")
+        @side       = side
+      end
+
+      def working_dir
+        File.join config[side][:working_dir]
+      end
+
+      def env
+        config[side][:env].to_s
+      end
+
+      def cleanup?
+        config[side][:cleanup]
+      end
+
+      private
+
+      def load_db_config!(config_file_contents)
+        yaml = YAML.load(ERB.new(config_file_contents).result)
+        @db_config = yaml[env].tap { |db_config| Postgres.validate!(db_config) }
+      end
+
+      attr_reader :cap, :config, :db_config, :side, :session_id
+    end
+  end
+end

data/lib/capistrano/db_sync/executor/local.rb

@@ -0,0 +1,38 @@
+require "fileutils"
+
+module Capistrano::DBSync
+  module Executor
+    class Local < Base
+      def initialize(cap, config)
+        super(cap, config, :local)
+        load_db_config!(File.read File.join("config", "database.yml"))
+      end
+
+      def restore!(dump_dir)
+        importer(dump_dir).restore(jobs: config[:local][:pg_jobs]).each do |cmd|
+          cap.info "Running locally: #{cmd}"
+          system(cmd)
+        end
+
+        cap.info "Completed database restore."
+      ensure
+        clean_dump_if_needed!(dump_dir)
+      end
+
+      private
+
+      def clean_dump_if_needed!(dump_dir)
+        if cleanup?
+          FileUtils.rm_rf dump_dir
+          cap.info "Removed #{dump_dir} locally."
+        else
+          cap.info "Leaving #{dump_dir} locally. Use \"local: { cleanup: true }\" to remove."
+        end
+      end
+
+      def importer(dump_dir)
+        Postgres::Importer.new(dump_dir, db_config)
+      end
+    end
+  end
+end

data/lib/capistrano/db_sync/executor/remote.rb

@@ -0,0 +1,56 @@
+module Capistrano::DBSync
+  module Executor
+    class Remote < Base
+      def initialize(cap, config)
+        super(cap, config, :remote)
+        load_db_config! cap.capture("cat #{File.join cap.current_path, 'config', 'database.yml'}")
+      end
+
+      # Returns the dump directory location that was downloaded to local
+      # machine, which is based on +local_working_dir+.
+      def dump_and_download_to!(local_working_dir)
+        dump!
+        download_to!(local_working_dir)
+      ensure
+        clean_dump_if_needed!
+      end
+
+      private
+
+      def dump!
+        cap.execute "mkdir -p #{dump_dir}"
+
+        exporter.dump(data_selection: config[:data_selection]).each do |cmd|
+          cap.execute cmd
+        end
+      end
+
+      def download_to!(local_working_dir)
+        system "mkdir -p #{local_working_dir}"
+        cap.download! dump_dir, local_working_dir, recursive: true
+
+        cap.info "Completed database dump and download."
+        File.join(local_working_dir, File.basename(dump_dir))
+      end
+
+      def clean_dump_if_needed!
+        if cleanup?
+          cap.execute "rm -rf #{dump_dir}"
+          cap.info "Removed #{dump_dir} from the server."
+        else
+          cap.info "Leaving #{dump_dir} on the server. Use \"remote: { cleanup: true}\" to remove."
+        end
+      end
+
+      private
+
+      def exporter
+        Postgres::Exporter.new(dump_dir, db_config)
+      end
+
+      def dump_dir
+        File.join(working_dir, "dump_#{session_id}_#{db_config['database']}")
+      end
+    end
+  end
+end

data/lib/capistrano/db_sync/postgres/cli.rb

@@ -0,0 +1,71 @@
+class Capistrano::DBSync::Postgres::CLI
+  def initialize(config)
+    @config = config
+  end
+
+  def dump(to_file, db, options = [])
+    "#{with_pw} pg_dump #{credentials} #{format_args} -f #{to_file} #{options.join(' ')} #{db}"
+  end
+
+  def restore(from_file, db, options = [])
+    "#{with_pw} pg_restore #{credentials} #{format_args} -d #{db} #{options.join(' ')} #{from_file}"
+  end
+
+  def drop_db(db)
+    psql %Q|DROP DATABASE IF EXISTS "#{db}";|
+  end
+
+  def create_db(db)
+    psql %Q|CREATE DATABASE "#{db}";|
+  end
+
+  def rename_db(old_db, new_db)
+    psql %Q|ALTER DATABASE "#{old_db}" RENAME TO "#{new_db}";|
+  end
+
+  def clone_db(new_db, template_db)
+    psql %Q|CREATE DATABASE "#{new_db}" WITH TEMPLATE "#{template_db}";|
+  end
+
+  def psql(command, db = "postgres")
+    normalized_command = command.gsub('"', '\"').gsub(/\s\s+|\n/, " ")
+    %Q|#{with_pw} psql #{credentials} -d #{db} -c "#{normalized_command}"|
+  end
+
+  def kill_processes_for_db(db)
+    psql <<-SQL.gsub("$", "\\$")
+      SELECT pg_terminate_backend(pg_stat_activity.pid)
+        FROM pg_stat_activity
+       WHERE pg_stat_activity.datname = $$#{db}$$
+         AND pid <> pg_backend_pid();
+    SQL
+  end
+
+  def copy_to_file(to_compressed_file, db, query)
+    psql "\\COPY (#{query}) TO PROGRAM 'gzip > #{to_compressed_file}'", db
+  end
+
+  def copy_from_file(from_compressed_file, db, table)
+    psql "\\COPY #{table} FROM PROGRAM 'gunzip --to-stdout #{from_compressed_file}'", db
+  end
+
+  private
+
+  def format_args
+    "--no-acl --no-owner --format=custom"
+  end
+
+  def credentials
+    credentials_params = []
+    credentials_params << "-U #{config['username']}" unless config.fetch('username', '').empty?
+    credentials_params << "-h #{config['host']}"     unless config.fetch('host', '').empty?
+    credentials_params << "-p #{config['port']}"     unless config.fetch('port', '').empty?
+    credentials_params.join(" ")
+  end
+
+  def with_pw
+    "PGPASSWORD='#{config['password']}'" unless config.fetch('password', '').empty?
+  end
+
+  attr_reader :config, :session_id
+end

data/lib/capistrano/db_sync/postgres/exporter.rb

@@ -0,0 +1,61 @@
+module Capistrano::DBSync
+  class Postgres::Exporter
+
+    # +working_dir+: The location where the dump files will be stored for dump or read for restore.
+    # +config+: database configuration hash with following skeleton:
+    #           {
+    #             "database" => "faceburger_production",
+    #             "username" => "fb_prod",
+    #             "password" => "BestBurger",
+    #             "host"     => "10.20.30.40",
+    #             "port"     => "5432"
+    #           }
+    def initialize(working_dir, config)
+      @working_dir = working_dir
+      @config      = config
+      @cli         = Postgres::CLI.new(config)
+    end
+
+    # Returns a set of commands to dump a database with table data selection support.
+    #
+    # +db+ (optional): Database name to dump
+    # +data_selection+ (optional): A hash mapping a table name to a query or nil in
+    # case no data is wanted for a table.
+    #
+    # Example:
+    #
+    # dump("/tmp/dump",
+    #      data_selection:
+    #        posts:    "SELECT * FROM posts    WHERE created_at > NOW() - interval '60 days'",
+    #        comments: "SELECT * FROM comments WHERE created_at > NOW() - interval '30 days'",
+    #        likes: nil
+    #      },
+    #      db: "faceburger_production")
+    #
+    # This outputs commands that will generate dump files as:
+    #   /tmp/dump/0001-faceburger_production.schema -- will contain db schema and data except
+    #                                                  for tables posts, comments and likes
+    #   /tmp/dump/0002-posts.table    -- will contain partial data of table posts
+    #   /tmp/dump/0003.comments.table -- will contain partial data of table comments
+    #
+    def dump(db = config["database"], data_selection: {})
+      file_namer = Postgres::FileNameGenerator.new(working_dir)
+      exclude_tables_args = data_selection.keys.map { |table| %Q|--exclude-table-data="#{table}"| }
+
+      [
+        cli.dump(file_namer.next(db, :schema), db, [exclude_tables_args]),
+        *dump_partial_selected_data(db, file_namer, data_selection)
+      ]
+    end
+
+    private
+
+    def dump_partial_selected_data(db, file_namer, data_selection)
+      data_selection.map do |table, query|
+        cli.copy_to_file(file_namer.next(table, :table), db, query) if query
+      end.compact
+    end
+
+    attr_reader :working_dir, :config, :cli
+  end
+end

data/lib/capistrano/db_sync/postgres/file_name_generator.rb

@@ -0,0 +1,22 @@
+class Capistrano::DBSync::Postgres::FileNameGenerator
+  def initialize(path)
+    @path = path
+    @sequence = 0
+  end
+
+  # Generates sequential file names.
+  # Examples:
+  # next("faceburger", :schema) => 0001-faceburger.schema
+  # next("posts", :table)       => 0002-posts.table
+  # next("comments", :table)    => 0003-comments.table
+  def next(name, extension)
+    raise ArgumentError unless [:schema, :table].include?(extension)
+    @sequence += 1
+    File.join(@path, "%04i-#{name}.#{extension}" % @sequence)
+  end
+
+  def self.extract_name(file_path)
+    file_name = File.basename(file_path)
+    file_name.scan(/\d+-(.*)\.(schema|table)$/).flatten.first
+  end
+end

data/lib/capistrano/db_sync/postgres/importer.rb

@@ -0,0 +1,79 @@
+module Capistrano::DBSync
+  class Postgres::Importer
+
+    # +working_dir+: The location where the dump files will be stored for dump or read for restore.
+    # +config+: database configuration hash with following skeleton:
+    #           {
+    #             "database" => "faceburger_production",
+    #             "username" => "fb_prod",
+    #             "password" => "BestBurger",
+    #             "host"     => "10.20.30.40",
+    #             "port"     => "5432"
+    #           }
+    def initialize(working_dir, config)
+      @working_dir = working_dir
+      @config      = config
+      @cli         = Postgres::CLI.new(config)
+    end
+
+    # Returns a set of commands to dump a database with table data selection support.
+    #
+    # +db+ (optional): Database name to restore data into.
+    # +jobs+ (optional): Number of concurrent jobs that Postgres will run to restore.
+    #
+    # The +working_dir+ should contain files with following name and extension patterns:
+    #
+    #   /tmp/dump/0001-faceburger_production.schema -- contains db schema and data except
+    #                                                  for tables posts and comments
+    #   /tmp/dump/0002-posts.table    -- contains partial data of table posts
+    #   /tmp/dump/0003.comments.table -- contains partial data of table comments
+    def restore(db = config["database"], jobs: 1)
+      temp_db   = "#{db}_#{Time.now.strftime("%Y%m%d%H%M%S")}"
+
+      [
+        cli.kill_processes_for_db(temp_db),
+                      cli.drop_db(temp_db),
+                    cli.create_db(temp_db),
+                *restore_files_to(temp_db, jobs),
+        cli.kill_processes_for_db(db),
+                      cli.drop_db(db),
+                    cli.rename_db(temp_db, db)
+      ]
+    end
+
+    private
+
+    # Commands to restore pg_dump output file and partial tables data files generated by
+    # Postgres COPY command.
+    def restore_files_to(to_db, jobs)
+      [
+        restore_pg_dump_file(to_db, %w(pre-data data), jobs),
+        *restore_table_copy_files(to_db),
+        restore_pg_dump_file(to_db, %w(post-data), jobs)
+      ]
+    end
+
+    # The +sections+ argument must match one of the following supported sections on pg_dump command:
+    # - Pre-data: include all other data definition items.
+    # - Data: contains actual table data, large-object contents, and sequence values.
+    # - Post-data: include definitions of indexes, triggers, rules, and constraints other
+    #   than validated check constraints.
+    def restore_pg_dump_file(to_db, sections = %w(pre-data data post-data), jobs)
+      files = Dir.glob(File.join(working_dir, "*.schema"))
+      raise "Expected to have only one pg_dump file, but found these: #{files.inspect}" if files.size > 1
+
+      sections_args = sections.map { |section| "--section=#{section}" }
+      cli.restore(files.first, to_db, [*sections_args, "--jobs=#{jobs}"])
+    end
+
+    def restore_table_copy_files(to_db)
+      files = Dir.glob(File.join(working_dir, "*.table"))
+      files.map do |file|
+        table_name = Postgres::FileNameGenerator.extract_name(file)
+        cli.copy_from_file(file, to_db, table_name)
+      end
+    end
+
+    attr_reader :working_dir, :config, :cli
+  end
+end

data/lib/capistrano/db_sync/postgres.rb

@@ -0,0 +1,9 @@
+module Capistrano::DBSync
+  module Postgres
+    def self.validate!(config)
+      unless %w(postgresql pg).include? config['adapter']
+        raise NotImplementedError, "Database adapter #{config['adapter']} is not supported"
+      end
+    end
+  end
+end

data/lib/capistrano/db_sync/tasks.rake

@@ -0,0 +1,25 @@
+require "capistrano"
+require "capistrano/version"
+Bundler.require(:development)
+
+namespace :db_sync do
+  desc <<-DESC
+    Synchronize your local database using remote database data.
+    Usage: $ cap <stage> db:pull
+  DESC
+
+  task :import do
+    config = Capistrano::DBSync::Configuration.new(self)
+
+    if config.data_sync_confirmed?
+      on roles(:db, primary: true) do
+        local = Capistrano::DBSync::Executor::Local.new(self, config)
+        remote = Capistrano::DBSync::Executor::Remote.new(self, config)
+
+        downloaded_dir = remote.dump_and_download_to! config[:local][:working_dir]
+
+        local.restore!(downloaded_dir)
+      end
+    end
+  end
+end

data/lib/capistrano/db_sync/version.rb

@@ -0,0 +1,5 @@
+module Capistrano
+  module DBSync
+    VERSION = "0.0.2"
+  end
+end

data/lib/capistrano/db_sync.rb

@@ -0,0 +1,7 @@
+module Capistrano
+  module DBSync
+  end
+end
+
+Dir.glob(File.join(File.dirname(__FILE__), "/db_sync/**/*.rb")).sort.each { |f| require f }
+load File.join(File.dirname(__FILE__), "/db_sync/tasks.rake")

data/spec/lib/capistrano/db_sync/postgres/cli_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+describe Capistrano::DBSync::Postgres::CLI do
+  let(:config) do
+    {
+      "database" => "staging",
+      "username" => "user",
+      "password" => "pw",
+      "adapter"  => "postgresql",
+      "host"     => "127.0.0.1",
+      "port"     => "5432",
+    }
+  end
+
+  let(:cli) { Capistrano::DBSync::Postgres::CLI.new(config) }
+
+  describe "#dump" do
+    it "generates pg_dump command" do
+      command = cli.dump("/tmp/staging.dump", "staging", ["--section=pre-data"])
+      command.must_equal "PGPASSWORD='pw' pg_dump -U user -h 127.0.0.1 -p 5432 --no-acl --no-owner --format=custom -f /tmp/staging.dump --section=pre-data staging"
+    end
+  end
+
+  describe "#restore" do
+    it "generates pg_dump command" do
+      command = cli.restore("/db/production.dump", "staging", ["--jobs=3"])
+      command.must_equal "PGPASSWORD='pw' pg_restore -U user -h 127.0.0.1 -p 5432 --no-acl --no-owner --format=custom -d staging --jobs=3 /db/production.dump"
+    end
+  end
+end

data/spec/lib/capistrano/db_sync/postgres/exporter_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+describe Capistrano::DBSync::Postgres::Exporter do
+  let(:working_dir) { "/tmp/dumps/" }
+  let(:config)      { { "database" => "faceburger_production", "host" => "10.20.30.40" } }
+  let(:exporter)    { Capistrano::DBSync::Postgres::Exporter.new(working_dir, config) }
+
+  describe "#dump" do
+    let(:data_selection) do
+      {
+        campaigns:   "SELECT * FROM campaigns WHERE date > NOW() - interval '160 days'",
+        keywords:    "SELECT * FROM keywords  WHERE created_at > NOW() - interval '160 days'",
+        phone_calls: nil
+      }
+    end
+
+    it "restore dump files" do
+      commands = exporter.dump(data_selection: data_selection)
+
+      # Assert dumping database schema with data except for tables specified on data_selection
+      commands[0].must_match /pg_dump.* -f \/tmp\/dumps\/0001-faceburger_production\.schema/
+      commands[0].must_match /--exclude-table-data="campaigns"/
+      commands[0].must_match /--exclude-table-data="keywords"/
+      commands[0].must_match /--exclude-table-data="phone_calls"/
+
+      # Assert dumping data for tables specified on data_selection
+      commands[1].must_match /COPY.*campaigns.*\/tmp\/dumps\/0002-campaigns\.table/
+      commands[2].must_match /COPY.*keywords.*\/tmp\/dumps\/0003-keywords\.table/
+    end
+  end
+end

data/spec/lib/capistrano/db_sync/postgres/importer_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+describe Capistrano::DBSync::Postgres::Importer do
+  let(:working_dir) { "/tmp/dumps/" }
+  let(:config)      { { "database" => "faceburger_development", "host" => "localhost" } }
+  let(:importer)    { Capistrano::DBSync::Postgres::Importer.new(working_dir, config) }
+
+  describe "#restore" do
+    before do
+      Dir.stubs(:glob).with("/tmp/dumps/*.schema")
+        .returns(["/tmp/dumps/0001-faceburger_production.schema"])
+
+      Dir.stubs(:glob).with("/tmp/dumps/*.table")
+        .returns(["/tmp/dumps/0002-campaigns.table", "/tmp/dumps/0003-keywords.table"])
+    end
+
+    it "restore dump files" do
+      commands = importer.restore(jobs: 3)
+
+      # Assert drop and create temporary database
+      commands[0].must_match /pg_terminate_backend.*faceburger_development_\d+/m
+      commands[1].must_match /DROP DATABASE IF EXISTS.*faceburger_development_\d+/
+      commands[2].must_match /CREATE DATABASE.*faceburger_development_\d+/
+
+      # Assert restore schema definition and data of tables with full data
+      commands[3].must_match /pg_restore.*--section=pre-data --section=data --jobs=3/
+      commands[3].must_match /pg_restore.* \/tmp\/dumps\/0001-faceburger_production\.schema/
+
+      # Assert import selective tables data
+      commands[4].must_match /COPY campaigns.*\/tmp\/dumps\/0002-campaigns\.table/
+      commands[5].must_match /COPY keywords.*\/tmp\/dumps\/0003-keywords\.table/
+
+      # Assert restore indexes, constraints, triggers and rules
+      commands[6].must_match /pg_restore.*--section=post-data --jobs=3/
+      commands[6].must_match /pg_restore.* \/tmp\/dumps\/0001-faceburger_production\.schema/
+
+      # Assert rename the temporary database to target restoring database name
+      commands[7].must_match /pg_terminate_backend.*faceburger_development/m
+      commands[8].must_match /DROP DATABASE IF EXISTS.*faceburger_development/
+      commands[9].must_match /ALTER DATABASE.*faceburger_development_\d+.*RENAME TO.*faceburger_development.*/
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,5 @@
+require 'pry'
+require 'capistrano/db_sync'
+require 'minitest/autorun'
+require 'minitest/pride'
+require 'mocha/mini_test'

metadata

@@ -0,0 +1,84 @@
+--- !ruby/object:Gem::Specification
+name: capistrano-db_sync
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+platform: ruby
+authors:
+- Rafael Sales
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-03-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: capistrano
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+description: Fast download and restore dumps using edge features of Postgres 9.x
+email:
+- rafaelcds@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- capistrano-db_sync.gemspec
+- lib/capistrano/db_sync.rb
+- lib/capistrano/db_sync/configuration.rb
+- lib/capistrano/db_sync/executor/base.rb
+- lib/capistrano/db_sync/executor/local.rb
+- lib/capistrano/db_sync/executor/remote.rb
+- lib/capistrano/db_sync/postgres.rb
+- lib/capistrano/db_sync/postgres/cli.rb
+- lib/capistrano/db_sync/postgres/exporter.rb
+- lib/capistrano/db_sync/postgres/file_name_generator.rb
+- lib/capistrano/db_sync/postgres/importer.rb
+- lib/capistrano/db_sync/tasks.rake
+- lib/capistrano/db_sync/version.rb
+- spec/lib/capistrano/db_sync/postgres/cli_spec.rb
+- spec/lib/capistrano/db_sync/postgres/exporter_spec.rb
+- spec/lib/capistrano/db_sync/postgres/importer_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/rafaelsales/capistrano-db_sync
+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.4.5
+signing_key: 
+specification_version: 4
+summary: A capistrano task to import remote Postgres databases
+test_files:
+- spec/lib/capistrano/db_sync/postgres/cli_spec.rb
+- spec/lib/capistrano/db_sync/postgres/exporter_spec.rb
+- spec/lib/capistrano/db_sync/postgres/importer_spec.rb
+- spec/spec_helper.rb