moped 1.5.3 → 2.0.0.beta

data/lib/moped/errors.rb

@@ -5,6 +5,18 @@ module Moped
     # source of information on error codes.
     ERROR_REFERENCE = "https://github.com/mongodb/mongo/blob/master/docs/errors.md"
 
+    # Raised when the connection pool is saturated and no new connection is
+    # reaped during the wait time.
+    class PoolSaturated < RuntimeError; end
+
+    # Raised when attempting to checkout a connection on a thread that already
+    # has a connection checked out.
+    class ConnectionInUse < RuntimeError; end
+
+    # Raised when attempting to checkout a pinned connection from the pool but
+    # it is already in use by another object on the same thread.
+    class PoolTimeout < RuntimeError; end
+
     # Generic error class for exceptions related to connection failures.
     class ConnectionFailure < StandardError; end
 
@@ -100,10 +112,7 @@ module Moped
     class PotentialReconfiguration < MongoError
 
       # Not master error codes.
-      NOT_MASTER = [ 13435, 13436, 10009]
-
-      # Error codes received around reconfiguration
-      CONNECTION_ERRORS_RECONFIGURATION = [ 15988, 10276, 11600, 9001, 13639, 10009, 11002 ]
+      NOT_MASTER = [ 13435, 13436 ]
 
       # Replica set reconfigurations can be either in the form of an operation
       # error with code 13435, or with an error message stating the server is
@@ -113,8 +122,28 @@ module Moped
         NOT_MASTER.include?(details["code"]) || err.include?("not master")
       end
 
-      def connection_failure?
-        CONNECTION_ERRORS_RECONFIGURATION.include?(details["code"])
+      # Is the error due to a namespace not being found?
+      #
+      # @example Is the namespace not found?
+      #   error.ns_not_found?
+      #
+      # @return [ true, false ] If the namespace was not found.
+      #
+      # @since 2.0.0
+      def ns_not_found?
+        details["errmsg"] == "ns not found"
+      end
+
+      # Is the error due to a namespace not existing?
+      #
+      # @example Doest the namespace not exist?
+      #   error.ns_not_exists?
+      #
+      # @return [ true, false ] If the namespace was not found.
+      #
+      # @since 2.0.0
+      def ns_not_exists?
+        details["errmsg"] =~ /namespace does not exist/
       end
     end
 

data/lib/moped/executable.rb

@@ -0,0 +1,96 @@
+# encoding: utf-8
+module Moped
+
+  # Provides common behavior around executing a thread local stack safely.
+  #
+  # @since 2.0.0
+  module Executable
+
+    # Given the name of a thread local stack, ensure that execution happens by
+    # starting and ending the stack execution cleanly.
+    #
+    # @example Ensure execution of a pipeline.
+    #   execute(:pipeline) do
+    #     yield(self)
+    #   end
+    #
+    # @param [ Symbol ] name The name of the stack.
+    #
+    # @return [ Object ] The result of the yield.
+    #
+    # @since 2.0.0
+    def execute(name)
+      begin_execution(name)
+      begin
+        yield(self)
+      ensure
+        end_execution(name)
+      end
+    end
+
+    # Are we currently executing a stack on the thread?
+    #
+    # @example Are we executing a pipeline?
+    #   executing?(:pipeline)
+    #
+    # @param [ Symbol ] name The name of the stack.
+    #
+    # @return [ true, false ] If we are executing the stack.
+    #
+    # @since 2.0.0
+    def executing?(name)
+      !stack(name).empty?
+    end
+
+    private
+
+    # Begin entry into a named thread local stack.
+    #
+    # @api private
+    #
+    # @example Begin entry into the stack.
+    #   executable.begin_execution(:create)
+    #
+    # @param [ String ] name The name of the stack.
+    #
+    # @return [ true ] True.
+    #
+    # @since 1.0.0
+    def begin_execution(name)
+      stack(name).push(true)
+    end
+
+    # Exit from a named thread local stack.
+    #
+    # @api private
+    #
+    # @example Exit from the stack.
+    #   executable.end_execution(:create)
+    #
+    # @param [ Symbol ] name The name of the stack
+    #
+    # @return [ true ] True.
+    #
+    # @since 1.0.0
+    def end_execution(name)
+      stack(name).pop
+    end
+
+    # Get the named stack.
+    #
+    # @api private
+    #
+    # @example Get a stack by name
+    #   executable.stack(:create)
+    #
+    # @param [ Symbol ] name The name of the stack
+    #
+    # @return [ Array ] The stack.
+    #
+    # @since 1.0.0
+    def stack(name)
+      stacks = (Thread.current[:"moped-stacks"] ||= {})
+      stacks[name] ||= []
+    end
+  end
+end

data/lib/moped/failover.rb

@@ -0,0 +1,41 @@
+# encoding: utf-8
+require "moped/failover/disconnect"
+require "moped/failover/ignore"
+require "moped/failover/reconfigure"
+require "moped/failover/retry"
+
+module Moped
+
+  # Provides behaviour around failover scenarios for different types of
+  # exceptions that get raised on connection and execution of operations.
+  #
+  # @since 2.0.0
+  module Failover
+    extend self
+
+    # Hash lookup for the failover classes based off the exception type.
+    #
+    # @since 2.0.0
+    STRATEGIES = {
+      Errors::AuthenticationFailure => Ignore,
+      Errors::ConnectionFailure => Retry,
+      Errors::CursorNotFound => Ignore,
+      Errors::OperationFailure => Reconfigure,
+      Errors::QueryFailure => Reconfigure
+    }.freeze
+
+    # Get the appropriate failover handler given the provided exception.
+    #
+    # @example Get the failover handler for an IOError.
+    #   Moped::Failover.get(IOError)
+    #
+    # @param [ Exception ] exception The raised exception.
+    #
+    # @return [ Object ] The failover handler.
+    #
+    # @since 2.0.0
+    def get(exception)
+      STRATEGIES.fetch(exception.class, Disconnect)
+    end
+  end
+end

data/lib/moped/failover/disconnect.rb

@@ -0,0 +1,31 @@
+# encoding: utf-8
+module Moped
+  module Failover
+
+    # Disconnect is for the case when we get exceptions we do not know about,
+    # and need to disconnect the node to cleanup the problem.
+    #
+    # @since 2.0.0
+    module Disconnect
+      extend self
+
+      # Executes the failover strategy. In the case of disconnect, we just re-raise
+      # the exception that was thrown previously extending a socket error and
+      # disconnect.
+      #
+      # @example Execute the disconnect strategy.
+      #   Moped::Failover::Disconnect.execute(exception, node)
+      #
+      # @param [ Exception ] exception The raised exception.
+      # @param [ Node ] node The node the exception got raised on.
+      #
+      # @raise [ Errors::SocketError ] The extended exception that was thrown.
+      #
+      # @since 2.0.0
+      def execute(exception, node)
+        node.disconnect
+        raise(exception.extend(Errors::SocketError))
+      end
+    end
+  end
+end

data/lib/moped/failover/ignore.rb

@@ -0,0 +1,29 @@
+# encoding: utf-8
+module Moped
+  module Failover
+
+    # Ignore is for the case when we get exceptions we deem are proper user
+    # or datbase errors and should be re-raised.
+    #
+    # @since 2.0.0
+    module Ignore
+      extend self
+
+      # Executes the failover strategy. In the case of ignore, we just re-raise
+      # the exception that was thrown previously.
+      #
+      # @example Execute the ignore strategy.
+      #   Moped::Failover::Ignore.execute(exception, node)
+      #
+      # @param [ Exception ] exception The raised exception.
+      # @param [ Node ] node The node the exception got raised on.
+      #
+      # @raise [ Exception ] The exception that was previously thrown.
+      #
+      # @since 2.0.0
+      def execute(exception, node)
+        raise(exception)
+      end
+    end
+  end
+end

data/lib/moped/failover/reconfigure.rb

@@ -0,0 +1,34 @@
+# encoding: utf-8
+module Moped
+  module Failover
+
+    # Reconfigure is for exceptions that indicate that a replica set was
+    # potentially reconfigured in the middle of an operation.
+    #
+    # @since 2.0.0
+    module Reconfigure
+      extend self
+
+      # Executes the failover strategy. In the case of reconfigure, we check if
+      # the failure was due to a replica set reconfiguration mid operation and
+      # raise a new error if appropriate.
+      #
+      # @example Execute the reconfigure strategy.
+      #   Moped::Failover::Reconfigure.execute(exception, node)
+      #
+      # @param [ Exception ] exception The raised exception.
+      # @param [ Node ] node The node the exception got raised on.
+      #
+      # @raise [ Exception, Errors::ReplicaSetReconfigure ] The exception that
+      #   was previously thrown or a reconfiguration error.
+      #
+      # @since 2.0.0
+      def execute(exception, node)
+        if exception.reconfiguring_replica_set?
+          raise(Errors::ReplicaSetReconfigured.new(exception.command, exception.details))
+        end
+        raise(exception)
+      end
+    end
+  end
+end

data/lib/moped/failover/retry.rb

@@ -0,0 +1,37 @@
+# encoding: utf-8
+module Moped
+  module Failover
+
+    # Retry is for the case when we get exceptions around the connection, and
+    # want to make another attempt to try and resolve the issue.
+    #
+    # @since 2.0.0
+    module Retry
+      extend self
+
+      # Executes the failover strategy. In the case of retyr, we disconnect and
+      # reconnect, then try the operation one more time.
+      #
+      # @example Execute the retry strategy.
+      #   Moped::Failover::Retry.execute(exception, node)
+      #
+      # @param [ Exception ] exception The raised exception.
+      # @param [ Node ] node The node the exception got raised on.
+      #
+      # @raise [ Errors::ConnectionFailure ] If the retry fails.
+      #
+      # @return [ Object ] The result of the block yield.
+      #
+      # @since 2.0.0
+      def execute(exception, node)
+        node.disconnect
+        begin
+          yield if block_given?
+        rescue Exception => e
+          node.down!
+          raise(e)
+        end
+      end
+    end
+  end
+end

data/lib/moped/indexes.rb

@@ -55,7 +55,10 @@ module Moped
     def create(key, options = {})
       spec = options.merge(ns: namespace, key: key)
       spec[:name] ||= key.to_a.join("_")
-      database[:"system.indexes"].insert(spec)
+
+      database.session.with(write: { w: 1 }) do |_s|
+        _s[:"system.indexes"].insert(spec)
+      end
     end
 
     # Drop an index, or all indexes.

data/lib/moped/instrumentable.rb

@@ -0,0 +1,39 @@
+# encoding: utf-8
+require "moped/instrumentable/log"
+require "moped/instrumentable/noop"
+
+module Moped
+  module Instrumentable
+
+    # The name of the topic of operations for Moped.
+    #
+    # @since 2.0.0
+    TOPIC = "moped.operations"
+
+    # Topic for warning instrumentation.
+    #
+    # @since 2.0.0
+    WARN = "moped.warn"
+
+    # @!attribute instrumenter
+    #   @return [ Object ] The instrumenter
+    attr_reader :instrumenter
+
+    # Instrument and execute the provided block.
+    #
+    # @example Instrument and execute.
+    #   instrument("moped.noop") do
+    #     node.connect
+    #   end
+    #
+    # @param [ String ] name The name of the operation.
+    # @param [ Hash ] payload The payload.
+    #
+    # @return [ Object ] The result of the yield.
+    #
+    # @since 2.0.0
+    def instrument(name, payload = {}, &block)
+      instrumenter.instrument(name, payload, &block)
+    end
+  end
+end

data/lib/moped/instrumentable/log.rb

@@ -0,0 +1,43 @@
+# encoding: utf-8
+module Moped
+  module Instrumentable
+
+    # Provides logging instrumentation for compatibility with active support
+    # notifications.
+    #
+    # @since 2.0.0
+    class Log
+
+      class << self
+
+        # Instrument the log payload.
+        #
+        # @example Instrument the log payload.
+        #   Log.instrument("moped.ops", {})
+        #
+        # @param [ String ] name The name of the logging type.
+        # @param [ Hash ] payload The log payload.
+        #
+        # @return [ Object ] The result of the yield.
+        #
+        # @since 2.0.0
+        def instrument(name, payload = {})
+          started = Time.new
+          begin
+            yield if block_given?
+          rescue Exception => e
+            payload[:exception] = [ e.class.name, e.message ]
+            raise e
+          ensure
+            runtime = ("%.4fms" % (1000 * (Time.now.to_f - started.to_f)))
+            if name == TOPIC
+              Moped::Loggable.log_operations(payload[:prefix], payload[:ops], runtime)
+            else
+              Moped::Loggable.debug(payload[:prefix], payload.reject { |k,v| k == :prefix }, runtime)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/moped/instrumentable/noop.rb

@@ -0,0 +1,31 @@
+# encoding: utf-8
+module Moped
+  module Instrumentable
+
+    # Does not instrument anything, just yields.
+    #
+    # @since 2.0.0
+    class Noop
+
+      class << self
+
+        # Do not instrument anything.
+        #
+        # @example Do not instrument.
+        #   Noop.instrument("moped.noop") do
+        #     node.connect
+        #   end
+        #
+        # @param [ String ] name The name of the operation.
+        # @param [ Hash ] payload The payload.
+        #
+        # @return [ Object ] The result of the yield.
+        #
+        # @since 2.0.0
+        def instrument(name, payload = {})
+          yield payload if block_given?
+        end
+      end
+    end
+  end
+end