mongo 1.3.0 → 1.12.5

data/test/tools/repl_set_manager.rb

@@ -1,266 +0,0 @@
-#!/usr/bin/ruby
-
-require 'thread'
-
-STDOUT.sync = true
-
-unless defined? Mongo
-  require File.join(File.dirname(__FILE__), '..', '..', 'lib', 'mongo')
-end
-
-class ReplSetManager
-
-  attr_accessor :host, :start_port, :ports, :name, :mongods
-
-  def initialize(opts={})
-    @start_port = opts[:start_port] || 30000
-    @ports      = []
-    @name       = opts[:name] || 'replica-set-foo'
-    @host       = opts[:host]  || 'localhost'
-    @retries    = opts[:retries] || 60
-    @config     = {"_id" => @name, "members" => []}
-    @durable    = opts.fetch(:durable, false)
-    @path       = File.join(File.expand_path(File.dirname(__FILE__)), "data")
-
-    @arbiter_count   = opts[:arbiter_count]   || 2
-    @secondary_count = opts[:secondary_count] || 1
-    @passive_count   = opts[:passive_count] || 1
-    @primary_count   = 1
-
-    @count = @primary_count + @passive_count + @arbiter_count + @secondary_count
-    if @count > 7
-      raise StandardError, "Cannot create a replica set with #{node_count} nodes. 7 is the max."
-    end
-
-    @mongods   = {}
-  end
-
-  def start_set
-    puts "** Starting a replica set with #{@count} nodes"
-
-    system("killall mongod")
-
-    n = 0
-    (@primary_count + @secondary_count).times do |n|
-      init_node(n)
-      n += 1
-    end
-
-    @passive_count.times do
-      init_node(n) do |attrs|
-        attrs['priority'] = 0
-      end
-      n += 1
-    end
-
-    @arbiter_count.times do
-      init_node(n) do |attrs|
-        attrs['arbiterOnly'] = true
-      end
-      n += 1
-    end
-
-    initiate
-    ensure_up
-  end
-
-  def cleanup_set
-    system("killall mongod")
-    @count.times do |n|
-      system("rm -rf #{@mongods[n]['db_path']}")
-    end
-  end
-
-  def init_node(n)
-    @mongods[n] ||= {}
-    port = @start_port + n
-    @ports << port
-    @mongods[n]['port'] = port
-    @mongods[n]['db_path'] = get_path("rs-#{port}")
-    @mongods[n]['log_path'] = get_path("log-#{port}")
-    system("rm -rf #{@mongods[n]['db_path']}")
-    system("mkdir -p #{@mongods[n]['db_path']}")
-
-    @mongods[n]['start'] = start_cmd(n)
-    start(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 --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
-
-  # Note that we have to rescue a connection failure
-  # when we run the StepDown command because that
-  # command will close the connection.
-  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.keys.select do |key|
-      @mongods[key]['up'] == false
-    end
-
-    nodes.each do |node|
-      start(node)
-    end
-
-    ensure_up
-  end
-
-  def get_node_from_port(port)
-    @mongods.keys.detect { |key| @mongods[key]['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 "** Ensuring members are up..."
-
-    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.map do |k, mongod|
-      "#{@host}:#{mongod['port']}"
-    end.join(',')
-    str
-  end
-
-  private
-
-  def initiate
-    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.keys.detect {|key| !@mongods[key]['arbiterOnly'] && @mongods[key]['up'] }
-      end
-      con = Mongo::Connection.new(@host, @mongods[node]['port'], :slave_ok => true)
-    end
-
-    return con
-  end
-
-  def get_path(name)
-    File.join(@path, name)
-  end
-
-  def attempt
-    raise "No block given!" unless block_given?
-    count = 0
-
-    while count < @retries do
-      begin
-        return yield
-        rescue Mongo::OperationFailure, Mongo::ConnectionFailure => ex
-          sleep(1)
-          count += 1
-      end
-    end
-
-    raise ex
-  end
-
-end

data/test/tools/sharding_manager.rb

@@ -1,202 +0,0 @@
-require 'repl_set_manager'
-require 'thread'
-
-class ShardingManager
-
-  attr_accessor :shards
-
-  def initialize(opts={})
-    @durable = opts.fetch(:durable, true)
-    @host    = "localhost"
-
-    @mongos_port = opts[:mongos_port] || 50000
-    @config_port = opts[:config_port] || 40000
-    @shard_start_port = opts[:start_shard_port] || 30000
-    @path       = File.join(File.expand_path(File.dirname(__FILE__)), "data")
-    system("rm -rf #{@path}")
-
-    @shard_count  = 2
-    @mongos_count = 1
-    @config_count = opts.fetch(:config_count, 1)
-    if ![1, 3].include?(@config_count)
-      raise ArgumentError, "Must specify 1 or 3 config servers."
-    end
-
-    @config_servers = {}
-    @mongos_servers = {}
-    @shards = []
-    @ports  = []
-  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
-
-  def start_cluster
-    start_sharding_components
-    start_mongos_servers
-    configure_cluster
-  end
-
-  def configure_cluster
-    add_shards
-    enable_sharding
-    shard_collection
-  end
-
-  def enable_sharding
-    mongos['admin'].command({:enablesharding => "app"})
-  end
-
-  def shard_collection
-    cmd = BSON::OrderedHash.new
-    cmd[:shardcollection] = "app.photos"
-    cmd[:key] = {:tid => 1}
-    p mongos['admin'].command(cmd)
-  end
-
-  def add_shards
-    @shards.each do |shard|
-      cmd = {:addshard => shard.shard_string}
-      p 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
-
-  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 = @shard_start_port + n * 100
-        shard = ReplSetManager.new(:arbiter_count => 0, :secondary_count => 2,
-                       :passive_count => 0, :start_port => port, :durable => @durable,
-                       :name => "shard-#{n}")
-        shard.start_set
-        shard.ensure_up
-        @shards << shard
-      end
-    end
-    threads.each {|t| t.join}
-  end
-
-  def start_config_servers
-    @config_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}")
-      @config_servers[n]['log_path'] = get_path("log-config-#{port}")
-      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}")
-      @mongos_servers[n]['pidfile_path'] = File.join(@mongos_servers[n]['db_path'], "mongod.lock")
-      @mongos_servers[n]['log_path'] = get_path("log-mongos-#{port}")
-      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
-
-  private
-
-  def cleanup_config
-  end
-
-  def get_path(name)
-    File.join(@path, name)
-  end
-
-  # TODO: put this into a shared module
-  def attempt
-    raise "No block given!" unless block_given?
-    count = 0
-
-    while count < 50 do
-      begin
-        return yield
-        rescue Mongo::OperationFailure, Mongo::ConnectionFailure
-          sleep(1)
-          count += 1
-      end
-    end
-
-    raise exception
-  end
-end

data/test/tools/test.rb

@@ -1,4 +0,0 @@
-require 'sharding_manager'
-
-m = ShardingManager.new(:config_count => 3)
-m.start_cluster

data/test/unit/pool_test.rb

@@ -1,9 +0,0 @@
-require './test/test_helper'
-include Mongo
-
-class PoolTest < Test::Unit::TestCase
-  context "Initialization: " do
-    should "do" do
-    end
-  end
-end

data/test/unit/repl_set_connection_test.rb

@@ -1,59 +0,0 @@
-require './test/test_helper'
-include Mongo
-
-class ReplSetConnectionTest < Test::Unit::TestCase
-  context "Initialization: " do
-    context "connecting to a replica set" do
-      setup do
-        TCPSocket.stubs(:new).returns(new_mock_socket('localhost', 27017))
-        @conn = ReplSetConnection.new(['localhost', 27017], :connect => false, :read_secondary => true)
-
-        admin_db = new_mock_db
-        @hosts = ['localhost:27018', 'localhost:27019', 'localhost:27020']
-
-        admin_db.stubs(:command).returns({'ok' => 1, 'ismaster' => 1, 'hosts' => @hosts}).
-          then.returns({'ok' => 1, 'ismaster' => 0, 'hosts' => @hosts, 'secondary' => 1}).
-          then.returns({'ok' => 1, 'ismaster' => 0, 'hosts' => @hosts, 'secondary' => 1}).
-          then.returns({'ok' => 1, 'ismaster' => 0, 'arbiterOnly' => 1})
-
-        @conn.stubs(:[]).with('admin').returns(admin_db)
-        @conn.connect
-      end
-
-      should "store the hosts returned from the ismaster command" do
-        assert_equal 'localhost', @conn.primary_pool.host
-        assert_equal 27017, @conn.primary_pool.port
-
-        assert_equal 'localhost', @conn.secondary_pools[0].host
-        assert_equal 27018, @conn.secondary_pools[0].port
-
-        assert_equal 'localhost', @conn.secondary_pools[1].host
-        assert_equal 27019, @conn.secondary_pools[1].port
-
-        assert_equal 2, @conn.secondary_pools.length
-      end
-    end
-
-    context "connecting to a replica set and providing seed nodes" do
-      setup do
-        TCPSocket.stubs(:new).returns(new_mock_socket)
-        @conn = ReplSetConnection.new(['localhost', 27017], ['localhost', 27019], :connect => false)
-
-        admin_db = new_mock_db
-        @hosts = ['localhost:27017', 'localhost:27018', 'localhost:27019']
-        admin_db.stubs(:command).returns({'ok' => 1, 'ismaster' => 1, 'hosts' => @hosts})
-        @conn.stubs(:[]).with('admin').returns(admin_db)
-        @conn.connect
-      end
-    end
-
-    context "initializing with a mongodb uri" do
-
-      should "parse a uri specifying multiple nodes" do
-        @conn = Connection.from_uri("mongodb://localhost:27017,mydb.com:27018", :connect => false)
-        assert_equal ['localhost', 27017], @conn.nodes[0]
-        assert_equal ['mydb.com', 27018], @conn.nodes[1]
-      end
-    end
-  end
-end

data/test/uri_test.rb

@@ -1,91 +0,0 @@
-require './test/test_helper'
-
-class TestThreading < Test::Unit::TestCase
-  include Mongo
-
-  def test_uri_without_port
-    parser = Mongo::URIParser.new('mongodb://localhost')
-    assert_equal 1, parser.nodes.length
-    assert_equal 'localhost', parser.nodes[0][0]
-    assert_equal 27017, parser.nodes[0][1]
-  end
-
-  def test_basic_uri
-    parser = Mongo::URIParser.new('mongodb://localhost:27018')
-    assert_equal 1, parser.nodes.length
-    assert_equal 'localhost', parser.nodes[0][0]
-    assert_equal 27018, parser.nodes[0][1]
-  end
-
-  def test_multiple_uris
-    parser = Mongo::URIParser.new('mongodb://a.example.com:27018,b.example.com')
-    assert_equal 2, parser.nodes.length
-    assert_equal 'a.example.com', parser.nodes[0][0]
-    assert_equal 27018, parser.nodes[0][1]
-    assert_equal 'b.example.com', parser.nodes[1][0]
-    assert_equal 27017, parser.nodes[1][1]
-  end
-
-  def test_complex_passwords
-    parser = Mongo::URIParser.new('mongodb://bob:secret.word@a.example.com:27018/test')
-    assert_equal "bob", parser.auths[0]["username"]
-    assert_equal "secret.word", parser.auths[0]["password"]
-
-    parser = Mongo::URIParser.new('mongodb://bob:s-_3#%R.t@a.example.com:27018/test')
-    assert_equal "bob", parser.auths[0]["username"]
-    assert_equal "s-_3#%R.t", parser.auths[0]["password"]
-  end
-
-  def test_passwords_contain_no_commas
-    assert_raise MongoArgumentError do
-      Mongo::URIParser.new('mongodb://bob:a,b@a.example.com:27018/test')
-    end
-  end
-
-  def test_multiple_uris_with_auths
-    parser = Mongo::URIParser.new('mongodb://bob:secret@a.example.com:27018/test,joe:secret2@b.example.com/test2')
-    assert_equal 2, parser.nodes.length
-    assert_equal 'a.example.com', parser.nodes[0][0]
-    assert_equal 27018, parser.nodes[0][1]
-    assert_equal 'b.example.com', parser.nodes[1][0]
-    assert_equal 27017, parser.nodes[1][1]
-    assert_equal 2, parser.auths.length
-    assert_equal "bob", parser.auths[0]["username"]
-    assert_equal "secret", parser.auths[0]["password"]
-    assert_equal "test", parser.auths[0]["db_name"]
-    assert_equal "joe", parser.auths[1]["username"]
-    assert_equal "secret2", parser.auths[1]["password"]
-    assert_equal "test2", parser.auths[1]["db_name"]
-  end
-
-  def test_opts_basic
-    parser = Mongo::URIParser.new('mongodb://localhost:27018?connect=direct;slaveok=true;safe=true')
-    assert_equal 'direct', parser.connect
-    assert parser.slaveok
-    assert parser.safe
-  end
-
-  def test_opts_with_amp_separator
-    parser = Mongo::URIParser.new('mongodb://localhost:27018?connect=direct&slaveok=true&safe=true')
-    assert_equal 'direct', parser.connect
-    assert parser.slaveok
-    assert parser.safe
-  end
-
-  def test_opts_safe
-    parser = Mongo::URIParser.new('mongodb://localhost:27018?safe=true;w=2;wtimeout=200;fsync=true')
-    assert parser.safe
-    assert_equal 2, parser.w
-    assert_equal 200, parser.wtimeout
-    assert parser.fsync
-  end
-
-  def test_opts_replica_set
-    assert_raise_error MongoArgumentError, "specify that connect=replicaset" do
-      Mongo::URIParser.new('mongodb://localhost:27018?replicaset=foo')
-    end
-    parser = Mongo::URIParser.new('mongodb://localhost:27018?connect=replicaset;replicaset=foo')
-    assert_equal 'foo', parser.replicaset
-    assert_equal 'replicaset', parser.connect
-  end
-end