mongodb-mongo 0.2.4 → 0.2.5

data/README.rdoc

@@ -32,6 +32,11 @@ Install the "mongo" gem by typing
   $ gem sources -a http://gems.github.com
   $ sudo gem install mongodb-mongo-ruby-driver
 
+The first line tells RubyGems to add the GitHub gem repository. You only need
+to run this command once.
+
+=== From the GitHub source
+
 The source code is available at http://github.com/mongodb/mongo-ruby-driver.
 You can either clone the git repository or download a tarball or zip file.
 Once you have the source, you can use it from wherever you downloaded it or

data/lib/mongo/cursor.rb

@@ -70,7 +70,19 @@ module XGen
         def next_object
           refill_via_get_more if num_remaining == 0
           o = @cache.shift
-          raise o['$err'] if o && o['$err']
+
+          if o && o['$err']
+            err = o['$err']
+
+            # If the server has stopped being the master (e.g., it's one of a
+            # pair but it has died or something like that) then we close that
+            # connection. If the db has auto connect option and a pair of
+            # servers, next request will re-open on master server.
+            @db.close if err == "not master"
+
+            raise err
+          end
+
           o
         end
 

data/lib/mongo/db.rb

@@ -61,6 +61,9 @@ module XGen
         # The database's socket. For internal (and Cursor) use only.
         attr_reader :socket
 
+        def slave_ok?; @slave_ok; end
+        def auto_reconnect?; @auto_reconnect; end
+
         # A primary key factory object (or +nil+). See the README.doc file or
         # DB#new for details.
         attr_reader :pk_factory
@@ -70,9 +73,12 @@ module XGen
           @pk_factory = pk_factory
         end
 
+        # Instances of DB are normally obtained by calling Mongo#db.
+        #
         # db_name :: The database name
         #
-        # nodes :: An array of [host, port] pairs.
+        # nodes :: An array of [host, port] pairs. See Mongo#new, which offers
+        #          a more flexible way of defining nodes.
         #
         # options :: A hash of options.
         #
@@ -92,27 +98,49 @@ module XGen
         #        object's +create_pk+ method will be called and the new hash
         #        returned will be inserted.
         #
-        # When a DB object first connects, it tries the first node. If that
-        # fails, it keeps trying to connect to the remaining nodes until it
-        # sucessfully connects.
+        # :slave_ok :: Only used if +nodes+ contains only one host/port. If
+        #              false, when connecting to that host/port we check to
+        #              see if the server is the master. If it is not, an error
+        #              is thrown.
+        #
+        # :auto_reconnect :: If the connection gets closed (for example, we
+        #                    have a server pair and saw the "not master"
+        #                    error, which closes the connection), then
+        #                    automatically try to reconnect to the master or
+        #                    to the single server we have been given. Defaults
+        #                    to +false+.
+        #
+        # When a DB object first connects to a pair, it will find the master
+        # instance and connect to that one. On socket error or if we recieve a
+        # "not master" error, we again find the master of the pair.
         def initialize(db_name, nodes, options={})
           raise "Invalid DB name \"#{db_name}\" (must be non-nil, non-zero-length, and can not contain \".\")" if !db_name || (db_name && db_name.length > 0 && db_name.include?("."))
           @name, @nodes = db_name, nodes
           @strict = options[:strict]
           @pk_factory = options[:pk]
+          @slave_ok = options[:slave_ok] && @nodes.length == 1 # only OK if one node
+          @auto_reconnect = options[:auto_reconnect]
           @semaphore = Object.new
           @semaphore.extend Mutex_m
-          connect_to_first_available_host
+          connect_to_master
         end
 
-        def connect_to_first_available_host
+        def connect_to_master
           close if @socket
           @host = @port = nil
           @nodes.detect { |hp|
             @host, @port = *hp
             begin
               @socket = TCPSocket.new(@host, @port)
-              break if ok?(db_command(:ismaster => 1)) # success
+
+              # Check for master. Can't call master? because it uses mutex,
+              # which may already be in use during this call.
+              semaphore_is_locked = @semaphore.locked?
+              @semaphore.unlock if semaphore_is_locked
+              is_master = master?
+              @semaphore.lock if semaphore_is_locked
+
+              break if @slave_ok || is_master
             rescue => ex
               close if @socket
             end
@@ -214,6 +242,28 @@ module XGen
           ok?(db_command(:drop => name))
         end
 
+        # Returns the error message from the most recently executed database
+        # operation for this connection, or +nil+ if there was no error.
+        #
+        # Note: as of this writing, errors are only detected on the db server
+        # for certain kinds of operations (writes). The plan is to change this
+        # so that all operations will set the error if needed.
+        def error
+          doc = db_command(:getlasterror => 1)
+          raise "error retrieving last error: #{doc}" unless ok?(doc)
+          doc['err']
+        end
+
+        # Returns +true+ if there is was an error caused by the most recently
+        # executed database operation.
+        #
+        # Note: as of this writing, errors are only detected on the db server
+        # for certain kinds of operations (writes). The plan is to change this
+        # so that all operations will set the error if needed.
+        def error?
+          error != nil
+        end
+
         # Returns true if this database is a master (or is not paired with any
         # other database), false if it is a slave.
         def master?
@@ -236,20 +286,6 @@ module XGen
           end
         end
 
-        # Switches our socket to the master database. If we are already the
-        # master, no change is made.
-        def switch_to_master
-          master_str = master()
-          unless master_str == "#@host:#@port"
-            @semaphore.synchronize {
-              master_str =~ /(.+):(\d+)/
-              @host, @port = $1, $2
-              close()
-              @socket = TCPSocket.new(@host, @port)
-            }
-          end
-        end
-
         # Close the connection to the database.
         def close
           @socket.close if @socket
@@ -387,7 +423,13 @@ module XGen
         end
 
         def send_to_db(message)
-          @socket.print(message.buf.to_s)
+          connect_to_master if !connected? && @auto_reconnect
+          begin
+            @socket.print(message.buf.to_s)
+          rescue => ex
+            close
+            raise ex
+          end
         end
 
         def full_coll_name(collection_name)

data/lib/mongo/mongo.rb

@@ -25,37 +25,73 @@ module XGen
 
         DEFAULT_PORT = 27017
 
-        # Either nodes_or_host is a host name string and port is an optional
-        # port number that defaults to DEFAULT_PORT, or nodes_or_host is an
-        # array of arrays, where each is a host/port pair (or a host with no
-        # port). Finally, if nodes_or_host is nil then host is 'localhost' and
-        # port is DEFAULT_PORT. Since that's so confusing, here are a few
-        # examples:
+        # Create a Mongo database server instance. You specify either one or a
+        # pair of servers. If one, you also say if connecting to a slave is
+        # OK. In either case, the host default is "localhost" and port default
+        # is DEFAULT_PORT.
         #
-        #  Mongo.new                         # localhost, DEFAULT_PORT
-        #  Mongo.new("localhost")            # localhost, DEFAULT_PORT
-        #  Mongo.new("localhost", 3000)      # localhost, 3000
-        #  Mongo.new([["localhost"]])        # localhost, DEFAULT_PORT
-        #  Mongo.new([["localhost", 3000]])  # localhost, 3000
-        #  Mongo.new([["db1.example.com", 3000], ["db2.example.com", 3000]]])
+        # If you specify a pair, pair_or_host is a hash with two keys :left
+        # and :right. Each key maps to either
+        # * a server name, in which case port is DEFAULT_PORT
+        # * a port number, in which case server is "localhost"
+        # * an array containing a server name and a port number in either order
         #
-        # When a DB object first connects, it tries nodes and stops at the
-        # first one it connects to.
-        def initialize(nodes_or_host=nil, port=nil)
-          @nodes = case nodes_or_host
+        # +options+ are passed on to each DB instance:
+        #
+        # :slave_ok :: Only used if one host is specified. If false, when
+        #              connecting to that host/port a DB object will check to
+        #              see if the server is the master. If it is not, an error
+        #              is thrown.
+        #
+        # :auto_reconnect :: If a DB connection gets closed (for example, we
+        #                    have a server pair and saw the "not master"
+        #                    error, which closes the connection), then
+        #                    automatically try to reconnect to the master or
+        #                    to the single server we have been given. Defaults
+        #                    to +false+.
+        #
+        # Since that's so confusing, here are a few examples:
+        #
+        #  Mongo.new                         # localhost, DEFAULT_PORT, !slave
+        #  Mongo.new("localhost")            # localhost, DEFAULT_PORT, !slave
+        #  Mongo.new("localhost", 3000)      # localhost, 3000, slave not ok
+        #  # localhost, 3000, slave ok
+        #  Mongo.new("localhost", 3000, :slave_ok => true)
+        #  # localhost, DEFAULT_PORT, auto reconnect
+        #  Mongo.new(nil, nil, :auto_reconnect => true)
+        #
+        #  # A pair of servers. DB will always talk to the master. On socket
+        #  # error or "not master" error, we will auto-reconnect to the
+        #  # current master.
+        #  Mongo.new({:left  => ["db1.example.com", 3000],
+        #             :right => "db2.example.com"}, # DEFAULT_PORT
+        #            nil, :auto_reconnect => true)
+        #
+        #  # Here, :right is localhost/DEFAULT_PORT. No auto-reconnect.
+        #  Mongo.new({:left => ["db1.example.com", 3000]})
+        #
+        # When a DB object first connects to a pair, it will find the master
+        # instance and connect to that one.
+        def initialize(pair_or_host=nil, port=nil, options={})
+          @pair = case pair_or_host
                    when String
-                     [[nodes_or_host, port || DEFAULT_PORT]]
-                   when Array
-                     nodes_or_host.collect { |nh| [nh[0], nh[1] || DEFAULT_PORT] }
+                     [[pair_or_host, port || DEFAULT_PORT]]
+                   when Hash
+                    connections = []
+                    connections << pair_val_to_connection(pair_or_host[:left])
+                    connections << pair_val_to_connection(pair_or_host[:right])
+                    connections
                    when nil
                      [['localhost', DEFAULT_PORT]]
                    end
+          @options = options
         end
 
-        # Return the XGen::Mongo::Driver::DB named +db_name+. See DB#new for
-        # +options+.
+        # Return the XGen::Mongo::Driver::DB named +db_name+. The slave_ok and
+        # auto_reconnect options passed in via #new may be overridden here.
+        # See DB#new for other options you can pass in.
         def db(db_name, options={})
-          XGen::Mongo::Driver::DB.new(db_name, @nodes, options)
+          XGen::Mongo::Driver::DB.new(db_name, @pair, @options.merge(options))
         end
 
         # Returns a hash containing database names as keys and disk space for
@@ -91,6 +127,26 @@ module XGen
 
         protected
 
+        # Turns an array containing an optional host name string and an
+        # optional port number integer into a [host, port] pair array.
+        def pair_val_to_connection(a)
+          case a
+          when nil
+            ['localhost', DEFAULT_PORT]
+          when String
+            [a, DEFAULT_PORT]
+          when Integer
+            ['localhost', a]
+          when Array
+            connection = ['localhost', DEFAULT_PORT]
+            connection[0] = a[0] if a[0].kind_of?(String)
+            connection[0] = a[1] if a[1].kind_of?(String)
+            connection[1] = a[0] if a[0].kind_of?(Integer)
+            connection[1] = a[1] if a[1].kind_of?(Integer)
+            connection
+          end
+        end
+
         # Send cmd (a hash, possibly ordered) to the admin database and return
         # the answer. Raises an error unless the return is "ok" (DB#ok?
         # returns +true+).

data/mongo-ruby-driver.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name = 'mongo'
-  s.version = '0.2.4'
+  s.version = '0.2.5'
   s.platform = Gem::Platform::RUBY
   s.summary = 'Simple pure-Ruby driver for the 10gen Mongo DB'
   s.description = 'A pure-Ruby driver for the 10gen Mongo DB. For more information about Mongo, see http://www.mongodb.org.'

data/tests/test_db.rb

@@ -28,7 +28,7 @@ class DBTest < Test::Unit::TestCase
   end
 
   def teardown
-    if @db.connected?
+    if @db && @db.connected?
       @users.clear if @users
       @db.close
     end
@@ -50,17 +50,10 @@ class DBTest < Test::Unit::TestCase
     assert_equal 'ruby-mongo-test.test', @db.full_coll_name(coll.name)
   end
 
-  def test_master
-    # Doesn't really test anything since we probably only have one database
-    # during this test.
-    @db.switch_to_master
-    assert @db.connected?
-  end
-
-  def test_array
+  def test_pair
     @db.close
     @users = nil
-    @db = Mongo.new([["nosuch.example.com"], [@host, @port]]).db('ruby-mongo-test')
+    @db = Mongo.new({:left => "nosuch.example.com", :right => [@host, @port]}).db('ruby-mongo-test')
     assert @db.connected?
   end
 
@@ -101,4 +94,28 @@ class DBTest < Test::Unit::TestCase
     @db.logout                  # only testing that we don't throw exception
   end
 
+  def test_auto_connect
+    @db.close
+    db = Mongo.new(@host, @port, :auto_reconnect => true).db('ruby-mongo-test')
+    assert db.connected?
+    assert db.auto_reconnect?
+    db.close
+    assert !db.connected?
+    assert db.auto_reconnect?
+    db.collection('test').insert('a' => 1)
+    assert db.connected?
+  end
+
+  def test_error
+    doc = @db.send(:db_command, :forceerror => 1)
+    assert @db.error?
+    err = @db.error
+    assert_match /forced error/, err
+
+    # ask again
+    assert @db.error?
+    err2 = @db.error
+    assert_equal err, err2
+  end
+
 end

data/tests/test_db_api.rb

@@ -47,6 +47,17 @@ class DBAPITest < Test::Unit::TestCase
     assert docs.detect { |row| row['b'] == 4 }
   end
 
+  def test_insert_multiple
+    @coll.insert({'a' => 2}, {'b' => 3})
+
+    assert_equal 3, @coll.count
+    docs = @coll.find().to_a
+    assert_equal 3, docs.length
+    assert docs.detect { |row| row['a'] == 1 }
+    assert docs.detect { |row| row['a'] == 2 }
+    assert docs.detect { |row| row['b'] == 3 }
+  end
+
   def test_find_simple
     @r2 = @coll.insert('a' => 2)
     @r3 = @coll.insert('b' => 3)

data/tests/test_mongo.rb

@@ -41,4 +41,24 @@ class MongoTest < Test::Unit::TestCase
     assert !@mongo.database_names.include?('will-be-deleted')
   end
 
+  def test_pair
+    db = Mongo.new({:left => ['foo', 123]})
+    pair = db.instance_variable_get('@pair')
+    assert_equal 2, pair.length
+    assert_equal ['foo', 123], pair[0]
+    assert_equal ['localhost', Mongo::DEFAULT_PORT], pair[1]
+
+    db = Mongo.new({:right => 'bar'})
+    pair = db.instance_variable_get('@pair')
+    assert_equal 2, pair.length
+    assert_equal ['localhost', Mongo::DEFAULT_PORT], pair[0]
+    assert_equal ['bar', Mongo::DEFAULT_PORT], pair[1]
+
+    db = Mongo.new({:right => [123, 'foo'], :left => 'bar'})
+    pair = db.instance_variable_get('@pair')
+    assert_equal 2, pair.length
+    assert_equal ['bar', Mongo::DEFAULT_PORT], pair[0]
+    assert_equal ['foo', 123], pair[1]
+  end
+
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: mongodb-mongo
 version: !ruby/object:Gem::Version 
-  version: 0.2.4
+  version: 0.2.5
 platform: ruby
 authors: 
 - Jim Menard