mongo-db-utils 0.1.6 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 415c2d49fcbcad5aa3e835eb0b5fe88c880e8cfe
-  data.tar.gz: 93218696727910919cd569d0658fa1f2fe8f6a65
+  metadata.gz: 64d078336bb048c54737b7b64e60fcf47c4f3d0e
+  data.tar.gz: 58354687f31dccf5167fd7b0b29137169a28d3b6
 SHA512:
-  metadata.gz: d6b92ba1baa0e548c2f845370e2a909602897ff216e6bb6366803c7535f286a22783be2cc9557a6816751bc9e74da2ebc137f3320214a4538bc5d9c91100ea49
-  data.tar.gz: a56d22c2bc234e4e9c9c2cadab2a27b019228a4ac577b620a1462e2cfd584ac6f3848f59ab4e8cd1447c8446102edc75cd923923a22e561ac1446faebbb326ba
+  metadata.gz: 8aaf333d8260db8be954322607dbd274dc618996c0dda3af22ec2e15682bc1b3c61cddb7bae22feecc351468afafb01d22e0ef59928d9dabb83ba64c11a781f5
+  data.tar.gz: a2aeaf7c4bca99df2cc66c356f05a151791aff770587e6aad751b4d0012d6c1db1150c1ef90cfd0748bf01cde71ff15979916e9c9e3f73a2a82497523e0feef7

data/lib/mongo-db-utils/cli.rb

@@ -40,6 +40,17 @@ module MongoDbUtils
       Cmd.backup_s3(backup_folder, db, bucket_name, access_key_id, secret_access_key)
     end
 
+    desc "restore_from_s3 MONGO_URI BUCKET ACCESS_KEY SECRET_ACCESS_KEY SOURCE_DB [REPLICA_SET_NAME]", "restore a db from Amason s3 with a mongo uri eg: mongodb://user:pass@server:port/dbname"
+    def restore_from_s3(mongo_uri, bucket_name, access_key_id, secret_access_key, source_db, replica_set_name = nil)
+      config = get_config
+      db = get_db(mongo_uri, replica_set_name)
+      raise "can't parse uri" if db.nil?
+      Dir.mktmpdir do |tmp_dir|
+        backup = Cmd.download_backup_from_s3(tmp_dir, 'latest', bucket_name, access_key_id, secret_access_key)
+        Cmd.restore_from_backup(tmp_dir, db, backup, source_db)
+      end
+    end
+
     private
 
     def get_config(path = ConfigLoader::CONFIG_LOCATION)

data/lib/mongo-db-utils/cmd.rb

@@ -8,14 +8,14 @@ module MongoDbUtils
 
     def self.backup(db, folder, final_path = nil, tar_it = true)
       puts ">> Backing up: #{db}, #{folder}, #{final_path}"
-      unless( db_exists?(db) )
+      unless (db_exists?(db))
         return false
       end
 
-      if( final_path.nil? )
-        out_path = "#{folder}/#{db.to_host_s}/#{db.name}/#{timestamp}"
+      if (final_path.nil?)
+        out_path = File.join(folder, db.to_host_s, db.name, timestamp)
       else
-        out_path = "#{folder}/#{final_path}"
+        out_path = File.join(folder, final_path)
       end
 
       full_path = File.expand_path(out_path)
@@ -23,6 +23,7 @@ module MongoDbUtils
       puts ">> final backup path: #{full_path}"
 
       FileUtils.mkdir_p(full_path)
+
       Dump.new(
         db.to_host_s,
         db.name,
@@ -30,42 +31,48 @@ module MongoDbUtils
         db.username,
         db.password).run
 
-      if( tar_it )
+      full_db_path = File.join(full_path, db.name)
+
+      if (tar_it)
         Dir.chdir(full_path)
-        `tar cvf #{db.name}.tar #{db.name}`
-        `rm -fr #{full_path}/#{db.name}`
-        "#{full_path}/#{db.name}.tar"
+        `tar --create --verbose --file=#{db.name}.tar #{db.name}`
+        delete_folder full_db_path
+        "#{full_db_path}.tar"
       else
-        "#{full_path}/#{db.name}"
+        full_db_path
       end
     end
 
     # With remote dbs you can't do a copy_database if you're not an admin.
     def self.copy(path, source, destination, halt_on_no_backup = true, skip_backup = false)
 
-      backup_made = if skip_backup then true else backup(destination, path) end
+      backup_made = if skip_backup
+                      true
+                    else
+                      backup(destination, path)
+                    end
 
-      if( !backup_made && halt_on_no_backup)
-        puts "aborting - no backup was made"
+      if !backup_made && halt_on_no_backup
+        puts 'aborting - no backup was made'
         return
       end
 
-      tmp_path = "~/.mongo-db-utils/tmp"
+      tmp_path = File.join(ConfigLoader::CONFIG_LOCATION, 'tmp')
 
       FileUtils.mkdir_p(tmp_path)
 
-      puts "backup to: #{tmp_path}/#{source.name}"
-      tmp_dump_path = backup(source,tmp_path, source.name, false)
-
-      username = destination.username
-      password = destination.password
+      puts "backup to: #{File.join(tmp_path, source.name)}"
+      tmp_dump_path = backup(source, tmp_path, source.name, false)
 
       # if the destination db doesn't exist
       # we assume that the user has admin control of the server
       # eg its a local server (this needs to be thought through a bit more)
-      if( !db_exists?(destination) )
-        username = ""
-        password = ""
+      username = ''
+      password = ''
+
+      if db_exists? destination
+        username = destination.username
+        password = destination.password
       end
 
       Restore.new(
@@ -75,16 +82,62 @@ module MongoDbUtils
         username,
         password).run
 
-      `rm -fr #{tmp_path}`
+      delete_folder tmp_path
     end
 
-     def self.backup_s3(backup_folder, db, bucket_name, access_key_id, secret_access_key)
+    def self.backup_s3(backup_folder, db, bucket_name, access_key_id, secret_access_key)
       tar_file = MongoDbUtils::Cmd.backup(db, backup_folder)
-      name = tar_file.gsub(File.expand_path(backup_folder), "")
+      name = tar_file.gsub(File.expand_path(backup_folder), '')
       MongoDbUtils::S3::put_file(tar_file, name, bucket_name, access_key_id, secret_access_key)
       file = File.basename(tar_file)
-      folder = tar_file.gsub(file, "")
-      `rm -fr #{folder}`
+      folder = tar_file.gsub(file, '')
+      delete_folder folder
+    end
+
+    def self.list_backups(bucket_name, access_key_id, secret_access_key)
+      MongoDbUtils::S3::list_bucket(bucket_name, access_key_id, secret_access_key)
+    end
+
+    def self.list_downloaded_backups(backup_folder)
+      FileUtils.mkdir_p(backup_folder)
+      Dir.entries(backup_folder).select { |a| a.end_with? '.tgz' }
+    end
+
+    def self.list_backup_folders(backup_folder, backup)
+      puts "reading backup folders from #{backup_folder} #{backup}"
+      folders = list_archive_folders(backup_folder, backup)
+      folders.map { |a| a.slice! File.basename(backup, '.tgz'); a.delete '/' }.select { |a| a != '' }
+    end
+
+    def self.download_backup_from_s3(backup_folder, backup, bucket_name, access_key_id, secret_access_key)
+      if backup == 'latest'
+        backup = get_latest_backup(bucket_name, access_key_id, secret_access_key)
+      end
+      backup_file = File.join(backup_folder, File.basename(backup))
+
+      puts "download_backup_from_s3 #{backup_file}"
+      if File.exists? backup_file
+        puts "File downloaded already #{backup_file}"
+      else
+        FileUtils.mkdir_p(backup_folder)
+        puts "Downloading #{backup_file}"
+        download_backup(backup_file, backup, bucket_name, access_key_id, secret_access_key)
+      end
+      backup
+    end
+
+    def self.restore_from_backup(backup_folder, db, backup, source_db)
+      Dir.mktmpdir do |dir|
+        puts "Unzipping archive ..."
+        unzip(File.join(backup_folder, backup), dir)
+        puts "Restoring db ..."
+        restore_db(db, File.join(dir, source_db ))
+      end
+    end
+
+
+    def self.delete_backup(backup_folder, backup)
+      delete_folder File.join(backup_folder, backup)
     end
 
 
@@ -92,7 +145,7 @@ module MongoDbUtils
 
     def self.timestamp
       t = Time.new
-      t.strftime("%Y.%m.%d__%H.%M")
+      t.strftime('%Y.%m.%d__%H.%M')
     end
 
     def self.db_exists?(db)
@@ -108,5 +161,56 @@ module MongoDbUtils
       exists
     end
 
+    def self.download_backup(download_file_name, backup, bucket_name, access_key_id, secret_access_key)
+      puts "downloading backup to #{download_file_name} from #{bucket_name} key #{backup}"
+      MongoDbUtils::S3::get_file(download_file_name, backup, bucket_name, access_key_id, secret_access_key)
+    end
+
+    def self.restore_db(destination, backup)
+      puts "restoring db #{destination} from #{backup}"
+
+      # if the destination db doesn't exist
+      # we assume that the user has admin control of the server
+      # eg its a local server (this needs to be thought through a bit more)
+      username = ''
+      password = ''
+
+      if db_exists? destination
+        username = destination.username
+        password = destination.password
+      end
+
+      Restore.new(
+        destination.to_host_s,
+        destination.name,
+        backup,
+        username,
+        password).run
+    end
+
+    def self.unzip(archive, dir)
+      command = "tar --extract --gzip --file=#{archive} --directory=#{dir} --strip 1"
+      output = `#{command} 2>&1`
+      raise "#{output} cmd <#{command}>" unless $?.to_i == 0
+    end
+
+    def self.list_archive_folders(folder, archive)
+      command = "tar --list --file=#{File.join(folder, archive)} | grep '/$'"
+      output = `#{command} 2>&1`
+      raise "#{output} cmd <#{command}>" unless $?.to_i == 0
+      output.split
+    end
+
+    def self.get_latest_backup(bucket_name, access_key_id, secret_access_key)
+      list_backups(
+        bucket_name,
+        access_key_id,
+        secret_access_key).select { |a| a.end_with? ".tgz" }.sort.pop
+    end
+
+    def self.delete_folder(path)
+      puts "deleting folder #{path}"
+      `rm --force --recursive #{path}`
+    end
   end
 end

data/lib/mongo-db-utils/config-loader.rb

@@ -8,8 +8,8 @@ module MongoDbUtils
 
   class ConfigLoader
 
-    ROOT_FOLDER = "~/.mongo-db-utils"
-    CONFIG_LOCATION = "#{ROOT_FOLDER}/config.yml"
+    ROOT_FOLDER = File.join("~",".mongo-db-utils")
+    CONFIG_LOCATION = File.join(ROOT_FOLDER, "config.yml")
 
     attr_reader :config
 
@@ -33,6 +33,7 @@ module MongoDbUtils
     end
 
     private
+
     def load
       full_path = File.expand_path(@config_path)
       puts "loading config from #{full_path}"
@@ -49,7 +50,7 @@ module MongoDbUtils
     def create_fresh_install_config(full_path)
         config = Model::Config.new
         config.writer = self
-        config.backup_folder = "#{ROOT_FOLDER}/backups"
+        config.backup_folder = File.join(ROOT_FOLDER, "backups")
         initialize_files(full_path)
         File.open( full_path, 'w' ) do |out|
           YAML.dump( config, out )

data/lib/mongo-db-utils/console.rb

@@ -1,6 +1,6 @@
 require 'highline/import'
 require 'mongo-db-utils/version'
-Dir['lib/mongo-db-utils/models/*.rb'].each {|file| require file.gsub("lib/", "") }
+Dir['lib/mongo-db-utils/models/*.rb'].each { |file| require file.gsub("lib/", "") }
 
 
 module MongoDbUtils
@@ -16,27 +16,27 @@ module MongoDbUtils
     end
 
     protected
-        def method_missing(name, *args, &block)
-          cleaned_args = args.map{ |a| trim(clean(a)) }
-          cleaned_args.each{ |a| puts "#{a} -> #{a.class}"}
-          @config.send(name, *cleaned_args, &block)
-        end
+    def method_missing(name, *args, &block)
+      cleaned_args = args.map { |a| trim(clean(a)) }
+      cleaned_args.each { |a| puts "#{a} -> #{a.class}" }
+      @config.send(name, *cleaned_args, &block)
+    end
 
-        def clean(a)
-          if a.class.to_s == "HighLine::String"
-            a.to_s
-          else
-            a
-          end
-        end
+    def clean(a)
+      if a.class.to_s == "HighLine::String"
+        a.to_s
+      else
+        a
+      end
+    end
 
-        def trim(s)
-          if(s.class.to_s == "String")
-            s.strip
-          else
-            s
-          end
-        end
+    def trim(s)
+      if (s.class.to_s == "String")
+        s.strip
+      else
+        s
+      end
+    end
   end
 
 
@@ -46,7 +46,7 @@ module MongoDbUtils
 =====================================
 || Mongo Db Utils - Version: #{MongoDbUtils::VERSION} ||
 =====================================
-eos
+    eos
 
 
     def initialize(config, cmd)
@@ -64,14 +64,39 @@ eos
     def main_menu
 
       my_menu("What do you want to do?") do |menu|
-        menu.choice "copy a db" do copy_a_db end
-        menu.choice "backup a db locally" do do_backup end
-        menu.choice "backup a db to an amazon s3 bucket" do backup_to_s3 end
-        menu.choice "remove config" do remove_config end
-        menu.choice "show config" do show_config end
-        menu.choice "add server to config" do add_config end
-        menu.choice "add Amazon bucket to config" do add_bucket_to_config end
-        menu.choice "remove server from config" do remove_server_from_config end
+        menu.choice "copy a db" do
+          copy_a_db
+        end
+        menu.choice "backup a db locally" do
+          do_backup
+        end
+        menu.choice "backup a db to an amazon s3 bucket" do
+          backup_to_s3
+        end
+        menu.choice "download a backup from an amazon s3 bucket" do
+          download_backup_from_s3
+        end
+        menu.choice "delete a backup from the downloads" do
+          delete_downloaded_backup
+        end
+        menu.choice "restore a db from a downloaded backup" do
+          restore_db_from_backup
+        end
+        menu.choice "remove config" do
+          remove_config
+        end
+        menu.choice "show config" do
+          show_config
+        end
+        menu.choice "add db server to config" do
+          add_config
+        end
+        menu.choice "add Amazon bucket to config" do
+          add_bucket_to_config
+        end
+        menu.choice "remove db server from config" do
+          remove_server_from_config
+        end
       end
     end
 
@@ -93,7 +118,6 @@ eos
 
 
     def backup_to_s3
-
       plan = Hash.new
 
       db_list_menu("Choose a DB:") do |db|
@@ -101,7 +125,7 @@ eos
       end
 
       if @config.has_buckets?
-        list_buckets("Choose a Bucket:") do |bucket|
+        bucket_list_menu("Choose a Bucket:") do |bucket|
           plan[:bucket] = bucket
         end
       else
@@ -119,6 +143,91 @@ eos
     end
 
 
+    def download_backup_from_s3
+      plan = Hash.new
+
+      if @config.has_buckets?
+        bucket_list_menu("Choose a source bucket:", true) do |bucket|
+          if bucket == 'back'
+            main_menu
+            return
+          end
+          plan[:bucket] = bucket
+        end
+      else
+        say("You don't have any buckets yet - add one..")
+        add_bucket_to_config
+        return
+      end
+
+      backups = @cmd.list_backups(
+        plan[:bucket].name,
+        plan[:bucket].access_key,
+        plan[:bucket].secret_key).select { |a| a.end_with? ".tgz" }
+
+      backup_list_menu("Choose a backup:", backups, true) do |backup|
+        if backup == 'back'
+          main_menu
+        else
+          plan[:backup] = backup
+          @cmd.download_backup_from_s3(
+            @config.backup_folder,
+            plan[:backup],
+            plan[:bucket].name,
+            plan[:bucket].access_key,
+            plan[:bucket].secret_key)
+        end
+      end
+    end
+
+
+    def delete_downloaded_backup
+      plan = Hash.new
+
+      downloaded_backups_list_menu("Choose a backup:", @cmd.list_downloaded_backups(@config.backup_folder), true) do |backup|
+        if backup == 'back'
+          main_menu
+          return
+        end
+        if ask("Delete backup #{backup}? (Y|n) [n]") != 'Y'
+          main_menu
+          return
+        end
+        plan[:backup] = backup
+        @cmd.delete_backup(
+          @config.backup_folder,
+          plan[:backup])
+      end
+    end
+
+
+    def restore_db_from_backup
+      plan = Hash.new
+
+      db_list_menu("Choose a target DB:") do |db|
+        plan[:db] = db
+      end
+
+      downloaded_backups_list_menu("Choose a backup:", @cmd.list_downloaded_backups(@config.backup_folder)) do |backup|
+        plan[:backup] = backup
+      end
+
+      source_db_list_menu("Choose a source_db in the backup:", @cmd.list_backup_folders(@config.backup_folder, plan[:backup])) do |folder|
+        plan[:source_db] = folder
+      end
+
+      if ask("Restore db #{db}? (Y|n) [n]") != 'Y'
+        main_menu
+        return
+      end
+
+      @cmd.restore_from_backup(
+        @config.backup_folder,
+        plan[:db],
+        plan[:backup],
+        plan[:source_db])
+    end
+
     def add_bucket_to_config
       say("add an amazon bucket:")
       bucket = MongoDbUtils::Model::Bucket.new
@@ -133,7 +242,6 @@ eos
       my_menu("")
     end
 
-
     def get_config
       say("You don't have any servers configured, please add one:")
       add_config
@@ -149,7 +257,7 @@ eos
       end
       say("--------------------")
       say("Amazon S3 Buckets")
-      if( @config.buckets.nil?)
+      if (@config.buckets.nil?)
         say("no buckets")
       else
         @config.buckets.sort.each do |bucket|
@@ -166,8 +274,12 @@ eos
 
     def add_config
       my_menu("Single db or replica set?") do |menu|
-        menu.choice "single db" do add_single_db end
-        menu.choice "replica set db" do add_replica_set end
+        menu.choice "single db" do
+          add_single_db
+        end
+        menu.choice "replica set db" do
+          add_replica_set
+        end
       end
     end
 
@@ -181,7 +293,9 @@ eos
       label = successful ? "add another?" : "try again?"
 
       my_menu("") do |menu|
-        menu.choice label do add_config end
+        menu.choice label do
+          add_config
+        end
       end
     end
 
@@ -195,11 +309,12 @@ eos
       say("bad replica set uri") unless successful
 
       my_menu("") do |menu|
-        menu.choice (successful ? "add another" : "try again?") do add_config end
+        menu.choice (successful ? "add another" : "try again?") do
+          add_config
+        end
       end
     end
 
-
     def remove_server_from_config
       db_list_menu("Remove server from config:") do |db|
         @config.remove_db(db)
@@ -223,10 +338,14 @@ eos
       say("#{plan[:source].to_s} --> #{plan[:destination].to_s}")
 
       my_menu("") do |menu|
-        menu.choice "Do it!" do begin_copy(plan, false) end
-        menu.choice "Do it - skip backup" do begin_copy(plan, true) end
+        menu.choice "Do it!" do
+          begin_copy(plan, false)
+        end
+        menu.choice "Do it - skip backup" do
+          begin_copy(plan, true)
+        end
         menu.choice "Reverse" do
-          show_copy_plan( {:source => plan[:destination], :destination => plan[:source]})
+          show_copy_plan({:source => plan[:destination], :destination => plan[:source]})
         end
       end
     end
@@ -238,16 +357,20 @@ eos
     def my_menu(prompt, show_defaults = true)
       say(prompt)
       choose do |menu|
-        menu.shell  = true
+        menu.shell = true
         menu.index = :number
         menu.prompt = "\n#{prompt}\n"
         menu.index_suffix = ") "
         menu.prompt = "?"
-        if( show_defaults)
-          menu.choice "Back" do main_menu end
-          menu.choice "Exit" do say("Goodbye"); abort("--"); end
+        if (show_defaults)
+          menu.choice "Back" do
+            main_menu
+          end
+          menu.choice "Exit" do
+            say("Goodbye"); abort("--");
+          end
         end
-        say(" ")
+        say("")
         yield menu if block_given?
       end
     end
@@ -255,19 +378,72 @@ eos
     def db_list_menu(prompt)
       my_menu(prompt, false) do |menu|
         @config.dbs.sort.each do |db|
-          menu.choice "#{db.to_s_simple}" do yield db if block_given? end
+          menu.choice "#{db.to_s_simple}" do
+            yield db if block_given?
+          end
         end
       end
     end
 
-    def list_buckets(prompt)
-      my_menu(prompt) do |menu|
+    def bucket_list_menu(prompt, show_defaults = false)
+      my_menu(prompt, false) do |menu|
+        if show_defaults
+          menu.choice 'Back' do
+            yield 'back' if block_given?
+          end
+        end
         @config.buckets.sort.each do |bucket|
-          menu.choice "#{bucket}" do yield bucket if block_given? end
+          menu.choice "#{bucket}" do
+            yield bucket if block_given?
+          end
+        end
+      end
+    end
+
+    def backup_list_menu(prompt, backups, show_defaults = false)
+      my_menu(prompt, false) do |menu|
+        if show_defaults
+          menu.choice 'Back' do
+            yield 'back' if block_given?
+          end
+        end
+        menu.choice 'latest' do
+          yield 'latest' if block_given?
+        end
+        backups.sort.each do |backup|
+          menu.choice "#{backup}" do
+            yield backup if block_given?
+          end
+        end
+      end
+    end
+
+    def source_db_list_menu(prompt, folders)
+      my_menu(prompt, false) do |menu|
+        folders.sort.each do |item|
+          menu.choice "#{item}" do
+            yield item if block_given?
+          end
         end
       end
     end
 
+    def downloaded_backups_list_menu(prompt, backups, show_defaults = false)
+      my_menu(prompt, false) do |menu|
+        if show_defaults
+          menu.choice 'Back' do
+            yield 'back' if block_given?
+          end
+        end
+        backups.sort.each do |item|
+          menu.choice "#{item}" do
+            yield item if block_given?
+          end
+        end
+      end
+    end
+
+
     private
     def clean(s)
       s.to_s.strip

data/lib/mongo-db-utils/s3.rb

@@ -6,10 +6,8 @@ module MongoDbUtils
 
     def self.put_file(file, name, bucket_name, access_key_id, secret_access_key)
       puts "putting file to Amazon S3"
-      AWS::S3::Base.establish_connection!(
-        :access_key_id     => access_key_id,
-        :secret_access_key => secret_access_key
-      )
+
+      self.s3connect(access_key_id, secret_access_key)
 
       begin
         AWS::S3::Bucket.find(bucket_name)
@@ -21,5 +19,46 @@ module MongoDbUtils
       end
       AWS::S3::S3Object.store(name, open(file), bucket_name)
     end
+
+
+    def self.get_file(filename, key, bucket_name, access_key_id, secret_access_key)
+      puts "getting file from Amazon S3"
+
+      self.s3connect(access_key_id, secret_access_key)
+
+      File.open(filename, 'wb') do |file|
+        AWS::S3::S3Object.stream(key, bucket_name) do |chunk|
+          file.write chunk
+        end
+        file.close
+      end
+    end
+
+
+    def self.list_bucket(bucket_name, access_key_id, secret_access_key)
+      puts "getting list of bucket keys from Amazon S3"
+
+      self.s3connect(access_key_id, secret_access_key)
+
+      begin
+        AWS::S3::Bucket.find(bucket_name).objects.collect(&:key)
+      rescue AWS::S3::NoSuchBucket
+        puts "Error:: Bucket does not exist: #{bucket_name}"
+        return nil
+      rescue AWS::S3::AllAccessDisabled
+        puts "Error:: You cannot access this bucket: #{bucket_name}"
+        return nil
+      end
+    end
+
+    private
+
+    def self.s3connect(access_key_id, secret_access_key)
+      AWS::S3::Base.establish_connection!(
+        :access_key_id => access_key_id,
+        :secret_access_key => secret_access_key
+      )
+    end
+
   end
 end

data/lib/mongo-db-utils/tools/commands.rb

@@ -6,39 +6,41 @@ module MongoDbUtils
 
     class ToolsException < RuntimeError
       attr :cmd, :output
-      def initialize(cmd, output)
+      def initialize(cmd, output, message)
+        super(message)
         @cmd = cmd
-        @output =output
+        @output = output
       end
+
     end
 
     class BaseCmd
 
-      def initialize(cmd_name, host_and_port, db, username = "", password = "")
-        @unsafeOptions = build_base_options(host_and_port, db, username, password)
-        @optionsWithoutCredentials = build_base_options(host_and_port, db, username.empty? ? '':'****', password.empty? ? '':'****')
+      def initialize(cmd_name, host_and_port, db, username = '', password = '')
+        @unsafe_options = build_base_options(host_and_port, db, username, password)
+        @options_without_credentials = build_base_options(host_and_port, db, username.empty? ? '':'****', password.empty? ? '':'****')
         @cmd_name = cmd_name
       end
 
       def run
         puts "[#{self.class}] run: #{cmd}"
-        output = `#{executableCmd}`
-        raise ToolsException.new("#{cmd}", output) unless $?.to_i == 0
+        output = `#{executable_cmd} 2>&1`
+        raise ToolsException.new("#{cmd}", output, "Error in #{cmd_name}:: #{output} cmd #{cmd}") unless $?.to_i == 0
       end
 
       def cmd
-        "#{@cmd_name} #{options_string(@optionsWithoutCredentials)}"
+        "#{@cmd_name} #{options_string(@options_without_credentials)}"
       end
 
-      def executableCmd
-        "#{@cmd_name} #{options_string(@unsafeOptions)}"
+      def executable_cmd
+        "#{@cmd_name} #{options_string(@unsafe_options)}"
       end
 
       private
       
-      def addOption(option)
-        @unsafeOptions << option
-        @optionsWithoutCredentials << option
+      def add_option(option)
+        @unsafe_options << option
+        @options_without_credentials << option
       end
 
       def o(key,value)
@@ -46,33 +48,33 @@ module MongoDbUtils
       end
 
       # options common to all commands
-      def build_base_options(host_and_port,db,username="",password="")
+      def build_base_options(host_and_port,db,username='',password='')
         options = []
-        options << o("-h", host_and_port)
-        options << o("-db", db)
-        options << o("-u", username)
-        options << o("-p", password)
+        options << o('-h', host_and_port)
+        options << o('-db', db)
+        options << o('-u', username)
+        options << o('-p', password)
         options
       end
 
       # given an array of options build a string of those options unless the option is empty
       def options_string(opts)
         opt_strings = opts.reject{ |o| o.empty? }.map { |o| o.to_s }
-        opt_strings.join(" ").strip
+        opt_strings.join(' ').strip
       end
     end
 
     class Dump < BaseCmd
-      def initialize(host_and_port,db,output,username = "", password = "")
-        super("mongodump", host_and_port, db, username, password)
-        addOption(o("-o", output))
+      def initialize(host_and_port,db,output,username = '', password = '')
+        super('mongodump', host_and_port, db, username, password)
+        add_option(o('-o', output))
       end
     end
 
     class Restore < BaseCmd
-      def initialize(host_and_port,db,source_folder,username = "", password = "")
-        super("mongorestore", host_and_port, db, username, password)
-        addOption("--drop")
+      def initialize(host_and_port,db,source_folder,username = '', password = '')
+        super('mongorestore', host_and_port, db, username, password)
+        add_option('--drop')
         @source_folder = source_folder
       end
 
@@ -80,29 +82,29 @@ module MongoDbUtils
         "#{super} #{@source_folder}"
       end
 
-      def executableCmd
+      def executable_cmd
         "#{super} #{@source_folder}"
       end
     end
 
     class Import < BaseCmd
-      def initialize(host_and_port, db, collection, file, username = "", password = "", opts = {})
-        super("mongoimport", host_and_port, db, username, password)
-        addOption(o("-c", collection))
-        addOption(o("--file", file))
-        addOption("--jsonArray") if opts[:json_array]
-        addOption("--drop") if opts[:drop]
+      def initialize(host_and_port, db, collection, file, username = '', password = '', opts = {})
+        super('mongoimport', host_and_port, db, username, password)
+        add_option(o('-c', collection))
+        add_option(o('--file', file))
+        add_option('--jsonArray') if opts[:json_array]
+        add_option('--drop') if opts[:drop]
       end
     end
 
     class Export < BaseCmd
 
-      def initialize(host_and_port, db, collection, query, output, username = "", password = "", opts = {})
-        super("mongoexport", host_and_port, db, username, password)
-        addOption(o("-c", collection))
-        addOption(o("-o", output))
-        addOption(o("--query", "'#{query}'"))
-        addOption("--jsonArray") if opts[:json_array]
+      def initialize(host_and_port, db, collection, query, output, username = '', password = '', opts = {})
+        super('mongoexport', host_and_port, db, username, password)
+        add_option(o('-c', collection))
+        add_option(o('-o', output))
+        add_option(o('--query', "'#{query}'"))
+        add_option('--jsonArray') if opts[:json_array]
       end
     end
 

data/lib/mongo-db-utils/version.rb

@@ -1,4 +1,4 @@
 module MongoDbUtils
-  VERSION = "0.1.6"
+  VERSION = "0.2.0"
   READY_FOR_USE = "(prod version)"
 end

data/spec/mongo_tools_cmd_spec.rb

@@ -9,11 +9,11 @@ describe Dump do
   end
 
   it "should work with single uris" do
-    Dump.new("host:port", "db", "out", "user", "pass").executableCmd.should eql "mongodump -h host:port -db db -u user -p pass -o out"
+    Dump.new("host:port", "db", "out", "user", "pass").executable_cmd.should eql "mongodump -h host:port -db db -u user -p pass -o out"
   end
 
   it "should work with single uris - no user/pass" do
-    Dump.new("host:port", "db", "out").executableCmd.should eql "mongodump -h host:port -db db -o out"
+    Dump.new("host:port", "db", "out").executable_cmd.should eql "mongodump -h host:port -db db -o out"
   end
 
   it "should safely work with replica set uris" do
@@ -23,7 +23,7 @@ describe Dump do
 
   it "should work with replica set uris" do
     expected = "mongodump -h setname/host1:port1,host2:port2 -db db -u user -p pass -o out"
-    Dump.new("setname/host1:port1,host2:port2","db", "out", "user", "pass").executableCmd.should eql expected
+    Dump.new("setname/host1:port1,host2:port2","db", "out", "user", "pass").executable_cmd.should eql expected
   end
 
 end
@@ -35,7 +35,7 @@ describe Restore do
   end
 
   it "should work with single uris" do
-    Restore.new("host:port", "db", "source", "user", "pass").executableCmd.should eql "mongorestore -h host:port -db db -u user -p pass --drop source"
+    Restore.new("host:port", "db", "source", "user", "pass").executable_cmd.should eql "mongorestore -h host:port -db db -u user -p pass --drop source"
   end
 
   it "should safely work with replica set uris" do
@@ -45,7 +45,7 @@ describe Restore do
 
   it "should work with replica set uris" do
     expected = "mongorestore -h setname/host1:port1,host2:port2 -db db -u user -p pass --drop source"
-    Restore.new("setname/host1:port1,host2:port2","db", "source", "user", "pass").executableCmd.should eql expected
+    Restore.new("setname/host1:port1,host2:port2","db", "source", "user", "pass").executable_cmd.should eql expected
   end
 end
 
@@ -56,11 +56,11 @@ describe Import do
   end
 
   it "should work with single uris - with user/pass" do
-    Import.new("host:port", "db", "coll", "myfile.json", "user", "pass").executableCmd.should eql "mongoimport -h host:port -db db -u user -p pass -c coll --file myfile.json"
+    Import.new("host:port", "db", "coll", "myfile.json", "user", "pass").executable_cmd.should eql "mongoimport -h host:port -db db -u user -p pass -c coll --file myfile.json"
   end
 
   it "should work with single uris - no user/pass" do
-    Import.new("host:port", "db", "coll", "myfile.json").executableCmd.should eql "mongoimport -h host:port -db db -c coll --file myfile.json"
+    Import.new("host:port", "db", "coll", "myfile.json").executable_cmd.should eql "mongoimport -h host:port -db db -c coll --file myfile.json"
   end
 
   it "should safely work with replica set uris" do
@@ -70,7 +70,7 @@ describe Import do
 
   it "should work with replica set uris" do
     expected = "mongoimport -h setname/host1:port1,host2:port2 -db db -u user -p pass -c coll --file myfile.json --jsonArray"
-    Import.new("setname/host1:port1,host2:port2","db", "coll", "myfile.json", "user", "pass", { :json_array => true} ).executableCmd.should eql expected
+    Import.new("setname/host1:port1,host2:port2","db", "coll", "myfile.json", "user", "pass", { :json_array => true} ).executable_cmd.should eql expected
   end
 end
 
@@ -81,11 +81,11 @@ describe Export do
   end
 
   it "should work with single uris - with user/pass" do
-    Export.new("host:port", "db", "coll", "{query}", "myfile.json", "user", "pass").executableCmd.should eql "mongoexport -h host:port -db db -u user -p pass -c coll -o myfile.json --query '{query}'"
+    Export.new("host:port", "db", "coll", "{query}", "myfile.json", "user", "pass").executable_cmd.should eql "mongoexport -h host:port -db db -u user -p pass -c coll -o myfile.json --query '{query}'"
   end
 
   it "should work with single uris - no user/pass" do
-    Export.new("host:port", "db", "coll", "{query}", "myfile.json").executableCmd.should eql "mongoexport -h host:port -db db -c coll -o myfile.json --query '{query}'"
+    Export.new("host:port", "db", "coll", "{query}", "myfile.json").executable_cmd.should eql "mongoexport -h host:port -db db -c coll -o myfile.json --query '{query}'"
   end
 
   it "should safely work with replica set uris" do
@@ -95,7 +95,7 @@ describe Export do
 
   it "should work with replica set uris" do
     expected = "mongoexport -h setname/host1:port1,host2:port2 -db db -u user -p pass -c coll -o myfile.json --query '{query}' --jsonArray"
-    Export.new("setname/host1:port1,host2:port2","db", "coll", "{query}", "myfile.json", "user", "pass", { :json_array => true} ).executableCmd.should eql expected
+    Export.new("setname/host1:port1,host2:port2","db", "coll", "{query}", "myfile.json", "user", "pass", { :json_array => true} ).executable_cmd.should eql expected
   end
 end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mongo-db-utils
 version: !ruby/object:Gem::Version
-  version: 0.1.6
+  version: 0.2.0
 platform: ruby
 authors:
 - edeustace
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-09-24 00:00:00.000000000 Z
+date: 2014-10-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec