retryable.rb in mongo-2.11.0.rc0

- old
+ new

@@ -117,16 +117,11 @@
         modern_read_with_retry(session, server_selector, &block)
       elsif client.max_read_retries > 0
         legacy_read_with_retry(session, server_selector, &block)
       else
         server = select_server(cluster, server_selector, session)
-        begin
-          yield server
-        rescue Error::SocketError, Error::SocketTimeoutError, Error::OperationFailure => e
-          e.add_note('retries disabled')
-          raise e
-        end
+        yield server
       end
     end
 
     # Execute a read operation with a single retry on network errors.
     #
@@ -217,18 +212,16 @@
         session.next_txn_num
       end
       begin
         yield(server, txn_num, false)
       rescue Error::SocketError, Error::SocketTimeoutError => e
-        e.add_note('modern retry')
         e.add_note("attempt 1")
         if session.in_transaction? && !ending_transaction
           raise e
         end
         retry_write(e, session, txn_num, &block)
       rescue Error::OperationFailure => e
-        e.add_note('modern retry')
         e.add_note("attempt 1")
         if e.unsupported_retryable_write?
           raise_unsupported_error(e)
         elsif (session.in_transaction? && !ending_transaction) || !e.write_retryable?
           raise e
@@ -255,16 +248,11 @@
     #
     # @api private
     def nro_write_with_retry(session, write_concern, &block)
       if session && session.client.options[:retry_writes]
         server = select_server(cluster, ServerSelector.primary, session)
-        begin
-          yield server
-        rescue Error::SocketError, Error::SocketTimeoutError, Error::OperationFailure => e
-          e.add_note('retries disabled')
-          raise e
-        end
+        yield server
       else
         legacy_write_with_retry(nil, session, &block)
       end
     end
 
@@ -290,12 +278,11 @@
       begin
         attempt += 1
         server ||= select_server(cluster, ServerSelector.primary, session)
         yield server
       rescue Error::OperationFailure => e
-        e.add_note('legacy retry')
-        e.add_note("attempt #{attempt}")
+        e.add_note("attempt #{attempt + 1}")
         server = nil
         if attempt > client.max_write_retries
           raise e
         end
         if e.write_retryable? && !(session && session.in_transaction?)
@@ -309,23 +296,22 @@
     end
 
     private
 
     def modern_read_with_retry(session, server_selector, &block)
+      attempt = 0
       server = select_server(cluster, server_selector, session)
       begin
         yield server
       rescue Error::SocketError, Error::SocketTimeoutError => e
-        e.add_note('modern retry')
-        e.add_note("attempt 1")
+        e.add_note("attempt #{attempt + 1}")
         if session.in_transaction?
           raise e
         end
         retry_read(e, server_selector, session, &block)
       rescue Error::OperationFailure => e
-        e.add_note('modern retry')
-        e.add_note("attempt 1")
+        e.add_note("attempt #{attempt + 1}")
         if session.in_transaction? || !e.write_retryable?
           raise e
         end
         retry_read(e, server_selector, session, &block)
       end
@@ -336,22 +322,20 @@
       server = select_server(cluster, server_selector, session)
       begin
         attempt += 1
         yield server
       rescue Error::SocketError, Error::SocketTimeoutError => e
-        e.add_note('legacy retry')
-        e.add_note("attempt #{attempt}")
+        e.add_note("attempt #{attempt + 1}")
         if attempt > client.max_read_retries || (session && session.in_transaction?)
           raise e
         end
         log_retry(e, message: 'Legacy read retry')
         server = select_server(cluster, server_selector, session)
         retry
       rescue Error::OperationFailure => e
-        e.add_note('legacy retry')
-        e.add_note("attempt #{attempt}")
-        if e.retryable? && !(session && session.in_transaction?)
+        e.add_note("attempt #{attempt + 1}")
+        if cluster.sharded? && e.retryable? && !(session && session.in_transaction?)
           if attempt > client.max_read_retries
             raise e
           end
           log_retry(e, message: 'Legacy read retry')
           sleep(client.read_retry_interval)
@@ -389,23 +373,20 @@
       log_retry(original_error, message: 'Read retry')
 
       begin
         yield server, true
       rescue Error::SocketError, Error::SocketTimeoutError => e
-        e.add_note('modern retry')
         e.add_note("attempt 2")
         raise e
       rescue Error::OperationFailure => e
-        e.add_note('modern retry')
         unless e.write_retryable?
           original_error.add_note("later retry failed: #{e.class}: #{e}")
           raise original_error
         end
         e.add_note("attempt 2")
         raise e
       rescue => e
-        e.add_note('modern retry')
         original_error.add_note("later retry failed: #{e.class}: #{e}")
         raise original_error
       end
     end
 
@@ -415,32 +396,26 @@
       # server description and/or topology as necessary (specifically,
       # a socket error or a not master error should have marked the respective
       # server unknown). Here we just need to wait for server selection.
       server = select_server(cluster, ServerSelector.primary, session)
       unless server.retry_writes?
-        # Do not need to add "modern retry" here, it should already be on
-        # the first exception.
         original_error.add_note('did not retry because server selected for retry does not supoprt retryable writes')
         raise original_error
       end
       log_retry(original_error, message: 'Write retry')
       yield(server, txn_num, true)
     rescue Error::SocketError, Error::SocketTimeoutError => e
-      e.add_note('modern retry')
       e.add_note('attempt 2')
       raise e
     rescue Error::OperationFailure => e
-      e.add_note('modern retry')
       if e.write_retryable?
         e.add_note('attempt 2')
         raise e
       else
         original_error.add_note("later retry failed: #{e.class}: #{e}")
         raise original_error
       end
     rescue => e
-      # Do not need to add "modern retry" here, it should already be on
-      # the first exception.
       original_error.add_note("later retry failed: #{e.class}: #{e}")
       raise original_error
     end
 
     # This is a separate method to make it possible for the test suite to