mongo 1.12.5 → 2.0.0.beta

data/lib/mongo/connection/node.rb

@@ -1,249 +0,0 @@
-# Copyright (C) 2009-2013 MongoDB, 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 Node
-
-    attr_accessor :host, :port, :address, :client, :socket, :last_state
-
-    def initialize(client, host_port)
-      @client = client
-      @manager = @client.local_manager
-      @host, @port = Support.normalize_seeds(host_port)
-      @address = "#{@host}:#{@port}"
-      @config = nil
-      @socket = nil
-      @node_mutex = Monitor.new
-    end
-
-    def eql?(other)
-      (other.is_a?(Node) && @address == other.address)
-    end
-    alias :== :eql?
-
-    def =~(other)
-      if other.is_a?(String)
-        h, p = Support.normalize_seeds(other)
-        h == @host && p == @port
-      else
-        false
-      end
-    end
-
-    def host_string
-      address
-    end
-
-    def config
-      connect unless connected?
-      set_config unless @config || !connected?
-      @config
-    end
-
-    def inspect
-      "<Mongo::Node:0x#{self.object_id.to_s(16)} @host=#{@host} @port=#{@port}>"
-    end
-
-    # Create a connection to the provided node,
-    # and, if successful, return the socket. Otherwise,
-    # return nil.
-    def connect
-      @node_mutex.synchronize do
-        begin
-          @socket = @client.socket_class.new(@host, @port,
-                                             @client.op_timeout,
-                                             @client.connect_timeout,
-                                             @client.socket_opts)
-        rescue ConnectionTimeoutError, OperationTimeout, ConnectionFailure, OperationFailure,
-               SocketError, SystemCallError, IOError => ex
-          @client.log(:debug, "Failed connection to #{host_string} with #{ex.class}, #{ex.message}.")
-          close
-        end
-      end
-    end
-
-    # This should only be called within a mutex
-    def close
-      if @socket && !@socket.closed?
-        @socket.close
-      end
-      @socket = nil
-      @config = nil
-    end
-
-    def connected?
-      @socket != nil && !@socket.closed?
-    end
-
-    def active?
-      begin
-        result = @client['admin'].command({:ping => 1}, :socket => usable_socket)
-      rescue OperationFailure, SocketError, SystemCallError, IOError
-        return nil
-      end
-      result['ok'] == 1
-    end
-
-    # Get the configuration for the provided node as returned by the
-    # ismaster command. Additionally, check that the replica set name
-    # matches with the name provided.
-    def set_config
-      @node_mutex.synchronize do
-        begin
-          if @config
-            @last_state = @config['ismaster'] ? :primary : :other
-          end
-
-          if @client.connect_timeout
-            Timeout::timeout(@client.connect_timeout, OperationTimeout) do
-              @config = @client['admin'].command({:ismaster => 1}, :socket => usable_socket)
-            end
-          else
-            @config = @client['admin'].command({:ismaster => 1}, :socket => usable_socket)
-          end
-
-          update_max_sizes
-
-          if @config['msg']
-            @client.log(:warn, "#{config['msg']}")
-          end
-
-          unless @client.mongos?
-            check_set_membership(@config)
-            check_set_name(@config)
-          end
-        rescue ConnectionFailure, OperationFailure, OperationTimeout, SocketError, SystemCallError, IOError => ex
-          @client.log(:warn, "Attempted connection to node #{host_string} raised " +
-                              "#{ex.class}: #{ex.message}")
-          # Socket may already be nil from issuing command
-          close
-        end
-      end
-    end
-
-    # Return a list of replica set nodes from the config.
-    # Note: this excludes arbiters.
-    def node_list
-      nodes = []
-      nodes += config['hosts'] if config['hosts']
-      nodes += config['passives'] if config['passives']
-      nodes += ["#{@host}:#{@port}"] if @client.mongos?
-      nodes
-    end
-
-    def arbiters
-      return [] unless config['arbiters']
-      config['arbiters'].map do |arbiter|
-        Support.normalize_seeds(arbiter)
-      end
-    end
-
-    def primary?
-      config['ismaster'] == true || config['ismaster'] == 1
-    end
-
-    def secondary?
-      config['secondary'] == true || config['secondary'] == 1
-    end
-
-    def tags
-      config['tags'] || {}
-    end
-
-    def host_port
-      [@host, @port]
-    end
-
-    def hash
-      address.hash
-    end
-
-    def healthy?
-      connected? && config
-    end
-
-    def max_bson_size
-      @max_bson_size || DEFAULT_MAX_BSON_SIZE
-    end
-
-    def max_message_size
-      @max_message_size || max_bson_size * MESSAGE_SIZE_FACTOR
-    end
-
-    def max_wire_version
-      @max_wire_version || 0
-    end
-
-    def min_wire_version
-      @min_wire_version || 0
-    end
-
-    def wire_version_feature?(feature)
-      min_wire_version <= feature && feature <= max_wire_version
-    end
-
-    def max_write_batch_size
-      @max_write_batch_size || Mongo::MongoClient::DEFAULT_MAX_WRITE_BATCH_SIZE
-    end
-
-    protected
-
-    # Ensure that this node is a healthy member of a replica set.
-    def check_set_membership(config)
-      if !config.has_key?('hosts')
-        message = "Will not connect to #{host_string} because it's not a member " +
-          "of a replica set."
-        raise ConnectionFailure, message
-      elsif config['hosts'].length == 1 && !config['ismaster'] &&
-        !config['secondary']
-        message = "Attempting to connect to an unhealthy, single-node replica set."
-        raise ConnectionFailure, message
-      end
-    end
-
-    # Ensure that this node is part of a replica set of the expected name.
-    def check_set_name(config)
-      if @client.replica_set_name
-        if !config['setName']
-          @client.log(:warn, "Could not verify replica set name for member #{host_string} " +
-            "because ismaster does not return name in this version of MongoDB")
-        elsif @client.replica_set_name != config['setName']
-          message = "Attempting to connect to replica set '#{config['setName']}' on member #{host_string} " +
-            "but expected '#{@client.replica_set_name}'"
-          raise ReplicaSetConnectionError, message
-        end
-      end
-    end
-
-    private
-
-    def usable_socket
-      if @socket && @socket.pid != Process.pid
-        @socket.close
-        @socket = nil
-        connect
-      else
-        @socket
-      end
-    end
-
-    def update_max_sizes
-      @max_bson_size = config['maxBsonObjectSize'] || DEFAULT_MAX_BSON_SIZE
-      @max_message_size = config['maxMessageSizeBytes'] || @max_bson_size * MESSAGE_SIZE_FACTOR
-      @max_wire_version = config['maxWireVersion'] || 0
-      @min_wire_version = config['minWireVersion'] || 0
-      @max_write_batch_size = config['maxWriteBatchSize'] || Mongo::MongoClient::DEFAULT_MAX_WRITE_BATCH_SIZE
-    end
-  end
-end

data/lib/mongo/connection/pool.rb

@@ -1,340 +0,0 @@
-# Copyright (C) 2009-2013 MongoDB, 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
-    PING_ATTEMPTS  = 6
-    MAX_PING_TIME  = 1_000_000
-    PRUNE_INTERVAL = 10_000
-
-    attr_accessor :host,
-                  :port,
-                  :address,
-                  :size,
-                  :timeout,
-                  :checked_out,
-                  :client,
-                  :node
-
-    # Create a new pool of connections.
-    def initialize(client, host, port, opts={})
-      @client = client
-
-      @host, @port = host, port
-
-      # A Mongo::Node object.
-      @node = opts[:node]
-
-      # The string address
-      @address = "#{@host}:#{@port}"
-
-      # Pool size and timeout.
-      @size    = opts.fetch(:size, 20)
-      @timeout = opts.fetch(:timeout, 30)
-
-      # Mutex for synchronizing pool access
-      @connection_mutex = Mutex.new
-
-      # Mutex for synchronizing pings
-      @ping_mutex = Mutex.new
-
-      # Condition variable for signal and wait
-      @queue = ConditionVariable.new
-
-      @sockets               = []
-      @checked_out           = []
-      @ping_time             = nil
-      @last_ping             = nil
-      @closed                = false
-      @thread_ids_to_sockets = {}
-      @checkout_counter      = 0
-    end
-
-    # Close this pool.
-    #
-    # @option opts [Boolean]:soft (false) If true,
-    #   close only those sockets that are not checked out.
-    def close(opts={})
-      @connection_mutex.synchronize do
-        if opts[:soft] && !@checked_out.empty?
-          @closing = true
-          close_sockets(@sockets - @checked_out)
-        else
-          close_sockets(@sockets)
-          @closed = true
-        end
-        @node.close if @node
-      end
-      true
-    end
-
-    def tags
-      @node.tags
-    end
-
-    def healthy?
-      close if @sockets.all?(&:closed?)
-      !closed? && node.healthy?
-    end
-
-    def closed?
-      @closed
-    end
-
-    def up?
-      !@closed
-    end
-
-    def inspect
-      "#<Mongo::Pool:0x#{self.object_id.to_s(16)} @host=#{@host} @port=#{port} " +
-        "@ping_time=#{@ping_time} #{@checked_out.size}/#{@size} sockets available " +
-        "up=#{!closed?}>"
-    end
-
-    def host_string
-      "#{@host}:#{@port}"
-    end
-
-    def host_port
-      [@host, @port]
-    end
-
-    # Refresh ping time only if we haven't
-    # checked within the last five minutes.
-    def ping_time
-      @ping_mutex.synchronize do
-        if !@last_ping || (Time.now - @last_ping) > 300
-          @ping_time = refresh_ping_time
-          @last_ping = Time.now
-        end
-      end
-      @ping_time
-    end
-
-    # Return the time it takes on average
-    # to do a round-trip against this node.
-    def refresh_ping_time
-      trials = []
-      PING_ATTEMPTS.times do
-        t1 = Time.now
-        if !self.ping
-          return MAX_PING_TIME
-        end
-        trials << (Time.now - t1) * 1000
-      end
-
-      trials.sort!
-
-      # Delete shortest and longest times
-      trials.delete_at(trials.length-1)
-      trials.delete_at(0)
-
-      total = 0.0
-      trials.each { |t| total += t }
-
-      (total / trials.length).ceil
-    end
-
-    def ping
-      begin
-        return self.client['admin'].command({:ping => 1}, :socket => @node.socket,
-                                                          :timeout => client.op_timeout || MongoClient::DEFAULT_OP_TIMEOUT)
-      rescue ConnectionFailure, OperationFailure, SocketError, SystemCallError, IOError
-        return false
-      end
-    end
-
-    # Return a socket to the pool.
-    def checkin(socket)
-      @connection_mutex.synchronize do
-        if @checked_out.delete(socket)
-          @queue.broadcast
-        else
-          return false
-        end
-      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
-        socket = @client.socket_class.new(@host, @port, @client.op_timeout,
-                                                        @client.connect_timeout,
-                                                        @client.socket_opts)
-        socket.pool = self
-      rescue => ex
-        socket.close if socket
-        @node.close if @node
-        raise ConnectionFailure, "Failed to connect to host #{@host} and port #{@port}: #{ex}"
-      end
-
-      @sockets << socket
-      @checked_out << socket
-      @thread_ids_to_sockets[Thread.current.object_id] = 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.
-    #
-    # @deprecated This method has been replaced by Pool#check_auths (private)
-    # and it isn't necessary to ever invoke this method directly.
-    # Authentication of sockets is handled upon checkout and checkin.
-    def authenticate_existing
-    end
-
-    # Store the logout op for each existing socket to be applied before
-    # the next use of each socket.
-    #
-    # @deprecated This method has been replaced by Pool#check_auths (private)
-    # and it isn't necessary to ever invoke this method directly.
-    # Authentication of sockets is handled upon checkout and checkin.
-    def logout_existing(database)
-    end
-
-    # Checks out the first available socket from the pool.
-    #
-    # If the pid has changed, remove the socket and check out
-    # new one.
-    #
-    # This method is called exclusively from #checkout;
-    # therefore, it runs within a mutex.
-    def checkout_existing_socket(socket=nil)
-      if !socket
-        available = @sockets - @checked_out
-        socket = available[rand(available.length)]
-      end
-
-      if socket.pid != Process.pid
-        @sockets.delete(socket)
-        if socket
-          socket.close unless socket.closed?
-        end
-        checkout_new_socket
-      else
-        @checked_out << socket
-        @thread_ids_to_sockets[Thread.current.object_id] = socket
-        socket
-      end
-    end
-
-    def prune_threads
-      live_threads = Thread.list.map(&:object_id)
-      @thread_ids_to_sockets.reject! do |key, value|
-        !live_threads.include?(key)
-      end
-    end
-
-    def check_prune
-      if @checkout_counter > PRUNE_INTERVAL
-          @checkout_counter = 0
-          prune_threads
-      else
-        @checkout_counter += 1
-      end
-    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
-      @client.connect if !@client.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
-          check_prune
-          socket = nil
-          if socket_for_thread = @thread_ids_to_sockets[Thread.current.object_id]
-            if !@checked_out.include?(socket_for_thread)
-              socket = checkout_existing_socket(socket_for_thread)
-            end
-          else
-            if @sockets.size < @size
-              socket = checkout_new_socket
-            elsif @checked_out.size < @sockets.size
-              socket = checkout_existing_socket
-            end
-          end
-
-          if socket
-            if !socket.closed?
-              begin
-                check_auths(socket)
-                return socket
-              rescue ConnectionFailure
-                # Socket failed authentication and will be cleaned up below
-              end
-            end
-
-            # Socket was closed from earlier network error, or just now from
-            # a network error when authenticating.
-            @checked_out.delete(socket)
-            @sockets.delete(socket)
-            @thread_ids_to_sockets.delete(Thread.current.object_id)
-          else
-            # Otherwise, wait
-            @queue.wait(@connection_mutex)
-          end
-        end
-      end
-    end
-
-    private
-
-    # Helper method to handle keeping track of auths/logouts for sockets.
-    #
-    # @param socket [Socket] The socket instance to be checked.
-    #
-    # @return [Socket] The authenticated socket instance.
-    def check_auths(socket)
-      # find and handle logouts
-      (socket.auths - @client.auths).each do |auth|
-        @client.issue_logout(auth[:source], :socket => socket)
-        socket.auths.delete(auth)
-      end
-
-      # find and handle new auths
-      (@client.auths - socket.auths).each do |auth|
-        @client.issue_authentication(auth, :socket => socket)
-        socket.auths.add(auth)
-      end
-
-      socket
-    end
-
-    def close_sockets(sockets)
-      sockets.each do |socket|
-        @sockets.delete(socket)
-        begin
-          socket.close unless socket.closed?
-        rescue IOError => ex
-          warn "IOError when attempting to close socket connected to #{@host}:#{@port}: #{ex.inspect}"
-        end
-      end
-    end
-
-  end
-end