postgres-clone 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 6aa1bdbfbc49b007f45a70183cfcf64f67f74d59
+  data.tar.gz: 6b42f1372dec85cb75629a7dae0ff2991e71baf6
+SHA512:
+  metadata.gz: 2bbf06fd4cf8f2b4ca18f443d434b3bbf5d8da59d78f228a83269abacf04c6131b41af26e4cba9a5a6f4a3b86bc6e84dc538c89ef8c36082637a5d84e0bf0622
+  data.tar.gz: 9a246fda241024a02fcea58c080389057d89a0da1f33ce7bc3a1281e2a6a4bb06bec112405f523b98284d7f7bb94ec19ab110f4d7a3704685b1dfe6d23e850fd

data/.gitignore

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

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--order random

data/.travis.yml

@@ -0,0 +1,4 @@
+language: ruby
+rvm:
+  - 2.2.4
+before_install: gem install bundler -v 1.11.2

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in postgres-clone.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Josh Rickard
+
+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,73 @@
+[![Build Status](https://travis-ci.org/joshrickard/postgres-clone.svg?branch=master)](https://travis-ci.org/joshrickard/postgres-clone)
+
+# PostgresClone
+
+A command line utility for cloning Postgres databases.
+
+
+## Installation
+
+```ruby
+gem install postgres-clone
+```
+
+
+## Usage
+
+After installing the `postgres-clone` gem, you will have access to the `pg-clone` command which facilitates copying Postgres databases.
+
+`pg-clone` will ssh into the remote server, perform a `pg_dump`, copy the dump to the target server, and then perform a `pg_restore`.
+
+
+### Options
+
+TODO:
+
+
+### Examples
+
+**Remote to Local**
+
+```
+# Dump remote database and restore to local Postgres server
+pg-clone --src-host=db.example.com --src-db=database --dst-host=localhost
+```
+
+**Remote to Remote**
+
+```
+# Dump remote database and restore to a different remote Postgres server
+pg-clone --src-host=db1.example.com --src-db=database --dst-host=db2.example.com
+```
+
+**Local to Local**
+
+```
+# Duplicate local Postgres database
+pg-clone --src-host=local --src-db=database --dst-host=localhost
+```
+
+**Local to Remote**
+
+```
+# Dump local database and restore to a remote database server
+pg-clone --src-host=local --src-db=database --dst-host=db.example.com
+```
+
+
+## TODOS
+
+* Test keyless runs
+* Clean up database dumps?
+* Add checks for existing databases
+* Add options for all prompts
+* Check for existing dump on target machines before doing work
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/joshrickard/postgres-clone.
+
+
+## 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,6 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require 'bundler/setup'
+require 'postgres-clone'
+
+# 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

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/exe/pg-clone

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+
+require 'bundler/setup'
+require 'postgres-clone'
+
+Postgres::Clone::Executable.start(ARGV)

data/lib/postgres-clone.rb

@@ -0,0 +1,6 @@
+require 'postgres/clone/version'
+require 'postgres/clone/executable'
+
+module Postgres
+
+end

data/lib/postgres/clone/command_line.rb

@@ -0,0 +1,21 @@
+require 'postgres/clone/logger'
+
+module Postgres
+  module Clone
+    module CommandLine
+      include Logger
+
+      def build_command(command, sudo: false, user: nil)
+        if sudo
+          "sudo#{user.nil? ? '' : " -u #{user}"} #{command}"
+        else
+          command
+        end
+      end
+
+      def log_command(host_name, command)
+        log_message(Rainbow("[#{host_name}] Executing: #{command}").darkgray)
+      end
+    end
+  end
+end

data/lib/postgres/clone/command_result.rb

@@ -0,0 +1,20 @@
+module Postgres
+  module Clone
+    class CommandResult
+      attr_reader :exit_code, :output
+
+      def initialize(exit_code:, output:)
+        @exit_code = exit_code
+        @output = output.strip
+      end
+
+      def failed?
+        !success?
+      end
+
+      def success?
+        exit_code == 0
+      end
+    end
+  end
+end

data/lib/postgres/clone/commands.rb

@@ -0,0 +1,211 @@
+require 'etc'
+require 'postgres/clone/command_result'
+require 'postgres/clone/local_commands'
+require 'postgres/clone/logger'
+require 'postgres/clone/remote_commands'
+
+module Postgres; module Clone;
+  module Commands
+    include Logger
+    include LocalCommands
+    include RemoteCommands
+
+    def copy_file(src_host, dst_host, file_path)
+      log_message("Copying #{file_path} from #{src_host} to #{dst_host}", header: '')
+
+      if src_host == dst_host
+        log_message(src_host, 'Source and destination host are the same, skipping file copy', color: :yellow, header: '')
+        return
+      end
+
+      result =
+        if local_host?(src_host)
+          if file_exists?(dst_host, file_path)
+            puts Rainbow("[#{dst_host}] File #{file_path} already exists!").green
+            return if %w(yes y).include?(
+              ask(Rainbow('Would you like to restore the existing dump (y/n)?').yellow).downcase
+            )
+            abort Rainbow("[#{dst_host}] File #{file_path} already exists!").red
+          else
+            run_local("scp #{file_path} #{dst_host}:#{file_path}")
+          end
+        elsif local_host?(dst_host)
+          if file_exists?('localhost', file_path)
+            puts Rainbow("[localhost] File #{file_path} already exists!").green
+            return if %w(yes y).include?(
+              ask(Rainbow('Would you like to restore the existing dump (y/n)?').yellow).downcase
+            )
+            abort Rainbow("[localhost] File #{file_path} already exists!").red
+          else
+            run_local("scp #{src_host}:#{file_path} #{file_path}")
+          end
+        else
+          if file_exists?(dst_host, file_path)
+            puts Rainbow("[#{dst_host}] File #{file_path} already exists!").green
+            return if %w(yes y).include?(
+              ask(Rainbow('Would you like to restore the existing dump (y/n)?').yellow).downcase
+            )
+            abort Rainbow("[#{dst_host}] File #{file_path} already exists!").red
+          else
+            run_remote(src_host, "scp #{file_path} #{dst_host}:#{file_path}")
+          end
+        end
+
+      abort Rainbow('The file copy failed, cancelling database clone').red if result.failed?
+    end
+
+    def current_user
+      # TODO: remote
+      Etc.getlogin
+    end
+
+    def disk_usage(host_name)
+      result =
+        if local_host?(host_name)
+          run_local(free_disk_space_command)
+        else
+          run_remote(host_name, free_disk_space_command)
+        end
+
+      columns = result.output.split(/\s+/)
+
+      abort Rainbow('Expected at least 5 columns of data from df -H').red unless columns.length >= 5
+
+      { available: columns[3], size: columns[1] }
+    end
+
+    def file_exists?(host_name, file_path)
+      log_message("Checking file existance: #{file_path}", host_name: host_name)
+
+      result =
+        if local_host?(host_name)
+          run_local(file_exists_command(file_path))
+        else
+          run_remote(host_name, file_exists_command(file_path))
+        end
+
+      result.success?
+    end
+
+    def file_exists_command(file_path)
+      "test -e #{file_path}"
+    end
+
+    def free_disk_space_command
+      'df -H / | grep "/$"'
+    end
+
+    def local_host?(host_name)
+      host_name == 'localhost'
+    end
+
+    def postgres_create_database(host_name, database_name, template: nil)
+      log_message("Creating database #{database_name}", host_name: host_name)
+
+      result =
+        if local_host?(host_name)
+          run_local(
+            postgres_create_database_command(database_name, template: template)
+          )
+        else
+          sudo_remote(
+            host_name,
+            postgres_create_database_command(database_name, template: template),
+            user: 'postgres'
+          )
+        end
+
+      abort Rainbow('Failed to create database').red if result.failed?
+    end
+
+    def postgres_create_database_command(database_name, template: nil)
+      "psql -c \"create database #{database_name}#{template.nil? ? '' : " with template #{template}"}\""
+    end
+
+    def postgres_dump_database(host_name, database_name, file_path)
+      log_message("Dumping database #{database_name} to #{file_path}", header: '', host_name: host_name)
+
+      if file_exists?(host_name, file_path)
+        puts Rainbow("[#{host_name}] File #{file_path} already exists!").green
+        use_existing_file = %w(yes y).include?(
+          ask(Rainbow('Would you like to restore the existing dump (y/n)?').yellow).downcase
+        )
+        return if use_existing_file
+        abort Rainbow("Please delete #{host_name}:#{file_path} before continuing").red
+      end
+
+      result =
+        if local_host?(host_name)
+          run_local(
+            postgres_dump_database_command(file_path, database_name)
+          )
+        else
+          sudo_remote(
+            host_name,
+            postgres_dump_database_command(file_path, database_name),
+            user: 'postgres'
+          )
+        end
+
+      if result.failed?
+        puts Rainbow('The database dump failed, cleaning up partial dump file').red
+        if local_host?(host_name)
+          sudo_local("rm #{file_path}")
+        else
+          sudo_remote(host_name, "rm #{file_path}")
+        end
+        abort Rainbow('Cancelling database clone').red
+      end
+    end
+
+    def postgres_dump_database_command(file_path, source_database)
+      "pg_dump --file=#{file_path} --no-acl --no-owner --format=custom #{source_database}"
+    end
+
+    def postgres_restore_database(host_name, database_name, file_path)
+      log_message("Restoring database #{database_name} from #{file_path}", header: '', host_name: host_name)
+
+      abort Rainbow("File #{file_path} does not exist!").red unless file_exists?(host_name, file_path)
+
+      # TODO: check to see if target database exists
+
+      postgres_create_database(host_name, database_name)
+
+      result =
+        if local_host?(host_name)
+          run_local(
+            postgres_restore_database_command(file_path, database_name)
+          )
+        else
+          sudo_remote(
+            host_name,
+            postgres_restore_database_command(file_path, database_name),
+            user: 'postgres'
+          )
+        end
+
+      abort Rainbow('The database restore failed').red if result.failed?
+    end
+
+    def postgres_restore_database_command(file_path, destination_database)
+      "pg_restore --dbname=#{destination_database} --jobs=4 -O #{file_path}"
+    end
+
+    def print_host_disk_space(host_name)
+      log_message('Checking free disk space', header: '', host_name: host_name)
+
+      usage = disk_usage(host_name)
+
+      log_message("#{usage[:available]} free of #{usage[:size]} total", host_name: host_name)
+    end
+
+    def user_password(host_name, user)
+      @user_passwords ||= {}
+      @user_passwords["#{host_name}_#{user}"] ||= begin
+        ask(Rainbow("#{user}'s password for #{host_name}? ").yellow, echo: false).tap do |_|
+          puts
+        end
+      end
+    end
+  end
+end; end;

data/lib/postgres/clone/executable.rb

@@ -0,0 +1,76 @@
+require 'thor'
+
+require 'postgres/clone/commands'
+
+module Postgres; module Clone;
+  class Executable < Thor
+    include Commands
+
+    option :src_host, required: true
+    option :src_db, required: true
+    option :dst_host, required: true
+    option :dst_db
+    option :file_path
+    option :verbose, default: true
+    desc 'clone_database', 'Clones a Postgres database from one host to another'
+    def clone_database
+      print_hosts_disk_space
+
+      if options[:src_host] == options[:dst_host]
+        create_database_using_template
+      else
+        create_database_using_restore
+      end
+
+      print_hosts_disk_space
+
+      close_ssh_connections
+    end
+
+    default_task :clone_database
+
+    private
+
+    def create_database_using_restore
+      file_path = options[:file_path] || "/tmp/#{file_name}"
+
+      postgres_dump_database(options[:src_host], options[:src_db], file_path)
+
+      copy_file(options[:src_host], options[:dst_host], file_path)
+
+      postgres_restore_database(
+        options[:dst_host],
+        options[:dst_db] || file_name,
+        file_path
+      )
+
+      log_message('Finished restoring database!', header: '', color: :green)
+    end
+
+    def create_database_using_template
+      postgres_create_database(
+        options[:src_host],
+        options[:dst_db] || file_name,
+        template: options[:src_db]
+      )
+
+      log_message('Finished creating database!', header: '', color: :green)
+    end
+
+    def file_name
+      @file_name ||= begin
+        if options[:file_path].nil?
+          "#{options[:src_db]}_#{Time.now.strftime('%Y%m%d')}"
+        else
+          File.basename(options[:file_path])
+        end
+      end
+    end
+
+    def print_hosts_disk_space
+      [options[:src_host], options[:dst_host]].uniq.each do |host_name|
+        print_host_disk_space(host_name)
+      end
+    end
+  end
+end; end;

data/lib/postgres/clone/local_commands.rb

@@ -0,0 +1,22 @@
+require 'postgres/clone/command_line'
+require 'postgres/clone/command_result'
+require 'postgres/clone/logger'
+
+module Postgres; module Clone;
+  module LocalCommands
+    include CommandLine
+
+    def run_local(command, sudo: false, user: nil)
+      actual_command = build_command(command, sudo: sudo, user: user)
+      log_command('localhost', actual_command)
+
+      output = `#{actual_command}`
+
+      CommandResult.new(exit_code: $?.exitstatus, output: output)
+    end
+
+    def sudo_local(command, user: nil)
+      run_local(command, sudo: true, user: user)
+    end
+  end
+end; end;

data/lib/postgres/clone/logger.rb

@@ -0,0 +1,14 @@
+require 'rainbow'
+
+module Postgres
+  module Clone
+    module Logger
+      DEFAULT_COLOR = :blue
+
+      def log_message(message, color: DEFAULT_COLOR, header: nil, host_name: nil)
+        puts header unless header.nil?
+        puts Rainbow("#{host_name.nil? ? '' : "[#{host_name}] "}#{message}").color(color)
+      end
+    end
+  end
+end

data/lib/postgres/clone/remote_commands.rb

@@ -0,0 +1,74 @@
+require 'net/ssh'
+require 'postgres/clone/command_line'
+require 'postgres/clone/command_result'
+require 'postgres/clone/logger'
+
+module Postgres; module Clone;
+  module RemoteCommands
+    include CommandLine
+    include Logger
+
+    def close_ssh_connections
+      (@ssh_connections || {}).values.each(&:close)
+    end
+
+    def open_ssh_connection(host_name, user)
+      @ssh_connections ||= {}
+      @ssh_connections[host_name] ||= begin
+        log_message("Opening ssh connection to #{host_name} as #{user}")
+        Net::SSH.start(host_name, user)
+      end
+    end
+
+    def run_remote(host_name, command, user: current_user, sudo: false)
+      result_attributes = { exit_code: nil, output: '' }
+
+      ssh = open_ssh_connection(host_name, user)
+      ssh.open_channel do |channel|
+        channel.request_pty { |_, success| abort('could not obtain pty') unless success }
+
+        actual_command = build_command(command, user: user, sudo: sudo)
+        log_message(actual_command, host_name: host_name, color: :gray)
+
+        channel.exec(actual_command) do |_, success|
+          abort('could not execute command') unless success
+
+          channel.on_data do |_, data|
+            puts data
+            case data
+            when /^\[sudo\] password for (.+):/i
+              password = user_password(host_name, $1)
+              log_message("Sending sudo password for #{user}", host_name: host_name, color: :gray)
+              channel.send_data("#{password}\n")
+            when /(.+)@(.+)'s password:/i
+              password = user_password($2, $1)
+              log_message("Sending user password for #{$1}", host_name: host_name, color: :gray)
+              channel.send_data("#{password}\n")
+            when /are you sure you want to continue connecting \(yes\/no\)\?/i
+              log_message('ignoring key warning', host_name: host_name, color: :yellow)
+              channel.send_data("yes\n")
+            else
+              result_attributes[:output] += data
+            end
+          end
+
+          channel.on_extended_data do |_, _, data|
+            log_message("stderr: #{data}", host_name: host_name, color: :red)
+          end
+
+          channel.on_request('exit-status') do |_, data|
+            result_attributes[:exit_code] = data.read_long
+          end
+        end
+      end
+
+      ssh.loop
+
+      CommandResult.new(result_attributes)
+    end
+
+    def sudo_remote(host_name, command, user: nil)
+      run_remote(host_name, command, user: user, sudo: true)
+    end
+  end
+end; end;

data/lib/postgres/clone/version.rb

@@ -0,0 +1,5 @@
+module Postgres
+  module Clone
+    VERSION = '0.1.0'
+  end
+end

data/postgres-clone.gemspec

@@ -0,0 +1,30 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'postgres/clone/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'postgres-clone'
+  spec.version       = Postgres::Clone::VERSION
+  spec.authors       = ['Josh Rickard']
+  spec.email         = ['josh.rickard@gmail.com']
+
+  spec.summary       = 'A command line utility for copying postgres databases.'
+  spec.description   = 'A command line utility for copying postgres databases.  Wraps pg_backup and pg_restore in a Ruby wrapper.'
+  spec.homepage      = 'https://github.com/joshrickard/postgres-clone'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = 'exe'
+  spec.executables   = 'pg-clone'
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'highline', '~> 1.7', '>= 1.7.8'
+  spec.add_dependency 'net-ssh', '~> 3.1', '>= 3.1.1'
+  spec.add_dependency 'rainbow', '~> 2.1', '>= 2.1.0'
+  spec.add_dependency 'thor', '~> 0.19', '>= 0.19.1'
+
+  spec.add_development_dependency 'bundler', '~> 1.11'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rspec', '~> 3.0'
+end

metadata

@@ -0,0 +1,188 @@
+--- !ruby/object:Gem::Specification
+name: postgres-clone
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Josh Rickard
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2016-05-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: highline
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.7.8
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.7.8
+- !ruby/object:Gem::Dependency
+  name: net-ssh
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.1.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.1.1
+- !ruby/object:Gem::Dependency
+  name: rainbow
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.1.0
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.19'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.19.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.19'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.19.1
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: A command line utility for copying postgres databases.  Wraps pg_backup
+  and pg_restore in a Ruby wrapper.
+email:
+- josh.rickard@gmail.com
+executables:
+- pg-clone
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- exe/pg-clone
+- lib/postgres-clone.rb
+- lib/postgres/clone/command_line.rb
+- lib/postgres/clone/command_result.rb
+- lib/postgres/clone/commands.rb
+- lib/postgres/clone/executable.rb
+- lib/postgres/clone/local_commands.rb
+- lib/postgres/clone/logger.rb
+- lib/postgres/clone/remote_commands.rb
+- lib/postgres/clone/version.rb
+- postgres-clone.gemspec
+homepage: https://github.com/joshrickard/postgres-clone
+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: A command line utility for copying postgres databases.
+test_files: []