mink 0.1

data/LICENSE.md

@@ -0,0 +1,13 @@
+Copyright 2011 Kyle Banker
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

data/README.md

@@ -0,0 +1,2 @@
+# Mink
+

data/bin/mink

@@ -0,0 +1,160 @@
+#!/usr/bin/ruby
+
+$:.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require "rubygems"
+require "fileutils"
+require "yaml"
+require "mink"
+
+module Mink
+  module Bin
+    extend self
+
+    VALID_CONFIGS = ["replicas", "shards"]
+    TEMPLATE_BASE = File.join(File.dirname(__FILE__), '..', 'templates')
+    CONFIG_NAME   = "mink.yml"
+
+    def init
+      load_config
+      check_mongod
+
+      if @config[:shards]
+        init_shards
+      else
+        init_replicas
+      end
+    end
+
+    def init_shards
+      m = Mink::ShardingManager.new(shard_config)
+      m.start_cluster
+    end
+
+    def init_replicas
+      m = Mink::ReplSetManager.new(replica_set_config)
+      m.start_set
+    end
+
+    def shard_config
+      config = @config[:shards]
+
+      { :shard_count => config[:shard_count],
+        :mongos_count => config[:mongos_count],
+        :mongos_start_port => config[:mongos_start_port],
+        :config_server_start_port => config[:config_server_start_port],
+        :config_server_count => config[:config_server_count],
+        :shard_database => config[:shard_database],
+        :shard_collection => config[:shard_collection],
+        :shard_key => config[:shard_key],
+        :working_dir => Dir.pwd,
+        :durable => @config[:durability],
+        :replica_set_config => replica_set_config
+      }
+    end
+
+    def replica_set_config
+      config = @config[:replica_set_config]
+
+      { :replica_count => config[:replica_count],
+        :arbiter_count => config[:arbiter_count],
+        :passive_count => config[:passive_count],
+        :name          => config[:name],
+        :start_port    => config[:start_port],
+        :mongod_path   => @mongod_path,
+        :working_dir   => Dir.pwd,
+        :durable       => @config[:durability]
+      }
+    end
+
+    def clean
+      system("killall mongod")
+      system("killall mongos")
+      FileUtils.rm_rf(config_path)
+      system("rm -rf #{File.join(Dir.pwd, "*.data")}")
+      system("rm -rf #{File.join(Dir.pwd, "*.log")}")
+    end
+
+    def write_config(name=nil)
+      if VALID_CONFIGS.include?(name)
+        config_source = File.join(TEMPLATE_BASE, name + ".yml")
+        FileUtils.cp(config_source, config_path)
+STDOUT << <<END_OF_NEXT_STEPS
+
+You've just created a mink config file at #{config_path}. Feel free to edit it.
+When you're ready to start the MongoDB cluster, enter
+
+  mink init
+
+END_OF_NEXT_STEPS
+      else
+        usage
+      end
+    end
+
+    def usage
+STDERR << <<END_OF_USAGE
+usage:  mink COMMAND
+
+Mink sets up MongoDB clusters on localhost. Good for testing and experimenting,
+but definitely NOT FOR PRODUCTION USE.
+
+  make        Creates a default config file for the specified cluster type. You have two choices:
+
+                replicas       Default config for a replica set with replica sets as shards
+                shards         Default config for a stand-alone replica set
+
+  init        Starts the MongoDB cluster whose configuration is specified in
+              the mink.yml config file from the current directory.
+
+  clean       Kill every running mongod and mongos. Delete mink.yml, all config files, and all data files.
+              Note: use this with caution! You may want to do this manually.
+
+example:
+
+  mink make replicas
+  mink init
+
+END_OF_USAGE
+    end
+
+    def load_config
+      config_filename = File.join(Dir.pwd, CONFIG_NAME)
+      if File.exists?(config_filename)
+        @config = YAML.load(File.open(config_filename, "r").read)
+      else
+        STDERR << "\nERROR: Can't find mink.yml in current folder!\nYou may need to run mink make\n\n"
+        usage
+        exit
+      end
+    end
+
+    def check_mongod
+      mongod_path = @config.fetch(:mongod_path, "")
+      if mongod_path.strip.length == 0 || !system(mongod_path + " --version")
+        raise ArgumentError, "mongod not found! Please check your mongod path in #{CONFIG_NAME}"
+      end
+    end
+
+    def config_path
+      File.join(Dir.pwd, CONFIG_NAME)
+    end
+
+  end
+end
+
+if ARGV.empty? || ARGV[0] == "-h"
+    Mink::Bin.usage
+    exit
+else
+    case ARGV[0]
+      when "make" then
+        Mink::Bin.write_config(ARGV[1])
+      when "init" then
+        Mink::Bin.init
+      when "clean" then
+        Mink::Bin.clean
+      else
+        Mink::Bin.usage
+        exit
+      end
+end

data/lib/mink.rb

@@ -0,0 +1,15 @@
+STDOUT.sync = true
+
+$:.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+
+require 'mongo'
+require 'thread'
+
+require 'mink/helpers/manager_helper'
+require 'mink/managers/repl_set_manager'
+require 'mink/managers/auth_repl_set_manager'
+require 'mink/managers/sharding_manager'
+
+module Mink
+  VERSION = "0.1"
+end

data/lib/mink/helpers/manager_helper.rb

@@ -0,0 +1,46 @@
+module Mink
+  module ManagerHelper
+
+    def get_path(name)
+      File.join(@working_dir, name)
+    end
+
+    def attempt
+      raise "No block given!" unless block_given?
+      count = 0
+      begin
+        return yield
+        rescue Mongo::OperationFailure, Mongo::ConnectionFailure => ex
+          sleep(1)
+          count += 1
+        retry if count < 60
+      end
+
+      raise ex
+    end
+
+    def kill_existing_mongods
+      if File.exists?(@pidlistfile)
+        pids = YAML.load(File.open(@pidlistfile, "r").read)
+        kill_pidlist(pids)
+      else
+        system("killall mongod")
+      end
+    end
+
+    def kill_existing_mongos
+      if File.exists?(@pidlistfile)
+        pids = YAML.load(File.open(@pidlistfile, "r").read)
+        kill_pidlist(pids)
+      else
+        system("killall mongos")
+      end
+    end
+
+    def kill_pidlist(pids)
+      pids.each do |pid|
+        system("kill -9 #{pid}")
+      end
+    end
+  end
+end

data/lib/mink/managers/auth_repl_set_manager.rb

@@ -0,0 +1,16 @@
+require File.join((File.expand_path(File.dirname(__FILE__))), 'repl_set_manager')
+
+module Mink
+  class AuthReplSetManager < ReplSetManager
+    def initialize(opts={})
+      super(opts)
+
+      @key_path = opts[:key_path] || File.join(File.expand_path(File.dirname(__FILE__)), "keyfile.txt")
+      system("chmod 600 #{@key_path}")
+    end
+
+    def start_cmd(n)
+      super + " --keyFile #{@key_path}"
+    end
+  end
+end

data/lib/mink/managers/repl_set_manager.rb

@@ -0,0 +1,266 @@
+module Mink
+  class ReplSetManager
+    include ManagerHelper
+
+    attr_accessor :host, :start_port, :ports, :name, :mongods, :pids
+
+    def initialize(opts={})
+      @durable     = opts.fetch(:durable, false)
+      @start_port  = opts.fetch(:start_port, 30000)
+      @name        = opts.fetch(:name, 'replica-set-foo')
+      @host        = opts.fetch(:host, 'localhost')
+      @working_dir = opts.fetch(:working_dir, nil)
+      @mongod_path = opts.fetch(:mongod_path, "mongod")
+      @write_conf  = opts.fetch(:write_conf, false)
+      @write_pids  = opts.fetch(:write_pids, false)
+      @replica_count   = opts[:replica_count] || 2
+      @arbiter_count   = opts[:arbiter_count] || 2
+      @passive_count   = opts[:passive_count] || 1
+      check_member_count
+
+      if !@working_dir
+        raise ArgumentError, "A working directory must be specified"
+      end
+
+      @data_path    = opts.fetch(:path, File.join(@working_dir, "data"))
+      @pidlistfile  = File.join(@working_dir, "mink.pidlist")
+
+      @ports      = []
+      @mongods    = []
+      @pids       = []
+      @config     = {"_id" => @name, "members" => []}
+    end
+
+    def start_set
+      puts "** Starting a replica set with #{@count} nodes"
+      kill_existing_mongods
+
+      n = 0
+      @replica_count.times do |n|
+        configure_node(n)
+        n += 1
+      end
+
+      @passive_count.times do
+        configure_node(n) do |attrs|
+          attrs['priority'] = 0
+        end
+        n += 1
+      end
+
+      @arbiter_count.times do
+        configure_node(n) do |attrs|
+          attrs['arbiterOnly'] = true
+        end
+        n += 1
+      end
+
+      write_conf if @write_conf
+      startup_mongods
+      initiate_repl_set
+      ensure_up
+    end
+
+    def cleanup_set
+      system("killall mongod")
+      @mongods.each do |mongod|
+        system("rm -rf #{mongod['db_path']}")
+      end
+    end
+
+    def configure_node(n)
+      @mongods[n] ||= {}
+      port = @start_port + n
+      @ports << port
+      @mongods[n]['port'] = port
+      @mongods[n]['db_path'] = get_path("#{port}.data")
+      @mongods[n]['log_path'] = get_path("#{port}.log")
+
+      @mongods[n]['start'] = start_cmd(n)
+
+      member = {'_id' => n, 'host' => "#{@host}:#{@mongods[n]['port']}"}
+
+      if block_given?
+        custom_attrs = {}
+        yield custom_attrs
+        member.merge!(custom_attrs)
+        @mongods[n].merge!(custom_attrs)
+      end
+
+      @config['members'] << member
+    end
+
+    def start_cmd(n)
+      @mongods[n]['start'] = "#{@mongod_path} --replSet #{@name} --logpath '#{@mongods[n]['log_path']}' " +
+       " --dbpath #{@mongods[n]['db_path']} --port #{@mongods[n]['port']} --fork"
+      @mongods[n]['start'] += " --dur" if @durable
+      @mongods[n]['start']
+    end
+
+    def kill(node, signal=2)
+      pid = @mongods[node]['pid']
+      puts "** Killing node with pid #{pid} at port #{@mongods[node]['port']}"
+      system("kill -#{signal} #{@mongods[node]['pid']}")
+      @mongods[node]['up'] = false
+      sleep(1)
+    end
+
+    def kill_primary(signal=2)
+      node = get_node_with_state(1)
+      kill(node, signal)
+      return node
+    end
+
+    def step_down_primary
+      primary = get_node_with_state(1)
+      con = get_connection(primary)
+      begin
+        con['admin'].command({'replSetStepDown' => 90})
+      rescue Mongo::ConnectionFailure
+      end
+    end
+
+    def kill_secondary
+      node = get_node_with_state(2)
+      kill(node)
+      return node
+    end
+
+    def restart_killed_nodes
+      nodes = @mongods.select do |mongods|
+        @mongods['up'] == false
+      end
+
+      nodes.each do |node|
+        start(node)
+      end
+
+      ensure_up
+    end
+
+    def get_node_from_port(port)
+      @mongods.detect { |mongod| mongod['port'] == port }
+    end
+
+    def start(node)
+      system(@mongods[node]['start'])
+      @mongods[node]['up'] = true
+      sleep(0.5)
+      @mongods[node]['pid'] = File.open(File.join(@mongods[node]['db_path'], 'mongod.lock')).read.strip
+    end
+    alias :restart :start
+
+    def ensure_up
+      print "[RS #{@name}] Ensuring members are up...\n"
+
+      attempt do
+        con = get_connection
+        status = con['admin'].command({'replSetGetStatus' => 1})
+        print "."
+        if status['members'].all? { |m| m['health'] == 1 && [1, 2, 7].include?(m['state']) } &&
+           status['members'].any? { |m| m['state'] == 1 }
+          print "all members up!\n\n"
+          return status
+        else
+          raise Mongo::OperationFailure
+        end
+      end
+    end
+
+    def primary
+      nodes = get_all_host_pairs_with_state(1)
+      nodes.empty? ? nil : nodes[0]
+    end
+
+    def secondaries
+      get_all_host_pairs_with_state(2)
+    end
+
+    def arbiters
+      get_all_host_pairs_with_state(7)
+    end
+
+    # String used for adding a shard via mongos
+    # using the addshard command.
+    def shard_string
+      str = "#{@name}/"
+      str << @mongods.select do |mongod|
+        !mongod['arbiterOnly'] && mongod['priority'] != 0
+      end.map do |mongod|
+        "#{@host}:#{mongod['port']}"
+      end.join(',')
+      str
+    end
+
+    def get_manual_conf
+    end
+
+    def write_conf(filename=nil)
+    end
+
+    private
+
+    def startup_mongods
+      @mongods.each do |mongod|
+        system("rm -rf #{mongod['db_path']}")
+        system("mkdir -p #{mongod['db_path']}")
+        system(mongod['start'])
+        mongod['up'] = true
+        sleep(0.5)
+        pid = File.open(File.join(mongod['db_path'], 'mongod.lock'), "r").read.strip
+        mongod['pid'] = pid
+        @pids << pid
+      end
+    end
+
+    def initiate_repl_set
+      con = get_connection
+
+      attempt do
+        con['admin'].command({'replSetInitiate' => @config})
+      end
+    end
+
+    def get_node_with_state(state)
+      status = ensure_up
+      node = status['members'].detect {|m| m['state'] == state}
+      if node
+        host_port = node['name'].split(':')
+        port = host_port[1] ? host_port[1].to_i : 27017
+        key = @mongods.keys.detect {|key| @mongods[key]['port'] == port}
+        return key
+      else
+        return false
+      end
+    end
+
+    def get_all_host_pairs_with_state(state)
+      status = ensure_up
+      nodes = status['members'].select {|m| m['state'] == state}
+      nodes.map do |node|
+        host_port = node['name'].split(':')
+        port = host_port[1] ? host_port[1].to_i : 27017
+        [host, port]
+      end
+    end
+
+    def get_connection(node=nil)
+      con = attempt do
+        if !node
+          node = @mongods.detect {|mongod| !mongod['arbiterOnly'] && mongod['up'] }
+        end
+        con = Mongo::Connection.new(@host, node['port'], :slave_ok => true)
+      end
+
+      return con
+    end
+
+    def check_member_count
+      @count = @replica_count + @arbiter_count + @passive_count
+
+      if @count > 7
+        raise StandardError, "Cannot create a replica set with #{node_count} nodes. 7 is the max."
+      end
+    end
+  end
+end

data/lib/mink/managers/sharding_manager.rb

@@ -0,0 +1,198 @@
+module Mink
+  class ShardingManager
+    include ManagerHelper
+
+    attr_accessor :shards
+
+    def initialize(opts={})
+      @durable = opts.fetch(:durable, true)
+
+      @mongos_port  = opts.fetch(:mongos_start_port, 50000)
+      @config_port  = opts.fetch(:config_server_start_port, 40000)
+      @working_dir  = opts.fetch(:working_dir, nil)
+      @mongod_path  = opts.fetch(:mongod_path, "mongod")
+      @mongos_path  = opts.fetch(:mongos_path, "mongos")
+      @write_conf   = opts.fetch(:write_conf, false)
+      @host         = opts.fetch(:host, "localhost")
+
+      @shard_count  = opts.fetch(:shard_count, 2)
+      @mongos_count = opts.fetch(:mongos_count, 1)
+      @config_server_count = opts.fetch(:config_server_count, 1)
+      @replica_set_config  = opts.fetch(:replica_set_config, {})
+
+      @shard_db     = opts.fetch(:shard_database, "app")
+      @shard_coll   = opts.fetch(:shard_collection, "images")
+      @shard_key    = opts.fetch(:shard_key, {:tid => 1})
+
+      if ![1, 3].include?(@config_server_count)
+        raise ArgumentError, "Must specify 1 or 3 config servers."
+      end
+
+      @pidlistfile  = File.join(@working_dir, "mink.pidlist")
+      @data_path    = opts.fetch(:path, File.join(@working_dir, "data"))
+
+      @config_servers = {}
+      @mongos_servers = {}
+      @shards = []
+      @ports  = []
+      @pids   = []
+    end
+
+    def start_cluster
+      kill_existing_mongods
+      kill_existing_mongos
+      start_sharding_components
+      start_mongos_servers
+      configure_cluster
+    end
+
+    def configure_cluster
+      add_shards
+      enable_sharding
+      if shard_collection
+        STDOUT << "Shard cluster initiated!\nEnter the following to connect:\n  mongo localhost:#{@mongos_port}"
+      end
+    end
+
+    def enable_sharding
+      mongos['admin'].command({:enablesharding => @shard_db})
+    end
+
+    def shard_collection
+      cmd = BSON::OrderedHash.new
+      cmd[:shardcollection] = "#{@shard_db}.#{@shard_coll}"
+      cmd[:key] = {:tid => 1}
+      mongos['admin'].command(cmd)
+    end
+
+    def add_shards
+      @shards.each do |shard|
+        cmd = {:addshard => shard.shard_string}
+        cmd
+        p mongos['admin'].command(cmd)
+      end
+      p mongos['admin'].command({:listshards => 1})
+    end
+
+    def mongos
+      attempt do
+        @mongos ||= Mongo::Connection.new(@host, @mongos_servers[0]['port'])
+      end
+    end
+
+    def kill_random
+      shard_to_kill = rand(@shard_count)
+      @shards[shard_to_kill].kill_primary
+    end
+
+    def restart_killed
+      threads = []
+      @shards.each do |k, shard|
+        threads << Thread.new do
+          shard.restart_killed_nodes
+        end
+      end
+    end
+
+    private
+
+    def start_sharding_components
+      system("killall mongos")
+
+      threads = []
+      threads << Thread.new do
+        start_shards
+      end
+
+      threads << Thread.new do
+        start_config_servers
+      end
+
+      threads.each {|t| t.join}
+
+      puts "\nShards and config servers up!"
+    end
+
+    def start_shards
+      threads = []
+
+      @shard_count.times do |n|
+          threads << Thread.new do
+          port = @replica_set_config[:start_port] + n * 100
+          name = "shard-#{n}-#{@replica_set_config[:name]}"
+          shard = ReplSetManager.new(@replica_set_config.merge(:start_port => port, :name => name))
+          shard.start_set
+          @shards << shard
+        end
+      end
+
+      threads.each {|t| t.join}
+
+      @shards.each do |shard|
+        @pids << shard.pids
+      end
+    end
+
+    def start_config_servers
+      @config_server_count.times do |n|
+        @config_servers[n] ||= {}
+        port = @config_port + n
+        @ports << port
+        @config_servers[n]['port'] = port
+        @config_servers[n]['db_path'] = get_path("config-#{port}.data")
+        @config_servers[n]['log_path'] = get_path("config-#{port}.log")
+        system("rm -rf #{@config_servers[n]['db_path']}")
+        system("mkdir -p #{@config_servers[n]['db_path']}")
+
+        @config_servers[n]['start'] = start_config_cmd(n)
+
+        start(@config_servers, n)
+      end
+    end
+
+    def start_mongos_servers
+      @mongos_count.times do |n|
+        @mongos_servers[n] ||= {}
+        port = @mongos_port + n
+        @ports << port
+        @mongos_servers[n]['port'] = port
+        @mongos_servers[n]['db_path'] = get_path("mongos-#{port}.data")
+        @mongos_servers[n]['pidfile_path'] = File.join(@mongos_servers[n]['db_path'], "mongod.lock")
+        @mongos_servers[n]['log_path'] = get_path("mongos-#{port}.log")
+        system("rm -rf #{@mongos_servers[n]['db_path']}")
+        system("mkdir -p #{@mongos_servers[n]['db_path']}")
+
+        @mongos_servers[n]['start'] = start_mongos_cmd(n)
+
+        start(@mongos_servers, n)
+      end
+    end
+
+    def start_config_cmd(n)
+      cmd = "mongod --configsvr --logpath '#{@config_servers[n]['log_path']}' " +
+       " --dbpath #{@config_servers[n]['db_path']} --port #{@config_servers[n]['port']} --fork"
+      cmd += " --dur" if @durable
+      cmd
+    end
+
+    def start_mongos_cmd(n)
+      "mongos --configdb #{config_db_string} --logpath '#{@mongos_servers[n]['log_path']}' " +
+        "--pidfilepath #{@mongos_servers[n]['pidfile_path']} --port #{@mongos_servers[n]['port']} --fork"
+    end
+
+    def config_db_string
+      @config_servers.map do |k, v|
+        "#{@host}:#{v['port']}"
+      end.join(',')
+    end
+
+    def start(set, node)
+      system(set[node]['start'])
+      set[node]['up'] = true
+      sleep(0.5)
+      set[node]['pid'] = File.open(File.join(set[node]['db_path'], 'mongod.lock')).read.strip
+    end
+    alias :restart :start
+
+  end
+end

data/mink.gemspec

@@ -0,0 +1,27 @@
+require "./lib/mink"
+
+Gem::Specification.new do |s|
+  s.name = 'mink'
+
+  s.version = Mink::VERSION
+
+  s.platform = Gem::Platform::RUBY
+  s.summary = 'MongoDB configuations on localhost made easy.'
+  s.description = 'Set up MongoDB shard clusters and replica sets on localhost with ease.'
+
+  s.require_paths = ['lib']
+
+  s.files  = ['README.md', 'mink.gemspec', 'LICENSE.md', 'lib/mink.rb']
+  s.files += Dir['lib/mink/**/*.rb']
+  s.files += Dir['templates/**/*.yml']
+  s.files += ['bin/mink']
+
+  s.executables = ['mink']
+
+  s.has_rdoc = false
+
+  s.authors = ['Kyle Banker']
+  s.email = 'kyle@10gen.com'
+
+  s.add_dependency('mongo', ['>= 1.2.0'])
+end

data/templates/replicas.yml

@@ -0,0 +1,14 @@
+--- 
+# Note: this assumes that mongod is in your path by default
+:mongod_path: mongod
+
+# Whether to enable single-server durability (1.7.5+)
+:durability: false
+
+# Each shard will consist of one replica set.
+:replica_set_config:
+  :replica_count: 2
+  :arbiter_count: 1
+  :passive_count: 0
+  :name: "test-rs"
+  :start_port: 30000

data/templates/shards.yml

@@ -0,0 +1,32 @@
+--- 
+# Note: this assumes that mongod and mongos are in your defaul path
+:mongod_path: mongod
+:mongos_path: mongos
+
+# Whether to enable single-server durability (1.7.5+)
+:durability: false
+
+# Shard configuration
+:shards:
+  :shard_count: 2
+
+  # Mongos servers
+  :mongos_start_port: 50000
+  :mongos_count: 1
+
+  # Config servers
+  :config_server_start_port: 40000
+  :config_server_count: 1
+
+  # Pick the collection to shard, along with the shard key
+  :shard_database: "app"
+  :shard_collection: "photos"
+  :shard_key: { photo_ts_id: 1 }
+
+# Each shard will consist of one replica set.
+:replica_set_config:
+  :replica_count: 2
+  :arbiter_count: 1
+  :passive_count: 0
+  :name: "test-rs"
+  :start_port: 30000

metadata

@@ -0,0 +1,91 @@
+--- !ruby/object:Gem::Specification 
+name: mink
+version: !ruby/object:Gem::Version 
+  hash: 9
+  prerelease: 
+  segments: 
+  - 0
+  - 1
+  version: "0.1"
+platform: ruby
+authors: 
+- Kyle Banker
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-02-07 00:00:00 -05:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: mongo
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 31
+        segments: 
+        - 1
+        - 2
+        - 0
+        version: 1.2.0
+  type: :runtime
+  version_requirements: *id001
+description: Set up MongoDB shard clusters and replica sets on localhost with ease.
+email: kyle@10gen.com
+executables: 
+- mink
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- README.md
+- mink.gemspec
+- LICENSE.md
+- lib/mink.rb
+- lib/mink/helpers/manager_helper.rb
+- lib/mink/managers/repl_set_manager.rb
+- lib/mink/managers/auth_repl_set_manager.rb
+- lib/mink/managers/sharding_manager.rb
+- templates/shards.yml
+- templates/replicas.yml
+- bin/mink
+has_rdoc: false
+homepage: 
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.4.1
+signing_key: 
+specification_version: 3
+summary: MongoDB configuations on localhost made easy.
+test_files: []
+