moped 1.5.3 → 2.0.0.beta

data/lib/moped/loggable.rb

@@ -0,0 +1,110 @@
+# encoding: utf-8
+module Moped
+
+  # Contains behaviour for logging.
+  #
+  # @since 1.0.0
+  module Loggable
+
+    # Log the provided operations.
+    #
+    # @example Log the operations.
+    #   Loggable.log_operations("MOPED", {}, 30)
+    #
+    # @param [ String ] prefix The prefix for all operations in the log.
+    # @param [ Array ] ops The operations.
+    # @param [ String ] runtime The runtime in formatted ms.
+    #
+    # @since 2.0.0
+    def self.log_operations(prefix, ops, runtime)
+      indent  = " "*prefix.length
+      if ops.length == 1
+        Moped.logger.debug([ prefix, ops.first.log_inspect, "runtime: #{runtime}" ].join(' '))
+      else
+        first, *middle, last = ops
+        Moped.logger.debug([ prefix, first.log_inspect ].join(' '))
+        middle.each { |m| Moped.logger.debug([ indent, m.log_inspect ].join(' ')) }
+        Moped.logger.debug([ indent, last.log_inspect, "runtime: #{runtime}" ].join(' '))
+      end
+    end
+
+    # Log the payload to debug.
+    #
+    # @example Log to debug.
+    #   Loggable.debug("MOPED", payload "30.012ms")
+    #
+    # @param [ String ] prefix The log prefix.
+    # @param [ String ] payload The log operations.
+    # @param [ String ] runtime The runtime in formatted ms.
+    #
+    # @since 2.0.0
+    def self.debug(prefix, payload, runtime)
+      Moped.logger.debug([ prefix, payload, "runtime: #{runtime}" ].join(' '))
+    end
+
+    # Log the payload to warn.
+    #
+    # @example Log to warn.
+    #   Loggable.warn("MOPED", payload "30.012ms")
+    #
+    # @param [ String ] prefix The log prefix.
+    # @param [ String ] payload The log operations.
+    # @param [ String ] runtime The runtime in formatted ms.
+    #
+    # @since 2.0.0
+    def self.warn(prefix, payload, runtime)
+      Moped.logger.warn([ prefix, payload, "runtime: #{runtime}" ].join(' '))
+    end
+
+    # Get the logger.
+    #
+    # @example Get the logger.
+    #   Loggable.logger
+    #
+    # @return [ Logger ] The logger.
+    #
+    # @since 1.0.0
+    def logger
+      return @logger if defined?(@logger)
+      @logger = rails_logger || default_logger
+    end
+
+    # Get the rails logger.
+    #
+    # @example Get the rails logger.
+    #   Loggable.rails_logger
+    #
+    # @return [ Logger ] The Rails logger.
+    #
+    # @since 1.0.0
+    def rails_logger
+      defined?(Rails) && Rails.respond_to?(:logger) && Rails.logger
+    end
+
+    # Get the default logger.
+    #
+    # @example Get the default logger.
+    #   Loggable.default_logger
+    #
+    # @return [ Logger ] The default logger.
+    #
+    # @since 1.0.0
+    def default_logger
+      logger = Logger.new(STDOUT)
+      logger.level = Logger::INFO
+      logger
+    end
+
+    # Set the logger.
+    #
+    # @example Set the logger.
+    #   Loggable.logger = logger
+    #
+    # @return [ Logger ] The logger.
+    #
+    # @since 1.0.0
+    def logger=(logger)
+      @logger = logger
+    end
+  end
+end

data/lib/moped/node.rb

@@ -1,28 +1,33 @@
+# encoding: utf-8
+require "moped/address"
+require "moped/authenticatable"
+require "moped/connection"
+require "moped/executable"
+require "moped/failover"
+require "moped/instrumentable"
+require "moped/operation"
+
 module Moped
 
   # Represents a client to a node in a server cluster.
   #
-  # @api private
+  # @since 1.0.0
   class Node
-
-    # @attribute [r] address The address of the node.
-    # @attribute [r] down_at The time the server node went down.
-    # @attribute [r] ip_address The node's ip.
-    # @attribute [r] peers Other peers in the replica set.
-    # @attribute [r] port The connection port.
-    # @attribute [r] resolved_address The host/port pair.
-    # @attribute [r] timeout The connection timeout.
-    # @attribute [r] options Additional options for the node (ssl).
-    attr_reader \
-      :address,
-      :down_at,
-      :ip_address,
-      :peers,
-      :port,
-      :resolved_address,
-      :timeout,
-      :options,
-      :refreshed_at
+    include Authenticatable
+    include Executable
+    include Instrumentable
+
+    # @!attribute address
+    #   @return [ Address ] The address.
+    # @!attribute down_at
+    #   @return [ Time ] The time the node was marked as down.
+    # @!attribute latency
+    #   @return [ Integer ] The latency in milliseconds.
+    # @!attribute options
+    #   @return [ Hash ] The node options.
+    # @!attribute refreshed_at
+    #   @return [ Time ] The last time the node did a refresh.
+    attr_reader :address, :down_at, :latency, :options, :refreshed_at
 
     # Is this node equal to another?
     #
@@ -35,29 +40,21 @@ module Moped
     #
     # @since 1.0.0
     def ==(other)
-      resolved_address == other.resolved_address
+      return false unless other.is_a?(Node)
+      address.resolved == other.address.resolved
     end
     alias :eql? :==
 
-    # Apply the authentication details to this node.
-    #
-    # @example Apply authentication.
-    #   node.apply_auth([ :db, "user", "pass" ])
+    # Is the node an arbiter?
     #
-    # @param [ Array<String> ] credentials The db, username, and password.
+    # @example Is the node an arbiter?
+    #   node.arbiter?
     #
-    # @return [ Node ] The authenticated node.
+    # @return [ true, false ] If the node is an arbiter.
     #
     # @since 1.0.0
-    def apply_auth(credentials)
-      unless auth == credentials
-        logouts = auth.keys - credentials.keys
-        logouts.each { |database| logout(database) }
-        credentials.each do |database, (username, password)|
-          login(database, username, password) unless auth[database] == [username, password]
-        end
-      end
-      self
+    def arbiter?
+      !!@arbiter
     end
 
     # Is the cluster auto-discovering new nodes in the cluster?
@@ -87,30 +84,65 @@ module Moped
     #
     # @since 1.0.0
     def command(database, cmd, options = {})
-      operation = Protocol::Command.new(database, cmd, options)
-
-      process(operation) do |reply|
-        result = reply.documents.first
-        if reply.command_failure?
-          if reply.unauthorized? && auth.has_key?(database)
-            login(database, *auth[database])
-            result = command(database, cmd, options)
-          else
-            raise Errors::OperationFailure.new(operation, result)
-          end
-        end
-        result
+      read(Protocol::Command.new(database, cmd, options))
+    end
+
+    # Connect the node on the underlying connection.
+    #
+    # @example Connect the node.
+    #   node.connect
+    #
+    # @raise [ Errors::ConnectionFailure ] If connection failed.
+    #
+    # @return [ true ] If the connection suceeded.
+    #
+    # @since 2.0.0
+    def connect
+      start = Time.now
+      connection{ |conn| conn.connect }
+      @latency = Time.now - start
+      @down_at = nil
+      true
+    end
+
+    # Is the node currently connected?
+    #
+    # @example Is the node connected?
+    #   node.connected?
+    #
+    # @return [ true, false ] If the node is connected or not.
+    #
+    # @since 2.0.0
+    def connected?
+      connection{ |conn| conn.connected? }
+    end
+
+    # Get the underlying connection for the node.
+    #
+    # @example Get the node's connection.
+    #   node.connection
+    #
+    # @return [ Connection ] The connection.
+    #
+    # @since 2.0.0
+    def connection
+      pool.with_connection do |conn|
+        yield(conn)
       end
     end
 
     # Force the node to disconnect from the server.
     #
-    # @return [ nil ] nil.
+    # @example Disconnect the node.
+    #   node.disconnect
+    #
+    # @return [ true ] If the disconnection succeeded.
     #
     # @since 1.2.0
     def disconnect
-      auth.clear
-      connection.disconnect
+      credentials.clear
+      connection{ |conn| conn.disconnect }
+      true
     end
 
     # Is the node down?
@@ -125,6 +157,20 @@ module Moped
       @down_at
     end
 
+    # Mark the node as down.
+    #
+    # @example Mark the node as down.
+    #   node.down!
+    #
+    # @return [ nil ] Nothing.
+    #
+    # @since 2.0.0
+    def down!
+      @down_at = Time.new
+      @latency = nil
+      disconnect if connected?
+    end
+
     # Yields the block if a connection can be established, retrying when a
     # connection error is raised.
     #
@@ -138,47 +184,16 @@ module Moped
     # @return [ nil ] nil.
     #
     # @since 1.0.0
-    def ensure_connected
-      # Don't run the reconnection login if we're already inside an
-      # +ensure_connected+ block.
-      return yield if Threaded.executing?(:connection)
-      Threaded.begin(:connection)
-      retry_on_failure = true
-
-      begin
-        connect unless connected?
-        yield
-      rescue Errors::PotentialReconfiguration => e
-        if e.reconfiguring_replica_set?
-          raise Errors::ReplicaSetReconfigured.new(e.command, e.details)
-        elsif e.connection_failure?
-          raise Errors::ConnectionFailure.new(e.inspect)
-        end
-        raise
-      rescue Errors::DoNotDisconnect
-        # These exceptions are "expected" in the normal course of events, and
-        # don't necessitate disconnecting.
-        raise
-      rescue Errors::ConnectionFailure
-        disconnect
-        if retry_on_failure
-          # Maybe there was a hiccup -- try reconnecting one more time
-          retry_on_failure = false
-          retry
-        else
-          # Nope, we failed to connect twice. Flag the node as down and re-raise
-          # the exception.
-          down!
-          raise
+    def ensure_connected(&block)
+      return yield if executing?(:connection)
+      execute(:connection) do
+        begin
+          connect unless connected?
+          yield(self)
+        rescue Exception => e
+          Failover.get(e).execute(e, self, &block)
         end
-      rescue
-        # Looks like we got an unexpected error, so we'll clean up the connection
-        # and re-raise the exception.
-        disconnect
-        raise $!.extend(Errors::SocketError)
       end
-    ensure
-      Threaded.end(:connection)
     end
 
     # Set a flag on the node for the duration of provided block so that an
@@ -186,17 +201,16 @@ module Moped
     #
     # @example Ensure this node is primary.
     #   node.ensure_primary do
-    #     #...
+    #     node.command(ismaster: 1)
     #   end
     #
     # @return [ nil ] nil.
     #
     # @since 1.0.0
     def ensure_primary
-      Threaded.begin(:ensure_primary)
-      yield
-    ensure
-      Threaded.end(:ensure_primary)
+      execute(:ensure_primary) do
+        yield(self)
+      end
     end
 
     # Execute a get more operation on the node.
@@ -214,9 +228,7 @@ module Moped
     #
     # @since 1.0.0
     def get_more(database, collection, cursor_id, limit)
-      reply = process(Protocol::GetMore.new(database, collection, cursor_id, limit))
-      raise Moped::Errors::CursorNotFound.new("GET MORE", cursor_id) if reply.cursor_not_found?
-      reply
+      read(Protocol::GetMore.new(database, collection, cursor_id, limit))
     end
 
     # Get the hash identifier for the node.
@@ -228,7 +240,7 @@ module Moped
     #
     # @since 1.0.0
     def hash
-      resolved_address.hash
+      address.resolved.hash
     end
 
     # Creat the new node.
@@ -241,14 +253,15 @@ module Moped
     #
     # @since 1.0.0
     def initialize(address, options = {})
-      @address = address
+      @address = Address.new(address)
       @options = options
-      @timeout = options[:timeout] || 5
       @down_at = nil
       @refreshed_at = nil
+      @latency = nil
       @primary = nil
       @secondary = nil
-      resolve_address
+      @instrumenter = options[:instrumenter] || Instrumentable::Log
+      @address.resolve(self)
     end
 
     # Insert documents into the database.
@@ -263,8 +276,8 @@ module Moped
     # @return [ Message ] The result of the operation.
     #
     # @since 1.0.0
-    def insert(database, collection, documents, options = {})
-      process(Protocol::Insert.new(database, collection, documents, options))
+    def insert(database, collection, documents, concern, options = {})
+      write(Protocol::Insert.new(database, collection, documents, options), concern)
     end
 
     # Kill all provided cursors on the node.
@@ -281,6 +294,20 @@ module Moped
       process(Protocol::KillCursors.new(cursor_ids))
     end
 
+    # Can we send messages to this node in normal cirucmstances? This is true
+    # only if the node is a primary or secondary node - arbiters or passives
+    # cannot be sent anything.
+    #
+    # @example Is the node messagable?
+    #   node.messagable?
+    #
+    # @return [ true, false ] If messages can be sent to the node.
+    #
+    # @since 2.0.0
+    def messagable?
+      primary? || secondary?
+    end
+
     # Does the node need to be refreshed?
     #
     # @example Does the node require refreshing?
@@ -295,6 +322,31 @@ module Moped
       !refreshed_at || refreshed_at < time
     end
 
+    # Is the node passive?
+    #
+    # @example Is the node passive?
+    #   node.passive?
+    #
+    # @return [ true, false ] If the node is passive.
+    #
+    # @since 1.0.0
+    def passive?
+      !!@passive
+    end
+
+    # Get all the other nodes in the replica set according to the server
+    # information.
+    #
+    # @example Get the node's peers.
+    #   node.peers
+    #
+    # @return [ Array<Node> ] The peers.
+    #
+    # @since 2.0.0
+    def peers
+      @peers ||= []
+    end
+
     # Execute a pipeline of commands, for example a safe mode persist.
     #
     # @example Execute a pipeline.
@@ -305,14 +357,12 @@ module Moped
     # @return [ nil ] nil.
     #
     # @since 1.0.0
+    # @todo: Remove with piggbacked gle.
     def pipeline
-      Threaded.begin(:pipeline)
-      begin
-        yield
-      ensure
-        Threaded.end(:pipeline)
+      execute(:pipeline) do
+        yield(self)
       end
-      flush unless Threaded.executing?(:pipeline)
+      flush unless executing?(:pipeline)
     end
 
     # Is the node the replica set primary?
@@ -324,31 +374,29 @@ module Moped
     #
     # @since 1.0.0
     def primary?
-      @primary
+      !!@primary
     end
 
-    # Is the node an arbiter?
+    # Processes the provided operation on this node, and will execute the
+    # callback when the operation is sent to the database.
     #
-    # @example Is the node an arbiter?
-    #   node.arbiter?
+    # @example Process a read operation.
+    #   node.process(query) do |reply|
+    #     return reply.documents
+    #   end
     #
-    # @return [ true, false ] If the node is an arbiter.
+    # @param [ Message ] operation The database operation.
+    # @param [ Proc ] callback The callback to run on operation completion.
     #
-    # @since 1.0.0
-    def arbiter?
-      @arbiter
-    end
-
-    # Is the node passive?
-    #
-    # @example Is the node passive?
-    #   node.passive?
-    #
-    # @return [ true, false ] If the node is passive.
+    # @return [ Object ] The result of the callback.
     #
     # @since 1.0.0
-    def passive?
-      @passive
+    def process(operation, &callback)
+      if executing?(:pipeline)
+        queue.push([ operation, callback ])
+      else
+        flush([[ operation, callback ]])
+      end
     end
 
     # Execute a query on the node.
@@ -367,25 +415,7 @@ module Moped
     #
     # @since 1.0.0
     def query(database, collection, selector, options = {})
-      operation = Protocol::Query.new(database, collection, selector, options)
-
-      process(operation) do |reply|
-        if reply.query_failed?
-          if reply.unauthorized? && auth.has_key?(database)
-            # If we got here, most likely this is the case of Moped
-            # authenticating successfully against the node originally, but the
-            # node has been reset or gone down and come back up. The most
-            # common case here is a rs.stepDown() which will reinitialize the
-            # connection. In this case we need to requthenticate and try again,
-            # otherwise we'll just raise the error to the user.
-            login(database, *auth[database])
-            reply = query(database, collection, selector, options)
-          else
-            raise Errors::QueryFailure.new(operation, reply.documents.first)
-          end
-        end
-        reply
-      end
+      read(Protocol::Query.new(database, collection, selector, options))
     end
 
     # Refresh information about the node, such as it's status in the replica
@@ -403,27 +433,18 @@ module Moped
     #
     # @since 1.0.0
     def refresh
-      if resolve_address
+      if address.resolve(self)
         begin
           @refreshed_at = Time.now
-          info = command("admin", ismaster: 1)
-          primary = true   if info["ismaster"]
-          secondary = true if info["secondary"]
-          generate_peers(info)
-
-          @primary, @secondary = primary, secondary
-          @arbiter = info["arbiterOnly"]
-          @passive = info["passive"]
-
-          if !primary && Threaded.executing?(:ensure_primary)
+          configure(command("admin", ismaster: 1))
+          if !primary? && executing?(:ensure_primary)
             raise Errors::ReplicaSetReconfigured.new("#{inspect} is no longer the primary node.", {})
-          elsif !primary && !secondary
+          elsif !messagable?
             # not primary or secondary so mark it as down, since it's probably
             # a recovering node withing the replica set
             down!
           end
         rescue Timeout::Error
-          @peers = []
           down!
         end
       end
@@ -442,8 +463,8 @@ module Moped
     # @return [ Message ] The result of the operation.
     #
     # @since 1.0.0
-    def remove(database, collection, selector, options = {})
-      process(Protocol::Delete.new(database, collection, selector, options))
+    def remove(database, collection, selector, concern, options = {})
+      write(Protocol::Delete.new(database, collection, selector, options), concern)
     end
 
     # Is the node a replica set secondary?
@@ -458,6 +479,18 @@ module Moped
       @secondary
     end
 
+    # Get the timeout, in seconds, for this node.
+    #
+    # @example Get the timeout in seconds.
+    #   node.timeout
+    #
+    # @return [ Integer ] The configured timeout or the default of 5.
+    #
+    # @since 1.0.0
+    def timeout
+      @timeout ||= (options[:timeout] || 5)
+    end
+
     # Execute an update command for the provided selector.
     #
     # @example Update documents.
@@ -472,8 +505,8 @@ module Moped
     # @return [ Message ] The result of the operation.
     #
     # @since 1.0.0
-    def update(database, collection, selector, change, options = {})
-      process(Protocol::Update.new(database, collection, selector, change, options))
+    def update(database, collection, selector, change, concern, options = {})
+      write(Protocol::Update.new(database, collection, selector, change, options), concern)
     end
 
     # Get the node as a nice formatted string.
@@ -485,117 +518,68 @@ module Moped
     #
     # @since 1.0.0
     def inspect
-      "<#{self.class.name} resolved_address=#{@resolved_address.inspect}>"
+      "<#{self.class.name} resolved_address=#{address.resolved.inspect}>"
     end
 
     private
 
-    def auth
-      @auth ||= {}
-    end
-
-    def login(database, username, password)
-      getnonce = Protocol::Command.new(database, getnonce: 1)
-      connection.write [getnonce]
-      result = connection.read.documents.first
-      raise Errors::OperationFailure.new(getnonce, result) unless result["ok"] == 1
-      authenticate = Protocol::Commands::Authenticate.new(database, username, password, result["nonce"])
-      connection.write [authenticate]
-      result = connection.read.documents.first
-
-      unless result["ok"] == 1
-        # See if we had connectivity issues so we can retry
-        e = Errors::PotentialReconfiguration.new(authenticate, result)
-        if e.reconfiguring_replica_set?
-          raise Errors::ReplicaSetReconfigured.new(e.command, e.details)
-        elsif e.connection_failure?
-          raise Errors::ConnectionFailure.new(e.inspect)
-        end
-
-        raise Errors::AuthenticationFailure.new(authenticate, result)
-      end
-      auth[database] = [username, password]
-    end
-
-    def logout(database)
-      command = Protocol::Command.new(database, logout: 1)
-      connection.write [command]
-      result = connection.read.documents.first
-      raise Errors::OperationFailure.new(command, result) unless result["ok"] == 1
-
-      auth.delete(database)
-    end
-
-    private
-
-    def generate_peers(info)
-      peers = []
-      if auto_discovering?
-        peers.push(info["primary"]) if info["primary"]
-        peers.concat(info["hosts"]) if info["hosts"]
-        peers.concat(info["passives"]) if info["passives"]
-        peers.concat(info["arbiters"]) if info["arbiters"]
-      end
-      @peers = peers.map{ |peer| discover(peer) }.uniq
-    end
-
-    def discover(peer)
-      Node.new(peer, options).tap do |node|
-        node.send(:auth).merge!(auth)
-      end
-    end
-
-    def initialize_copy(_)
-      @connection = nil
-    end
-
-    def connection
-      @connection ||= Connection.new(ip_address, port, timeout, options)
-    end
-
-    def connected?
-      connection.connected?
-    end
-
-    # Mark the node as down.
+    # Configure the node based on the return from the ismaster command.
     #
-    # Returns nothing.
-    def down!
-      @down_at = Time.new
-
-      disconnect
-    end
-
-    # Connect to the node.
+    # @api private
     #
-    # Returns nothing.
-    # Raises Moped::ConnectionError if the connection times out.
-    # Raises Moped::ConnectionError if the server is unavailable.
-    def connect
-      connection.connect
-      @down_at = nil
+    # @example Configure the node.
+    #   node.configure(ismaster)
+    #
+    # @param [ Hash ] settings The result of the ismaster command.
+    #
+    # @since 2.0.0
+    def configure(settings)
+      @arbiter = settings["arbiterOnly"]
+      @passive = settings["passive"]
+      @primary = settings["ismaster"]
+      @secondary = settings["secondary"]
+      discover(settings["hosts"]) if auto_discovering?
     end
 
-    def process(operation, &callback)
-      if Threaded.executing? :pipeline
-        queue.push [operation, callback]
-      else
-        flush([[operation, callback]])
+    # Discover the additional nodes.
+    #
+    # @api private
+    #
+    # @example Discover the additional nodes.
+    #   node.discover([ "127.0.0.1:27019" ])
+    #
+    # @param [ Array<String> ] nodes The new nodes.
+    #
+    # @since 2.0.0
+    def discover(*nodes)
+      nodes.flatten.compact.each do |peer|
+        node = Node.new(peer, options)
+        node.credentials.merge!(credentials)
+        peers.push(node)
       end
     end
 
-    def queue
-      Threaded.stack(:pipelined_operations)
-    end
-
+    # Flush the node operations to the database.
+    #
+    # @api private
+    #
+    # @example Flush the operations.
+    #   node.flush([ command ])
+    #
+    # @param [ Array<Message> ] ops The operations to flush.
+    #
+    # @return [ Object ] The result of the operations.
+    #
+    # @since 2.0.0
     def flush(ops = queue)
       operations, callbacks = ops.transpose
-
       logging(operations) do
         ensure_connected do
-          connection.write operations
-          replies = connection.receive_replies(operations)
-
+          replies = nil
+          connection do |conn|
+            conn.write(operations)
+            replies = conn.receive_replies(operations)
+          end
           replies.zip(callbacks).map do |reply, callback|
             callback ? callback[reply] : reply
           end.last
@@ -605,50 +589,85 @@ module Moped
       ops.clear
     end
 
+    # Yield the block with logging.
+    #
+    # @api private
+    #
+    # @example Yield with logging.
+    #   logging(operations) do
+    #     node.command(ismaster: 1)
+    #   end
+    #
+    # @param [ Array<Message> ] operations The operations.
+    #
+    # @return [ Object ] The result of the yield.
+    #
+    # @since 2.0.0
     def logging(operations)
-      instrument_start = (logger = Moped.logger) && logger.debug? && Time.new
-      yield
-    ensure
-      log_operations(logger, operations, 1000 * (Time.new.to_f - instrument_start.to_f)) if instrument_start
+      instrument(TOPIC, prefix: "  MOPED: #{address.resolved}", ops: operations) do
+        yield if block_given?
+      end
     end
 
-    def log_operations(logger, ops, duration_ms)
-      prefix  = "  MOPED: #{resolved_address} "
-      indent  = " "*prefix.length
-      runtime = (" (%.4fms)" % duration_ms)
-
-      if ops.length == 1
-        logger.debug prefix + ops.first.log_inspect + runtime
-      else
-        first, *middle, last = ops
+    # Get the connection pool for the node.
+    #
+    # @api private
+    #
+    # @example Get the connection pool.
+    #   node.pool
+    #
+    # @return [ Connection::Pool ] The connection pool.
+    #
+    # @since 2.0.0
+    def pool
+      @pool ||= Connection::Manager.pool(self)
+    end
 
-        logger.debug prefix + first.log_inspect
-        middle.each { |m| logger.debug indent + m.log_inspect }
-        logger.debug indent + last.log_inspect + runtime
-      end
+    # Execute a read operation.
+    #
+    # @api private
+    #
+    # @example Execute a read operation.
+    #   node.read(operation)
+    #
+    # @param [ Message ] operation The read operation.
+    #
+    # @return [ Object ] The result of the read.
+    #
+    # @since 2.0.0
+    def read(operation)
+      Operation::Read.new(operation).execute(self)
     end
 
-    def resolve_address
-      unless ip_address
-        begin
-          parse_address and true
-        rescue SocketError
-          if logger = Moped.logger
-            logger.warn " MOPED: Could not resolve IP address for #{address}"
-          end
-          @down_at = Time.new
-          false
-        end
-      else
-        true
-      end
+    # Execute a write operation.
+    #
+    # @api private
+    #
+    # @example Execute a write operation.
+    #   node.write(operation, concern)
+    #
+    # @param [ Message ] operation The write operation.
+    # @param [ WriteConcern ] concern The write concern.
+    #
+    # @return [ Object ] The result of the write.
+    #
+    # @since 2.0.0
+    def write(operation, concern)
+      Operation::Write.new(operation, concern).execute(self)
     end
 
-    def parse_address
-      host, port = address.split(":")
-      @port = (port || 27017).to_i
-      @ip_address = ::Socket.getaddrinfo(host, nil, ::Socket::AF_INET, ::Socket::SOCK_STREAM).first[3]
-      @resolved_address = "#{@ip_address}:#{@port}"
+    # Get the queue of operations.
+    #
+    # @api private
+    #
+    # @example Get the operation queue.
+    #   node.queue
+    #
+    # @return [ Array<Message> ] The queue of operations.
+    #
+    # @since 2.0.0
+    def queue
+      stack(:pipelined_operations)
     end
   end
 end