mongo 1.12.5 → 2.0.0.beta

data/lib/mongo/connection/pool_manager.rb

@@ -1,320 +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 PoolManager
-    include ThreadLocalVariableManager
-
-    attr_reader :client,
-                :hosts,
-                :pools,
-                :secondaries,
-                :secondary_pools,
-                :arbiters,
-                :primary,
-                :primary_pool,
-                :seeds,
-                :max_bson_size,
-                :max_message_size,
-                :max_wire_version,
-                :min_wire_version
-
-    # Create a new set of connection pools.
-    #
-    # The pool manager will by default use the original seed list passed
-    # to the connection objects, accessible via connection.seeds. In addition,
-    # the user may pass an additional list of seeds nodes discovered in real
-    # time. The union of these lists will be used when attempting to connect,
-    # with the newly-discovered nodes being used first.
-    def initialize(client, seeds=[])
-      @client                                   = client
-      @seeds                                    = seeds
-
-      initialize_immutable_state
-      initialize_mutable_state
-
-      @pools                                    = Set.new
-      @primary                                  = nil
-      @primary_pool                             = nil
-      @members                                  = Set.new
-      @refresh_required                         = false
-      @max_bson_size                            = DEFAULT_MAX_BSON_SIZE
-      @max_message_size                         = @max_bson_size * MESSAGE_SIZE_FACTOR
-      @max_wire_version                         = 0
-      @min_wire_version                         = 0
-      @connect_mutex                            = Mutex.new
-      thread_local[:locks][:connecting_manager] = false
-    end
-
-    def inspect
-      "<Mongo::PoolManager:0x#{self.object_id.to_s(16)} @seeds=#{@seeds}>"
-    end
-
-    def connect
-      @connect_mutex.synchronize do
-        begin
-          thread_local[:locks][:connecting_manager] = true
-          @refresh_required = false
-          disconnect_old_members
-          connect_to_members
-          initialize_pools(@members)
-          update_max_sizes
-          @seeds = discovered_seeds
-        ensure
-          thread_local[:locks][:connecting_manager] = false
-        end
-      end
-      clone_state
-    end
-
-    def refresh!(additional_seeds)
-      @seeds |= additional_seeds
-      connect
-    end
-
-    # We're healthy if all members are pingable and if the view
-    # of the replica set returned by isMaster is equivalent
-    # to our view. If any of these isn't the case,
-    # set @refresh_required to true, and return.
-    def check_connection_health
-      return if thread_local[:locks][:connecting_manager]
-      members = copy_members
-      begin
-        seed = get_valid_seed_node
-      rescue ConnectionFailure
-        @refresh_required = true
-        return
-      end
-
-      unless current_config = seed.config
-        @refresh_required = true
-        seed.close
-        return
-      end
-
-      if current_config['hosts'].length != members.length
-        @refresh_required = true
-        seed.close
-        return
-      end
-
-      current_config['hosts'].each do |host|
-        member = members.detect do |m|
-          m.address == host
-        end
-
-        if member && validate_existing_member(current_config, member)
-          next
-        else
-          @refresh_required = true
-          seed.close
-          return
-        end
-      end
-
-      seed.close
-    end
-
-    # The replica set connection should initiate a full refresh.
-    def refresh_required?
-      @refresh_required
-    end
-
-    def closed?
-      pools.all? { |pool| pool.closed? }
-    end
-
-    def close(opts={})
-      begin
-        pools.each { |pool| pool.close(opts) }
-      rescue ConnectionFailure
-      end
-    end
-
-    def read
-      read_pool.host_port
-    end
-
-    private
-
-    def update_max_sizes
-      unless @members.size == 0
-        @max_bson_size = @members.map(&:max_bson_size).min
-        @max_message_size = @members.map(&:max_message_size).min
-        @max_wire_version = @members.map(&:max_wire_version).min
-        @min_wire_version = @members.map(&:min_wire_version).max
-      end
-    end
-
-    def validate_existing_member(current_config, member)
-      if current_config['ismaster'] && member.last_state != :primary
-        return false
-      elsif member.last_state != :other
-        return false
-      end
-      return true
-    end
-
-    # For any existing members, close and remove any that are unhealthy or already closed.
-    def disconnect_old_members
-      @pools_mutable.reject!   {|pool| !pool.healthy? }
-      @members.reject! {|node| !node.healthy? }
-    end
-
-    # Connect to each member of the replica set
-    # as reported by the given seed node.
-    def connect_to_members
-      seed = get_valid_seed_node
-      seed.node_list.each do |host|
-        if existing = @members.detect {|node| node =~ host }
-          if existing.healthy?
-            # Refresh this node's configuration
-            existing.set_config
-            # If we are unhealthy after refreshing our config, drop from the set.
-            if !existing.healthy?
-              @members.delete(existing)
-            else
-              next
-            end
-          else
-            existing.close
-            @members.delete(existing)
-          end
-        end
-
-        node = Mongo::Node.new(self.client, host)
-        node.connect
-        @members << node if node.healthy?
-      end
-      seed.close
-
-      if @members.empty?
-        raise ConnectionFailure, "Failed to connect to any given member."
-      end
-    end
-
-    # Initialize the connection pools for the primary and secondary nodes.
-    def initialize_pools(members)
-      @primary_pool = nil
-      @primary = nil
-      @secondaries_mutable.clear
-      @secondary_pools_mutable.clear
-      @hosts_mutable.clear
-
-      members.each do |member|
-        member.last_state = nil
-        @hosts_mutable << member.host_string
-        if member.primary?
-          assign_primary(member)
-        elsif member.secondary?
-          # member could be not primary but secondary still is false
-          assign_secondary(member)
-        end
-      end
-
-      @arbiters_mutable = members.first.arbiters
-    end
-
-    def assign_primary(member)
-      member.last_state = :primary
-      @primary = member.host_port
-      if existing = @pools_mutable.detect {|pool| pool.node == member }
-        @primary_pool = existing
-      else
-        @primary_pool = Pool.new(self.client, member.host, member.port,
-          :size => self.client.pool_size,
-          :timeout => self.client.pool_timeout,
-          :node => member
-        )
-        @pools_mutable << @primary_pool
-      end
-    end
-
-    def assign_secondary(member)
-      member.last_state = :secondary
-      @secondaries_mutable << member.host_port
-      if existing = @pools_mutable.detect {|pool| pool.node == member }
-        @secondary_pools_mutable << existing
-      else
-        pool = Pool.new(self.client, member.host, member.port,
-          :size => self.client.pool_size,
-          :timeout => self.client.pool_timeout,
-          :node => member
-        )
-        @secondary_pools_mutable << pool
-        @pools_mutable << pool
-      end
-    end
-
-    # Iterate through the list of provided seed
-    # nodes until we've gotten a response from the
-    # replica set we're trying to connect to.
-    #
-    # If we don't get a response, raise an exception.
-    def get_valid_seed_node
-      @seeds.each do |seed|
-        node = Mongo::Node.new(self.client, seed)
-        node.connect
-        return node if node.healthy?
-      end
-
-      raise ConnectionFailure, "Cannot connect to a replica set using seeds " +
-        "#{@seeds.map {|s| "#{s[0]}:#{s[1]}" }.join(', ')}"
-    end
-
-    def discovered_seeds
-      @members.map(&:host_port)
-    end
-
-    def copy_members
-       members = Set.new
-       @connect_mutex.synchronize do
-         @members.map do |m|
-           members << m.dup
-         end
-       end
-       members
-    end
-
-    def initialize_immutable_state
-      @hosts           = Set.new.freeze
-      @pools           = Set.new.freeze
-      @secondaries     = Set.new.freeze
-      @secondary_pools = [].freeze
-      @arbiters        = [].freeze
-    end
-
-    def initialize_mutable_state
-      @hosts_mutable           = Set.new
-      @pools_mutable           = Set.new
-      @secondaries_mutable     = Set.new
-      @secondary_pools_mutable = []
-      @arbiters_mutable        = []
-    end
-
-    def clone_state
-      @hosts           = @hosts_mutable.clone
-      @pools           = @pools_mutable.clone
-      @secondaries     = @secondaries_mutable.clone
-      @secondary_pools = @secondary_pools_mutable.clone
-      @arbiters        = @arbiters_mutable.clone
-
-      @hosts.freeze
-      @pools.freeze
-      @secondaries.freeze
-      @secondary_pools.freeze
-      @arbiters.freeze
-    end
-  end
-end

data/lib/mongo/connection/sharding_pool_manager.rb

@@ -1,67 +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 ShardingPoolManager < PoolManager
-    def inspect
-      "<Mongo::ShardingPoolManager:0x#{self.object_id.to_s(16)} @seeds=#{@seeds}>"
-    end
-
-    # "Best" should be the member with the fastest ping time
-    # but connect/connect_to_members reinitializes @members
-    def best(members)
-      Array(members.first)
-    end
-
-    def connect
-      @connect_mutex.synchronize do
-        begin
-          thread_local[:locks][:connecting_manager] = true
-          @refresh_required = false
-          disconnect_old_members
-          connect_to_members
-          initialize_pools best(@members)
-          update_max_sizes
-          @seeds = discovered_seeds
-        ensure
-          thread_local[:locks][:connecting_manager] = false
-        end
-      end
-    end
-
-    # Checks that each node is healthy (via check_is_master) and that each
-    # node is in fact a mongos. If either criteria are not true, a refresh is
-    # set to be triggered and close() is called on the node.
-    #
-    # @return [Boolean] indicating if a refresh is required.
-    def check_connection_health
-      @refresh_required = false
-      @members.each do |member|
-        begin
-          config = @client.check_is_master([member.host, member.port])
-          unless config && config.has_key?('msg')
-            @refresh_required = true
-            member.close
-          end
-        rescue OperationTimeout
-          @refresh_required = true
-          member.close
-        end
-        break if @refresh_required
-      end
-      @refresh_required
-    end
-
-  end
-end

data/lib/mongo/connection/socket/ssl_socket.rb

@@ -1,95 +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.
-
-require 'openssl'
-
-module Mongo
-
-  # A basic wrapper over Ruby's SSLSocket that initiates
-  # a TCP connection over SSL and then provides an basic interface
-  # mirroring Ruby's TCPSocket, vis., TCPSocket#send and TCPSocket#read.
-  class SSLSocket
-    include SocketUtil
-
-    def initialize(host, port, op_timeout=nil, connect_timeout=nil, opts={})
-      @op_timeout      = op_timeout
-      @connect_timeout = connect_timeout
-      @pid             = Process.pid
-      @auths           = Set.new
-
-      @tcp_socket = ::TCPSocket.new(host, port)
-      @tcp_socket.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1)
-
-      @context = OpenSSL::SSL::SSLContext.new
-
-      if opts[:cert]
-        @context.cert = OpenSSL::X509::Certificate.new(File.open(opts[:cert]))
-      end
-
-      if opts[:key]
-        if opts[:key_pass_phrase]
-          @context.key = OpenSSL::PKey::RSA.new(File.open(opts[:key]), opts[:key_pass_phrase])
-        else
-          @context.key = OpenSSL::PKey::RSA.new(File.open(opts[:key]))
-        end
-      end
-
-      if opts[:verify]
-        @context.ca_file = opts[:ca_cert]
-        @context.verify_mode = OpenSSL::SSL::VERIFY_PEER
-      end
-
-      begin
-        @socket = OpenSSL::SSL::SSLSocket.new(@tcp_socket, @context)
-        @socket.sync_close = true
-        connect
-      rescue OpenSSL::SSL::SSLError
-        raise ConnectionFailure, "SSL handshake failed. MongoDB may " +
-                                 "not be configured with SSL support."
-      end
-
-      if opts[:verify]
-        unless OpenSSL::SSL.verify_certificate_identity(@socket.peer_cert, host)
-          raise ConnectionFailure, "SSL handshake failed. Hostname mismatch."
-        end
-      end
-
-      self
-    end
-
-    def connect
-      if @connect_timeout
-        Timeout::timeout(@connect_timeout, ConnectionTimeoutError) do
-          @socket.connect
-        end
-      else
-        @socket.connect
-      end
-    end
-
-    def send(data)
-      @socket.syswrite(data)
-    end
-
-    def read(length, buffer)
-      if @op_timeout
-        Timeout::timeout(@op_timeout, OperationTimeout) do
-          @socket.sysread(length, buffer)
-        end
-      else
-        @socket.sysread(length, buffer)
-      end
-    end
-  end
-end