mongo-lyon 1.2.4

data/lib/mongo/util/core_ext.rb

@@ -0,0 +1,60 @@
+# 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.
+# ++
+
+#:nodoc:
+class Object
+
+  #:nodoc:
+  def tap
+    yield self
+    self
+  end unless respond_to? :tap
+
+end
+
+#:nodoc:
+module Enumerable
+
+  #:nodoc:
+  def each_with_object(memo)
+    each { |element| yield(element, memo) }
+    memo
+  end unless [].respond_to?(:each_with_object)
+
+end
+
+#:nodoc:
+class Hash
+
+  #:nodoc:
+  def assert_valid_keys(*valid_keys)
+    unknown_keys = keys - [valid_keys].flatten
+    raise(ArgumentError, "Unknown key(s): #{unknown_keys.join(", ")}") unless unknown_keys.empty?
+  end
+
+end
+
+#:nodoc:
+class String
+
+  #:nodoc:
+  def to_bson_code
+    BSON::Code.new(self)
+  end
+
+end

data/lib/mongo/util/pool.rb

@@ -0,0 +1,185 @@
+# 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 Pool
+
+    attr_accessor :host, :port, :size, :timeout, :safe, :checked_out, :unix_socket_path
+
+    # Create a new pool of connections.
+    #
+    def initialize(connection, host, port, opts={})
+      @connection  = connection
+
+      @host, @port = host, port
+
+      unless @port
+        @unix_socket_path = host
+        @host = nil
+      end
+
+      # Pool size and timeout.
+      @size      = opts[:size] || 1
+      @timeout   = opts[:timeout]   || 5.0
+
+      # Mutex for synchronizing pool access
+      @connection_mutex = Mutex.new
+
+      # Condition variable for signal and wait
+      @queue = ConditionVariable.new
+
+      # Operations to perform on a socket
+      @socket_ops = Hash.new { |h, k| h[k] = [] }
+
+      @sockets      = []
+      @checked_out  = []
+    end
+
+    def close
+      @sockets.each do |sock|
+        begin
+          sock.close
+        rescue IOError => ex
+          warn "IOError when attempting to close socket connected to #{self.to_s}: #{ex.inspect}"
+        end
+      end
+      @host = @port = @unix_socket_path = nil
+      @sockets.clear
+      @checked_out.clear
+    end
+
+    # Return a socket to the pool.
+    def checkin(socket)
+      @connection_mutex.synchronize do
+        @checked_out.delete(socket)
+        @queue.signal
+      end
+      true
+    end
+
+    # Adds a new socket to the pool and checks it out.
+    #
+    # This method is called exclusively from #checkout;
+    # therefore, it runs within a mutex.
+    def checkout_new_socket
+      begin
+        if @unix_socket_path
+          socket = UNIXSocket.new(@unix_socket_path)
+        else
+          socket = TCPSocket.new(@host, @port)
+          socket.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1)
+        end
+      rescue => ex
+        raise ConnectionFailure, "Failed to connect to #{self.to_s}: #{ex}"
+      end
+
+      # If any saved authentications exist, we want to apply those
+      # when creating new sockets.
+      @connection.apply_saved_authentication(:socket => socket)
+
+      @sockets << socket
+      @checked_out << socket
+      socket
+    end
+
+    # If a user calls DB#authenticate, and several sockets exist,
+    # then we need a way to apply the authentication on each socket.
+    # So we store the apply_authentication method, and this will be
+    # applied right before the next use of each socket.
+    def authenticate_existing
+      @connection_mutex.synchronize do
+        @sockets.each do |socket|
+          @socket_ops[socket] << Proc.new do
+            @connection.apply_saved_authentication(:socket => socket)
+          end
+        end
+      end
+    end
+
+    # Store the logout op for each existing socket to be applied before
+    # the next use of each socket.
+    def logout_existing(db)
+      @connection_mutex.synchronize do
+        @sockets.each do |socket|
+          @socket_ops[socket] << Proc.new do
+            @connection.db(db).issue_logout(:socket => socket)
+          end
+        end
+      end
+    end
+
+    # Checks out the first available socket from the pool.
+    #
+    # This method is called exclusively from #checkout;
+    # therefore, it runs within a mutex.
+    def checkout_existing_socket
+      socket = (@sockets - @checked_out).first
+      @checked_out << socket
+      socket
+    end
+
+    # Check out an existing socket or create a new socket if the maximum
+    # pool size has not been exceeded. Otherwise, wait for the next
+    # available socket.
+    def checkout
+      @connection.connect if !@connection.connected?
+      start_time = Time.now
+      loop do
+        if (Time.now - start_time) > @timeout
+            raise ConnectionTimeoutError, "could not obtain connection within " +
+              "#{@timeout} seconds. The max pool size is currently #{@size}; " +
+              "consider increasing the pool size or timeout."
+        end
+
+        @connection_mutex.synchronize do
+          socket = if @checked_out.size < @sockets.size
+                     checkout_existing_socket
+                   elsif @sockets.size < @size
+                     checkout_new_socket
+                   end
+
+          if socket
+
+          # This calls all procs, in order, scoped to existing sockets.
+          # At the moment, we use this to lazily authenticate and
+          # logout existing socket connections.
+          @socket_ops[socket].reject! do |op|
+            op.call
+          end
+
+            return socket
+          else
+            # Otherwise, wait
+            if @logger
+              @logger.warn "MONGODB Waiting for available connection; " +
+                "#{@checked_out.size} of #{@size} connections checked out."
+            end
+            @queue.wait(@connection_mutex)
+          end
+        end
+      end
+    end
+
+    def to_s
+      if @unix_socket_path
+        "#{@unix_socket_path}"
+      else
+        "#{@host}:#{@port}"
+      end
+    end
+  end
+end

data/lib/mongo/util/server_version.rb

@@ -0,0 +1,71 @@
+# 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
+  # Simple class for comparing server versions.
+  class ServerVersion
+    include Comparable
+
+    def initialize(version)
+      @version = version
+    end
+
+    # Implements comparable.
+    def <=>(new)
+      local, new  = self.to_a, to_array(new)
+      for n in 0...local.size do
+        break if elements_include_mods?(local[n], new[n])
+        if local[n] < new[n].to_i
+          result = -1
+          break;
+        elsif local[n] > new[n].to_i
+          result = 1
+          break;
+        end
+      end
+      result || 0
+    end
+
+    # Return an array representation of this server version.
+    def to_a
+      to_array(@version)
+    end
+
+    # Return a string representation of this server version.
+    def to_s
+      @version
+    end
+
+    private
+
+    # Returns true if any elements include mod symbols (-, +)
+    def elements_include_mods?(*elements)
+      elements.any? { |n| n =~ /[\-\+]/ }
+    end
+
+    # Converts argument to an array of integers,
+    # appending any mods as the final element.
+    def to_array(version)
+      array = version.split(".").map {|n| (n =~ /^\d+$/) ? n.to_i : n }
+      if array.last =~ /(\d+)([\-\+])/
+        array[array.length-1] = $1.to_i
+        array << $2
+      end
+      array
+    end
+  end
+end

data/lib/mongo/util/support.rb

@@ -0,0 +1,82 @@
+# 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.
+# ++
+
+require 'digest/md5'
+
+module Mongo
+  module Support
+    include Mongo::Conversions
+    extend self
+
+    # Generate an MD5 for authentication.
+    #
+    # @param [String] username
+    # @param [String] password
+    # @param [String] nonce
+    #
+    # @return [String] a key for db authentication.
+    def auth_key(username, password, nonce)
+      Digest::MD5.hexdigest("#{nonce}#{username}#{hash_password(username, password)}")
+    end
+
+    # Return a hashed password for auth.
+    #
+    # @param [String] username
+    # @param [String] plaintext
+    #
+    # @return [String]
+    def hash_password(username, plaintext)
+      Digest::MD5.hexdigest("#{username}:mongo:#{plaintext}")
+    end
+
+
+    def validate_db_name(db_name)
+      unless [String, Symbol].include?(db_name.class)
+        raise TypeError, "db_name must be a string or symbol"
+      end
+
+      [" ", ".", "$", "/", "\\"].each do |invalid_char|
+        if db_name.include? invalid_char
+          raise Mongo::InvalidNSName, "database names cannot contain the character '#{invalid_char}'"
+        end
+      end
+      raise Mongo::InvalidNSName, "database name cannot be the empty string" if db_name.empty?
+      db_name
+    end
+
+    def format_order_clause(order)
+      case order
+        when String, Symbol then string_as_sort_parameters(order)
+        when Array then array_as_sort_parameters(order)
+        else
+          raise InvalidSortValueError, "Illegal sort clause, '#{order.class.name}'; must be of the form " +
+            "[['field1', '(ascending|descending)'], ['field2', '(ascending|descending)']]"
+      end
+    end
+
+    # Determine if a database command has succeeded by
+    # checking the document response.
+    #
+    # @param [Hash] doc
+    #
+    # @return [Boolean] true if the 'ok' key is either 1 or *true*.
+    def ok?(doc)
+      doc['ok'] == 1.0 || doc['ok'] == true
+    end
+  end
+end

data/lib/mongo/util/uri_parser.rb

@@ -0,0 +1,181 @@
+# 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\d]+):([^@]+)@)?([-.\w\d]+)(:([\w\d]+))?(\/([-\d\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)
+      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