dumpr 1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: dd3cfde68c281a599acafcb492f09bc434ca3a80d066f3617e6d6c504aa2c3f2
+  data.tar.gz: 1208625e0f1dbfef63210656a3313905ce1d1ec5f74c51718652781495998636
+SHA512:
+  metadata.gz: '0148d00c1f332b28dc6f1e640792c4c58bed2242abc64e1094e10e4fc534c589e71bc9e929b23988e9a9053a00b1ceb9a3989704f9856abb8d77b7a9521794ad'
+  data.tar.gz: 75414e3b37615572f70df9dba1a8cbca2b07609bee818cf1ca44d11d32bb060e4d5b4c6cb6238f4edea33e2fa5009805bf149d22e4f2c17946b41640174dcad4

data/.gitignore

@@ -0,0 +1,23 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log
+.DS_Store

data/Gemfile

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

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) James Dickson
+
+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,86 @@
+## Dumpr
+A Ruby Gem that's objective is to make dumping and importing databases easy.
+
+Features:
+* generates gzipped sql dump files for a specific database or specific tables.
+* automates transfer of dump files to remote hosts
+* automates import
+
+Executables installed:
+* dumpr
+
+### Dependencies
+* [Ruby ≥ 1.8.7](http://www.ruby-lang.org/en/downloads/)
+
+**SSH access is assumed to be automated with .ssh/config entries**
+
+### Installation
+
+```sh
+  gem install dumpr
+```
+### Usage
+
+Use the `dumpr` executable to export and import your databases.
+
+#### dumpr
+
+The *dumpr* command can be used to export and import database dumps.
+
+*Exporting*
+
+Generate yourdb.sql.gz and transfer it to server2
+
+```sh
+  dumpr --user user --password pw --db yourdb --dumpfile yourdb.sql --destination dbserver2:/data/dumps/
+```
+
+*Importing*
+
+Then, over on dbserver2, import your dump file
+```sh
+  dumpr -i --user user --password pw --dumpfile /data/dumps/yourdb.sql
+```
+
+## Ruby API
+
+You can write your own scripts that use a *Dumpr::Driver*
+
+### Exporting
+
+Generate yourdb.sql.gz and transfer it to server2
+```ruby
+ Dumpr::Driver::Mysql.export( 
+    :user => 'backupuser', :pass => 'dbpass',
+    :db => 'yourdb', 
+    :destination => 'server2:/data/dumps/yourdb.sql'
+ )
+```
+
+### Importing
+
+Then, over on dbserver2, import your dump file
+```ruby
+ Dumpr::Driver::Mysql.import( 
+    :user => 'importuser', :pass => 'pass',
+    :db => 'yourdb', 
+    :dumpfile => '/data/dumps/yourdb.sql'
+)
+```
+
+### Standard Dumpr::Driver options
+
+See *Dumpr::Driver*
+  
+  
+## CHANGELOG
+
+* Version 1.0
+
+## TODO
+
+* Dumpr::Driver::Postgres
+* automate importing after an export (socket communication exporter/importer, or just some dumb lockfile checking / polling)
+* security: stop logging passwords
+* daemonize 
+* SSH parameters

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/bin/csv2sqlinsert

@@ -0,0 +1,35 @@
+#!/usr/bin/env ruby
+# author: jdickson
+# script: csv2sqlinsert
+# todo: optparse
+
+require 'rubygems'
+require 'dumpr/chunkpipe'
+
+USAGE = "Usage: cat yourdata.csv | #{File.basename($0)} yourtable 1000 > insert.sql"
+if ARGV.length < 2
+  puts USAGE
+  exit
+end
+table_name = ARGV[0]
+chunk_size = ARGV[1].to_i
+pause_sec = (ARGV[2] || 0).to_i
+delim="\n"
+i = 0
+total = 0
+ChunkPipe.open(STDIN, STDOUT, chunk_size, delim) do |lines|
+  i+=1
+  total += lines.length  
+  out = ""
+  out << "INSERT IGNORE INTO `#{table_name}` VALUES \n"
+  lines.each_with_index do |line, idx|
+    line = line.strip.gsub('\N', 'NULL')
+    out << "(#{line})" << (idx == (lines.length-1) ? "" : ",") << "\n"
+  end
+  out << ";\n"
+  out << "select sleep(#{pause_sec.to_f});\n" if pause_sec != 0
+  out << "select 'completed chunk #{i} (#{total} records so far)' as '';\n"  
+  out
+end
+
+exit 0

data/bin/dumpr

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+require 'rubygems'
+require 'dumpr/cli'
+Dumpr::CLI.execute(ARGV)

data/dumpr.gemspec

@@ -0,0 +1,22 @@
+$:.push File.expand_path("../lib", __FILE__)
+require "dumpr/version"
+
+Gem::Specification.new do |s|
+
+  s.name        = "dumpr"
+  s.version     = Dumpr::Version.to_s
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["James Dickson"]
+  s.email       = ["jdickson@bcap.com"]
+  s.homepage    = "http://github.com/sixjameses/dumpr"
+  s.summary     = "Dump and load databases."
+  s.description = "Dumpr provides an easy way to dump and import databases."
+  s.files       = `git ls-files -z`.split("\x0")
+  s.executables = s.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  s.test_files  = s.files.grep(%r{^(test|spec|features)/})
+  s.require_paths = ["lib"]
+  s.extra_rdoc_files = ["README.md"]
+  s.licenses    = ['MIT']
+  s.required_ruby_version = '>= 2.2.1'
+  #s.add_dependency('highline')
+end

data/lib/dumpr.rb

@@ -0,0 +1,34 @@
+require 'dumpr/version'
+require 'dumpr/driver'
+
+module Dumpr
+
+  # error raised when there is a bad configuration
+  class BadConfig < RuntimeError; end
+
+  # error raised when a dump filename already exists
+  class DumpFileExists < RuntimeError; end
+
+  # error raised when there is a dump operation in progress
+  class BusyDumping < RuntimeError; end
+
+  # error raised when there is a command failure
+  class CommandFailure < RuntimeError; end
+
+  def dump(driver, opts)
+    driver = Driver.find(driver).new(opts)
+    driver.dump()
+  end
+
+  def import(driver, opts)
+    driver = Driver.find(driver).new(opts)
+    driver.import()
+  end
+
+  def export(driver, opts)
+    dump(driver, opts)
+  end
+
+  module_function :dump, :import, :export
+
+end

data/lib/dumpr/chunkpipe.rb

@@ -0,0 +1,51 @@
+# author :jdickson
+# ChunkPipe
+# An IO pipe that provides generic parsing / rewriting 
+# of a stream of packets (or lines in a file).
+# It passes chunks of packets to a block
+# The return value of the block is written to the other end of the pipe
+# packet delimiter is not removed from packet suffix
+# 
+# Silly Example that simply passes through the data: 
+# ChunkPipe.open(STDIN, STDOUT, 1000, "\n") {|lines| lines.join }
+#
+module ChunkPipe
+
+  MAX_CHUNK_SIZE = 1000000
+
+  def open(reader, writer, chunk_size, packet_delim, read_timeout=3, &block)
+    if chunk_size < 1 || chunk_size > MAX_CHUNK_SIZE
+      raise ArgumentError.new "invalid chunk size #{chunk_size.inspect}"
+    end
+    chunk_idx = 0
+    packet_idx = 0
+    packets = []
+    stopblocking = Thread.new do
+      sleep read_timeout
+      reader.close # this can raise IOError
+      raise IOError.new "ChunkPipe read time out (#{read_timeout}s)"
+    end
+    while packet = reader.gets(packet_delim) do
+      stopblocking.kill if stopblocking.alive?
+      packets << packet
+      if ((packet_idx+1) % chunk_size == 0)
+        data = yield packets 
+        writer << data if data
+        chunk_idx+=1
+        packets = []
+      end
+      packet_idx+=1
+      #break if reader.eof?
+    end
+    unless packets.empty?
+      data = yield packets 
+      writer << data if data
+    end
+  ensure
+    reader.close if reader && !reader.closed?
+    writer.close if writer && !writer.closed?
+  end
+
+  module_function :open
+
+end

data/lib/dumpr/cli.rb

@@ -0,0 +1,156 @@
+require 'dumpr'
+require 'optparse'
+require 'ostruct'
+# command line functions for bin/dumpr
+module Dumpr
+  class CLI
+    PROG_NAME = File.basename($0)
+
+
+    def self.execute(args)
+      # default options
+      options = {}
+      options[:dumpdir] = Dir.pwd
+      options[:driver] = :mysql
+      options[:gzip] = true
+
+
+      op = OptionParser.new do |opts|
+
+        opts.banner = <<-ENDSTR
+Usage: #{PROG_NAME} [options]
+
+Exporting:
+
+  #{PROG_NAME} --user youruser --password yourpass --db yourdb --dumpfile yourdb.sql --destination server2:/data/backups
+
+Importing:
+
+  #{PROG_NAME} -i --user youruser --password yourpass --db yourdb --dumpfile /data/backups/yourdb.sql
+
+Don't forget to set up your .ssh/config so you won't be prompted for ssh passwords for file transfers
+
+Options:
+
+ENDSTR
+
+        opts.on("-t", "--type [TYPE]", "Database type.  (mysql is the default) ") do |val|
+          options[:driver] = val
+        end
+
+        opts.on("-i", "--import", "Import dump file.  Default behavior is to dump and export to --destination") do |val|
+          options[:import] = val
+        end
+
+        opts.on("--all-databases", "dump/import ALL databases") do |val|
+          options[:all_databases] = val
+        end
+
+        opts.on("--db DATABASE", "--database DATABASE", "Database to dump/import") do |val|
+          options[:database] = val
+        end
+
+        # TODO: Add support to Driver for this
+        opts.on("--databases [x,y,z]", Array, "dump/import multiple databases") do |val|
+          options[:databases] = val
+        end
+
+        opts.on("--tables [t1,t2,t3]", Array, "dump certain tables, to be used on conjuction with a single --database") do |val|
+          options[:tables] = val
+        end
+
+        opts.on("-u USER", "--user USER", "Database user") do |val|
+          options[:user] = val
+        end
+
+        opts.on("-p PASS", "--password PASS", "--password=pass", "Database password") do |val|
+          options[:password] = val
+        end
+
+        opts.on("-h HOST", "--host HOST", "Database host") do |val|
+          options[:host] = val
+        end
+
+        opts.on("-P PORT", "--port PORT", "Database port") do |val|
+          options[:port] = val
+        end
+
+        opts.on("--dumpfile [DUMPFILE]", "Filename of dump to create/import") do |val|
+          options[:dumpfile] = val
+        end
+
+        opts.on("--destination [DESTINATION]", "Destination for dumpfile. This can be a remote host:path.") do |val|
+          options[:destination] = val
+        end
+
+        opts.on("--dumpdir", "Default directory for dumpfiles. Default is working directory") do |val|
+          options[:dumpdir] = val
+        end
+
+        opts.on("--dump-options=[DUMPOPTIONS]", "Extra options to be included in dump command") do |val|
+          options[:dump_options] = val
+        end
+
+        opts.on("--no-gzip", "Don't use gzip") do |val|
+          options[:gzip] = false
+        end
+
+        opts.on("--gzip-options=[GZIPOPTIONS]", "gzip compression options.  Default is -9 (slowest /max compression)") do |val|
+          options[:gzip_options] = val
+        end
+
+        opts.on("--log-file [LOGFILE]", "Log file.  Default is stdout.") do |val|
+          options[:log_file] = val
+        end
+
+        opts.on("--force", "Overwrite dumpfile if it exists already.") do |val|
+          options[:force] = val
+        end
+
+        opts.on("-h", "--help", "Show this message") do
+         puts opts
+         exit
+        end
+
+        opts.on("-v", "--version", "Show version") do
+          puts Dumpr::Version
+          exit
+        end
+
+      end
+
+      begin
+        op.parse!(args)
+      rescue OptionParser::MissingArgument => e
+        puts "invalid arguments.  try #{PROG_NAME} --help"
+        exit 1
+      end
+
+
+      # do it
+      begin
+        if options[:import]
+          Dumpr.import(options[:driver], options)
+        else
+          Dumpr.export(options[:driver], options)
+        end
+      rescue Dumpr::BadConfig => e
+        puts "bad arguments: #{e.message}.\n See --help"
+        exit 1
+      rescue Dumpr::DumpFileExists => e
+        puts "#{e.message}\nIt looks like this dump exists already. You should move it, or use --force to trash it"
+        exit 1
+      rescue Dumpr::BusyDumping => e
+        puts "#{e.message}\n See --help"
+        exit 1
+      rescue Dumpr::CommandFailure => e
+        puts e.message
+        exit 1
+      end
+
+      exit 0
+
+    end
+
+  end
+end

data/lib/dumpr/driver.rb

@@ -0,0 +1,222 @@
+# abstract driver that does everything
+require 'dumpr'
+require 'dumpr/util'
+require 'logger'
+
+module Dumpr
+  module Driver
+
+    def find(driver)
+      driver_file = "dumpr/driver/#{driver}"
+      require(driver_file)
+      const_ar = driver.to_s.split("/").reject{|i| i==""}.collect {|i| i.capitalize.gsub(/_(.)/) {$1.upcase} }
+      klass_str = const_ar.join('::')
+      begin
+        klass = const_ar.inject(self) do |mod, const_name|
+          mod.const_get(const_name)
+        end
+      rescue NameError => e
+        raise e
+        raise BadConfig, "could not find `#{klass_str}' in `#{driver_file}'"
+      end
+      raise BadConfig, "#{klass.name} is not a type of Dumpr::Driver!" unless klass < Dumpr::Driver::Base
+      return klass
+    rescue LoadError
+      raise BadConfig, "failed to load '#{driver_file}' !'"
+    end
+
+    module_function :find
+
+    # abstract interface for all drivers
+    class Base
+      attr_reader :opts
+      attr_reader :host, :port, :user, :password, :database, :tables
+      attr_reader :gzip, :gzip_options, :dumpdir, :dumpfile, :dump_options, :import_options
+      attr_reader :destination, :destination_host, :destination_dumpfile
+
+      def initialize(opts)
+        self.configure(opts)
+      end
+
+      def configure(opts)
+        opts = (@opts||{}).merge(opts)
+        # db connection settings
+        @host = opts[:host] || "localhost"
+        @port = opts[:port]
+        @user = opts[:user] or raise BadConfig.new ":user => <db user> is required"
+        @password = (opts[:password]  || opts[:pass]) or raise BadConfig.new ":pass => <db password> is required"
+
+        # dump all_databases or specific database(s)
+        @all_databases = nil
+        @database = nil
+        @databases = nil
+        @tables = nil
+        if (opts[:database] || opts[:db])
+          @database = (opts[:database] || opts[:db])
+          @tables = [opts[:table], opts[:tables]].flatten.uniq.compact
+        elsif opts[:databases]
+          @databases = [opts[:databases]].flatten.uniq.compact # not used/supported yet
+        elsif opts[:all_databases]
+          @all_databases = true
+        else
+          raise BadConfig.new ":database => <db schema name> is required"
+        end
+
+        # dump settings
+        @gzip = opts[:gzip].nil? ? true : opts[:gzip]
+        @gzip_options = opts[:gzip_options] || "-9"
+        @dumpdir = opts[:dumpdir] || "./"
+        @dumpfile = (opts[:dumpfile] || opts[:filename]) or raise BadConfig.new ":dumpfile => <file.sql> is required"
+        @dumpfile = @dumpfile[0].chr == "/" ? @dumpfile : File.join(@dumpdir, @dumpfile)
+        @dumpfile.chomp!(".gz")
+        # (optional) :destination is where dumps are exported to, and can be a remote host:path
+        @destination = opts[:destination] || @dumpfile
+        if @destination.include?(":")
+          @destination_host, @destination_dumpfile = @destination.split(":")[0], @destination.split(":")[1]
+        else
+          @destination_host, @destination_dumpfile = "localhost", @destination
+        end
+        # destination might be a path only, so build the entire filepath
+        if File.extname(@destination_dumpfile) == ""
+          @destination_dumpfile = File.join(@destination_dumpfile, File.basename(@dumpfile))
+        end
+        @destination_dumpfile.chomp!(".gz")
+        @dump_options = opts[:dump_options]
+        @import_options = opts[:import_options]
+
+        # set / update logger
+        if opts[:logger]
+          @logger = opts[:logger]
+        elsif opts[:log_file]
+          @logger = Logger.new(opts[:log_file])
+        end
+        @logger = Logger.new(STDOUT) if !@logger
+        @logger.level = opts[:log_level] if opts[:log_level] # expects integer
+
+        @opts = opts
+      end
+
+      def logger
+        @logger
+      end
+
+      def dump_cmd
+        raise BadConfig.new "#{self.class} has not defined dump_cmd!"
+      end
+
+      # DUMPING + EXPORTING
+
+      def remote_destination?
+        @destination_host && @destination_host != "localhost"
+      end
+
+      # creates @dumpfile
+      # pipes :dump_cmd to gzip, rather than write the file to disk twice
+      # if @destination is defined, it then moves the dump to the @destination, which can be a remote host:path
+      def dump
+        logger.debug("begin dump")
+        dumpfn = @dumpfile + (@gzip ? ".gz" : "")
+        Util.with_lockfile("localhost", dumpfn, @opts[:force]) do
+
+          logger.debug "preparing dump..."
+          if !File.exists?(File.dirname(dumpfn))
+            run "mkdir -p #{File.dirname(dumpfn)}"
+          end
+
+          # avoid overwriting dump files..
+          if File.exists?(dumpfn)
+            if @opts[:force]
+              logger.warn "#{dumpfn} exists, moving it to #{dumpfn}.1"
+              #run "rm -f #{dumpfn}.1;"
+              run "mv #{dumpfn} #{dumpfn}.1"
+            else
+              logger.warn "#{dumpfn} already exists!"
+              raise DumpFileExists.new "#{dumpfn} already exists!"
+            end
+          end
+
+          logger.debug "dumping..."
+          if @gzip
+            run "#{dump_cmd} | gzip #{gzip_options} > #{dumpfn}"
+          else
+            run "#{dump_cmd} > #{dumpfn}"
+          end
+          dumpsize = Util.human_file_size("localhost", dumpfn)
+          logger.info("generated #{dumpfn} (#{dumpsize})")
+
+          if @destination
+            if remote_destination?
+              logger.debug "exporting to #{@destination_host}..."
+              Util.with_lockfile(@destination_host, @destination_dumpfile, @opts[:force]) do
+                run "scp #{dumpfn} #{@destination_host}:#{@destination_dumpfile}#{@gzip ? '.gz' : ''}"
+              end
+            elsif @destination_dumpfile && @destination_dumpfile+(@gzip ? '.gz' : '') != dumpfn
+              logger.debug "exporting..."
+              destdir = File.dirname(@destination_dumpfile)
+              run "mkdir -p #{destdir}" if !Util.dir_exists?("localhost", destdir)
+              Util.with_lockfile("localhost", @destination_dumpfile, @opts[:force]) do
+                run "mv #{dumpfn} #{@destination_dumpfile}#{@gzip ? '.gz' : ''}"
+              end
+            end
+          end
+
+        end # with_lockfile
+        logger.debug("end dump")
+      end
+
+      # IMPORTING
+
+      def import_cmd
+        raise BadConfig.new "#{self.class} has not defined import_cmd!"
+      end
+
+      def decompress
+        if File.exists?(@dumpfile + ".gz")
+          if File.exists?(@dumpfile) && !@opts[:force]
+            logger.warn "skipping decompress because #{@dumpfile} already exists."
+          else
+            logger.debug "decompressing..."
+            run "gzip -d -f #{@dumpfile}.gz"
+          end
+        else
+          logger.warn "decompress failed. #{@dumpfile}.gz does not exist!"
+        end
+      end
+
+      def import
+        Util.with_lockfile("localhost", @dumpfile, @opts[:force]) do
+          decompress if @gzip
+
+          if !File.exists?(@dumpfile)
+            raise "Cannot import #{@dumpfile} because it does not exist!"
+          else
+            dumpsize = Util.human_file_size("localhost", @dumpfile)
+            logger.info("importing #{@dumpfile} (#{dumpsize})")
+            run import_cmd
+          end
+
+        end # with_lockfile
+      end
+
+      protected
+
+      def scrub_cmd(cmd)
+        cmd.gsub(/password=[^\s]+/, 'password=xxxxxx')
+      end
+
+      def run(cmd)
+        start_time = Time.now
+        logger.info "running command: #{scrub_cmd cmd}"
+        stdout = `#{cmd}`
+        took_sec = (Time.now - start_time).round()
+        if $?.success?
+          logger.info "finished (took #{took_sec}s)"
+        else
+          logger.error "failed (took #{took_sec}s) status: #{$?.exitstatus}"
+          raise CommandFailure.new("Aborting because the following command failed: #{scrub_cmd cmd}")
+        end
+      end
+
+    end
+  end
+end

data/lib/dumpr/driver/mysql.rb

@@ -0,0 +1,30 @@
+require 'dumpr/driver'
+module Dumpr
+  module Driver
+    class Mysql < Base
+
+      def port
+        @port || 3306
+      end
+
+      def dump_options
+        @dump_options || "--single-transaction --quick"
+      end
+
+      def dump_cmd
+        if @all_databases
+          "mysqldump -u #{user} --password=#{password} -h #{host} -P #{port} --all-databases #{dump_options}"
+        elsif @databases
+          "mysqldump -u #{user} --password=#{password} -h #{host} -P #{port} --databases #{databases.join(' ')} #{dump_options}"
+        else
+          "mysqldump -u #{user} --password=#{password} -h #{host} -P #{port} #{database} #{tables ? tables.join(' ') : ''} #{dump_options}"
+        end
+      end
+
+      def import_cmd
+        "mysql -u #{user} --password=#{password} -h #{host} -P #{port} #{database} < #{dumpfile}"
+      end
+
+    end
+  end
+end

data/lib/dumpr/util.rb

@@ -0,0 +1,102 @@
+#TODO: Refactor this
+# Utility methods for touching/reading local and remote files
+module Dumpr
+  module Util
+
+    def self.file_exists?(h, fn)
+      if h == "localhost"
+        File.exists?(fn)
+      else
+        `ssh #{h} test -f '#{fn}' &> /dev/null`
+        $?.success?
+      end
+    end
+
+    def self.dir_exists?(h, fn)
+      if h == "localhost"
+        File.exists?(fn)
+      else
+        `ssh #{h} test -d '#{fn}' &> /dev/null`
+        $?.success?
+      end
+    end
+
+    # touch a file  and optionally overwrite it's content with msg
+    def self.touch_file(h, fn, msg=nil)
+      cmd = "touch #{fn}" + (msg ? " && echo '#{msg}' > #{fn}" : '')
+      if h == "localhost"
+        system(cmd)
+      else
+        system("ssh #{h} '#{cmd}'")
+      end
+    end
+
+    # return contents of a file
+    def self.cat_file(h, fn)
+      cmd = "cat #{fn}"
+      if h == "localhost"
+        `#{cmd}`.strip
+      else
+        `ssh #{h} #{cmd}`.strip
+      end
+    end
+
+    def self.remove_file(h, fn)
+      cmd = "rm #{fn}"
+      if h == "localhost"
+        system(cmd)
+      else
+        system("ssh #{h} #{cmd}")
+      end
+    end
+
+    # return the human readable size of a file like 10MB
+    def self.human_file_size(h, fn)
+      cmd = "du -h #{fn} | cut -f 1"
+      if h == "localhost"
+        `#{cmd}`.strip
+      else
+        `ssh #{h} #{cmd}`.strip
+      end
+    end
+
+    def self.process_running?(h, pid)
+      cmd = "ps -p #{pid}"
+      if h == "localhost"
+        system(cmd)
+      else
+        system("ssh #{h} #{cmd}")
+      end
+    end
+
+    def self.with_lockfile(h, fn, remove_dead_locks=false)
+      fn = fn.chomp('.dumpr.lock') + '.dumpr.lock'
+      mylock = nil
+      if file_exists?(h, fn)
+        pid = cat_file(h, fn)
+        mylock = Process.pid == pid
+        if mylock
+          # my own lock.. proceed
+        elsif process_running?(h, pid)
+          raise BusyDumping.new "Lockfile '#{fn}' exists for another process (#{pid})!"
+        else
+          if remove_dead_locks
+            puts "Removing lockfile '#{fn}' for dead process (#{pid})"
+            remove_file(h, fn)
+          else
+            raise BusyDumping.new "Lockfile '#{fn}' exists for dead process (#{pid}) ! You may want to investigate the reason why, or use --force"
+          end
+        end
+      end
+      begin
+        touch_file(h, fn, Process.pid)
+        yield
+      rescue => e
+        raise e
+      ensure
+        remove_file(h, fn)
+      end
+    end
+
+  end
+end

data/lib/dumpr/version.rb

@@ -0,0 +1,3 @@
+module Dumpr
+  Version = "1.0".freeze
+end

metadata

@@ -0,0 +1,62 @@
+--- !ruby/object:Gem::Specification
+name: dumpr
+version: !ruby/object:Gem::Version
+  version: '1.0'
+platform: ruby
+authors:
+- James Dickson
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2020-04-10 00:00:00.000000000 Z
+dependencies: []
+description: Dumpr provides an easy way to dump and import databases.
+email:
+- jdickson@bcap.com
+executables:
+- csv2sqlinsert
+- dumpr
+extensions: []
+extra_rdoc_files:
+- README.md
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- bin/csv2sqlinsert
+- bin/dumpr
+- dumpr.gemspec
+- lib/dumpr.rb
+- lib/dumpr/chunkpipe.rb
+- lib/dumpr/cli.rb
+- lib/dumpr/driver.rb
+- lib/dumpr/driver/mysql.rb
+- lib/dumpr/util.rb
+- lib/dumpr/version.rb
+homepage: http://github.com/sixjameses/dumpr
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.2.1
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.6
+signing_key: 
+specification_version: 4
+summary: Dump and load databases.
+test_files: []