mongo-db-utils 0.0.9 → 0.0.9.2

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

@@ -1,59 +1,68 @@
-require 'mongo-db-utils/models'
+project_root = File.dirname(File.absolute_path(__FILE__))
+
+Dir.glob(project_root + '/lib/mongo-db-utils/models/*', &method(:require))
+
 require 'yaml'
 
 module MongoDbUtils
 
   class ConfigLoader
-    
+
     ROOT_FOLDER = "~/.mongo-db-utils"
     CONFIG_LOCATION = "#{ROOT_FOLDER}/config.yml"
 
-    def self.load(load_path = CONFIG_LOCATION)
-      full_path = File.expand_path(load_path)
-      puts "loading config from #{full_path}"
+    attr_reader :config
 
-      if File.exist?(full_path) && YAML.load(File.open(full_path))
-        config = YAML.load(File.open(full_path))
-        config.writer = self
-        config
-      else
-        self.create_fresh_install_config(full_path)
-      end
+    def initialize(config_path)
+      @config_path = config_path
+      load
     end
 
-    def self.flush(path = CONFIG_LOCATION)
-      path = File.expand_path(path)
+    def flush
+      path = File.expand_path(@config_path)
       puts "removing: #{path}"
       FileUtils.rm(path) if File.exist?(path)
-      self.initialize_files(path)
+      initialize_files(path)
     end
 
-    def self.save(config, path = CONFIG_LOCATION)
+    def save(config)
       raise "config is nil" if config.nil?
-
-      File.open( File.expand_path(path), 'w' ) do |out|
+      File.open( File.expand_path(@config_path), 'w' ) do |out|
         YAML.dump( config, out )
       end
     end
 
-    private 
-    def self.create_fresh_install_config(full_path)
+    private
+    def load
+      full_path = File.expand_path(@config_path)
+      puts "loading config from #{full_path}"
+
+      if File.exist?(full_path) && YAML.load(File.open(full_path))
+        config = YAML.load(File.open(full_path))
+        config.writer = self
+        @config = config
+      else
+        @config = create_fresh_install_config(full_path)
+      end
+    end
+
+    def create_fresh_install_config(full_path)
         config = Model::Config.new
         config.writer = self
         config.backup_folder = "#{ROOT_FOLDER}/backups"
-        self.initialize_files(full_path)
+        initialize_files(full_path)
         File.open( full_path, 'w' ) do |out|
           YAML.dump( config, out )
         end
         config
     end
 
-    def self.get_folder_name(path)
+    def get_folder_name(path)
       /(.*)\/.*.yml/.match(path)[1]
     end
 
-    def self.initialize_files(path)
-      folder = self.get_folder_name(path)
+    def initialize_files(path)
+      folder = get_folder_name(path)
       FileUtils.mkdir_p(folder) unless File.exist?(folder)
       FileUtils.touch(path)
     end

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

@@ -1,8 +1,45 @@
 require 'highline/import'
 require 'mongo-db-utils/version'
-require 'mongo-db-utils/models'
+Dir['lib/mongo-db-utils/models/*.rb'].each {|file| require file.gsub("lib/", "") }
+
 
 module MongoDbUtils
+
+  # This is a workaround for this issue:
+  # https://github.com/JEG2/highline/issues/69
+  # In ruby 2 + highline the yaml strings don't get serialized correctly.
+  # The workaround is for any argument that is of type HighLine::String to call to_s on it
+  class ConfigProxy
+
+    def initialize(config)
+      @config = config
+    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 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
+  end
+
+
   class Console
 
     HEADER = <<-eos
@@ -13,7 +50,7 @@ eos
 
 
     def initialize(config, cmd)
-      @config = config
+      @config = ConfigProxy.new(config)
       @cmd = cmd
     end
 
@@ -128,9 +165,15 @@ eos
     end
 
     def add_config
-      entry = Hash.new
-      entry[:mongo_uri] = ask("Mongo uri (eg: 'mongodb://user:pass@locahost:27017/db')")
-      new_uri = entry[:mongo_uri].gsub(" ", "")
+      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
+      end
+    end
+
+    def add_single_db
+      mongo_uri = ask("Mongo uri (eg: 'mongodb://user:pass@locahost:27017/db')")
+      new_uri = mongo_uri.to_s.strip
       successful = @config.add_db_from_uri(new_uri)
 
       say("bad uri!") unless successful
@@ -142,6 +185,21 @@ eos
       end
     end
 
+    def add_replica_set
+      mongo_uri = ask("Replica Set uri: (eg: mongodb://user:pass@host1:port,host2:port,.../db)1
+")
+      replica_set_name = ask("Replica Set name: ")
+
+      successful = @config.add_replica_set(mongo_uri, replica_set_name)
+
+      say("bad replica set uri") unless successful
+
+      my_menu("") do |menu|
+        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)
@@ -209,5 +267,10 @@ eos
       end
     end
 
+    private
+    def clean(s)
+      s.to_s.strip
+    end
+
   end
 end

data/lib/mongo-db-utils/models/bucket.rb

@@ -0,0 +1,17 @@
+module MongoDbUtils
+  module Model
+
+   class Bucket
+    attr_accessor :name, :access_key, :secret_key
+
+    def to_s
+      "#{name} | #{access_key} | #{secret_key}"
+    end
+
+    def <=> (other)
+      self.name <=> other.name
+    end
+  end
+
+end
+end

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

@@ -0,0 +1,82 @@
+require 'mongo-db-utils/models/db'
+module MongoDbUtils
+
+  module Model
+    class Config
+      attr_reader :dbs, :buckets
+      attr_writer :writer
+      attr_accessor :backup_folder
+
+      def initialize
+        @dbs = []
+        @buckets = []
+      end
+
+      def empty?
+        @dbs.nil? || @dbs.empty?
+      end
+
+      def has_buckets?
+        !@buckets.nil? && !@buckets.empty?
+      end
+
+      def flush
+        @dbs = []
+        @writer.flush
+      end
+
+      def remove_db(db)
+        @dbs = @dbs - [db]
+        save
+      end
+
+      def add_replica_set(uri, name)
+        add_db ReplicaSetDb.new(uri,name)
+      end
+
+
+      def add_db_from_uri(uri)
+        add_db Db.new(uri)
+      end
+
+      def already_contains(db)
+        !@dbs.find{|current| current.uri == db.uri }.nil?
+      end
+
+      # because we are serializing the config - the bucket may be nil
+      # at this point
+      def add_bucket(bucket)
+        @buckets = [] if @buckets.nil?
+        unless already_contains_bucket?(bucket)
+          @buckets << bucket
+          save
+        end
+      end
+
+      def already_contains_bucket?(bucket)
+        !@buckets.find{ |b| b.to_s == bucket.to_s}.nil?
+      end
+
+      def to_s
+        "Config"
+      end
+
+      private
+      def save
+        @writer.save(self) unless @writer.nil?
+      end
+
+      def add_db(db)
+        @dbs = [] if @dbs.nil?
+        unless db.nil? || already_contains(db)
+          @dbs << db
+          @dbs.sort!
+          save
+        end
+        @dbs.include?(db) && !db.nil?
+      end
+
+    end
+
+  end
+end

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

@@ -0,0 +1,81 @@
+module MongoDbUtils
+  module Model
+
+    # A Db stored in the config
+    class Db
+
+      URI_NO_USER = /mongodb:\/\/(.*)\/(.*$)/
+      URI_USER = /mongodb:\/\/(.*):(.*)@(.*)\/(.*$)/
+
+      attr_accessor :username, :password, :name, :uri
+
+      def initialize(uri)
+        user,pwd,host_port,db = nil
+
+        if( uri.match(URI_USER))
+          match, user, pwd, host_port, name = *uri.match(URI_USER)
+        elsif(uri.match(URI_NO_USER))
+          match, host_port, name = *uri.match(URI_NO_USER)
+          user = ""
+          pwd = ""
+        end
+
+        raise "can't parse uri" if( host_port.nil? || name.nil? )
+
+        @host_port = host_port
+        @name = name
+        @username = user
+        @password = pwd
+        @uri = uri
+      end
+
+      def authentication_required?
+        has?(self.username) && has?(self.password)
+      end
+
+      # Return the host string in a format that is compatable with mongo binary tools
+      # See: http://docs.mongodb.org/manual/reference/program/mongodump/#cmdoption-mongodump--host
+      def to_host_s
+        "#{@host_port}"
+      end
+
+      def to_s_simple
+        "#{@name} on #{@host_port} - (#{@username}:#{@password})"
+      end
+
+      def to_s
+        "[SingleDb-(#{to_host_s}/#{name})]"
+      end
+
+      def <=>(other)
+        self.to_s <=> other.to_s
+      end
+
+      private
+      def has?(s)
+        !s.nil? && !s.empty?
+      end
+    end
+
+
+    class ReplicaSetDb < Db
+
+      attr_reader :set_name
+      def initialize(uri, name)
+        super(uri)
+        @set_name = name
+      end
+
+      # Note: we override this to provide a replica set format
+      def to_host_s
+        "#{@set_name}/#{@host_port}"
+      end
+
+      def to_s
+        "[ReplicaSetDb-(#{to_host_s}/#{@name})]"
+      end
+    end
+
+
+  end
+end

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

@@ -0,0 +1,80 @@
+require 'aws/s3'
+
+module MongoDbUtils
+
+  module Tools
+
+    class BaseCmd
+      private
+      def self.o(key,value)
+        Option.new(key,value)
+      end
+
+      # options common to all commands
+      def self.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
+      end
+
+      # given an array of options build a string of those options unless the option is empty
+      def self.options_string(opts)
+        out = ""
+        opts.each do |o|
+          out << "#{o.key} #{o.value} " unless o.empty?
+        end
+        out.strip
+      end
+    end
+
+    class Dump < BaseCmd
+
+      # create the cmd string that will be executed by the system
+      def self.cmd(host_and_port,db,output,username = "", password = "")
+        options = build_base_options(host_and_port,db,username,password)
+        options << o("-o", output)
+        "mongodump #{options_string(options)}"
+      end
+
+      # run the command
+      def self.run(host_and_port,db,output,username="", password ="")
+        cmd_string = self.cmd(host_and_port,db,output,username,password)
+        puts "[Dump] run: #{cmd_string}"
+        `#{cmd_string}`
+      end
+
+    end
+
+    class Restore < BaseCmd
+      def self.cmd(host_and_port,db,source_folder,username = "", password = "")
+        options = build_base_options(host_and_port,db,username,password)
+        params = options_string(options) << " --drop #{source_folder}"
+        "mongorestore #{params}"
+      end
+
+      def self.run(host_and_port,db,source_folder,username="", password ="")
+        cmd_string = self.cmd(host_and_port,db,source_folder,username,password)
+        puts "[Restore] run: #{cmd_string}"
+        `#{cmd_string}`
+      end
+    end
+
+
+    class Option
+      attr_accessor :key, :value
+
+      def initialize(key,value)
+        @key = key
+        @value = value
+      end
+
+      def empty?
+        @value.nil? || @value.empty?
+      end
+    end
+
+  end
+end