moped 1.5.3 → 2.0.0.beta

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 76d85fae38ea0ef7558bf6961c620082e3792f8c
-  data.tar.gz: c166d20629d965e0db7dfba2a91b758eaba55083
+  metadata.gz: 13a013a208ac0941e9a6d68d183574f2becafa79
+  data.tar.gz: 808d31b55227c47ff8d9503918c218d191b6b193
 SHA512:
-  metadata.gz: 7027124e3caefcc77952ae0f8af98690f877b67ae759a175fdd79b65c4e4b063106a15b3fdda1163ab3e506e4778e22833eae70abed95b7e88286ee4abee6508
-  data.tar.gz: 0a0eb20add7205c06e78be13f82861dc999a37376bf7f7de3d68f10853152c11853a217b25b43f7bbeb9247dfef6d292014feb416c8481691a3d7b6fcb4d96f1
+  metadata.gz: 56f954deab2f283830fc371a134d8f1b9055b6d985910886a27ed905a55b58403044f7acd9ea58e363b5dd296858a7dadc152ca8934e048c9fcec7ad60e5d600
+  data.tar.gz: b568935bcda3e6a73e5601819de389bab69f9e1acba1b40395bd0042b1a062ea86606e787778505fb08a3230855e9cf1b8be57d30925bd6611fe03967a8d1114

data/CHANGELOG.md

@@ -1,5 +1,47 @@
 # Overview
 
+## 2.0.0
+
+### New Features
+
+* \#196 Adding method on collection to rename itself (Arthur Neves)
+
+### API Changes (Backwards Incompatible)
+
+* \#190 Connection retries are now logged. (Jan Paul Posma)
+
+* \#133 Moped now supports the new read preferences that the core drivers
+  provide. These include:
+
+    - `:primary`: Will always read from a primary node. (default)
+    - `:primary_preferred`: Attempt a primary first, then secondary if none available.
+    - `:secondary`: Will always read from a secondary node.
+    - `:secondary_preferred`: Attempt a secondary first, then primary if none available.
+    - `:nearest`: Attempt to read from the node with the lowest latency.
+
+    Sample syntax:
+
+        Moped::Session.new([ "127.0.0.1:27017" ], read: :secondary)
+        session.with(read: :nearest)[:users].find
+
+    The `:consistency` option is no longer valid and will be ignored.
+
+* \#92 Moped now defaults all writes to propagate (formerly "safe mode") and now
+  has different propagate semantics:
+
+    - `{ w: -1 }`: Don't verify writes and raise no network errors.
+    - `{ w: 0 }`: Don't verify writes and raise network errors.
+    - `{ w: 1 }`: Verify writes on the primary node. (default)
+    - `{ w: n }`: Verify writes on n number of nodes.
+    - `{ w: :majority }`: Verify writes on a majority of nodes.
+
+    Sample syntax:
+
+        Moped::Session.new([ "127.0.0.1:27017" ], write: { w: 0 })
+        session.with(write: { w: -1 })[:users].insert(document)
+
+    The `:safe` option is no longer valid and will be ignored.
+
 ## 1.5.1
 
 ### Resolved Issues
@@ -23,15 +65,10 @@
 
         Moped::Session.new([ "127.0.0.1:27017" ], auto_discover: false)
 
-* \#189 Moped now logs connection attempts during retries. (Jan Paul Posma)
-
 ## 1.4.6
 
 ### Resolved Issues
 
-* \#192 Return the proper result after reauthentication attempts.
-  (Jonathan Hyman)
-
 * \#191 Checking for "not authorized" in error messages. (Jonathan Hyman)
 
 ## 1.4.5

data/README.md

@@ -1,4 +1,4 @@
-Mop[ed [![Build Status](https://secure.travis-ci.org/mongoid/moped.png?branch=master&.png)](http://travis-ci.org/mongoid/moped) [![Code Climate](https://codeclimate.com/github/mongoid/moped.png)](https://codeclimate.com/github/mongoid/moped)
+Moped [![Build Status](https://secure.travis-ci.org/mongoid/moped.png?branch=master&.png)](http://travis-ci.org/mongoid/moped) [![Code Climate](https://codeclimate.com/github/mongoid/moped.png)](https://codeclimate.com/github/mongoid/moped) [![Coverage Status](https://coveralls.io/repos/mongoid/moped/badge.png?branch=master)](https://coveralls.io/r/mongoid/moped?branch=master)
 ========
 
 Moped is a MongoDB driver for Ruby, which exposes a simple, elegant, and fast

data/lib/moped.rb

@@ -1,21 +1,18 @@
+# encoding: utf-8
 require "logger"
 require "stringio"
 require "monitor"
-
-require "moped/bson"
-require "moped/cluster"
-require "moped/collection"
-require "moped/connection"
-require "moped/cursor"
-require "moped/database"
+require "timeout"
+require "bson"
+require "optionable"
 require "moped/errors"
 require "moped/indexes"
-require "moped/logging"
-require "moped/mongo_uri"
-require "moped/node"
+require "moped/loggable"
+require "moped/uri"
 require "moped/protocol"
-require "moped/query"
 require "moped/session"
-require "moped/session/context"
-require "moped/threaded"
 require "moped/version"
+
+module Moped
+  extend Loggable
+end

data/lib/moped/address.rb

@@ -0,0 +1,56 @@
+# encoding: utf-8
+module Moped
+
+  # Encapsulates behaviour around addresses and resolving dns.
+  #
+  # @since 2.0.0
+  class Address
+
+    # @!attribute host
+    #   @return [ String ] The host name.
+    # @!attribute ip
+    #   @return [ String ] The ip address.
+    # @!attribute original
+    #   @return [ String ] The original host name.
+    # @!attribute port
+    #   @return [ Integer ] The port.
+    # @!attribute resolved
+    #   @return [ String ] The full resolved address.
+    attr_reader :host, :ip, :original, :port, :resolved
+
+    # Instantiate the new address.
+    #
+    # @example Instantiate the address.
+    #   Moped::Address.new("localhost:27017")
+    #
+    # @param [ String ] address The host:port pair as a string.
+    #
+    # @since 2.0.0
+    def initialize(address)
+      @original = address
+      @host, port = address.split(":")
+      @port = (port || 27017).to_i
+    end
+
+    # Resolve the address for the provided node. If the address cannot be
+    # resolved the node will be flagged as down.
+    #
+    # @example Resolve the address.
+    #   address.resolve(node)
+    #
+    # @param [ Node ] node The node to resolve for.
+    #
+    # @return [ String ] The resolved address.
+    #
+    # @since 2.0.0
+    def resolve(node)
+      begin
+        @ip ||= Socket.getaddrinfo(host, nil, Socket::AF_INET, Socket::SOCK_STREAM).first[3]
+        @resolved ||= "#{ip}:#{port}"
+      rescue SocketError => e
+        node.instrument(Node::WARN, prefix: "  MOPED:", message: "Could not resolve IP for: #{original}")
+        node.down! and false
+      end
+    end
+  end
+end

data/lib/moped/authenticatable.rb

@@ -0,0 +1,89 @@
+# encoding: utf-8
+module Moped
+
+  # Provides behaviour to nodes around authentication.
+  #
+  # @since 2.0.0
+  module Authenticatable
+
+    # Apply authentication credentials.
+    #
+    # @example Apply the authentication credentials.
+    #   node.apply_credentials({ "moped_test" => [ "user", "pass" ]})
+    #
+    # @param [ Hash ] credentials The authentication credentials in the form:
+    #   { database_name: [ user, password ]}
+    #
+    # @return [ Object ] The authenticated object.
+    #
+    # @since 2.0.0
+    def apply_credentials(logins)
+      unless credentials == logins
+        logouts = credentials.keys - logins.keys
+        logouts.each do |database|
+          logout(database)
+        end
+        logins.each do |database, (username, password)|
+          unless credentials[database] == [ username, password ]
+            login(database, username, password)
+          end
+        end
+      end
+      self
+    end
+
+    # Get the applied credentials.
+    #
+    # @example Get the applied credentials.
+    #   node.credentials
+    #
+    # @return [ Hash ] The credentials.
+    #
+    # @since 2.0.0
+    def credentials
+      @credentials ||= {}
+    end
+
+    # Login the user to the provided database with the supplied password.
+    #
+    # @example Login the user to the database.
+    #   node.login("moped_test", "user", "pass")
+    #
+    # @param [ String ] database The database name.
+    # @param [ String ] username The username.
+    # @param [ String ] password The password.
+    #
+    # @raise [ Errors::AuthenticationFailure ] If the login failed.
+    #
+    # @return [ Array ] The username and password.
+    #
+    # @since 2.0.0
+    def login(database, username, password)
+      getnonce = Protocol::Command.new(database, getnonce: 1)
+      result = Operation::Read.new(getnonce).execute(self)
+      authenticate = Protocol::Commands::Authenticate.new(database, username, password, result["nonce"])
+      connection do |conn|
+        conn.write([ authenticate ])
+        document = conn.read.documents.first
+        raise Errors::AuthenticationFailure.new(authenticate, document) unless document["ok"] == 1
+        credentials[database] = [username, password]
+      end
+    end
+
+    # Logout the user from the provided database.
+    #
+    # @example Logout from the provided database.
+    #   node.logout("moped_test")
+    #
+    # @param [ String ] database The database name.
+    #
+    # @return [ Array ] The username and password.
+    #
+    # @since 2.0.0
+    def logout(database)
+      command = Protocol::Command.new(database, logout: 1)
+      Operation::Read.new(command).execute(self)
+      credentials.delete(database)
+    end
+  end
+end

data/lib/moped/cluster.rb

@@ -1,23 +1,47 @@
+# encoding: utf-8
+require "moped/node"
+
 module Moped
 
   # The cluster represents a cluster of MongoDB server nodes, either a single
   # node, a replica set, or a mongos server.
+  #
+  # @since 1.0.0
   class Cluster
 
-    # @attribute [r] options The cluster options.
-    # @attribute [r] seeds The seeds the cluster was initialized with.
-    attr_reader :options, :seeds
+    # The default interval that a node would be flagged as "down".
+    #
+    # @since 2.0.0
+    DOWN_INTERVAL = 30
+
+    # The default interval that a node should be refreshed in.
+    #
+    # @since 2.0.0
+    REFRESH_INTERVAL = 300
+
+    # The default time to wait to retry an operation.
+    #
+    # @since 2.0.0
+    RETRY_INTERVAL = 0.25
+
+    # @!attribute options
+    #   @return [ Hash ] The refresh options.
+    # @!attribute peers
+    #   @return [ Array<Node> ] The node peers.
+    # @!attribute seeds
+    #   @return [ Array<Node> ] The seed nodes.
+    attr_reader :options, :peers, :seeds
 
     # Get the credentials for the cluster.
     #
-    # @example Get the authentication details.
-    #   cluster.auth
+    # @example Get the applied credentials.
+    #   node.credentials
     #
-    # @return [ Hash ] the cached authentication credentials for this cluster.
+    # @return [ Hash ] The credentials.
     #
-    # @since 1.0.0
-    def auth
-      @auth ||= {}
+    # @since 2.0.0
+    def credentials
+      @credentials ||= {}
     end
 
     # Disconnects all nodes in the cluster. This should only be used in cases
@@ -28,7 +52,7 @@ module Moped
     #
     # @since 1.2.0
     def disconnect
-      nodes(include_arbiters: true).each { |node| node.disconnect } and true
+      nodes.each { |node| node.disconnect } and true
     end
 
     # Get the interval at which a node should be flagged as down before
@@ -41,45 +65,7 @@ module Moped
     #
     # @since 1.2.7
     def down_interval
-      options[:down_interval]
-    end
-
-    # Get the number of times an operation should be retried before raising an
-    # error.
-    #
-    # @example Get the maximum retries.
-    #   cluster.max_retries
-    #
-    # @return [ Integer ] The max retries.
-    #
-    # @since 1.2.7
-    def max_retries
-      options[:max_retries]
-    end
-
-    # Get the interval in which the node list should be refreshed.
-    #
-    # @example Get the refresh interval, in seconds.
-    #   cluster.refresh_interval
-    #
-    # @return [ Integer ] The refresh interval.
-    #
-    # @since 1.2.7
-    def refresh_interval
-      options[:refresh_interval]
-    end
-
-    # Get the operation retry interval - the time to wait before retrying a
-    # single operation.
-    #
-    # @example Get the retry interval, in seconds.
-    #   cluster.retry_interval
-    #
-    # @return [ Integer ] The retry interval.
-    #
-    # @since 1.2.7
-    def retry_interval
-      options[:retry_interval]
+      @down_interval ||= options[:down_interval] || DOWN_INTERVAL
     end
 
     # Initialize the new cluster.
@@ -98,16 +84,34 @@ module Moped
     #
     # @since 1.0.0
     def initialize(hosts, options)
-      @seeds = hosts
-      @nodes = hosts.map { |host| Node.new(host, options) }
+      @seeds = hosts.map{ |host| Node.new(host, options) }
       @peers = []
+      @options = options
+    end
+
+    # Provide a pretty string for cluster inspection.
+    #
+    # @example Inspect the cluster.
+    #   cluster.inspect
+    #
+    # @return [ String ] A nicely formatted string.
+    #
+    # @since 1.0.0
+    def inspect
+      "#<#{self.class.name}:#{object_id} @seeds=#{seeds.inspect}>"
+    end
 
-      @options = {
-        down_interval: 30,
-        max_retries: 20,
-        refresh_interval: 300,
-        retry_interval: 0.25
-      }.merge(options)
+    # Get the number of times an operation should be retried before raising an
+    # error.
+    #
+    # @example Get the maximum retries.
+    #   cluster.max_retries
+    #
+    # @return [ Integer ] The max retries.
+    #
+    # @since 1.2.7
+    def max_retries
+      @max_retries ||= options[:max_retries] || seeds.size
     end
 
     # Returns the list of available nodes, refreshing 1) any nodes which were
@@ -120,25 +124,19 @@ module Moped
     # @return [ Array<Node> ] the list of available nodes.
     #
     # @since 1.0.0
-    def nodes(opts = {})
-      current_time = Time.new
-      down_boundary = current_time - down_interval
-      refresh_boundary = current_time - refresh_interval
-
+    def nodes
       # Find the nodes that were down but are ready to be refreshed, or those
       # with stale connection information.
-      needs_refresh, available = @nodes.partition do |node|
-        node.down? ? (node.down_at < down_boundary) : node.needs_refresh?(refresh_boundary)
+      needs_refresh, available = seeds.partition do |node|
+        refreshable?(node)
       end
 
       # Refresh those nodes.
-      available.concat refresh(needs_refresh)
+      available.concat(refresh(needs_refresh))
 
       # Now return all the nodes that are available and participating in the
       # replica set.
-      available.reject do |node|
-        node.down? || !member?(node) || (!opts[:include_arbiters] && node.arbiter?)
-      end
+      available.reject{ |node| node.down? }
     end
 
     # Refreshes information for each of the nodes provided. The node list
@@ -155,24 +153,19 @@ module Moped
     # @return [ Array<Node> ] the available nodes
     #
     # @since 1.0.0
-    def refresh(nodes_to_refresh = @nodes)
+    def refresh(nodes_to_refresh = seeds)
       refreshed_nodes = []
       seen = {}
-
       # Set up a recursive lambda function for refreshing a node and it's peers.
       refresh_node = ->(node) do
         unless seen[node]
           seen[node] = true
-
           # Add the node to the global list of known nodes.
-          @nodes << node unless @nodes.include?(node)
-
+          seeds.push(node) unless seeds.include?(node)
           begin
             node.refresh
-
             # This node is good, so add it to the list of nodes to return.
-            refreshed_nodes << node unless refreshed_nodes.include?(node)
-
+            refreshed_nodes.push(node) unless refreshed_nodes.include?(node)
             # Now refresh any newly discovered peer nodes - this will also
             # remove nodes that are not included in the peer list.
             refresh_peers(node, &refresh_node)
@@ -183,7 +176,32 @@ module Moped
       end
 
       nodes_to_refresh.each(&refresh_node)
-      refreshed_nodes.to_a
+      refreshed_nodes
+    end
+
+    # Get the interval in which the node list should be refreshed.
+    #
+    # @example Get the refresh interval, in seconds.
+    #   cluster.refresh_interval
+    #
+    # @return [ Integer ] The refresh interval.
+    #
+    # @since 1.2.7
+    def refresh_interval
+      @refresh_interval ||= options[:refresh_interval] || REFRESH_INTERVAL
+    end
+
+    # Get the operation retry interval - the time to wait before retrying a
+    # single operation.
+    #
+    # @example Get the retry interval, in seconds.
+    #   cluster.retry_interval
+    #
+    # @return [ Integer ] The retry interval.
+    #
+    # @since 1.2.7
+    def retry_interval
+      @retry_interval ||= options[:retry_interval] || RETRY_INTERVAL
     end
 
     # Yields the replica set's primary node to the provided block. This method
@@ -202,30 +220,16 @@ module Moped
     # @return [ Object ] The result of the yield.
     #
     # @since 1.0.0
-    def with_primary(retries = max_retries, &block)
+    def with_primary(&block)
       if node = nodes.find(&:primary?)
         begin
           node.ensure_primary do
-            return yield node.apply_auth(auth)
+            return yield(node.apply_credentials(credentials))
           end
         rescue Errors::ConnectionFailure, Errors::ReplicaSetReconfigured
-          # Fall through to the code below if our connection was dropped or the
-          # node is no longer the primary.
         end
       end
-
-      if retries > 0
-        # We couldn't find a primary node, so refresh the list and try again.
-        warning("  MOPED: Retrying connection to primary for replica set #{inspect}")
-        sleep(retry_interval)
-        refresh
-        with_primary(retries - 1, &block)
-      else
-        raise(
-          Errors::ConnectionFailure,
-          "Could not connect to a primary node for replica set #{inspect}"
-        )
-      end
+      raise Errors::ConnectionFailure, "Could not connect to a primary node for replica set #{inspect}"
     end
 
     # Yields a secondary node if available, otherwise the primary node. This
@@ -243,63 +247,92 @@ module Moped
     # @return [ Object ] The result of the yield.
     #
     # @since 1.0.0
-    def with_secondary(retries = max_retries, &block)
-      available_nodes = nodes.shuffle!.partition(&:secondary?).flatten
-
+    def with_secondary(&block)
+      available_nodes = nodes.select(&:secondary?).shuffle!
       while node = available_nodes.shift
         begin
-          return yield node.apply_auth(auth)
-        rescue Errors::ConnectionFailure
-          warning("  MOPED: Connection failed to secondary node #{node.inspect}, trying next node.")
-          # That node's no good, so let's try the next one.
-          next
-        rescue Errors::ReplicaSetReconfigured
-          # That node's no good, so let's try the next one.
+          return yield(node.apply_credentials(credentials))
+        rescue Errors::ConnectionFailure => e
           next
         end
       end
-
-      if retries > 0
-        # We couldn't find a secondary or primary node, so refresh the list and
-        # try again.
-        warning("  MOPED: Could not connect to any node in replica set #{inspect}, refreshing list.")
-        sleep(retry_interval)
-        refresh
-        with_secondary(retries - 1, &block)
-      else
-        raise(
-          Errors::ConnectionFailure,
-          "Could not connect to any secondary or primary nodes for replica set #{inspect}"
-        )
-      end
-    end
-
-    def inspect
-      "<#{self.class.name} nodes=#{@nodes.inspect}>"
+      raise Errors::ConnectionFailure, "Could not connect to a secondary node for replica set #{inspect}"
     end
 
     private
 
-    def initialize_copy(_)
-      @nodes = @nodes.map(&:dup)
+    # Get the boundary where a node that is down would need to be refreshed.
+    #
+    # @api private
+    #
+    # @example Get the down boundary.
+    #   cluster.down_boundary
+    #
+    # @return [ Time ] The down boundary.
+    #
+    # @since 2.0.0
+    def down_boundary
+      Time.new - down_interval
     end
 
-    def member?(node)
-      @peers.empty? || @peers.include?(node)
+    # Get the standard refresh boundary to discover new nodes.
+    #
+    # @api private
+    #
+    # @example Get the refresh boundary.
+    #   cluster.refresh_boundary
+    #
+    # @return [ Time ] The refresh boundary.
+    #
+    # @since 2.0.0
+    def refresh_boundary
+      Time.new - refresh_interval
     end
 
-    def refresh_peers(node, &block)
-      peers = node.peers
-      return if !peers || peers.empty?
-      peers.each do |node|
-        block.call(node) unless @nodes.include?(node)
-        @peers.push(node) unless peers.include?(node)
-      end
+    # Is the provided node refreshable? This is in the case where the refresh
+    # boundary has passed, or the node has been down longer than the down
+    # boundary.
+    #
+    # @api private
+    #
+    # @example Is the node refreshable?
+    #   cluster.refreshable?(node)
+    #
+    # @param [ Node ] node The Node to check.
+    #
+    # @since 2.0.0
+    def refreshable?(node)
+      node.down? ? node.down_at < down_boundary : node.needs_refresh?(refresh_boundary)
+    end
+
+    # Creating a cloned cluster requires cloning all the seed nodes.
+    #
+    # @api prviate
+    #
+    # @example Clone the cluster.
+    #   cluster.clone
+    #
+    # @return [ Cluster ] The cloned cluster.
+    #
+    # @since 1.0.0
+    def initialize_copy(_)
+      @seeds = seeds.map(&:dup)
     end
 
-    def warning(message)
-      if logger = Moped.logger
-        logger.warn(message)
+    # Refresh the peers based on the node's peers.
+    #
+    # @api private
+    #
+    # @example Refresh the peers.
+    #   cluster.refresh_peers(node)
+    #
+    # @param [ Node ] node The node to refresh the peers for.
+    #
+    # @since 1.0.0
+    def refresh_peers(node, &block)
+      node.peers.each do |node|
+        block.call(node) unless seeds.include?(node)
+        peers.push(node) unless peers.include?(node)
       end
     end
   end