mongo 1.3.0 → 1.12.5

data/lib/mongo/util/uri_parser.rb

@@ -1,185 +0,0 @@
-# encoding: UTF-8
-
-# --
-# Copyright (C) 2008-2011 10gen Inc.
-#
-# 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.
-# ++
-
-module Mongo
-  class URIParser
-
-    DEFAULT_PORT = 27017
-    MONGODB_URI_MATCHER = /(([-.\w]+):([^@]+)@)?([-.\w]+)(:([\w]+))?(\/([-\w]+))?/
-    MONGODB_URI_SPEC = "mongodb://[username:password@]host1[:port1][,host2[:port2],...[,hostN[:portN]]][/database]"
-    SPEC_ATTRS = [:nodes, :auths]
-    OPT_ATTRS  = [:connect, :replicaset, :slaveok, :safe, :w, :wtimeout, :fsync]
-
-    OPT_VALID  = {:connect    => lambda {|arg| ['direct', 'replicaset'].include?(arg)},
-                  :replicaset => lambda {|arg| arg.length > 0},
-                  :slaveok    => lambda {|arg| ['true', 'false'].include?(arg)},
-                  :safe       => lambda {|arg| ['true', 'false'].include?(arg)},
-                  :w          => lambda {|arg| arg =~ /^\d+$/ },
-                  :wtimeout   => lambda {|arg| arg =~ /^\d+$/ },
-                  :fsync      => lambda {|arg| ['true', 'false'].include?(arg)}
-                 }
-
-    OPT_ERR    = {:connect    => "must be 'direct' or 'replicaset'",
-                  :replicaset => "must be a string containing the name of the replica set to connect to",
-                  :slaveok    => "must be 'true' or 'false'",
-                  :safe       => "must be 'true' or 'false'",
-                  :w          => "must be an integer specifying number of nodes to replica to",
-                  :wtimeout   => "must be an integer specifying milliseconds",
-                  :fsync      => "must be 'true' or 'false'"
-                 }
-
-    OPT_CONV   = {:connect    => lambda {|arg| arg},
-                  :replicaset => lambda {|arg| arg},
-                  :slaveok    => lambda {|arg| arg == 'true' ? true : false},
-                  :safe       => lambda {|arg| arg == 'true' ? true : false},
-                  :w          => lambda {|arg| arg.to_i},
-                  :wtimeout   => lambda {|arg| arg.to_i},
-                  :fsync      => lambda {|arg| arg == 'true' ? true : false}
-                 }
-
-    attr_reader :nodes, :auths, :connect, :replicaset, :slaveok, :safe, :w, :wtimeout, :fsync
-
-    # Parse a MongoDB URI. This method is used by Connection.from_uri.
-    # Returns an array of nodes and an array of db authorizations, if applicable.
-    #
-    # Note: passwords can contain any character except for a ','.
-    #
-    # @core connections
-    def initialize(string)
-      if string =~ /^mongodb:\/\//
-        string = string[10..-1]
-      else
-        raise MongoArgumentError, "MongoDB URI must match this spec: #{MONGODB_URI_SPEC}"
-      end
-
-      hosts, opts = string.split('?')
-      parse_hosts(hosts)
-      parse_options(opts)
-      configure_connect
-    end
-
-    def connection_options
-      opts = {}
-
-      if (@w || @wtimeout || @fsync) && !@safe
-        raise MongoArgumentError, "Safe must be true if w, wtimeout, or fsync is specified"
-      end
-
-      if @safe
-        if @w || @wtimeout || @fsync
-          safe_opts = {}
-          safe_opts[:w] = @w if @w
-          safe_opts[:wtimeout] = @wtimeout if @wtimeout
-          safe_opts[:fsync] = @fsync if @fsync
-        else
-          safe_opts = true
-        end
-
-        opts[:safe] = safe_opts
-      end
-
-      if @slaveok
-        if @connect == 'direct'
-          opts[:slave_ok] = true
-        else
-          opts[:read_secondary] = true
-        end
-      end
-
-      opts[:rs_name] = @replicaset if @replicaset
-
-      opts
-    end
-
-    private
-
-    def parse_hosts(hosts)
-      @nodes = []
-      @auths = []
-      specs = hosts.split(',')
-      specs.each do |spec|
-        matches  = MONGODB_URI_MATCHER.match(spec)
-        if !matches
-          raise MongoArgumentError, "MongoDB URI must match this spec: #{MONGODB_URI_SPEC}"
-        end
-
-        uname = matches[2]
-        pwd   = matches[3]
-        host  = matches[4]
-        port  = matches[6] || DEFAULT_PORT
-        if !(port.to_s =~ /^\d+$/)
-          raise MongoArgumentError, "Invalid port #{port}; port must be specified as digits."
-        end
-        port    = port.to_i
-        db      = matches[8]
-
-        if uname && pwd && db
-          auths << {'db_name' => db, 'username' => uname, 'password' => pwd}
-        elsif uname || pwd || db
-          raise MongoArgumentError, "MongoDB URI must include all three of username, password, " +
-            "and db if any one of these is specified."
-        end
-
-        @nodes << [host, port]
-      end
-    end
-
-    # This method uses the lambdas defined in OPT_VALID and OPT_CONV to validate
-    # and convert the given options.
-    def parse_options(opts)
-      # initialize instance variables for available options
-      OPT_VALID.keys.each { |k| instance_variable_set("@#{k}", nil) }
-
-      return unless opts
-
-      separator = opts.include?('&') ? '&' : ';'
-      opts.split(separator).each do |attr|
-        key, value = attr.split('=')
-        key   = key.to_sym
-        value = value.strip.downcase
-        if !OPT_ATTRS.include?(key)
-          raise MongoArgumentError, "Invalid Mongo URI option #{key}"
-        end
-
-        if OPT_VALID[key].call(value)
-          instance_variable_set("@#{key}", OPT_CONV[key].call(value))
-        else
-          raise MongoArgumentError, "Invalid value for #{key}: #{OPT_ERR[key]}"
-        end
-      end
-    end
-
-    def configure_connect
-      if @nodes.length > 1 && !@connect
-        @connect = 'replicaset'
-      end
-
-      if !@connect
-        if @nodes.length > 1
-          @connect = 'replicaset'
-        else
-          @connect = 'direct'
-        end
-      end
-
-      if @connect == 'direct' && @replicaset
-        raise MongoArgumentError, "If specifying a replica set name, please also specify that connect=replicaset"
-      end
-    end
-  end
-end

data/test/async/collection_test.rb

@@ -1,224 +0,0 @@
-require 'test/test_helper'
-
-class TestCollection < Test::Unit::TestCase
-  @@connection ||= Connection.new(ENV['MONGO_RUBY_DRIVER_HOST'] || 'localhost', ENV['MONGO_RUBY_DRIVER_PORT'] || Connection::DEFAULT_PORT)
-  @@db   = @@connection.db(MONGO_TEST_DB)
-  @@test = @@db.collection("test")
-  @@version = @@connection.server_version
-
-  def setup
-    @@test.remove
-  end
-
-  def wait_for_async
-    sleep 0.2
-  end
-
-  def test_async_update
-    id1 = @@test.save("x" => 5)
-    failsafe = mock('failsafe will get called in block', :call => true)
-
-    @@test.update({}, {"$inc" => {"x" => 1}}, :async => true) do |error, result|
-      assert_nil error
-      assert result
-      failsafe.call
-    end
-    wait_for_async
-
-    assert_equal 1, @@test.count()
-    assert_equal 6, @@test.find_one(:_id => id1)["x"]
-  end
-
-  if @@version >= "1.1.3"
-    def test_async_multi_update
-      failsafe = mock('failsafe will get called in block', :call => true)
-
-      @@test.save("num" => 10)
-      @@test.save("num" => 10)
-      @@test.save("num" => 10)
-      assert_equal 3, @@test.count
-
-      @@test.update({"num" => 10}, {"$set" => {"num" => 100}}, :multi => true, :async => true) do |error, result|
-        assert_nil error
-        assert result
-        failsafe.call
-      end
-      wait_for_async
-    end
-  end
-
-  def test_async_upsert
-    failsafe = mock('failsafe will get called in block')
-    failsafe.expects(:call).times(2)
-
-    @@test.update({"page" => "/"}, {"$inc" => {"count" => 1}}, :upsert => true, :async => true) do |error, result|
-      assert_nil error
-      assert result
-      failsafe.call
-    end
-
-    @@test.update({"page" => "/"}, {"$inc" => {"count" => 1}}, :upsert => true, :async => true) do |error, result|
-      assert_nil error
-      assert result
-      failsafe.call
-    end
-    wait_for_async
-
-    assert_equal 1, @@test.count()
-    assert_equal 2, @@test.find_one()["count"]
-  end
-
-  def test_async_save
-    failsafe = mock('failsafe will get called in block', :call => true)
-
-    # note that the first parameter has explicit curly brackets around
-    # the hash; without those brackets as a delimiter, the :async key is
-    # viewed as part of the required +document+ parameter
-    @@test.save({"hello" => "world"}, :async => true) do |error, result|
-      assert_nil error
-      assert result
-      failsafe.call
-    end
-    wait_for_async
-    
-    assert_equal "world", @@test.find_one()["hello"]
-  end
-
-  def test_async_save_with_exception
-    failsafe = mock('failsafe will get called in block', :call => true)
-
-    @@test.create_index("hello", :unique => true)
-    @@test.save("hello" => "world")
-    
-    # all async calls on collections occur in :safe mode
-    @@test.save({"hello" => "world"}, :async => true) do |error, result|
-      assert error
-      assert error.instance_of?(OperationFailure)
-      assert_nil result
-      failsafe.call
-    end
-    wait_for_async
-    
-    assert_equal 1, @@test.count()
-    @@test.drop
-  end
-
-  def test_async_remove
-    failsafe = mock('failsafe will get called in block', :call => true)
-
-    @conn = Connection.new
-    @db   = @conn[MONGO_TEST_DB]
-    @test = @db['test-async-remove']
-    @test.save({:a => 50})
-    @test.remove({}, :async => true) do |error, result|
-      assert_nil error
-      assert result
-      failsafe.call
-    end
-    wait_for_async
-    
-    @test.drop
-  end
-
-  def test_async_count
-    failsafe = mock('failsafe will get called in block', :call => true)
-
-    @@test.drop
-
-    @@test.save("x" => 1)
-    @@test.save("x" => 2)
-
-    @@test.count(:async => true) do |error, result|
-      assert_nil error
-      assert_equal 2, result
-      failsafe.call
-    end
-    wait_for_async
-  end
-
-  # Note: #size is just an alias for #count.
-  def test_async_size
-    failsafe = mock('failsafe will get called in block', :call => true)
-    
-    @@test.drop
-
-    @@test.save("x" => 1)
-    @@test.save("x" => 2)
-
-    @@test.size(:async => true) do |error, result|
-      assert_nil error
-      assert_equal 2, result
-      failsafe.call
-    end
-    wait_for_async
-  end
-
-  def test_async_find_one
-    failsafe = mock('failsafe will get called in block', :call => true)
-
-    id = @@test.save("hello" => "world", "foo" => "bar")
-
-    @@test.find_one({}, :async => true) do |error, result|
-      assert_nil error
-      assert_equal @@test.find_one(id), result
-      failsafe.call
-    end
-    wait_for_async
-  end
-
-  def test_async_insert
-    failsafe = mock('failsafe will get called in block', :call => true)
-
-    doc = {"hello" => "world"}
-    @@test.insert(doc, :async => true) do |error, result|
-      assert_nil error
-      assert result
-      failsafe.call
-    end
-    wait_for_async
-    
-    assert_equal 1, @@test.count
-  end
-
-  def test_async_find
-    assert_raise RuntimeError do
-      @@test.find({}, :async => true)
-    end
-  end
-
-  if @@version > "1.3.0"
-    def test_async_find_and_modify
-      failsafe = mock('failsafe will get called in block', :call => true)
-
-      @@test << { :a => 1, :processed => false }
-      @@test << { :a => 2, :processed => false }
-      @@test << { :a => 3, :processed => false }
-
-      @@test.find_and_modify(:query => {}, :sort => [['a', -1]], :update => {"$set" => {:processed => true}}, :async => true) do |error, result|
-        assert_nil error
-        assert result
-        failsafe.call
-      end
-      wait_for_async
-
-      assert @@test.find_one({:a => 3})['processed']
-    end
-
-    def test_async_find_and_modify_with_invalid_options
-      failsafe = mock('failsafe will get called in block', :call => true)
-
-      @@test << { :a => 1, :processed => false }
-      @@test << { :a => 2, :processed => false }
-      @@test << { :a => 3, :processed => false }
-
-      @@test.find_and_modify(:blimey => {}, :async => true) do |error, result|
-        assert error
-        assert error.instance_of?(OperationFailure)
-        assert_nil result
-        failsafe.call
-      end
-      wait_for_async
-    end
-  end
-
-end

data/test/async/connection_test.rb

@@ -1,24 +0,0 @@
-require 'test/test_helper'
-include Mongo
-
-class ConnectionTest < Test::Unit::TestCase
-  context "Initialization: " do
-
-    context "given async connection options" do
-
-      should "default the workers pool to 1" do
-        Async::WorkerPool.expects(:new).with(1)
-
-        Connection.new('localhost', 27017)
-      end
-
-      should "override the workers pool size with the :worker_pool_size key" do
-        size = 6
-        Async::WorkerPool.expects(:new).with(size)
-
-        Connection.new('localhost', 27017, :worker_pool_size => size)
-      end
-    end # context 'given async connection options'
-
-  end # context 'Initialization'
-end

data/test/async/cursor_test.rb

@@ -1,162 +0,0 @@
-require 'test/test_helper'
-require 'logger'
-
-class CursorTest < Test::Unit::TestCase
-
-  include Mongo
-
-  @@connection = Connection.new(ENV['MONGO_RUBY_DRIVER_HOST'] || 'localhost',
-                        ENV['MONGO_RUBY_DRIVER_PORT'] || Connection::DEFAULT_PORT)
-  @@db   = @@connection.db(MONGO_TEST_DB)
-  @@coll = @@db.collection('test')
-  @@version = @@connection.server_version
-
-  def wait_for_async
-    sleep 0.2
-  end
-
-  def setup
-    @@coll.remove
-    @@coll.insert('a' => 1)     # collection not created until it's used
-    @@coll_full_name = "#{MONGO_TEST_DB}.test"
-  end
-
-  def test_async_explain
-    failsafe = mock('failsafe will get called in block', :call => true)
-
-    cursor = @@coll.find('a' => 1)
-
-    cursor.explain(:async => true) do |error, result|
-      assert_not_nil result['cursor']
-      assert_kind_of Numeric, result['n']
-      assert_kind_of Numeric, result['millis']
-      assert_kind_of Numeric, result['nscanned']
-      failsafe.call
-    end
-    wait_for_async
-  end
-
-  def test_async_count
-    failsafe = mock('failsafe will get called in block')
-    failsafe.expects(:call).times(3)
-
-    @@coll.remove
-
-    @@coll.find.count(:async => true) do |error, count|
-      assert_equal 0, count
-      failsafe.call
-    end
-    wait_for_async
-
-    10.times do |i|
-      @@coll.save("x" => i)
-    end
-
-    @@coll.find.count(:async => true) do |error, count|
-      assert_equal 10, count
-      failsafe.call
-    end
-    wait_for_async
-
-    @@coll.find({"x" => 1}).count(:async => true) do |error, count|
-      assert_equal 1, count
-      failsafe.call
-    end
-    wait_for_async
-  end
-
-  def test_async_close
-    failsafe = mock('failsafe will get called in block', :call => true)
-
-    @@coll.remove
-    cursor = @@coll.find
-    
-    cursor.close(:async => true) do |error, result|
-      assert_nil error
-      assert result
-      assert cursor.closed?
-      failsafe.call
-    end
-    wait_for_async
-  end
-
-  def test_async_has_next
-    failsafe = mock('failsafe will get called in block', :call => true)
-
-    @@coll.remove
-    200.times do |n|
-      @@coll.save("x" => n)
-    end
-
-    cursor = @@coll.find
-    cursor.has_next?(:async => true) do |error, result|
-      assert_nil error
-      assert result
-      failsafe.call
-    end
-    wait_for_async
-  end
-
-  def test_async_next_document
-    failsafe = mock('failsafe will get called in block')
-    failsafe.expects(:call).times(2)
-
-    @@coll.remove
-    200.times do |n|
-      @@coll.save("x" => n)
-    end
-
-    cursor = @@coll.find
-    cursor.next_document(:async => true) do |error, result|
-      assert_nil error
-      assert result
-      failsafe.call
-    end
-    wait_for_async
-
-    callback = Proc.new do |error, result| 
-      assert_nil error
-      assert result
-      failsafe.call
-    end
-
-    cursor.next_document(:async => true, :callback => callback)
-    wait_for_async
-  end
-
-  def test_async_to_a
-    failsafe = mock('failsafe will get called in block')
-    failsafe.expects(:call)
-
-    @@coll.remove
-    total = 200
-    total.times do |n|
-      @@coll.save("x" => n)
-    end
-
-    cursor = @@coll.find
-    cursor.to_a(:async => true) do |error, result|
-      assert_nil error
-      assert_equal total, result.size
-      failsafe.call
-    end
-    wait_for_async
-  end
-
-  def test_async_each
-    @@coll.remove
-    total = 200
-    total.times do |n|
-      @@coll.save("x" => n)
-    end
-
-    cursor = @@coll.find
-    count = 0
-    cursor.each(:async => true) do |error, result|
-      count += 1
-    end
-    wait_for_async
-    
-    assert_equal total, count
-  end
-end

data/test/async/worker_pool_test.rb

@@ -1,99 +0,0 @@
-require 'test/test_helper'
-include Mongo
-
-class WorkerPoolTest < Test::Unit::TestCase
-  context "Initialization: " do
-
-    def wait_for_async
-      sleep 0.2
-    end
-
-    setup do
-      def new_mock_queue
-        stub_everything('queue')
-      end
-
-      def new_mock_thread
-        stub_everything('thread')
-      end
-    end
-
-    context "given a size" do
-      setup do
-        @size = 5
-      end
-
-      should "allocate a Thread 'size' times" do
-        Queue.stubs(:new).returns(new_mock_queue)
-        Thread.expects(:new).times(@size).returns(new_mock_thread)
-        Async::WorkerPool.new @size
-      end
-
-      should "set 'abort_on_exception' for each current thread" do
-        Queue.stubs(:new).returns(new_mock_queue)
-        thread = new_mock_thread
-        Thread.stubs(:new).returns(thread)
-
-        thread.expects(:abort_on_exception=).with(true).times(@size)
-
-        Async::WorkerPool.new @size
-      end
-
-      should "save each thread into the workers queue" do
-        assert_equal @size, Async::WorkerPool.new(@size).workers.size
-      end
-
-    end # context 'given a size'
-
-
-    context "given a job" do
-      setup do
-        @pool = Async::WorkerPool.new 1
-        @command = stub_everything('command')
-        @cmd_args = stub_everything('command args')
-        @callback = stub_everything('callback')
-      end
-
-      should "remove nils from the command args array and pass the results to the callback" do
-        args = [nil, @cmd_args]
-        @command.expects(:call).with(@cmd_args).returns(2)
-        @callback.expects(:call).with(nil, 2)
-
-        @pool.enqueue @command, args, @callback
-        wait_for_async
-      end
-
-      should "execute the original command with args and pass the results to the callback" do
-        @cmd_args.expects(:compact).returns(@cmd_args)
-        @command.expects(:call).with(@cmd_args).returns(2)
-        @callback.expects(:call).with(nil, 2)
-
-        @pool.enqueue @command, @cmd_args, @callback
-        wait_for_async
-      end
-
-      should "capture any exceptions and pass them to the callback" do
-        args = [@cmd_args]
-        error = StandardError.new
-        @command.expects(:call).with(@cmd_args).raises(error)
-        @callback.expects(:call).with(error, nil)
-
-        @pool.enqueue @command, args, @callback
-        wait_for_async
-      end
-
-      should "abort the thread when the callback raises an exception" do
-        args = [@cmd_args]
-        error = StandardError.new
-        @callback.expects(:call).raises(error)
-
-        assert_raises(StandardError) do
-          @pool.enqueue @command, args, @callback
-          wait_for_async
-        end
-      end
-    end # context 'given a job'
-
-
-  end
-end